Mutable variables in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a mutable variable named count with initial value 5.

Rust

let [1] count = 5;

Drag options to blanks, or click blank then click option'

Avar

Bmut

Cconst

Dlet

Attempts:

3 left

💡 Hint

Common Mistakes

Using var instead of let.

Forgetting to add mut for mutability.

Using const which creates an immutable constant.

In Rust, to declare a mutable variable, you use let mut. The keyword mut makes the variable mutable.

2fill in blank

medium

Complete the code to change the value of the mutable variable score to 10.

Rust

let mut score = 5;
score [1] 10;

Drag options to blanks, or click blank then click option'

A=>

B==

C=

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of = for assignment.

Using => which is not valid here.

To assign a new value to a mutable variable in Rust, use the single equals sign =.

3fill in blank

hard

Fix the error in the code by making the variable name mutable so it can be changed.

Rust

[1] name = "Alice";
name = "Bob";

Drag options to blanks, or click blank then click option'

Alet mut

Bconst

Cmut

Dvar

Attempts:

3 left

💡 Hint

Common Mistakes

Using only mut without let.

Using const which is immutable.

Using var which is not valid in Rust.

In Rust, to declare a mutable variable, you write let mut before the variable name.

4fill in blank

hard

Fill both blanks to create a mutable variable temperature and assign it the value 25.

Rust

[1] [2] temperature = 25;

Drag options to blanks, or click blank then click option'

Alet

Bmut

Cvar

Dconst

Attempts:

3 left

💡 Hint

Common Mistakes

Using var which is not valid in Rust.

Using const which creates an immutable variable.

Swapping the order of let and mut.

The correct way to declare a mutable variable in Rust is let mut followed by the variable name.

5fill in blank

hard

Fill all three blanks to declare a mutable variable speed, assign it 30, and then update it to 50.

Rust

[1] [2] speed = 30;
speed [3] 50;

Drag options to blanks, or click blank then click option'

Alet

Bmut

C=

Dconst

Attempts:

3 left

💡 Hint

Common Mistakes

Using const instead of let.

Forgetting mut to allow changing the variable.

Using == instead of = for assignment.

Declare a mutable variable with let mut, assign initial value with =, and update it with =.

Practice

1. What keyword do you use in Rust to make a variable mutable?

easy

A. let

B. var

C. change

D. mut

Solution

1. Step 1: Understand variable declaration in Rust

   Rust uses let to declare variables, but by default they are immutable.

2. Step 2: Identify how to make variables mutable

   Adding mut after let makes the variable mutable.

3. Final Answer:

   mut -> Option D

4. Quick Check:

   Use let mut for mutable variables [OK]

Hint: Remember: let mut makes variables changeable [OK]

Common Mistakes:

• Using 'var' instead of 'mut'
• Forgetting 'mut' and expecting change
• Using 'let' alone for mutable variables

2. Which of the following is the correct syntax to declare a mutable integer variable named x with value 5 in Rust?

easy

A. let mut x = 5;

B. var mut x = 5;

C. mut let x = 5;

D. let x = 5;

Solution

1. Step 1: Recall correct order of keywords

   In Rust, let comes first, then mut to mark mutability.

2. Step 2: Check each option's syntax

   let mut x = 5; uses let mut x = 5; which is correct. Others have wrong order or invalid keywords.

3. Final Answer:

   let mut x = 5; -> Option A

4. Quick Check:

   Correct syntax is let mut variable = value; [OK]

Hint: Always write let mut in that order [OK]

Common Mistakes:

• Swapping 'mut' and 'let'
• Using 'var' instead of 'let'
• Omitting 'mut' when variable changes

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

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

medium

A. 3

B. 2

C. 1

D. Compilation error

Solution

1. Step 1: Understand variable initialization and mutation

   The variable count starts at 1 and is mutable.

2. Step 2: Calculate the new value after addition

   Adding 2 to 1 gives 3, so count becomes 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Mutable variable updated correctly outputs 3 [OK]

Hint: Mutable lets you add and update variable values [OK]

Common Mistakes:

• Expecting original value without mutation
• Thinking code causes error without 'mut'
• Confusing output with variable name

4. Identify the error in this Rust code snippet:

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

medium

A. Missing semicolon after println!

B. Variable x is not declared

C. Cannot assign twice to immutable variable x

D. Incorrect println! syntax

Solution

1. Step 1: Check variable mutability

   Variable x is declared without mut, so it is immutable.

2. Step 2: Analyze reassignment attempt

   Assigning x = 20; tries to change an immutable variable, causing a compile error.

3. Final Answer:

   Cannot assign twice to immutable variable x -> Option C

4. Quick Check:

   Immutable variables cannot be reassigned [OK]

Hint: Add mut to allow variable reassignment [OK]

Common Mistakes:

• Ignoring need for 'mut' to reassign
• Thinking println! needs semicolon error
• Assuming variable is undeclared

5. You want to create a counter that increases by 1 every time a function is called. Which Rust code correctly uses a mutable variable to achieve this?

fn main() {
    let mut counter = 0;
    increment(&mut counter);
    increment(&mut counter);
    println!("{}", counter);
}

fn increment(count: &mut i32) {
    *count += 1;
}

hard

A. Code fails because counter is immutable

B. Code compiles and prints 2

C. Code prints 0 because counter is not updated

D. Code fails due to wrong function signature

Solution

1. Step 1: Check mutability of counter

   Counter is declared mutable with let mut counter = 0;.

2. Step 2: Understand function parameter and mutation

   Function increment takes a mutable reference and increases the value by 1 each call.

3. Step 3: Count increments and final output

   Called twice, counter increases from 0 to 2, then printed.

4. Final Answer:

   Code compiles and prints 2 -> Option B

5. Quick Check:

   Mutable variable with mutable reference updates correctly [OK]

Hint: Use let mut and mutable references to update variables [OK]

Common Mistakes:

• Forgetting 'mut' on variable or reference
• Passing immutable reference to function
• Expecting counter to update without mutable reference