AtCoder Beginner Contest 247 B(2)

https://atcoder.jp/contests/abc247/tasks/abc247_b

    match m.get(&k.to_string()) {
        Some(n) => {
            let n1 = n + 1;
            m.insert(k.to_string(), n1)
        }
        None    => m.insert(k.to_string(), 1)
    };

は、entryを使ってこう書けるんですね。

    let e = m.entry(k.to_string()).or_insert_with(|| 0);
    *e += 1

値じゃなくてclosureを使わないといけないみたいです。

// Unique Nicknames
#![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(k: &String, m: &mut HashMap<String,i32>) {
    let e = m.entry(k.to_string()).or_insert_with(|| 0);
    *e += 1
}

fn is_all_unique_nickname(names: &Vec<(String,String)>) -> bool {
    let mut m = HashMap::<String,i32>::new();
    for (s, t) in names.iter() {
        count(&s, &mut m);
        count(&t, &mut m);
    }
    
    for (s, t) in names.iter() {
        if s == t {
            if m[s] != 2 {
                return false
            }
        }
        else {
            if m[s] != 1 && m[t] != 1 {
                return false
            }
        }
    }
    return true
}

fn main() {
    let N: usize = read();
    let mut names = Vec::<(String,String)>::new();
    for _ in 0..N {
        let v: Vec<String> = read_vec();
        names.push((v[0].to_string(), v[1].to_string()))
    }
    
    let b = is_all_unique_nickname(&names);
    println!("{}", if b { "Yes" } else { "No" });
}

AtCoder Beginner Contest 247 B

https://atcoder.jp/contests/abc247/tasks/abc247_b

StringをHashMapのキーにするときには、to_string()をつけるとよいようです。
それから、

    match m.get(&k.to_string()) {
        Some(n) => m.insert(k.to_string(), n + 1),
        None    => m.insert(k.to_string(), 1)
    };

だとwarningがでてしまいますね。
こう書き換えます。

    match m.get(&k.to_string()) {
        Some(n) => {
            let n1 = n + 1;
            m.insert(k.to_string(), n1)
        }
        None    => m.insert(k.to_string(), 1)
    };

// Unique Nicknames
#![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(k: &String, m: &mut HashMap<String,i32>) {
    match m.get(&k.to_string()) {
        Some(n) => {
            let n1 = n + 1;
            m.insert(k.to_string(), n1)
        }
        None    => m.insert(k.to_string(), 1)
    };
}

fn is_all_unique_nickname(names: &Vec<(String,String)>) -> bool {
    let mut m = HashMap::<String,i32>::new();
    for (s, t) in names.iter() {
        count(&s, &mut m);
        count(&t, &mut m);
    }
    
    for (s, t) in names.iter() {
        if s == t {
            if m[s] != 2 {
                return false
            }
        }
        else {
            if m[s] != 1 && m[t] != 1 {
                return false
            }
        }
    }
    return true
}

fn main() {
    let N: usize = read();
    let mut names = Vec::<(String,String)>::new();
    for _ in 0..N {
        let v: Vec<String> = read_vec();
        names.push((v[0].to_string(), v[1].to_string()))
    }
    
    let b = is_all_unique_nickname(&names);
    println!("{}", if b { "Yes" } else { "No" });
}

AtCoder Beginner Contest 248 B

https://atcoder.jp/contests/abc248/tasks/abc248_b

0からの無限列を出すときは、

0..

こうですね。
以下はpow関数を使っているのでやや効率が悪いですが。

// Slimes
#![allow(non_snake_case)]

use num_traits::pow;

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 v = read_vec();
    let A: i64 = v[0];
    let B: i64 = v[1];
    let K: i64 = v[2];
    let n = (0usize..).filter(|&i| A * pow(K, i) >= B).next().unwrap();
    println!("{}", n);
}

AtCoder Beginner Contest 249 B

https://atcoder.jp/contests/abc249/tasks/abc249_b

大文字小文字判定は、is_uppercase/is_lowercaseです。

// Perfect String
#![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 is_all_different_chars(S: &String) -> bool {
    let mut s = HashSet::<char>::new();
    for c in S.chars() {
        if s.contains(&c) {
            return false
        }
        s.insert(c);
    }
    return true
}

fn is_perfect(S: &String) -> bool {
    S.chars().any(|c| c.is_lowercase()) &&
    S.chars().any(|c| c.is_uppercase()) &&
    is_all_different_chars(&S)
}

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

AtCoder Beginner Contest 250 B

https://atcoder.jp/contests/abc250/tasks/abc250_b

あえてcharのMatrixみたいなのを作ってそれを表示します。
Matrixを作るには、Iterator::collectを二重に適用すればよいですね。
ただ、そうすると複雑な形になって読みにくいので、closureを使っています。

    let f = |i, j| -> char {
        if (i/A + j/B) % 2 == 0 { '.' } else { '#' }
    };

// Enlarged Checker Board
#![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 print_table(table: &Vec::<Vec::<char>>) {
    for v in table.iter() {
        let s: String = v.iter().collect();
        println!("{}", s)
    }
}

fn main() {
    let v = read_vec();
    let N: usize = v[0];
    let A: usize = v[1];
    let B: usize = v[2];
    
    let f = |i, j| -> char {
        if (i/A + j/B) % 2 == 0 { '.' } else { '#' }
    };
    let table = (0..(A*N)).map(|i| (0..(B*N)).map(|j| f(i, j)).
                                                    collect()).collect();
    print_table(&table)
}

AtCoder Beginner Contest 251 B

https://atcoder.jp/contests/abc251/tasks/abc251_b

use itertools::Itertools;

として手元でコンパイルすると、

error[E0432]: unresolved import `itertools`
 --> ABC251B.rs:4:5
  |
4 | use itertools::Itertools;
  |     ^^^^^^^^^ maybe a missing crate `itertools`?

crateが無いらしいです。一方、AtCoderではこうしたエラーは出ないので、crateを使えるとよいです。

https://qiita.com/Kerzival/items/053ae4674be648f5ada3

CargoでCargo.tomlに

[dependencies]
itertools = "0.10.3"

と書くとItertoolsが使えるようになります。単にダウンロードしてくるだけですね。バージョン番号は適当に検索して。

https://crates.io/crates/itertools

// At Most 3 (Judge ver.)
#![allow(non_snake_case)]

use itertools::Itertools;
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_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn comb(A: &Vec<i32>, n: usize) -> HashSet<i32> {
    let mut s = HashSet::<i32>::new();
    for v in A.iter().combinations(n) {
        s.insert(v.iter().map(|&e| e).sum());
    }
    return s
}

fn main() {
    let v = read_vec();
    let _N: i32 = v[0];
    let W: i32 = v[1];
    let A = read_vec();
    let mut s: HashSet<i32> = A.iter().map(|e| *e).collect();
    for n in 2..4 {
        let s1 = comb(&A, n);
        s = s.union(&s1).map(|&e| e).collect::<HashSet<i32>>()
    }
    println!("{}", s.iter().filter(|&e| *e <= W).count());
}

AtCoder Beginner Contest 252 B

https://atcoder.jp/contests/abc252/tasks/abc252_b

デバッグでHashSetをVecに変換しましたが、from_iterを使うと簡単です。

use std::iter::FromIterator;

let w = Vec::from_iter(max_index_set.iter());

// Takahashi's Failure
#![allow(non_snake_case)]

use std::collections::HashSet;


//////////////////// library ////////////////////

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()
}


//////////////////// process ////////////////////

fn max_foods(A: &Vec<i32>) -> HashSet<usize> {
    let max_score = A.iter().max().unwrap();
    return (0..A.len()).filter(|&i| A[i] == *max_score).collect()
}

fn main() {
    let v = read_vec();
    let _N: usize = v[0];
    let _K: usize = v[1];
    let A = read_vec();
    let B: Vec<usize> = read_vec();
    let max_index_set = max_foods(&A);
    let b = B.iter().any(|&i| max_index_set.contains(&(i - 1)));
    println!("{}", if b { "Yes" } else { "No" });
}