What Iteration Means

Iteration is the repetition of a portion of an algorithm. Instead of writing the same instruction over and over, you write it once and tell the program how many times, or under what condition, to repeat it. Iteration is one of the three fundamental building blocks of every algorithm, alongside sequencing and selection, and it is exactly what the Create Performance Task rubric looks for.

There are two flavors. Definite iteration repeats a fixed, known number of times. In AP pseudocode this is REPEAT n TIMES, and in Python it is for i in range(n). Indefinite iteration repeats until some condition is met, and you do not know in advance how many passes that will take. That is REPEAT UNTIL(condition) in pseudocode and while in Python.

for i in range(3):
    print("hi")

REPEAT 3 TIMES
{
    DISPLAY("hi")
}

The loop above runs exactly three times because range(3) produces the values 0, 1, and 2. The important idea for definite iteration: range(n) runs the body n times, but the loop variable takes the values 0 through n minus 1, not 1 through n. That gap is the source of the most common loop bug on the exam.

for i in range(4):
    print("x")

Counters and Accumulators

Two patterns power almost every useful loop. A counter is a variable that goes up by one each pass to tally how many times something happened. An accumulator is a variable that keeps a running total, updated on every pass, so that by the end it holds the combined result of the whole loop.

The recipe is always the same: set the variable to a starting value before the loop, update it inside the loop, and read it after the loop. Forgetting the initialization, or putting the final print inside the loop instead of after it, are classic mistakes.

total = 0
for i in range(1, 6):
    total = total + i
print(total)

total <- 0
i <- 1
REPEAT 5 TIMES
{
    total <- total + i
    i <- i + 1
}
DISPLAY(total)

This loop adds 1, then 2, then 3, 4, and 5 into total, so it prints 15. Notice the Python range(1, 6) stops before 6, giving the values 1 through 5. The pseudocode reaches the same result with REPEAT 5 TIMES and its own counter. Both are definite iteration; they run a fixed five times.

REPEAT UNTIL Is the Opposite of while

This is the single most tested idea in this topic, and it trips up students every year. A Python while loop keeps going while its condition is true and stops when the condition becomes false. An AP REPEAT UNTIL loop is the mirror image: it keeps going until its condition becomes true, checking after nothing and stopping the moment the condition is true.

Because they are opposites, translating between them means negating the condition. A loop that should continue while count < 3 in Python becomes REPEAT UNTIL (count >= 3) in pseudocode. Same behavior, flipped condition.

count = 0
while count < 3:
    print(count)
    count = count + 1

count <- 0
REPEAT UNTIL (count >= 3)
{
    DISPLAY(count)
    count <- count + 1
}

Both loops above print 0, 1, 2 and then stop. The Python version continues while count < 3 is true. The pseudocode version repeats until count >= 3 is true. Read the two conditions and confirm they are logical opposites of each other. If you ever see a REPEAT UNTIL and want to think in Python, mentally rewrite it as while not (condition).

x = 0
while x < 5:
    print(x)

Zero Passes and Infinite Loops

Two boundary cases show up again and again. First, a loop can run its body zero times. If a REPEAT UNTIL condition is already true when the loop is first reached, the body never runs at all. The same happens in Python when a while condition is false from the start.

x = 10
while x < 5:
    print("run")
    x = x + 1
print("done")

x <- 10
REPEAT UNTIL (x >= 5)
{
    DISPLAY("run")
    x <- x + 1
}
DISPLAY("done")

Here x is 10, so the Python condition x < 5 is false immediately and the body is skipped; the program prints only done. The pseudocode REPEAT UNTIL (x >= 5) is already true (10 is at least 5), so it also skips the body. A loop running zero times is not an error, it is a legal and common outcome.

Second, an infinite loop happens when the stopping condition never becomes true. In a counter loop this almost always means you forgot to update the counter, so the condition is stuck. Every indefinite loop must contain something that eventually makes it stop.

total = 0
for i in range(1, 5):
    total = total + i
print(total)

Key Vocabulary