Submission #1547289

---

Source Code Expand

#[allow(dead_code)]
#[allow(unused_macros)]
#[macro_use]
mod procon {
    macro_rules! list_to_tuple {
        ($ls:expr, $($x:ident),*) => {
            let mut i = 0;
            $(
                let $x = $ls[i];
                println!("let {} = ls[{}] (={})", stringify!($x), i, $ls[i]);
                i += 1;
            )*
            assert!(i == $ls.len());
        };
    }

    use std::io;

    //
    // stdin helpers
    //

    pub fn read_item<T>() -> T
        where T : super::std::str::FromStr,
              <T as super::std::str::FromStr>::Err : super::std::fmt::Debug {
        let mut buf = String::new();
        let _ = io::stdin().read_line(&mut buf);
        buf.trim().parse::<T>().unwrap()
    }
    pub fn read_i32() -> i32 { read_item::<i32>() }

    pub fn read_list<T>() -> Vec<T>
        where T : super::std::str::FromStr,
              <T as super::std::str::FromStr>::Err : super::std::fmt::Debug,
              super::std::vec::Vec<T> : super::std::iter::FromIterator<T> {
        let mut buf = String::new();
        let _ = io::stdin().read_line(&mut buf);
        let mut res = Vec::new();
        for item in buf.trim().split_whitespace().map(|s| s.parse::<T>()).into_iter() {
            match item {
                Ok(i) => res.push(i),
                _ => (),
            }
        }
        res
    }
    pub fn read_list_i32() -> Vec<i32> { read_list::<i32>() }

    pub fn read_tuple2<T>() -> (T, T) 
        where T : super::std::str::FromStr,
              T : Copy,
              <T as super::std::str::FromStr>::Err : super::std::fmt::Debug,
              super::std::vec::Vec<T> : super::std::iter::FromIterator<T> {
        let ls = read_list::<T>();
        (ls[0], ls[1])
    }
    pub fn read_tuple3<T>() -> (T, T, T)
        where T : super::std::str::FromStr,
              T : Copy,
              <T as super::std::str::FromStr>::Err : super::std::fmt::Debug,
              super::std::vec::Vec<T> : super::std::iter::FromIterator<T> {
        let ls = read_list::<T>();
        (ls[0], ls[1], ls[2])
    }
} // mod procon

fn solve(m : i32) -> i32 {
    let km = m as f32 / 1000.0;
    let vv = match m {
        v if                v <     100 => 0.0,
        v if    100 <= v && v <=  5_000 => km * 10.0,
        v if  6_000 <= v && v <= 30_000 => km + 50.0,
        v if 35_000 <= v && v <= 70_000 => (km - 30.0) / 5.0 + 80.0,
        _                               => 89.0,
    };
    vv as i32
}

use procon::*;
fn main() {
    let m = read_i32();

    assert_eq!(solve(10), 0);
    assert_eq!(solve(100), 1);
    assert_eq!(solve(2000), 20);
    assert_eq!(solve(5000), 50);
    assert_eq!(solve(6000), 56);
    assert_eq!(solve(15000), 65);
    assert_eq!(solve(35000), 81);
    let vv = solve(m);
    println!("{:02}", vv);
}

Submission Info

Compile Error

warning: unknown lint: `unused_macros`, #[warn(unknown_lints)] on by default
 --> ./Main.rs:2:9
  |
2 | #[allow(unused_macros)]
  |         ^^^^^^^^^^^^^

Judge Result