fn main() {
    let x: i32 = 1_000_000_000;
    let y: i32 = 1_000_000_000;
    println!("{}", x * y);
}

Because it won't even compile.

error: this arithmetic operation will overflow
 --> foo.rs:4:20
  |
4 |     println!("{}", x * y);
  |                    ^^^^^ attempt to compute `1000000000_i32 * 1000000000_i32`, which would overflow
  |
  = note: `#[deny(arithmetic_overflow)]` on by default

error: aborting due to previous error

Overflow!

$$$10^9 \times 10^9$$$ does not fit inside the i32 type which can only hold numbers up to $$$2^{31}-1$$$. To store large numbers like $$$10^{18}$$$, you'll need bigger integer types like i64.

fn test(v: Vec<i32>) -> usize {
    v.len()
}

fn main() {
    const N: usize = 1_000_000;
    let mut sum = 0;
    let v = vec![0; N];
    for _i in 1..=N {
        sum += test(v);
    }
    println!("{}", sum);
}

You guessed correctly! It won't compile.

error[E0382]: use of moved value: `v`
  --> foo.rs:10:21
   |
8  |     let v = vec![0; N];
   |         - move occurs because `v` has type `Vec<i32>`, which does not implement the `Copy` trait
9  |     for _i in 1..=N {
   |     --------------- inside of this loop
10 |         sum += test(v);
   |                     ^ value moved here, in previous iteration of loop
   |
note: consider changing this parameter type in function `test` to borrow instead if owning the value isn't necessary
  --> foo.rs:1:12
   |
1  | fn test(v: Vec<i32>) -> usize {
   |    ----    ^^^^^^^^ this parameter takes ownership of the value
   |    |
   |    in this function
help: consider cloning the value if the performance cost is acceptable
   |
10 |         sum += test(v.clone());
   |                      ++++++++

Types like Vec don't have the Copy trait to avoid accidental copying. So, it is moved into the test function. As you can see from the extremely helpful compile error messages, you moved v into a function during the first iteration of the loop, so you can't use it in the next iterations.

How to fix this? The compiler already told you the answer! You can either borrow the parameter (&Vec instead of Vec), or add .clone() to get an owned version of v. (And as the compiler message suggests, the second method will be slower.)

use std::io::{stdin, BufRead};

const N: usize = 100_000;

fn main() {
    let test_cases = 100_000;
    for _i in 0..test_cases {
        let a = vec![0; N];
        let n = stdin().lock().lines().next().parse();
        let mut sum: i32 = 0;
        for i in 0..n {
            sum += a[i];
        }
        println!("{}", sum);
    }
    // it is guaranteed that total sum of n is <= 100000
}

You guessed correctly again! It won't compile.

error[E0599]: no method named `parse` found for enum `Option` in the current scope
 --> foo.rs:9:47
  |
9 |         let n = stdin().lock().lines().next().parse();
  |                                               ^^^^^ method not found in `Option<Result<String, std::io::Error>>`

This is because a BufRead returns a Result<String, std::io::Error> when you read a line. The lines() method returns an iterator of lines. The first() method returns the first value of an iterator, which can be None. Its type is Option<Result<String, std::io::Error>>. Finally, the parse() method parses the string into a number, which may fail, so it returns a Result.

The correct code is to get the "success" values inside Options and Results! You can do it with unwrap (NOT RECOMMENDED). For example: let n = stdin().lock().lines().next().unwrap().unwrap().parse().unwrap();.

However, this is considered bad pratice, as you should always handle the error and none values properly.

fn main() {
    const N: usize = 5;
    let a = [0; N];
    a.fill(1);
    println!("{:?}", a);
}

Because it won't compile.

error[E0596]: cannot borrow `a` as mutable, as it is not declared as mutable
 --> foo.rs:4:5
  |
3 |     let a = [0; N];
  |         - help: consider changing this to be mutable: `mut a`
4 |     a.fill(1);
  |     ^^^^^^^^^ cannot borrow as mutable

Since you modify a, you need to declare it as mutable with let mut a = [0; N];.

Because endl isn't a thing in Rust.

By the way, println! is also quite slow. If you need to print many lines, consider using a BufWriter or converting all lines to strings first, joining those strings with "\n" then printing the joined string all at once.

Rust has the functions pow(), ilog(), ilog2(), etc. for integer types. These are pretty safe to use, since their results are either integers or rounded to integers so are precise. If you worry about overflowing, functions like checked_pow() return Option to help you check cases where integer overflows happen.

fn main() {
    assert_eq!(5i32.pow(2), 25);
    assert_eq!(69i32.ilog(3), 3);
}

fn main() {
    let v = Vec::<i32>::new();
    println!("{}", v.len() - 1);
}

Because of integer overflow.

thread 'main' panicked at 'attempt to subtract with overflow', foo.rs:3:20
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

v.len() is an unsigned integer 0 and is the lowest number an unsigned type can represent. Attempting to subtract a positive value from it will result in an overflow.

fn main() {
    let a = 1;
    let b = 3;
    // we want to take a + b and bitwise & it with 3
    let result = a + b & 3;
    println!("{}", result);
}

The precedence of the + operator is higher than the & operator, so the operator + operates first, meaning a+b = 4 executes and then the & operator comes into play, so 4&3 executes and the output is clearly 0 for this.

Check out this to learn more about Rust operator precedence.

use std::collections::HashMap;
use std::io::{stdin, BufRead};

fn main() {
    const N: usize = 30_000;
    let mut mp = HashMap::<i64, usize>::new();
    for _i in 0..N {
        let x = stdin().lock().lines().next().unwrap().unwrap().parse().unwrap();
        *mp.entry(x).or_insert(0) += 1;
    }
    println!("{}", mp.values().max().unwrap())
}

Rust's HashMap by default uses a cryptographic hash function, which is also seeded by secure random numbers. This means it is extremely difficult to generate a hash collision in advance that blows up its complexity.

use std::collections::HashMap;

fn main() {
    let mut mp = HashMap::<i64, usize>::new();
    // add 1 to 5 to the map
    for k in 0..5 {
        *mp.entry(k).or_insert(0) += 1;
    }
    let mut cnt: usize = 0;
    // check how many numbers in the keys exist in the map
    for k in mp.keys() {
        if *mp.entry(*k).or_insert(0) != 0 {
            cnt += 1;
        }
    }
    // now print the size of the map
    println!("{} {}", cnt, mp.len())
}

Wrong, it's actually compile error.

error[E0502]: cannot borrow `mp` as mutable because it is also borrowed as immutable
  --> foo.rs:11:13
   |
10 |     for k in mp.keys() {
   |              ---------
   |              |
   |              immutable borrow occurs here
   |              immutable borrow later used here
11 |         if *mp.entry(*k).or_insert(0) != 0 {
   |             ^^^^^^^^^^^^ mutable borrow occurs here

In Rust, when you have a mutable borrow of a variable, then you cannot have other references to that variable, even immutable ones. The borrow checker of Rust is an extremely powerful feature, as it prevents many bugs (usually data races) that are caused by accidentally changing values while using them. You can learn more about references and borrowing by smashing me.

fn main() {
    const N: usize = 1_000_000;
    let mut s = String::new();
    for _i in 0..N {
        s = s + "ゑ";
    }
    println!("{}", s)
}

It's not $$$O(n^2)$$$! It's $$$O(n)$$$ actually.

This is because in Rust, the + operator of Strings consumes the value on the left hand side, while the right hand side is used to extend the buffer of the left string. This means that s = s + "ゑ"; is equivalent to pushing a string to s and then moving it to itself, without allocating a new String. This operation takes $$$O(1)$$$ amortized time.