Arithmetic operators in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using arithmetic operators?

Consider the following Rust code snippet. What will it print when run?

Rust

fn main() {
    let a = 10;
    let b = 3;
    let result = a % b + a / b * b;
    println!("{}", result);
}

A 10

B 3

C 9

D 1

💡 Hint

Remember the order of operations: division and multiplication happen before addition.

The expression is evaluated as (a % b) + ((a / b) * b). Here, a % b is 10 % 3 = 1, a / b is 10 / 3 = 3 (integer division), so 3 * 3 = 9. Adding 1 + 9 gives 10.

❓ Predict Output

intermediate

What is the value of x after this Rust code runs?

Look at this Rust code. What is the final value of x?

Rust

fn main() {
    let mut x = 5;
    x += 3 * 2 - 4 / 2;
    println!("{}", x);
}

A 8

B 11

C 9

D 10

💡 Hint

Calculate the expression on the right side first, then add to x.

The expression is 3 * 2 - 4 / 2 = 6 - 2 = 4. Then x += 4 means x = 5 + 4 = 9.

❓ Predict Output

advanced

What does this Rust code print?

Analyze this Rust code snippet and determine its output.

Rust

fn main() {
    let a = 7;
    let b = 2;
    let c = a / b;
    let d = a as f64 / b as f64;
    println!("{} {}", c, d);
}

A 3 3.5

B 3 3

C 3.5 3

D 3.5 3.5

💡 Hint

Integer division truncates, but casting to float allows decimal division.

a / b is integer division: 7 / 2 = 3. Casting to f64 makes it floating point division: 7.0 / 2.0 = 3.5.

❓ Predict Output

advanced

What is the output of this Rust code with mixed arithmetic?

What will this Rust program print?

Rust

fn main() {
    let x = 4;
    let y = 3;
    let z = (x + y) * (x - y) / y;
    println!("{}", z);
}

A 7

B 2

C 1

D 3

💡 Hint

Calculate inside parentheses first, then multiply, then divide.

(4 + 3) = 7, (4 - 3) = 1, so 7 * 1 = 7, then 7 / 3 = 2 (integer division).

❓ Predict Output

expert

What is the output of this Rust code involving overflow with wrapping arithmetic?

Consider this Rust code using wrapping_add. What will it print?

Rust

fn main() {
    let max = u8::MAX; // 255
    let result = max.wrapping_add(10);
    println!("{}", result);
}

A 0

B 265

C 10

D 9

💡 Hint

Wrapping addition wraps around on overflow instead of panicking.

u8 max is 255. Adding 10 wraps around: 255 + 10 = 265 mod 256 = 9.