ソートするだけですね。

// Minimize Ordering
#![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 main() {
	let S: String = read();
	let mut v: Vec<char> = S.chars().collect();
	v.sort();
	let T = v.iter().map(|c| c.to_string()).collect::<Vec::<String>>().join("");
	println!("{}", T)
}

2022-09-07

AtCoder Beginner Contest 243 B

https://atcoder.jp/contests/abc243/tasks/abc243_b

HashSet同士のintersectはHashSet<&i32>なんですね。

// Hit and Blow
#![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_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn num_match_at_same_positions(A: &Vec<i32>, B: &Vec<i32>) -> usize {
    let mut counter = 0;
    for (a, b) in A.iter().zip(B) {
        if a == b {
            counter += 1
        }
    }
    return counter
}

fn num_match_at_different_positions(A: &Vec<i32>, B: &Vec<i32>) -> usize {
    let set_A: HashSet<i32> = A.iter().cloned().collect();
    let set_B: HashSet<i32> = B.iter().cloned().collect();
    let intersect: HashSet<&i32> = set_A.intersection(&set_B).collect();
    return intersect.len()
}

fn main() {
    let _N: usize = read();
    let A = read_vec();
    let B = read_vec();
    let num1 = num_match_at_same_positions(&A, &B);
    let num2 = num_match_at_different_positions(&A, &B);
    println!("{}", num1);
    println!("{}", num2 - num1)
}

2022-09-06

AtCoder Beginner Contest 244 B

https://atcoder.jp/contests/abc244/tasks/abc244_b

位置と方向をセットにすると簡単です。

// Go Straight and Turn Right
#![allow(non_snake_case)]

use std::ops::Add;

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

#[derive(Clone, Copy)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Self;
    
    fn add(self, other: Self) -> Self {
        Self { x: self.x + other.x, y: self.y + other.y }
    }
}

impl Point {
    fn rotate(&self) -> Point {
        Point { x: self.y, y: -self.x }
    }
}

struct State {
    position: Point,
    direction: Point
}

impl State {
    fn init() -> State {
        State { position: Point {x: 0, y: 0}, direction: Point {x: 1, y: 0} }
    }
    
    fn straight(&self) -> State {
        State { position: self.position + self.direction,
                direction: self.direction }
    }
    
    fn rotate(&self) -> State {
        State { position: self.position, direction: self.direction.rotate() }
    }
}

fn main() {
    let _N: usize = read();
    let T: String = read();
    let mut s: State = State::init();
    for c in T.chars() {
        match c {
            'S' => s = s.straight(),
            'R' => s = s.rotate(),
            _   => ()
        }
    }
    println!("{} {}", s.position.x, s.position.y)
}

2022-09-05

AtCoder Beginner Contest 266 B

https://atcoder.jp/contests/abc266/tasks/abc266_b

Pythonなら剰余そのままですが、RustはC++との互換性のためか被除数が負だと負になってしまうんですねえ。

// Modulo Number
#![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 modulo(n: i64, q: i64) -> i64 {
    let r = n % q;
    if r >= 0 {
        r
    }
    else {
        r + q
    }
}

fn main() {
    let D: i64 = 998244353;
    let N: i64 = read();
    let r = modulo(N, D);
    println!("{}", r)
}

2022-09-04

AtCoder Beginner Contest 267 B

https://atcoder.jp/contests/abc267/tasks/abc267_b

効率が悪いですが、順番を追ってやれば問題ないですね。

// Split?
#![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_split(bs: &Vec<bool>) -> bool {
    if bs[0] {
        return false
    }
    
    // 各列にピンがあるか
    let mut exists: Vec<bool> = (0..7).map(|_| false).collect();
    let cs: Vec<usize> = vec![3, 2, 4, 1, 3, 5, 0, 2, 4, 6];
    for (i, &c) in cs.iter().enumerate() {
        if bs[i] {
            exists[c] = true
        }
    }
    
    // ピンが無い列に対して、その両側にピンがある列があるか
    for c in 1..6 {
        if !exists[c] {
            if (0..c).any(|j| exists[j]) && ((c+1)..7).any(|j| exists[j]) {
                return true
            }
        }
    }
    return false
}

fn main() {
    let S: String = read();
    let bs = S.chars().map(|c| c == '1').collect();     // 各ピンが立っているか
    
    println!("{}", if is_split(&bs) { "Yes" } else { "No" })
}

2022-09-02

AtCoder Beginner Contest 245 B

https://atcoder.jp/contests/abc245/tasks/abc245_b

read_setを書いてみましたが、たくさんTraitが要りますね。

// Mex
#![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: std::str::FromStr + std::cmp::Eq + std::hash::Hash>() -> HashSet<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}

fn main() {
    let _N: usize = read();
    let s: HashSet<usize> = read_set();
    for i in 0usize.. {
        if !s.contains(&i) {
            println!("{}", i);
            break
        }
    }
}

2022-09-01

AtCoder Beginner Contest 246 B

https://atcoder.jp/contests/abc246/tasks/abc246_b

最初からf64にすれば楽ですね。

// Get Closer
#![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 main() {
    let v = read_vec();
    let A: f64 = v[0];
    let B: f64 = v[1];
    let dist = (A * A + B * B).sqrt();
    println!("{} {}", A / dist, B / dist)
}

inamori’s diary

AtCoder Beginner Contest 242 B