Scope of variables in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code with variable shadowing?

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

Rust

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

A 6\n5

B 6\n6

C 5\n6

D 5\n5

💡 Hint

Remember that inner let shadows the outer variable.

The inner block creates a new x equal to the outer x plus 1, so it prints 6. Outside the block, the original x remains 5.

❓ Predict Output

intermediate

What error does this Rust code produce due to variable scope?

What error will this Rust code produce when compiled?

Rust

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

A error: cannot find value `y` in this scope

B error: use of moved value: `y`

C error: expected `;` after expression

D No error, prints 10

💡 Hint

Variables declared inside a block are not accessible outside it.

The variable y is declared inside the inner block and is not visible outside. Trying to print it outside causes a 'not found in this scope' error.

🔧 Debug

advanced

Why does this Rust code fail to compile due to variable borrowing and scope?

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

Rust

fn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s;
    println!("{} {} {}", r1, r2, r3);
}

A Cannot borrow `s` as immutable because it is already borrowed as mutable

B No error, prints: hello hello hello

C Cannot print multiple references in one println!

D Cannot borrow `s` as mutable because it is also borrowed as immutable

💡 Hint

Rust enforces rules about mutable and immutable references coexisting.

You cannot have a mutable reference while immutable references to the same variable exist. Here, `r1` and `r2` are immutable references, so `r3` mutable borrow is invalid.

❓ Predict Output

advanced

What is the output of this Rust code with nested scopes and variable shadowing?

What will this Rust program print?

Rust

fn main() {
    let a = 1;
    {
        let a = 2;
        {
            let a = 3;
            println!("{}", a);
        }
        println!("{}", a);
    }
    println!("{}", a);
}

A 3\n3\n3

B 1\n2\n3

C 3\n2\n1

D 1\n1\n1

💡 Hint

Each inner block shadows the variable from the outer block.

The innermost block prints 3, the middle block prints 2, and the outer block prints 1.

❓ Predict Output

expert

What is the value of `x` after this Rust code runs with shadowing and mutation?

After running this Rust code, what is the final value of x printed?

Rust

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

A Compilation error due to borrowing

B 6

C 7

D 5

💡 Hint

Understand how mutable references and shadowing work together.

The mutable reference x inside the block points to the outer x. Incrementing it changes the original x to 6.

Practice

1. What does the scope of a variable in Rust determine?

easy

A. Where the variable can be accessed or used

B. The type of the variable

C. The value stored in the variable

D. The memory size of the variable

Solution

1. Step 1: Understand the meaning of scope

   Scope means the part of the code where a variable is valid and can be used.

2. Step 2: Identify what scope controls

   Scope controls access to the variable, not its type, value, or memory size.

3. Final Answer:

   Where the variable can be accessed or used -> Option A

4. Quick Check:

   Scope = access area [OK]

Hint: Scope means where you can use the variable [OK]

Common Mistakes:

• Confusing scope with variable type
• Thinking scope controls variable value
• Mixing scope with memory size

2. Which of the following is the correct way to declare a variable inside a block in Rust?

easy

A. var x = 5;

B. let x = 5;

C. int x = 5;

D. declare x = 5;

Solution

1. Step 1: Recall Rust variable declaration syntax

   Rust uses let keyword to declare variables.

2. Step 2: Check each option

   Only let x = 5; is valid Rust syntax; others are from other languages or invalid.

3. Final Answer:

   let x = 5; -> Option B

4. Quick Check:

   Rust variables start with let [OK]

Hint: Rust variables start with let keyword [OK]

Common Mistakes:

• Using var instead of let
• Using type declarations like int
• Using declare keyword

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

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

medium

A. 10\n10

B. 20\n20

C. 10\n20

D. 20\n10

Solution

1. Step 1: Identify variable shadowing inside inner block

   Inside the inner block, x is redefined as 20, shadowing outer x.

2. Step 2: Trace the print statements

   First print shows inner x = 20; second print shows outer x = 10.

3. Final Answer:

   20 10 -> Option D

4. Quick Check:

   Inner shadow = 20, outer original = 10 [OK]

Hint: Inner block shadows outer variable [OK]

Common Mistakes:

• Ignoring shadowing and printing outer value twice
• Assuming inner variable changes outer variable
• Confusing print order

4. Identify the error in this Rust code snippet:

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

medium

A. Variable y is used outside its scope

B. Missing semicolon after let y = 5

C. println! macro is misspelled

D. No error, code runs fine

Solution

1. Step 1: Check where y is declared and used

   Variable y is declared inside inner block and goes out of scope after block ends.

2. Step 2: Analyze usage of y outside block

   Using y in println! outside block causes error because y is not visible there.

3. Final Answer:

   Variable y is used outside its scope -> Option A

4. Quick Check:

   Use inside scope only [OK]

Hint: Variables vanish outside their block scope [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming println! is wrong
• Ignoring variable scope rules

5. Consider this Rust code:

fn main() {
    let mut count = 0;
    for i in 0..3 {
        let count = count + i;
        println!("{}", count);
    }
    println!("Final count: {}", count);
}

What will be the output and why?

hard

A. 0\n1\n2\nFinal count: 6

B. 0\n1\n2\nFinal count: 2

C. 0\n1\n2\nFinal count: 0

D. Compilation error due to variable shadowing

Solution

1. Step 1: Understand variable shadowing inside the loop

   Inside the loop, count is shadowed by a new variable count equal to outer count plus i. Outer count remains unchanged.

2. Step 2: Trace loop iterations and prints

   Iterations: i=0 -> inner count=0, print 0; i=1 -> inner count=1, print 1; i=2 -> inner count=2, print 2. Outer count stays 0.

3. Step 3: Final print shows outer count

   After loop, outer count is still 0, so prints "Final count: 0".

4. Final Answer:

   0 1 2 Final count: 0 -> Option C

5. Quick Check:

   Shadowing hides outer count, outer unchanged [OK]

Hint: Shadowing inside loop doesn't change outer variable [OK]

Common Mistakes:

• Assuming outer count changes inside loop
• Confusing shadowing with mutation
• Expecting sum accumulation in outer count