Loop labels in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested loops with labels

What is the output of this Rust code using loop labels?

Rust

fn main() {
    let mut count = 0;
    'outer: loop {
        println!("Outer loop start");
        'inner: loop {
            count += 1;
            if count == 2 {
                break 'outer;
            }
            break 'inner;
        }
        println!("Outer loop end");
    }
    println!("Count: {}", count);
}

A

Outer loop start
Count: 2

B

Outer loop start
Outer loop end
Outer loop start
Count: 2

C

Outer loop start
Outer loop end
Count: 2

D

Outer loop start
Outer loop end
Outer loop start
Outer loop end
Count: 2

💡 Hint

Look at where the break statements with labels exit the loops.

The outer loop runs twice. First: prints 'Outer loop start', inner increments count to 1 and breaks 'inner', prints 'Outer loop end'. Second: prints 'Outer loop start', inner increments to 2 and breaks 'outer' without printing 'Outer loop end'. Then prints 'Count: 2'.

❓ Predict Output

intermediate

Value of variable after labeled loops

What is the value of variable `i` after running this Rust code?

Rust

fn main() {
    let mut i = 0;
    'counting_up: loop {
        i += 1;
        'counting_down: loop {
            i -= 1;
            break 'counting_up;
        }
    }
    println!("i = {}", i);
}

A i = 0

B i = 1

C i = -1

D Compilation error

💡 Hint

Check which loop the break statement exits and when increments/decrements happen.

The outer loop increments i to 1, then the inner loop decrements i to 0 and breaks the outer loop. Final value i = 0.

🔧 Debug

advanced

Identify the error with loop labels

What error does this Rust code produce?

Rust

fn main() {
    let mut x = 0;
    'outer: loop {
        'inner: loop {
            if x > 5 {
                break 'outer;
            }
            x += 1;
            break 'inner;
        }
        break 'inner;
    }
    println!("x = {}", x);
}

A x = 6

B error: unused label 'inner

C x = 1

D error: cannot break to label 'inner from outside its loop

💡 Hint

Check where the break statements with labels are used relative to their loops.

The break 'inner outside the inner loop causes a compile error because it tries to break to a label not in scope at that point.

📝 Syntax

advanced

Which option correctly uses loop labels to break outer loop?

Which code snippet correctly breaks the outer loop from inside the inner loop using labels?

A

fn main() {
    'outer: loop {
        loop {
            break 'outer;
        }
    }
}

B

fn main() {
    loop 'outer {
        loop {
            break 'outer;
        }
    }
}

C

fn main() {
    'outer: loop {
        loop {
            break outer;
        }
    }
}

D

fn main() {
    'outer: loop {
        loop {
            break 'inner;
        }
    }
}

💡 Hint

Remember the syntax for labeling loops and breaking to labels.

Option A uses correct syntax: 'outer: before outer loop and break 'outer; inside inner loop. A breaks to undefined 'inner, B has invalid label position after loop, C misses ' in break outer.

🚀 Application

expert

How many times does the inner loop run?

Consider this Rust code. How many times does the inner loop execute before the program ends?

Rust

fn main() {
    let mut count = 0;
    'outer: loop {
        'inner: loop {
            count += 1;
            if count == 3 {
                break 'outer;
            }
            break 'inner;
        }
    }
    println!("Count: {}", count);
}

A 1

B 2

C 3

D Infinite loop

💡 Hint

Count how many times the inner loop increments before breaking the outer loop.

The inner loop runs once per outer loop iteration. It increments count and breaks inner loop unless count == 3, then breaks outer loop. So inner loop runs 3 times total.