Questions: While Loops

Question 1

Consider this loop: `count = 3; while (count > 0) { print(count); }`. What happens when it runs?

• A. It prints 3, 2, 1 then stops
• B. It prints 3 once, because the condition is checked after the body
• C. It runs forever, printing 3 indefinitely
• D. It prints nothing, because count starts at 3 which is greater than 0

Answer: (C)

The loop body never modifies `count`, so the condition `count > 0` remains true forever — this is an infinite loop. The most common while-loop bug is forgetting to update the variable controlling the condition. The loop should include `count = count - 1` (or `count--`) inside the body. Option A is what the corrected version would do; option B gets the condition-checking timing wrong (it is checked at the top, not after the body).

Question 2

A loop starts with `count = 0` and has the condition `while (count < 5)`. How many times does the body execute?

• A. 4 times (0, 1, 2, 3)
• B. 5 times (0, 1, 2, 3, 4)
• C. 6 times (0, 1, 2, 3, 4, 5)
• D. It depends on what is inside the body

Answer: (B)

With `count` starting at 0 and incrementing by 1 each iteration, the body executes when count = 0, 1, 2, 3, 4 — five times. When count reaches 5, the condition `count < 5` is false and the loop exits without running. This is the classic off-by-one question: `< 5` gives five iterations (0 through 4), while `<= 5` would give six iterations (0 through 5). Tracing through the first and last iterations by hand is the reliable way to resolve these.

Question 3

A while loop checks its condition continuously — if the condition becomes false in the middle of the loop body, the loop exits immediately at that point.

• T. True
• F. False

Answer: False

The condition is checked only at the TOP of each iteration, not continuously during the body. Once the loop body starts executing, it runs to completion before the condition is checked again. This means a while loop always finishes its current iteration in full, even if the condition would be false halfway through. Understanding this timing is essential for reasoning about loop behavior and avoiding subtle bugs.

Question 4

A while loop may execute its body zero times if its condition is false when the loop is first reached.

• T. True
• F. False

Answer: True

The condition is evaluated BEFORE the first execution of the body. If the condition is already false, the loop body never runs at all — execution jumps immediately to whatever code follows the loop. This is different from a do-while loop, which executes the body at least once before checking the condition. This behavior is intentional and useful: it means you can safely enter a while loop even when the data might already satisfy the exit condition.

Question 5

Why must something inside a while loop's body eventually make the condition false? What happens if it doesn't, and how do you design against it?

Model answer: If nothing in the body changes the variables in the condition, the condition evaluates to the same value every iteration and the loop never exits — this is an infinite loop. To prevent it, identify which variable(s) the condition depends on, and ensure the body contains code that moves those variables toward the exit condition. Common patterns: decrement a counter, advance an index, read new input, or narrow a search range. Tracing the first few and last iteration by hand verifies the loop terminates correctly.

A while loop is essentially a contract: 'keep going as long as this is true.' If the body never changes what 'this' evaluates to, the contract is never renegotiated and the loop is stuck. Infinite loops are especially insidious because the program doesn't crash — it just hangs, consuming CPU. Good loop design always makes the termination condition explicit: after writing the condition, ask 'what code in the body guarantees this eventually becomes false?'