Writing Algorithms and Identifying Errors

Running total / sum.

Total ← 0
FOR Counter ← 1 TO N
  INPUT Number
  Total ← Total + Number
NEXT Counter
OUTPUT Total

Count items meeting a condition.

Count ← 0
FOR Counter ← 1 TO N
  INPUT X
  IF X > 50 THEN
    Count ← Count + 1
  ENDIF
NEXT Counter
OUTPUT Count

Find the maximum.

INPUT Number
Max ← Number
FOR Counter ← 2 TO N
  INPUT Number
  IF Number > Max THEN
    Max ← Number
  ENDIF
NEXT Counter
OUTPUT Max

Find the minimum. Same pattern, with < instead of > and Min instead of Max.

Average. Compute the running total then divide by N.

Total ← 0
FOR Counter ← 1 TO N
  INPUT Number
  Total ← Total + Number
NEXT Counter
Average ← Total / N
OUTPUT Average

Cambridge tip. Memorise the patterns so you don't have to invent them in the exam. Most Paper 2 algorithm questions are variations on these.

Linear search. Look for a target in an array, one element at a time, from start to end.

Found ← FALSE
INPUT Target
FOR Counter ← 1 TO N
  IF Array[Counter] = Target THEN
    Found ← TRUE
  ENDIF
NEXT Counter
IF Found = TRUE THEN
  OUTPUT 'Found'
ELSE
  OUTPUT 'Not found'
ENDIF

Worst-case complexity: O(n) — every element checked. Works on UNSORTED arrays.

Bubble sort. Repeatedly compare adjacent pairs; swap if out of order. After each pass, the next-largest element 'bubbles' into place.

FOR Pass ← 1 TO N-1
  FOR Counter ← 1 TO N-Pass
    IF Array[Counter] > Array[Counter+1] THEN
      Temp ← Array[Counter]
      Array[Counter] ← Array[Counter+1]
      Array[Counter+1] ← Temp
    ENDIF
  NEXT Counter
NEXT Pass

Worst-case complexity: O(n²) — slow on large arrays but easy to code and reason about.

Cambridge tip. Memorise both algorithms in pseudocode. Mark schemes accept slight variations as long as the LOGIC is correct.

Many Paper 2 questions show an algorithm and ask 'find the error(s)'. The standard checking strategy:

1. Read the question's INTENT. What's the algorithm SUPPOSED to do? Don't assume — read carefully.

2. Check initialisation.

• Sum / count / found-flag → initialised to 0 / 0 / FALSE before the loop?
• Max / Min → initialised to the FIRST input (not 0 — fails for negatives)?

3. Check loop bounds.

• FOR Counter ← 1 TO N — runs N times INCLUSIVE.
• WHILE / REPEAT termination conditions — does the loop reach its end correctly?

4. Check the body.

• Running total: Total ← Total + Number (NOT Total ← Number).
• Counter: Count ← Count + 1.
• Conditions: > vs >= matters.

5. Check output.

• Right variable being output?
• Correct identifier (no typos)?

6. Trace the algorithm with sample inputs. A trace table reveals errors that visual inspection misses.

Common errors to look for.

• Overwriting instead of accumulating (Total ← Number).
• Initialising Max to 0 instead of first input.
• Off-by-one in loop bounds.
• Wrong comparison operator (> vs >=).
• Spelling mismatches between assignment and output.
• Missing ENDIF / ENDWHILE / NEXT.

Cambridge tip. Mark scheme typically wants you to IDENTIFY the error AND give the CORRECTION — both halves earn marks.