Quiz: Repetition: Loops and Iteration

Test your understanding before moving on. Target: 70% or higher to proceed confidently.


Section 1: Multiple Choice (1 point each)

1. What values does range(3, 8) produce?

  • A) 3, 4, 5, 6, 7, 8
  • B) 3, 4, 5, 6, 7
  • C) 4, 5, 6, 7
  • D) 3, 4, 5, 6, 7, 8, 9
Answer **B)** 3, 4, 5, 6, 7 *Why B:* `range(start, stop)` produces values from `start` up to but *not including* `stop`. So `range(3, 8)` gives 3, 4, 5, 6, 7 — five values. *Why not A:* 8 is excluded (the stop value is never included). *Why not C:* 3 is the start value and is included. *Why not D:* `range()` stops before the stop value, not after it. *Reference:* Section 5.2.2

2. How many times does the body of this loop execute?

for i in range(0, 10, 3):
    print(i)
  • A) 3
  • B) 4
  • C) 10
  • D) 0
Answer **B)** 4 *Why B:* `range(0, 10, 3)` produces the values 0, 3, 6, 9 — four values. (The next would be 12, which is >= 10, so it stops.) *Why not A:* There are four values, not three. *Why not C:* The step of 3 means not every integer from 0-9 is produced. *Why not D:* The range is valid and produces values. *Reference:* Section 5.2.2

3. Which loop is best suited for asking the user to re-enter input until it's valid?

  • A) for loop with range()
  • B) while loop
  • C) Nested for loop
  • D) Either for or while — there's no difference
Answer **B)** `while` loop *Why B:* You don't know how many invalid attempts the user will make, so the number of iterations is unknown. A `while` loop continues until a condition is met. *Why not A:* A `for` loop with `range()` requires knowing the number of iterations in advance. *Why not C:* Nesting is irrelevant to input validation. *Why not D:* While both can technically work, `while` is clearly more appropriate and idiomatic for condition-controlled repetition. *Reference:* Section 5.5

4. What is the output of this code?

total = 0
for num in range(1, 5):
    total += num
print(total)
  • A) 15
  • B) 10
  • C) 4
  • D) 5
Answer **B)** 10 *Why B:* `range(1, 5)` produces 1, 2, 3, 4. The sum 1+2+3+4 = 10. *Why not A:* 15 would be the sum of 1+2+3+4+5, but 5 is excluded from `range(1, 5)`. *Why not C:* 4 is the last value, not the sum. *Why not D:* 5 is the stop value (excluded), not the sum. *Reference:* Section 5.6.1

5. What does the break statement do?

  • A) Skips to the next iteration of the loop
  • B) Ends the program entirely
  • C) Immediately exits the enclosing loop
  • D) Pauses the loop for one second
Answer **C)** Immediately exits the enclosing loop *Why C:* `break` terminates the current loop and continues execution after the loop. *Why not A:* That's what `continue` does. *Why not B:* `break` exits the loop, not the program. Code after the loop still runs. *Why not D:* Python has no built-in pause statement (you'd use `time.sleep()` for that). *Reference:* Section 5.7.1

6. What is the output of this code?

for i in range(5):
    if i == 3:
        continue
    print(i, end=" ")
  • A) 0 1 2
  • B) 0 1 2 4
  • C) 0 1 2 3 4
  • D) 3
Answer **B)** 0 1 2 4 *Why B:* When `i` is 3, `continue` skips the `print()` and moves to the next iteration. All other values (0, 1, 2, 4) are printed. *Why not A:* The loop doesn't stop at 3; it only skips 3. *Why not C:* The value 3 is skipped due to `continue`. *Why not D:* `continue` skips the current iteration, it doesn't select only that value. *Reference:* Section 5.7.2

7. In a nested loop where the outer loop runs 3 times and the inner loop runs 5 times, how many times does the inner loop's body execute?

  • A) 3
  • B) 5
  • C) 8
  • D) 15
Answer **D)** 15 *Why D:* For each of the 3 outer iterations, the inner loop runs 5 times: 3 × 5 = 15. *Why not A:* 3 is only the outer loop count. *Why not B:* 5 is only the inner loop count per outer iteration. *Why not C:* Loop iterations multiply, not add. *Reference:* Section 5.8.1

8. Which of the following correctly describes the accumulator pattern?

  • A) Initialize a variable inside the loop, update it outside the loop, use it during the loop
  • B) Initialize a variable before the loop, update it inside the loop, use it after the loop
  • C) Use break to accumulate values in a list
  • D) Use range() to automatically sum a sequence
Answer **B)** Initialize a variable before the loop, update it inside the loop, use it after the loop *Why B:* The three steps are: (1) initialize before, (2) update inside, (3) use after. *Why not A:* If you initialize inside the loop, the accumulator resets every iteration. *Why not C:* `break` exits loops; it doesn't accumulate. *Why not D:* `range()` generates values but doesn't sum them. *Reference:* Section 5.6.1

9. What is an infinite loop?

  • A) A loop that runs exactly once
  • B) A loop that iterates over an infinitely long list
  • C) A loop whose exit condition is never met, so it runs forever
  • D) A loop with more than 1,000 iterations
Answer **C)** A loop whose exit condition is never met, so it runs forever *Why C:* An infinite loop occurs when the condition of a `while` loop never becomes `False`, or the loop has no mechanism to terminate. *Why not A:* A loop that runs once is just a normal loop with one iteration. *Why not B:* Python lists are finite; and infinite iteration is about the exit condition, not the data size. *Why not D:* The number of iterations doesn't define infinite — a loop running 1 million times is fine if it eventually stops. *Reference:* Section 5.9.1

10. What is the output of this code?

for i in range(3):
    for j in range(2):
        print(f"{i}-{j}", end=" ")
    print()
  • A) 0-0 0-1 on the first line, 1-0 1-1 on the second, 2-0 2-1 on the third
  • B) 0-0 1-0 2-0 on the first line, 0-1 1-1 2-1 on the second
  • C) 0-0 0-1 0-2 1-0 1-1 1-2 all on one line
  • D) 0-0 1-1 2-2 all on one line
Answer **A)** `0-0 0-1` on the first line, `1-0 1-1` on the second, `2-0 2-1` on the third *Why A:* The outer loop variable `i` stays constant while the inner loop variable `j` cycles through its full range. After the inner loop completes, `print()` creates a newline, and `i` advances. *Why not B:* The inner loop iterates `j`, not `i`, within each row. *Why not C:* The `print()` after the inner loop creates newlines between rows. *Why not D:* Both variables independently cycle through their ranges. *Reference:* Section 5.8.1

Section 2: True/False with Justification (1 point each)

11. "range(5) produces the values 1, 2, 3, 4, 5."

Answer **False** *Explanation:* `range(5)` produces 0, 1, 2, 3, 4 — five values starting from 0, stopping before 5. To get 1 through 5, you'd use `range(1, 6)`.

12. "A while loop always executes its body at least once."

Answer **False** *Explanation:* A `while` loop checks the condition *before* the first iteration. If the condition is `False` from the start, the body never executes. For example, `while False: print("hello")` never prints anything.

13. "The else clause of a loop runs only when the loop exits due to a break statement."

Answer **False** *Explanation:* It's the opposite. The `else` clause runs when the loop completes *without* encountering a `break`. If `break` is triggered, the `else` is skipped. Think of it as "no break" rather than "else."

14. "The accumulator pattern requires the accumulator to be initialized to 0."

Answer **False** *Explanation:* The initial value depends on the operation. For summing, use 0. For multiplying (like factorial), use 1. For finding a maximum, use the first value or a very small number. For building strings, use `""`. The key is choosing an initial value that doesn't distort the result.

Section 3: Short Answer (2 points each)

15. Explain in 2-3 sentences why an infinite loop is usually a bug, and describe how to identify one when your program is running.

Sample Answer An infinite loop is usually a bug because the programmer intended the loop to terminate but the exit condition is never reached — typically because the loop variable isn't being updated correctly. You can identify one when your program appears to freeze, keeps printing the same output repeatedly, or consumes 100% CPU without progressing. To stop it, press Ctrl+C in the terminal. *Rubric — full credit requires:* - Explaining that the exit condition is never met - Describing at least one observable symptom - Mentioning Ctrl+C or a way to stop it

16. Write the range() call that produces each sequence of values. Don't use any code besides range().

a) 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 b) 5, 6, 7, 8, 9, 10 c) 10, 8, 6, 4, 2 d) 100, 200, 300, 400, 500

Sample Answer a) `range(10)` b) `range(5, 11)` c) `range(10, 0, -2)` (or `range(10, 1, -2)`) d) `range(100, 501, 100)` (or `range(100, 600, 100)`) *Rubric — full credit requires:* - All four correct (note: there may be multiple valid stop values for some)

17. A student writes this code to compute the average of 5 numbers entered by the user. Identify the bug and explain how to fix it.

for i in range(5):
    num = float(input("Enter a number: "))
    total = 0
    total += num
average = total / 5
print(f"Average: {average}")
Sample Answer The bug is that `total = 0` is *inside* the loop. Every iteration, `total` is reset to 0 before adding the new number. So `total` only ever holds the last number entered. The fix is to move `total = 0` above the `for` line — initialize the accumulator *before* the loop starts. Fixed code:
total = 0
for i in range(5):
    num = float(input("Enter a number: "))
    total += num
average = total / 5
print(f"Average: {average}")
*Rubric — full credit requires:* - Correctly identifying that `total = 0` is inside the loop - Explaining the consequence (total resets each iteration) - Providing the fix (move initialization before the loop)

Section 4: Code Tracing (2 points each)

18. Trace through this code and write the exact output.

result = 1
for i in range(1, 5):
    result *= i
    print(f"i={i}, result={result}")
Answer
i=1, result=1
i=2, result=2
i=3, result=6
i=4, result=24
Trace: - `i=1`: result = 1 * 1 = 1 - `i=2`: result = 1 * 2 = 2 - `i=3`: result = 2 * 3 = 6 - `i=4`: result = 6 * 4 = 24 This computes 4! (four factorial).

19. Trace through this code and write the exact output.

x = 16
count = 0
while x > 1:
    x = x // 2
    count += 1
print(f"x={x}, count={count}")
Answer
x=1, count=4
Trace: - Iteration 1: x = 16 // 2 = 8, count = 1 - Iteration 2: x = 8 // 2 = 4, count = 2 - Iteration 3: x = 4 // 2 = 2, count = 3 - Iteration 4: x = 2 // 2 = 1, count = 4 - Check: x=1, 1 > 1 is False, loop ends This counts how many times you can halve 16 before reaching 1 (i.e., log base 2 of 16 = 4).

20. Trace through this code and write the exact output.

for i in range(4):
    if i == 2:
        break
    print(i, end=" ")
else:
    print("done")
print("after")
Answer
0 1 after
Trace: - i=0: 0 != 2, print "0 " - i=1: 1 != 2, print "1 " - i=2: 2 == 2, `break` — exit loop immediately - The `else` clause does NOT run because the loop was terminated by `break` - "after" prints because it's outside the loop entirely Note: "done" is never printed because `break` prevents the `else` from executing.

Scoring & Next Steps

Score Assessment Recommended Action
< 50% Needs review Re-read sections 5.2-5.6, redo Part A and B exercises
50-70% Partial Review weak areas, focus on accumulator pattern and range()
70-85% Solid Ready to proceed; revisit any missed loop control topics
> 85% Strong Proceed to Chapter 6; consider the advanced exercises