Программы на Rust компилируются на сервере с помощью Rust 1.75.0 x64. Компилятор запускается со следующими опциями:

rustc -O %1

Вы можете скачать компилятор на официальном сайте.

Примеры решения задач

Пример решения задачи 1000. A + B problem на Rust:

use std::io;

fn main() {
    let mut input = String::new();

    io::stdin()
        .read_line(&mut input)
        .unwrap();

    let mut s = input.trim().split(' ');

    let a_str = s.next().unwrap();
    let a: i32 = a_str.parse().unwrap();

    let b_str = s.next().unwrap();
    let b: i32 = b_str.parse().unwrap();

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

Более продвинутое и эффективное решение этой же задачи:

use std::io;

fn main() {
    let mut input = String::new();

    io::stdin()
        .read_line(&mut input)
        .expect("correct input");
    let res = input.trim()
                   .split(' ')
                   .map(|a| a.parse::<i32>())
                   .map(|a| a.expect("parsed integer"))
                   .fold(0i32, |sum, a| sum + a);

    println!("{}", res);
}

Пример решения задачи 1001. Обратный корень на Rust:

use std::io;
use std::io::prelude::*;

fn main() {
    let mut v: Vec<i64> = Vec::new();
    let stdin = io::stdin();

    for t in stdin.lock().lines() {
        let cur_line = t.unwrap();
        for u in cur_line.split(' ') {
            let cur_txt = u.trim();
            if cur_txt.len() > 0 {
                let cur_num: i64 = cur_txt.parse().unwrap();
                v.push(cur_num);
            }
        }
    }
    let mut i = v.len();
    while i > 0 {
        i -= 1;
        let f_num = v[i] as f64;
        println!("{:.*}", 4, f_num.sqrt());
    }
}

Более продвинутое и эффективное решение этой же задачи:

use std::io::{self, BufReader};
use std::io::prelude::*;

fn solve(input: &mut Read, output: &mut Write) {
    let reader = BufReader::new(input);
    let mut v: Vec<i64> = Vec::new();

    for t in reader.lines()
                   .map(|a| a.expect("correct input")) {
        for u in t.split(' ')
                  .map(|a| a.trim())
                  .filter(|a| a.len() > 0)
                  .map(|a| a.parse::<i64>().expect("parsed integer")) {
            v.push(u);
        }
    }

    for u in v.into_iter().rev().map(|a| a as f64) {
        writeln!(output, "{:.*}", 4, u.sqrt()).expect("valid output");
    }
}

fn main() {
    solve(&mut io::stdin(), &mut io::stdout());
}

Tests

Rust имеет встроенную систему модульного тестирования. Тестовая секция определяется специальным атрибутом #[test]. Она будет скомпилирована только если задана специальная опция:

rustc --test main.rs

Пример чтения тестовых данных из файла (для решения задачи 1001 выше):

fn solve(input: &mut Read, output: &mut Write) {
    ...
}

fn main() {
    solve(&mut io::stdin(), &mut io::stdout());
}

#[cfg(test)]
mod tests {
    use std::fs::File;
    use solve;

    #[test]
    fn basic_test() {
        let mut f = File::open("test1.txt").expect("correct test");
        let mut buf: Vec<u8> = Vec::new();

        solve(&mut f, &mut buf);

        let res = String::from_utf8(buf).expect("valid string");
        assert_eq!(res,
"2297.0716
936297014.1164
0.0000
37.7757
");
    }
}

Прежние компиляторы

• Компилятор Rust 1.9.0 x86 использовался до 12 апреля 2018 года.
• Компилятор Rust 1.25.0 x86 использовался до 1 сентября 2020 года.
• Компилятор Rust 1.45.0 x64 использовался до 22 января 2022 года.
• Компилятор Rust 1.58.1 x64 использовался до 22 января 2024 года.