Mutable variables in Rust - Time & Space Complexity

Time Complexity: Mutable variables

O(n)

Understanding Time Complexity

Let's see how using mutable variables affects how long a program takes to run.

We want to know how the program's steps grow when we change the input size.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn sum_numbers(n: u32) -> u32 {
    let mut total = 0;
    for i in 1..=n {
        total += i;
    }
    total
}

This code adds numbers from 1 up to n using a mutable variable to keep the running total.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding each number to the total inside the loop.
• How many times: Exactly n times, once for each number from 1 to n.

How Execution Grows With Input

Each time n gets bigger, the loop runs more times, so the work grows steadily.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The number of steps grows directly with n; doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line with the size of the input.

Common Mistake

[X] Wrong: "Using a mutable variable makes the program faster or slower in a way that changes the time complexity."

[OK] Correct: The mutable variable just holds the running total; it doesn't add extra loops or steps. The main factor is how many times the loop runs.

Interview Connect

Understanding how loops and variables affect time helps you explain your code clearly and shows you know what makes programs faster or slower.

Self-Check

"What if we replaced the loop with recursion that sums numbers? How would the time complexity change?"

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