Rust is a great language, but not for competitive programming. It may increase in popularity as competitive programmers who also have real jobs switch to it for work and will be more inclined to keep it as their primary language for competitive programming, but even if Rust completely replaces C++ in the real world, I seriously doubt it will ever reach a double-digit share on platforms like CodeForces because the barrier of entry is so much higher compared to C++ and most other languages,

January 21st is Saturday though

Rust is getting increasingly more popular on CodeForces

13 people in #844, 6 in #843 — the same as 7 months ago...

Well, I had a hard time reading input in Rust without having a prewritten scanner. If the contest doesn't go well, I suggest you to do first several projecteuler.net problems (the rules of PE allow streaming and spoiling first 100 problems wherever you want); or maybe even start the stream earlier and practice them prior to the codeforces contest, as it seems more logical to do it in this order (basic stuff first, reading input second).

I am not a rustacean and speak from the position of somebody who also tried to take a glance at Rust in the recent past.

Note: Sorry for being odd one out among all red coders.

Peltora stream about to begin. This stream is going to make or break my Saturday. But very much excited for this. Hope to see some cool stuffs.

Hi,

I certainly agree that Rust is gaining popularity very fast. Here is good resource to start competitive programming in Rust.

Competitive Programming in Rust

It has basic functions at least start Competitive Programming in Rust.

Thank You

bro, you really wanna deal with borrow checker when you're a power user in CP? yeah no, I reckon python is the future.

why this code is failing to solve the problem https://codeforces.net/problemset/problem/1883/C 1883 C. Raspberries

use std::{ collections::VecDeque, fmt, io::{self, BufRead}, str::FromStr, };

struct Scanner { tokens: VecDeque, }

impl Scanner { pub fn new() -> Self { let stdin = io::stdin(); let mut tokens = VecDeque::new(); for line in stdin.lock().lines() { for token in line.unwrap().split_ascii_whitespace() { tokens.push_back(token.to_owned()); } } Self { tokens } }

pub fn next<T: FromStr>(&mut self) -> T
where
    <T as FromStr>::Err: fmt::Debug,
{
    T::from_str(&self.tokens.pop_front().unwrap()).unwrap()
}

}

fn main() { let mut input = Scanner::new(); let tests: i32 = input.next();

for _ in 0..tests {
    let n: i32 = input.next();
    let k: i32 = input.next();

    let mut myvec: Vec<i32> = Vec::new();
    let mut mysecondvec: Vec<i32> = Vec::new();
    let mut x: i32 = 0;

    for _ in 0..n {
        let num: i32 = input.next();
        myvec.push(-num % k);
    }

    if k == 4 {
        for i in 0..n {
            mysecondvec.push(myvec[i as usize] % 2);
        }
        mysecondvec.sort();
        x = mysecondvec[0] + mysecondvec[1];
        myvec.push(x);
    }

    let mut min_value = myvec.iter().min().unwrap();
    // Added this line to print the minimum value for each test case
    println!("{}", min_value);
}

}

it seems like it until you gotta as usize as i64 and as i32 1 million times