Mutable variables in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code with mutable variables?

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

Rust

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

A Compilation error

B 5

C 8

D 0

💡 Hint

Remember that mut allows the variable to be changed.

The variable x is declared mutable with mut. It starts at 5, then 3 is added, so the output is 8.

❓ Predict Output

intermediate

What error does this Rust code produce?

What error will this Rust code produce?

Rust

fn main() {
    let x = 10;
    x = 20;
    println!("{}", x);
}

A Prints 10

B Prints 20

C Runtime error: variable not mutable

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

💡 Hint

Variables are immutable by default in Rust.

The variable x is not declared mutable, so assigning a new value causes a compile-time error.

🔧 Debug

advanced

Why does this Rust code fail to compile?

Examine the code below. Why does it fail to compile?

Rust

fn main() {
    let mut x = 1;
    let y = &x;
    x = 2;
    println!("{}", y);
}

A Cannot assign to `x` because it is borrowed as immutable by `y`

B Prints 2

C Prints 1

D Compilation error: `y` is not initialized

💡 Hint

Rust enforces borrowing rules to prevent data races.

The variable x is borrowed immutably by y. You cannot mutate x while an immutable borrow exists.

🧠 Conceptual

advanced

Which statement about mutable variables in Rust is true?

Choose the correct statement about mutable variables in Rust.

A Variables are immutable by default and must be declared with <code>mut</code> to be changed.

B All variables are mutable by default unless declared with <code>const</code>.

C Mutable variables can be changed even when borrowed immutably.

D Declaring a variable with <code>let mut</code> disables Rust's ownership rules.

💡 Hint

Think about Rust's default variable behavior.

Rust variables are immutable by default. You must use mut to allow changes. Ownership and borrowing rules still apply.

❓ Predict Output

expert

What is the output of this Rust code involving mutable references?

Analyze the code and select the output it produces.

Rust

fn main() {
    let mut x = 10;
    {
        let y = &mut x;
        *y += 5;
    }
    println!("{}", x);
}

A 10

B 15

C Compilation error: cannot borrow `x` as mutable more than once

D Runtime error: mutable borrow out of scope

💡 Hint

Mutable references allow changing the value they point to.

The mutable reference y changes x by adding 5. After the inner scope ends, x is 15.