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.

Practice

1. What does it mean when a variable is immutable in Rust?

easy

A. It can be changed anytime during the program.

B. Its value cannot be changed after it is set.

C. It is only accessible inside a function.

D. It automatically becomes mutable after declaration.

Solution

1. Step 1: Understand Rust variable default behavior

   In Rust, variables are immutable by default, meaning their values cannot be changed once assigned.

2. Step 2: Interpret immutability meaning

   Immutability means the value is fixed and cannot be reassigned or modified after initialization.

3. Final Answer:

   Its value cannot be changed after it is set. -> Option B

4. Quick Check:

   Immutable means unchangeable = A [OK]

Hint: Immutable means no changes allowed after assignment [OK]

Common Mistakes:

• Thinking immutable means variable is hidden or local
• Confusing immutability with mutability
• Assuming variables change automatically

2. Which of the following is the correct way to declare a mutable variable named count with value 10 in Rust?

easy

A. let mut count = 10;

B. let count = 10;

C. mut let count = 10;

D. count mut = 10;

Solution

1. Step 1: Recall Rust syntax for mutable variables

   In Rust, to make a variable mutable, you write let mut variable_name = value;.

2. Step 2: Check each option

   let mut count = 10; uses the correct syntax. The other options use incorrect syntax.

3. Final Answer:

   let mut count = 10; -> Option A

4. Quick Check:

   Mutable variable syntax = let mut name = value [OK]

Hint: Use 'let mut' before variable name for mutability [OK]

Common Mistakes:

• Placing 'mut' after variable name
• Using 'mut let' instead of 'let mut'
• Omitting 'mut' for mutable variables

3. What will be the output of this Rust code?

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

medium

A. 10

B. Compilation error

C. Runtime error

D. 5

Solution

1. Step 1: Analyze variable declaration and assignment

   Variable x is declared as immutable with value 5. The reassignment line is commented out, so it does not execute.

2. Step 2: Understand the print statement

   The program prints the value of x, which remains 5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Immutable variable unchanged prints original value = 5 [OK]

Hint: Commented reassignment means original value prints [OK]

Common Mistakes:

• Assuming reassignment happens despite comment
• Expecting compilation error due to reassignment line
• Confusing output with reassignment value

4. Identify the error in this Rust code snippet:

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

medium

A. Cannot assign to immutable variable `x`

B. Variable `x` is not declared

C. println! macro syntax is incorrect

D. Missing semicolon after let statement

Solution

1. Step 1: Check variable mutability

   Variable x is declared immutable by default with let x = 3;.

2. Step 2: Identify reassignment error

   Trying to assign x = 4; causes a compile-time error because x is immutable.

3. Final Answer:

   Cannot assign to immutable variable `x` -> Option A

4. Quick Check:

   Immutable variables cannot be reassigned = D [OK]

Hint: Reassigning immutable variable causes compile error [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming println! syntax error
• Ignoring immutability rules

5. You want to create a counter that increases by 1 each time a function is called. Which of these Rust code snippets correctly uses an immutable variable to achieve this behavior?

hard

A. Use let mut count = 0; and increment inside the function.

B. Use let count = 0; and reassign count = count + 1; inside the function.

C. Use let count = 0; and return count + 1 without changing count.

D. Use let mut count = 0; but never increment it.

Solution

1. Step 1: Understand immutability and counter logic

   An immutable variable cannot be changed, so you cannot increment it directly.

2. Step 2: Analyze options for correct usage

   Use let count = 0; and return count + 1 without changing count. uses an immutable variable count and returns count + 1 without changing count, which respects immutability and simulates increment.

3. Final Answer:

   Use let count = 0; and return count + 1 without changing count. -> Option C

4. Quick Check:

   Immutable means no change; return new value instead = A [OK]

Hint: Immutable vars can't change; return new value instead [OK]

Common Mistakes:

• Trying to reassign immutable variable
• Forgetting to declare variable mutable when needed
• Ignoring that immutable variables can't be incremented