Immutable variables in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

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

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

Rust

fn main() {
    let x = 5;
    // x = 10; // This line is commented out
    println!("{}", x);
}

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

B 10

C 5

D 0

💡 Hint

Remember that variables declared with let are immutable by default in Rust.

The variable x is immutable and initialized to 5. The commented line does not run, so x remains 5. The program prints 5.

❓ Predict Output

intermediate

What error does this Rust code produce?

What error will this Rust code produce when compiled?

Rust

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

A Compilation error: cannot assign twice to immutable variable `y`

B Prints 4

C Runtime error: cannot assign to immutable variable

D Prints 3

💡 Hint

Try to assign a new value to an immutable variable in Rust.

Variables declared with let are immutable by default. Assigning a new value to y 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 a = 10;
    let a = a + 5;
    a = 20;
    println!("{}", a);
}

A Because the second <code>a</code> shadows the first and is immutable, so <code>a = 20</code> is invalid

B Because Rust does not allow variable shadowing

C Because <code>a</code> is mutable but not initialized

D Because <code>a</code> is declared twice with the same value

💡 Hint

Think about variable shadowing and immutability in Rust.

The second a shadows the first and is immutable. Trying to assign a = 20 causes a compile error because a is not mutable.

🧠 Conceptual

advanced

Which statement about Rust immutable variables is true?

Choose the correct statement about immutable variables in Rust.

A Immutable variables can be changed anytime without any special syntax.

B Immutable variables can be reassigned only if declared with <code>mut</code> keyword.

C Immutable variables are automatically mutable if used inside functions.

D Immutable variables cannot be changed after assignment unless shadowed by a new variable with the same name.

💡 Hint

Recall how shadowing works in Rust.

Immutable variables cannot be changed after assignment. However, you can declare a new variable with the same name (shadowing) which can have a different value.

❓ Predict Output

expert

What is the output of this Rust code involving immutable and mutable variables?

Analyze the code and select the output it produces.

Rust

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

A 7

B 8

C Compilation error due to reassignment of immutable variable

D 6

💡 Hint

Consider how shadowing and mutability interact in this code.

The first x is 5, shadowed by x = 6, then shadowed by mutable x = 7. Then x is incremented to 8 and printed.