AtCoder Beginner Contest 268 B

https://atcoder.jp/contests/abc268/tasks/abc268_b

部分文字列はこんな感じで取れるようです。

    let sub = &T[..S.len()];

// Prefix?
#![allow(non_snake_case)]

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn is_prefix(S: &String, T: &String) -> bool {
    if S.len() > T.len() {
        return false
    }
    let sub = &T[..S.len()];
    S == sub
}

fn main() {
    let S: String = read();
    let T: String = read();
    println!("{}", if is_prefix(&S, &T) { "Yes" } else { "No" })
}

AtCoder Beginner Contest 236 B

https://atcoder.jp/contests/abc236/tasks/abc236_b

enumerateは、本当はindexと値の参照のタプルを返します。

// Who is missing?
#![allow(non_snake_case)]

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn who_is_missing(A: &Vec<usize>) -> usize {
    let N: usize = (A.len() + 1) / 4;
    let mut B: Vec<i32> = (0..N).map(|_| 0).collect();
    for a in A.iter() {
        B[a-1] += 1
    }
    for (i, &n) in B.iter().enumerate() {
        if n != 4 {
            return i + 1
        }
    }
    return N + 1
}

fn main() {
    let _N: usize = read();
    let A = read_vec();
    println!("{}", who_is_missing(&A))
}

AtCoder Beginner Contest 237 B

https://atcoder.jp/contests/abc237/tasks/abc237_b

typeを使うと型のaliasを作ることができます。

type Matrix<T> = Vec<Vec<T>>;

std::str::FromStrの逆のTraitはstd::string::ToStringなんですね。

// Matrix Transposition
#![allow(non_snake_case)]

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

type Matrix<T> = Vec<Vec<T>>;

fn read_matrix<T: std::str::FromStr>(H: usize) -> Matrix<T> {
    (0..H).map(|_| read_vec()).collect()
}

fn transpose<T: Copy>(M: &Matrix<T>) -> Matrix<T> {
    let H = M.len();
    let W = M[0].len();
    (0..W).map(|j| (0..H).map(|i| M[i][j]).collect()).collect()
}

fn print_matrix<T: std::string::ToString>(M: &Matrix<T>) {
    for v in M.iter() {
        println!("{}", v.iter().map(|c| c.to_string()).
                        collect::<Vec::<String>>().join(" "))
    }
}

fn main() {
    let v = read_vec();
    let H: usize = v[0];
    let _W: usize = v[1];
    let A: Matrix<i32> = read_matrix(H);
    let B = transpose(&A);
    print_matrix(&B);
}

AtCoder Beginner Contest 238 B

https://atcoder.jp/contests/abc238/tasks/abc238_b

ソートして差を取るだけですが、最後に360を付ける必要がありますね。

// Pizza
#![allow(non_snake_case)]

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn main() {
    let N: usize = read();
    let A: Vec<i32> = read_vec();
    let mut B = Vec::<i32>::new();
    B.push(0);
    for (i, a) in A.iter().enumerate() {
        B.push((B[i] + a) % 360)
    }
    B.push(360);
    B.sort();
    let max_angle = (0..(N+1)).map(|i| B[i+1] - B[i]).max();
    println!("{}", max_angle.unwrap())
}

AtCoder Beginner Contest 239 B

https://atcoder.jp/contests/abc239/tasks/abc239_b

余りと同じで商もPythonならそのままなのですが。

// Integer Division
#![allow(non_snake_case)]

use std::collections::HashSet;

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn int_div(n: i64, d: i64) -> i64 {
    if n >= 0 {
        n / d
    }
    else {
        (n - d + 1) / d
    }
}

fn main() {
    let X: i64 = read();
    println!("{}", int_div(X, 10))
}

AtCoder Beginner Contest 240 B

https://atcoder.jp/contests/abc240/tasks/abc240_b

Traitの指定にwhereを使うとちょっときれいに書けます。

// Count Distinct Integers
#![allow(non_snake_case)]

use std::collections::HashSet;

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn read_set<T>() -> HashSet<T>
    where T: std::str::FromStr + std::cmp::Eq + std::hash::Hash {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn main() {
    let _N: usize = read();
    let A: HashSet<i32> = read_set();
    println!("{}", A.len())
}

AtCoder Beginner Contest 241 B

https://atcoder.jp/contests/abc241/tasks/abc241_b

HashMapの値を変えるには、get_mutとメソッドを使うんですね。

// Pasta
#![allow(non_snake_case)]

use std::collections::HashMap;

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn count(A: Vec<i32>) -> HashMap<i32,i32> {
    let mut m = HashMap::<i32,i32>::new();
    for x in A {
        let counter = m.entry(x).or_insert(0);
        *counter += 1;
    }
    return m
}

fn exists_all(mut m: HashMap<i32,i32>, B: Vec<i32>) -> bool {
    for b in B.iter() {
        match m.get_mut(b) {
            Some(0) => { return false },
            Some(n) => { *n -= 1 },
            None    => { return false }
        }
    }
    return true
}

fn main() {
    let _v: Vec<usize> = read_vec();
    let A: Vec<i32> = read_vec();
    let B: Vec<i32> = read_vec();
    let m = count(A);
    println!("{}", if exists_all(m, B) { "Yes" } else { "No" })
}