[8.1.4c] Iteration

[8.1.4c] Iteration

Iteration means repeating a block of steps. Computers are good at doing the same action quickly and accurately many times, so loops are a core tool in every program. The IGCSE syllabus expects you to understand and use three main loop types: count-controlled loops (repeat a known number of times), pre-condition loops (test before each pass), and post-condition loops (test after each pass). Choosing the right kind of loop makes your algorithm simpler, safer, and easier to read.

Why programs need loops

Many real tasks involve repetition: summing exam marks in an array, asking a user again until a valid input is entered, or simulating days in a simple model. Without loops you would have to copy and paste the same code over and over, which is error-prone. With loops, you write the steps once and let the computer repeat them under control of a clear condition.

Three loop families at a glance

Each loop family has a distinct purpose. Use the tabbed examples to compare how they read and when they should be preferred.

• Count-controlled (FOR)
• Pre-condition (WHILE)
• Post-condition (REPEAT..UNTIL)

// CAIE Pseudocode
FOR i ← 1 TO 10
  OUTPUT i, " squared is ", i * i
NEXT i

# Python
for i in range(1, 11):
    print(i, "squared is", i * i)

// CAIE Pseudocode
DECLARE total : INTEGER ← 0
DECLARE input : INTEGER
INPUT input
WHILE input <> 0 DO
  total ← total + input
  INPUT input
ENDWHILE
OUTPUT "Sum = ", total

# Python
total = 0
value = int(input("Enter number (0 to stop): "))
while value != 0:
    total += value
    value = int(input("Enter number (0 to stop): "))
print("Sum =", total)

// CAIE Pseudocode
DECLARE choice : CHAR
REPEAT
  OUTPUT "(A)dd, (Q)uit"
  INPUT choice
  choice ← TOUPPER(choice)
  IF choice = 'A' THEN
    OUTPUT "Adding..."
  ENDIF
UNTIL choice = 'Q'

// Typical Python alternative using while True and break
while True:
    choice = input("(A)dd, (Q)uit: ").strip().upper()
    if choice == "A":
        print("Adding...")
    elif choice == "Q":
        break

Choosing the right loop

Off-by-one and boundary thinking

The most common loop bug is the off-by-one error: running one too many or one too few times. With count-controlled loops, check whether the end value is included. In CAIE pseudocode, FOR i ← 1 TO 5 runs five passes (1, 2, 3, 4, 5). In Python, range(1, 6) is needed to include 5. For pre- and post-condition loops, focus on when the condition becomes TRUE or FALSE, and ensure it is updated correctly inside the body.

• Correct range (1..5 inclusive)
• Off-by-one mistake
• Edge case: empty range

// CAIE Pseudocode
FOR i ← 1 TO 5
  OUTPUT i
NEXT i

# Python
for i in range(1, 6):
    print(i)

# Python off-by-one: prints 1..4 only
for i in range(1, 5):
    print(i)

# Python empty range: prints nothing
for i in range(5, 5):
    print(i)

Loop control and safety

• Initialisation: set counters and totals to sensible starting values before the loop.
• Update: ensure your loop variable or condition changes on each pass, otherwise you risk an infinite loop.
• Termination: define clearly when the loop should stop, and test boundary cases to prove it does.
• Nesting: loops can be placed inside other loops to process 2D structures (e.g. rows and columns), but complexity rises quickly, so keep each level clear.

Deep Dive: Choosing between WHILE and REPEAT..UNTIL for validation

For input validation, both structures work. A WHILE loop will only run the body if the value is already valid, which is unusual for validation. The common pattern is REPEAT..UNTIL: prompt the user, check the value, and repeat until it passes the test. In languages without a direct post-condition loop you can simulate it with while True plus break once the input is acceptable. The key is clarity: make the validation rule easy to read and place the prompt where the user expects it.

Key terminology

• Iteration: repeating a block of statements controlled by a count or condition.
• Count-controlled loop: a loop that runs a fixed number of times using a counter.
• Pre-condition loop: tests before each pass (WHILE); may run zero times.
• Post-condition loop: tests after each pass (REPEAT..UNTIL); runs at least once.
• Off-by-one error: executing one too many or too few iterations due to incorrect bounds.