AOJ ITP1 (Rust)

https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/all

1_A: Hello World

fn main() {
    println!("Hello world");
}

1_B: X Cubic

use std::io;

fn main() {
    let mut x = String::new();
    io::stdin().read_line(&mut x).unwrap();
    let x: i32 = x.trim().parse().unwrap();

    println!("{}", x.pow(3));
}

1_C: Rectangle

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let a: i32 = iter.next().unwrap().parse().unwrap();
    let b: i32 = iter.next().unwrap().parse().unwrap();

    println!("{} {}", a * b, 2 * (a + b));
}

1_D: Watch

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let S: i32 = buf.trim().parse().unwrap();

    println!("{}:{}:{}", S / 3600, S % 3600 / 60, S % 60);
}

2_A: Small, Large, or Equal

use std::cmp::Ordering;
use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let a: i32 = iter.next().unwrap().parse().unwrap();
    let b: i32 = iter.next().unwrap().parse().unwrap();

    println!(
        "a {} b",
        match a.cmp(&b) {
            Ordering::Less => "<",
            Ordering::Greater => ">",
            Ordering::Equal => "==",
        }
    );
}

2_B: Range

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let a: i32 = iter.next().unwrap().parse().unwrap();
    let b: i32 = iter.next().unwrap().parse().unwrap();
    let c: i32 = iter.next().unwrap().parse().unwrap();

    if a < b && b < c {
        println!("Yes");
    } else {
        println!("No");
    }
}

2_C: Sorting Three Numbers

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let mut v = [0, 0, 0];
    for i in 0..3 {
        v[i] = iter.next().unwrap().parse().unwrap();
    }
    v.sort();
    println!("{} {} {}", v[0], v[1], v[2]);
}

2_D: Circle in a Rectangle

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let W: i32 = iter.next().unwrap().parse().unwrap();
    let H: i32 = iter.next().unwrap().parse().unwrap();
    let x: i32 = iter.next().unwrap().parse().unwrap();
    let y: i32 = iter.next().unwrap().parse().unwrap();
    let r: i32 = iter.next().unwrap().parse().unwrap();

    if x >= r && x <= W - r && y >= r && y <= H - r {
        println!("Yes");
    } else {
        println!("No");
    }
}

3_A: Print Many Hello World

fn main() {
    for _ in 0..1000 {
        println!("Hello World");
    }
}

3_B: Print Test Cases

use std::io;

fn main() {
    let mut i = 1;
    loop {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).ok();
        let x: i32 = buf.trim().parse().unwrap();
        if x == 0 {
            break;
        }
        println!("Case {}: {}", i, x);
        i += 1;
    }
}

3_C: Swapping Two Numbers

use std::io;

fn main() {
    loop {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).ok();
        let mut iter = buf.split_whitespace();

        let x: i32 = iter.next().unwrap().parse().unwrap();
        let y: i32 = iter.next().unwrap().parse().unwrap();
        if x == 0 && y == 0 {
            break;
        }
        if x < y {
            println!("{} {}", x, y);
        } else {
            println!("{} {}", y, x);
        }
    }
}

3_D: How Many Divisors?

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).ok();
    let mut iter = buf.split_whitespace();

    let a: i32 = iter.next().unwrap().parse().unwrap();
    let b: i32 = iter.next().unwrap().parse().unwrap();
    let c: i32 = iter.next().unwrap().parse().unwrap();
    let mut ans = 0;

    for i in a..b + 1 {
        if c % i == 0 {
            ans += 1;
        }
    }
    println!("{}", ans);
}

4_A: A / B Problem

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let a: i32 = iter.next().unwrap().parse().unwrap();
    let b: i32 = iter.next().unwrap().parse().unwrap();

    println!("{} {} {}", a / b, a % b, (a as f64) / (b as f64));
}

4_B: Circle

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let r: f64 = iter.next().unwrap().parse().unwrap();
    let pi: f64 = std::f64::consts::PI;

    println!("{} {}", r * r * pi, 2.0 * r * pi);
}

4_C: Simple Calculator

最初はopをcharで読み込むコードを書いていて手元では正しく動作していたが、AOJで使われているバージョンのRustではCompile ErrorだったのでStringを使うことにした。

use std::io;

fn main() {
    loop {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();

        let a: i32 = iter.next().unwrap().parse().unwrap();
        let op: String = iter.next().unwrap().parse().unwrap();
        let b: i32 = iter.next().unwrap().parse().unwrap();

        println!(
            "{}",
            match op.as_ref() {
                "+" => a + b,
                "-" => a - b,
                "*" => a * b,
                "/" => a / b,
                "?" => break,
                _ => panic!("Invalid operation!"),
            }
        );
    }
}

4_D: Min, Max and Sum

n
a_1 a_2 ... a_n

という形式の入力をどう受け取ればいいのかよく分からなかった。 調べると出てくるtanakhさんのマクロを参考にread_to_string() を使ったらそれっぽい動作にすることができたが、ターミナルで実行するときに入力が終わったらCtrl+Dを押す必要があるのが気持ち悪い。

use std::io;
use std::io::Read;

fn main() {
    let mut buf = String::new();
    io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let n: usize = iter.next().unwrap().parse().unwrap();
    let mut a: Vec<i32> = Vec::with_capacity(n);

    for _ in 0..n {
        let a_i: i32 = iter.next().unwrap().parse().unwrap();
        a.push(a_i);
    }

    a.sort();

    let mut sum: i64 = 0;
    for i in 0..n {
        sum += a[i] as i64;
    }

    println!("{} {} {}", a[0], a[n - 1], sum);}

for文を使ってるのにわざわざ添字を使っているのは、イテレータ経由でアクセスした要素をキャストするとコンパイラに怒られたからなのだが、いろいろやってたら

for i in a.iter() {
    sum += *i as i64;
}

で動かすことができた。 （sumの型がi32のときはfor文の中身をsum += iにしてもコンパイルが通ったが、これは&Tから*const Tへの型強制が暗黙に行われたから？cf. 型間のキャスト）

5_A: Print a Rectangle

use std::io;
use std::io::Read;

fn main() {
    loop {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();

        let H: i32 = iter.next().unwrap().parse().unwrap();
        let W: i32 = iter.next().unwrap().parse().unwrap();

        if H == 0 && W == 0 {
            break;
        }

        for _ in 0..H {
            for _ in 0..W {
                print!("#");
            }
            println!("");
        }
        println!("");
    }
}

5_B: Print a Frame

use std::io;
use std::io::Read;

fn main() {
    loop {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();

        let H: i32 = iter.next().unwrap().parse().unwrap();
        let W: i32 = iter.next().unwrap().parse().unwrap();

        if H == 0 && W == 0 {
            break;
        }

        for _ in 0..W {
            print!("#");
        }
        println!("");
        for _ in 0..H-2 {
            print!("#");
            for _ in 0..W-2 {
                print!(".");
            }
            println!("#");
        }
        for _ in 0..W {
            print!("#");
        }
        println!("\n");
    }
}

5_C: Print a Chessboard

use std::io;
use std::io::Read;

fn main() {
    loop {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();

        let H: i32 = iter.next().unwrap().parse().unwrap();
        let W: i32 = iter.next().unwrap().parse().unwrap();

        if H == 0 && W == 0 {
            break;
        }

        for i in 0..H {
            for j in 0..W {
                if (i + j) % 2 == 0 {
                    print!("#");
                } else {
                    print!(".");
                }
            }
            println!("");
        }
        println!("");
    }
}

5_D: Structured Programming

同じ終了判定が2ヶ所にあるのが汚いが、これ以外にパッと書く方法が思い浮かばなかった。

use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let n: i32 = iter.next().unwrap().parse().unwrap();

    let mut i = 1;
    loop {
        let mut x = i;
        if x % 3 == 0 {
            print!(" {}", i);
            i += 1;
            if i <= n {
                continue;
            } else {
                break;
            }
        }
        loop {
            if x % 10 == 3 {
                print!(" {}", i);
                break;
            }
            x /= 10;
            if x == 0 {
                break;
            }
        }
        i += 1;
        if i <= n {
            continue;
        } else {
            break;
        }
    }
    println!("");
}