Loop construct in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a nested loop with break

What is the output of this Rust code snippet?

Rust

fn main() {
    let mut count = 0;
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if i * j > 4 {
                break 'outer;
            }
            count += 1;
        }
    }
    println!("{}", count);
}

A 6

B 9

C 5

D 4

💡 Hint

Remember that break with label exits the outer loop immediately.

The inner loop increments count while i*j <= 4. When i=2 and j=3, i*j=6 > 4, so break 'outer stops all loops. The count increments 5 times before breaking.

🧠 Conceptual

intermediate

Understanding loop labels in Rust

Which statement best describes the purpose of loop labels in Rust?

A They automatically count the number of iterations.

B They are used to name variables inside loops.

C They define the type of loop (for, while, or loop).

D They allow breaking or continuing an outer loop from inside an inner loop.

💡 Hint

Think about how to control nested loops.

Loop labels let you specify which loop to break or continue when loops are nested, avoiding ambiguity.

❓ Predict Output

advanced

Output of a loop with match and continue

What is the output of this Rust program?

Rust

fn main() {
    let mut x = 0;
    let mut result = 0;
    loop {
        x += 1;
        match x {
            3 => continue,
            5 => break,
            _ => result += x,
        }
    }
    println!("{}", result);
}

A 7

B 9

C 10

D 15

💡 Hint

Remember that continue skips the rest of the loop body for that iteration.

The loop adds x to result except when x is 3 (skips adding) and stops when x is 5. So result = 1+2+4 = 7 + 5 skipped + break at 5.

🔧 Debug

advanced

Identify the error in this loop code

What error will this Rust code produce when compiled?

Rust

fn main() {
    let mut i = 0;
    while i < 5 {
        println!("{}", i);
        i = i + 1;
    }
}

A SyntaxError: missing semicolon after i = i + 1

B RuntimeError: infinite loop

C TypeError: cannot add integer to mutable variable

D No error, prints numbers 0 to 4

💡 Hint

Check punctuation carefully in Rust statements.

Rust requires semicolons at the end of statements. Missing semicolon after i = i + 1 causes a syntax error.

🚀 Application

expert

Calculate sum of even numbers using loop and continue

Which Rust code correctly calculates the sum of even numbers from 1 to 10 using a loop and continue?

A

let mut sum = 0;
for n in 1..=10 {
    if n % 2 == 0 { continue; }
    sum += n;
}
println!("{}", sum);

B

let mut sum = 0;
let mut n = 1;
loop {
    if n > 10 { break; }
    if n % 2 != 0 { n += 1; continue; }
    sum += n;
    n += 1;
}
println!("{}", sum);

C

let mut sum = 0;
let mut n = 1;
while n <= 10 {
    if n % 2 == 0 { sum += n; }
    n += 1;
}
println!("{}", sum);

D

let mut sum = 0;
let mut n = 1;
loop {
    if n > 10 { break; }
    if n % 2 == 0 { sum += n; }
    n += 1;
}
println!("{}", sum);

💡 Hint

Use continue to skip odd numbers inside the loop.

Option B uses loop and continue correctly to skip odd numbers and sum even numbers. Option B incorrectly continues on even numbers. Option B uses while but no continue. Option B sums even numbers but does not use continue.

Practice

1. What does the loop keyword do in Rust?

easy

A. It runs the loop a fixed number of times.

B. It creates an infinite loop that runs until break is called.

C. It runs the loop only once.

D. It creates a loop that runs only if a condition is true.

Solution

1. Step 1: Understand the loop keyword

   The loop keyword in Rust creates a loop that repeats forever unless stopped.

2. Step 2: Identify how to stop the loop

   To stop a loop, you must use break inside it; otherwise, it runs infinitely.

3. Final Answer:

   It creates an infinite loop that runs until break is called. -> Option B

4. Quick Check:

   loop = infinite loop until break [OK]

Hint: Remember: loop runs forever unless broken [OK]

Common Mistakes:

• Thinking loop runs a fixed number of times
• Confusing loop with for or while
• Assuming loop stops automatically

2. Which of the following is the correct syntax to create an infinite loop in Rust?

easy

A. loop { println!("Hello"); }

B. while True { println!("Hello"); }

C. for i in 0.. { println!("Hello"); }

D. repeat { println!("Hello"); }

Solution

1. Step 1: Check Rust syntax for infinite loops

   Rust uses the keyword loop to create an infinite loop.

2. Step 2: Verify each option

   while True { println!("Hello"); } uses while True which is invalid syntax in Rust. for i in 0.. { println!("Hello"); } uses for with an infinite range, but 0.. is not valid without an end. repeat { println!("Hello"); } uses repeat which does not exist in Rust. loop { println!("Hello"); } correctly uses loop.

3. Final Answer:

   loop { println!("Hello"); } -> Option A

4. Quick Check:

   Correct infinite loop syntax = loop [OK]

Hint: Use loop keyword for infinite loops in Rust [OK]

Common Mistakes:

• Using while True which is invalid in Rust
• Trying to use repeat which doesn't exist
• Using for without a proper range

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

let mut count = 0;
loop {
    count += 1;
    if count == 3 {
        break;
    }
    println!("{}", count);
}

medium

A. 1 2

B. 0 1 2

C. 1 2 3

D. No output (infinite loop)

Solution

1. Step 1: Trace the loop iterations

   Initially, count = 0. In the first loop, count becomes 1, which is printed. Then count becomes 2 and printed. When count becomes 3, the loop breaks before printing.

2. Step 2: List printed values

   Only 1 and 2 are printed before the break stops the loop.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   Loop prints until count == 3, so prints 1 and 2 [OK]

Hint: Check when break happens before printing [OK]

Common Mistakes:

• Printing count after break condition
• Starting count from 0 but expecting 0 to print
• Assuming infinite loop without break

4. Identify the error in this Rust loop code:

let mut i = 0;
loop {
    if i == 5 {
        break;
    }
    println!("{}", i);
}

medium

A. 'println!' macro syntax is wrong.

B. Missing semicolon after 'break'.

C. 'loop' keyword is used incorrectly.

D. Variable 'i' is not incremented, causing an infinite loop.

Solution

1. Step 1: Check loop control variable

   The variable i is initialized but never changed inside the loop.

2. Step 2: Understand loop behavior

   Since i never increments, i == 5 is never true, so break is never reached, causing an infinite loop.

3. Final Answer:

   Variable 'i' is not incremented, causing an infinite loop. -> Option D

4. Quick Check:

   Loop needs variable increment to reach break [OK]

Hint: Always update loop variables to avoid infinite loops [OK]

Common Mistakes:

• Forgetting to increment loop variable
• Assuming break works without condition change
• Misunderstanding loop syntax

5. How can you use a loop to sum numbers from 1 to 5 in Rust?

hard

A. Use loop with a counter but never update sum.

B. Use loop without break and add numbers forever.

C. Use a loop with a counter and break when counter > 5, adding each to sum.

D. Use loop with a counter but break immediately without adding.

Solution

1. Step 1: Plan the loop with counter and sum

   Initialize a counter at 1 and sum at 0. Use loop to add counter to sum.

2. Step 2: Use break to stop after 5

   Increment counter each loop. When counter > 5, use break to exit loop.

3. Step 3: Result is sum of 1 to 5

   This method correctly sums numbers 1+2+3+4+5 = 15.

4. Final Answer:

   Use a loop with a counter and break when counter > 5, adding each to sum. -> Option C

5. Quick Check:

   Loop + counter + break = sum 1 to 5 [OK]

Hint: Increment counter and break after limit to sum [OK]

Common Mistakes:

• Not breaking loop causing infinite sum
• Not incrementing counter
• Not adding counter to sum