Submission #2296736

---

Source Code Expand

use std::env;
use std::io::*;
use std::str::*;
use std::mem;
use std::collections::HashMap;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin.bytes().map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}
fn read_char() -> char {
    let c = read::<String>();
    let c = c.chars().collect::<Vec<char>>();
    c[0]
}
fn read_String_Vec() -> Vec<char> {
    let S = read::<String>();
    S.chars().collect::<Vec<char>>()
}

fn vecchar_to_String(Vs: &Vec<char>) -> String {
    let mut S = String::new();
    for i in 0..Vs.len() {
        S.push(Vs[i]);
    }
    S
}

/*
文字コード
A : 65
Z : 90
a : 97
z : 122
0 : 48
9 : 57
*/

/*
let N = read::<i32>();
let S = read::<String>();
let S = read_String_Vec();
let C = read_char();
*/

/*
 .to_string() : * -> String
 &*S          : String -> &str
*/

fn main() {
    // main の引数
    /*
        引数なしのときargs.len() = 1;
    */
    let args: Vec<String> = env::args().collect();

    let Deg = read::<i32>(); // 風向
    let Dis = read::<i32>(); // 風力

    let Dis = Dis as f64 / 60.0 + 0.051; // 風力 m/s
    //println!("風力 : {}", Dis);

    let Dis = ((Dis * 10.0) as i32) as f64 / 10.0;
    //println!("風力 : {}", Dis);
    let Dis = {
        if Dis <= 0.2 {
            0
        } else if Dis <= 1.5 {
            1
        } else if Dis <= 3.3 {
            2
        } else if Dis <= 5.4 {
            3
        } else if Dis <= 7.9 {
            4
        } else if Dis <= 10.7 {
            5
        } else if Dis <= 13.8 {
            6
        } else if Dis <= 17.1 {
            7
        } else if Dis <= 20.7 {
            8
        } else if Dis <= 24.4 {
            9
        } else if Dis <= 28.4 {
            10
        } else if Dis <= 32.6 {
            11
        } else {
            12
        }
    };

    //println!("風力 : {}", Dis);
    // let S = read::<String>();
    // let S = read_String_Vec();
    // let C = read_char();
    // 0 <= Deg < 3600
    let Deg = (Deg*10 + 1125) % 36000;    // 0 <= Deg < 36000
    let Deg = Deg / 2250;
    //println!("Deg : {}", Deg);
    let D = ["N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
         "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"];
    let Deg = D[Deg as usize];

    if Dis == 0 {
        println!("C 0");
    } else {
        println!("{} {}", Deg, Dis);
    }
}

Submission Info

Compile Error

warning: unused import: `std::mem`, #[warn(unused_imports)] on by default
 --> ./Main.rs:4:5
  |
4 | use std::mem;
  |     ^^^^^^^^

warning: unused import: `std::collections::HashMap`, #[warn(unused_imports)] on by default
 --> ./Main.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: function is never used: `read_char`, #[warn(dead_code)] on by default
  --> ./Main.rs:15:1
   |
15 |   fn read_char() -> char {
   |  _^ starting here...
16 | |     let c = read::<String>();
17 | |     let c = c.chars().collect::<Vec<char>>();
18 | |     c[0]
19 | | }
   | |_^ ...ending here

warning: function is never used: `read_String_Vec`, #[warn(dead_code)] on by default
  --> ./Main.rs:20:1
   |
20 |   fn read_String_Vec() -> Vec<char> {
   |  _^ starting here...
21 | |     let S = read::<String>();
22 | |     S.chars().collect::<Vec<char>>()
23 | | }
   | |_^ ...ending here

warning: function `read_String_Vec` should have a snake case name such as `read_string_vec`, #[war...

Judge Result