Lecture 06 — Traces and Loop Reasoning

Learning objectives

• Trace loops with a variable table
• Predict loop outputs before running code
• Identify off-by-one errors systematically

Case-based lecture: you attempt, we discuss, then we reveal.

The plan

• Four cases: cs-021, cs-022, cs-023, cs-024
• Each: 5-minute attempt → discussion → reveal → prompt
• Worked examples in between — ask anything
• Break mid-lecture · exit question at the end

Key definitions

• Trace table (state table) — one row per loop pass; one column per variable the loop reads or writes.
• Loop condition — the boolean that decides whether another pass happens; it belongs in the table.
• Off-by-one error — a loop that runs once too often or too few; two classic causes are boundary mix-ups (≤ vs <) and wrong initialisation.
• Nested loop — a loop inside a loop; the inner loop runs fully for every outer pass.
• Invariant (informal) — a statement that is true before and after every pass; why the loop's answer is right.
• Termination — the proof a loop ends: name a quantity that strictly decreases (or increases) and is bounded.

Trace the tally: loop reasoning on paper

Expected: 48

Cost: O(limit). Skipped items cost a condition check but no addition - skipping is not free.

Nested loops, traced honestly

count = 0
for row in range(4):
    for col in range(3):
        count += 1
print(count)

Expected: four lines: * then **. then ***.. then ****...

Cost: O(n^2) characters - the sum 1 + 3 + 5 + ... + (2n - 1) = n^2 is the doubling-grid fact from the lecture.

• **Input:** numbers 1..12, skip multiples of 3
• **Output:** sum 1+2+4+5+7+8+10+11 = 48
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-021 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Which accumulator was hardest to get right, and what test would have caught the mistake?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-021 — not embedded in this deck.

• **Input:** n = 96
• **Output:** 96->48->24->12->6->3 (stop, odd): 5 divisions, 6 values seen
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-022 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Where exactly would this solution break first if the input grew to a million items — and would anything break at all?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-022 — not embedded in this deck.

• **Input:** n = 4 (rows); inner prints star when col <= row else dot
• **Output:** row1 '*'; row2 '**.'; row3 '***..'; row4 '****...' - each row adds one extra '*' and one extra '.'
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-023 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Which accumulator was hardest to get right, and what test would have caught the mistake?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-023 — not embedded in this deck.

• **Input:** three loops: (a) range(1, n) summing 1..n, (b) while i <= n: i += 2 summing 1..n, (c) i = n; while i > 0: i -= i // 4 + 1
• **Output:** the diagnosis: (a) misses the last value n; (b) visits only odd i, so every even value is skipped; (c) terminates, with a step count that grows logarithmically
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-024 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Where exactly would this solution break first if the input grew to a million items — and would anything break at all?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-024 — not embedded in this deck.

Common misconceptions

• Tracing in the head - the table exists precisely because heads lie.
• Omitting the loop-condition column, then wondering why termination is unclear.
• Fixing the condition when the bug is the initialisation (and vice versa).
• Assuming nested loops always multiply costs - they do, but say it with the grid, not as a slogan.

Summary & exit question

• Named technique today: Traces and Loop Reasoning
• Four cases attempted — methods before answers

Exit question (choose one, 60 seconds)

1. What belongs in every column of a state table?
2. Give the two classic off-by-one causes.
3. When does a nested loop's inner count matter most?