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.