Loop with break in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a loop with break returning a value

What is the output of this Rust program?

Rust

fn main() {
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 5 {
            break count * 2;
        }
    };
    println!("{}", result);
}

A 0

B 5

C 10

D Compilation error

💡 Hint

The loop breaks when count reaches 5 and returns count * 2.

The loop increments count from 0 to 5. When count is 5, it breaks and returns 5 * 2 = 10. This value is stored in result and printed.

❓ Predict Output

intermediate

Loop with break inside nested loops

What will be printed by this Rust code?

Rust

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

A Compilation error

B i = 3, j = 3

C i = 1, j = 1

D i = 1, j = 3

💡 Hint

The break with label exits the outer loop when j reaches 3.

The inner loop increments j until it reaches 3, then breaks the outer loop. i was incremented once before entering inner loop, so i=1 and j=3.

🔧 Debug

advanced

Identify the error in loop with break

What error does this Rust code produce?

Rust

fn main() {
    let mut x = 0;
    let y = loop {
        x += 1;
        if x > 3 {
            break x;
        }
    };
    println!("{}", y);
}

A SyntaxError: missing semicolon after x += 1

B TypeError: cannot break with a value

C No error, prints 4

D RuntimeError: infinite loop

💡 Hint

Check punctuation carefully inside the loop.

The line 'x += 1' is missing a semicolon, causing a syntax error.

❓ Predict Output

advanced

Loop with break returning a tuple

What is the output of this Rust program?

Rust

fn main() {
    let mut a = 0;
    let mut b = 1;
    let result = loop {
        if a > 3 {
            break (a, b);
        }
        a += 1;
        b += 2;
    };
    println!("{:?}", result);
}

A (3, 7)

B (4, 9)

C (4, 5)

D Compilation error

💡 Hint

The loop breaks when a becomes greater than 3, returning (a, b).

a increments from 0 to 4, b increments by 2 each time from 1 to 9. When a is 4 (>3), loop breaks returning (4,9).

🧠 Conceptual

expert

Behavior of break in infinite loop with condition

Consider this Rust code snippet: fn main() { let mut n = 0; loop { n += 1; if n == 10 { break; } } println!("{}", n); } What is the value printed and why?

A 10, because the loop breaks exactly when n reaches 10

B 9, because the break happens before incrementing n to 10

C Compilation error due to missing break value

D Infinite loop, because break has no value

💡 Hint

The break without a value just exits the loop; n increments before the check.

n starts at 0, increments to 10, then break exits the loop. The printed value is 10.

Practice

1. What does the break keyword do inside a loop in Rust?

easy

A. It restarts the loop from the beginning.

B. It stops the loop immediately and exits it.

C. It skips the current iteration and continues the loop.

D. It pauses the loop until a condition is true.

Solution

1. Step 1: Understand the role of break in loops

   The break keyword is used to stop the loop immediately, no matter where it is in the loop.

2. Step 2: Compare with other loop controls

   Unlike continue which skips to the next iteration, break exits the loop completely.

3. Final Answer:

   It stops the loop immediately and exits it. -> Option B

4. Quick Check:

   break = stop loop [OK]

Hint: Remember: break means stop the loop now [OK]

Common Mistakes:

• Confusing break with continue
• Thinking break pauses instead of stops
• Assuming break restarts the loop

2. Which of the following is the correct syntax to break out of a loop in Rust?

easy

A. break()

B. exit loop;

C. break;

D. stop;

Solution

1. Step 1: Recall Rust loop break syntax

   In Rust, to exit a loop, you simply write break; with a semicolon.

2. Step 2: Check other options for syntax errors

   break() is invalid because break is a keyword, not a function. exit loop; and stop; are not Rust keywords.

3. Final Answer:

   break; -> Option C

4. Quick Check:

   Correct break syntax = break; [OK]

Hint: Use break with semicolon to exit loops [OK]

Common Mistakes:

• Using break as a function call
• Writing break without semicolon
• Using non-existent keywords like exit or stop

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. 1 2 3

C. 3

D. 0 1 2

Solution

1. Step 1: Trace the loop iterations and print statements

   Loop starts with count = 0. Each loop adds 1 to count. When count reaches 3, break stops the loop. The print happens only if count is not 3.

2. Step 2: List printed values

   When count=1, prints 1; count=2, prints 2; count=3 triggers break before print, so 3 is not printed.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   Print before break stops at 3, so output is 1 2 [OK]

Hint: Break stops before printing 3, so only 1 and 2 print [OK]

Common Mistakes:

• Assuming break prints the last value
• Counting from 0 instead of 1
• Ignoring that break stops loop before print

4. Identify the error in this Rust code snippet:

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

medium

A. Missing semicolon after break

B. Variable i is not mutable

C. println! macro is used incorrectly

D. Loop condition is missing

Solution

1. Step 1: Check syntax around break statement

   In Rust, statements must end with a semicolon. The break statement here lacks a semicolon.

2. Step 2: Verify other parts of the code

   Variable i is mutable, println! is correctly used, and loop without condition is valid in Rust.

3. Final Answer:

   Missing semicolon after break -> Option A

4. Quick Check:

   break needs semicolon to avoid syntax error [OK]

Hint: Always put semicolon after break [OK]

Common Mistakes:

• Forgetting semicolon after break
• Thinking loop needs condition
• Misreading println! syntax

5. You want to sum numbers from 1 to 10 but stop adding when the sum reaches or exceeds 20. Which Rust code correctly uses a loop with break to do this?

hard

A. let mut sum = 0;
let mut n = 1;
loop {
sum += n;
if sum >= 20 {
break;
}
n += 1;
}
println!("{}", sum);

B. let mut sum = 0;
for n in 1..=10 {
sum += n;
if sum >= 20 {
break;
}
}
println!("{}", sum);

C. let mut sum = 0;
let mut n = 1;
while n <= 10 {
sum += n;
if sum >= 20 {
break;
}
n += 1;
}
println!("{}", sum);

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

Solution

1. Step 1: Understand the problem requirements

   Sum numbers from 1 to 10, but stop if sum reaches or exceeds 20. Use loop with break.

2. Step 2: Analyze each option for correctness

   let mut sum = 0; let mut n = 1; loop { sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); breaks after adding sum >= 20 but does not stop when n > 10, so it does not enforce the limit to 10. let mut sum = 0; for n in 1..=10 { sum += n; if sum >= 20 { break; } } println!("{}", sum); uses for loop, not loop. let mut sum = 0; let mut n = 1; while n <= 10 { sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); uses while loop, not loop. let mut sum = 0; let mut n = 1; loop { if n > 10 { break; } sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); correctly breaks if n > 10 or sum >= 20, stopping properly.

3. Final Answer:

   Correctly uses loop with break to stop at sum >= 20 or n > 10. -> Option D

4. Quick Check:

   let mut sum = 0; let mut n = 1; loop { if n > 10 { break; } sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); [OK]

Hint: Check all break conditions to avoid infinite loops [OK]

Common Mistakes:

• Missing break for loop exit condition
• Using wrong loop type
• Not checking both sum and count limits