Assignment operators in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

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

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

Rust

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

A 16

B 10

C 13

D 8

💡 Hint

Remember that += adds and assigns, and *= multiplies and assigns.

Starting with x = 5, x += 3 makes x = 8. Then x *= 2 makes x = 16. So the output is 16.

❓ Predict Output

intermediate

What value does variable y hold after this code?

Analyze the Rust code below and determine the final value of y.

Rust

fn main() {
    let mut y = 10;
    y -= 4;
    y /= 3;
    println!("{}", y);
}

A 3

B 2

C 1

D 0

💡 Hint

Integer division truncates towards zero in Rust.

Starting with y = 10, y -= 4 makes y = 6. Then y /= 3 divides 6 by 3, resulting in 2.

❓ Predict Output

advanced

What is printed by this Rust code using bitwise assignment operators?

Look at the Rust code below. What will it print?

Rust

fn main() {
    let mut z = 0b1100u8; // binary 12
    z &= 0b1010; // binary 10
    z |= 0b0101; // binary 5
    println!("{:b}", z);
}

A 1101

B 1000

C 1111

D 1010

💡 Hint

Apply bitwise AND then OR step by step on the binary numbers.

Start: z = 1100 (12)
After z &= 1010: z = 1000 (8)
After z |= 0101: z = 1101 (13)
Printed in binary: 1101

❓ Predict Output

advanced

What error does this Rust code produce?

Examine the Rust code below. What error will it cause when compiled?

Rust

fn main() {
    let x = 5;
    x += 1;
    println!("{}", x);
}

A no error, prints 6

B error: expected `;` after expression

C error: mismatched types

D error: cannot assign twice to immutable variable `x`

💡 Hint

Variables are immutable by default in Rust unless declared mut.

The variable x is not mutable, so x += 1 causes a compile-time error about assigning to an immutable variable.

🧠 Conceptual

expert

How many times is the variable a updated in this Rust code?

Consider the following Rust code snippet. How many times is the variable a updated (assigned a new value) during execution?

Rust

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

A 5

B 4

C 6

D 7

💡 Hint

Count each assignment operator usage as one update.

The variable a is initialized once, then updated 5 times by the assignment operators: +=, *=, -=, /=, and %=. Each counts as one update.