[7.9] Write/amend algorithms

[7.9] Write and amend algorithms using pseudocode, program code and flowcharts

In this benchmark you will practise designing clear algorithms and expressing them in three complementary representations: CAIE-style pseudocode, program code (we will use Python as a concrete example), and flowcharts. You will also learn how to amend an existing algorithm to fix errors, improve clarity, or add small features while keeping the overall intent the same. Strong exam answers show you can move between these forms confidently and keep the logic consistent.

What is an algorithm?

An algorithm is a finite, ordered sequence of steps that solves a general problem. Good algorithms have predictable inputs, clearly defined processes, and unambiguous outputs. For IGCSE you must be able to create algorithms that use common constructs: sequence (one step after another), selection (IF, CASE), and iteration (FOR, WHILE, REPEAT). You should also be comfortable with typical patterns such as counters, accumulators, flags, and search/sort routines.

Pseudocode, program code, and flowcharts compared

From requirements to three representations

Suppose we need an algorithm that reads a list of positive integers, outputs the count of values over a threshold, and the average of those values. Below are aligned versions in pseudocode, Python, and a flowchart-oriented step outline. Notice how the logic remains the same while the representation changes.

• CAIE pseudocode version
• Python code version
• Flowchart step outline

// CAIE Pseudocode
DECLARE numbers : ARRAY OF INTEGER
DECLARE threshold : INTEGER
DECLARE total : INTEGER ← 0
DECLARE count : INTEGER ← 0
INPUT threshold
// assume numbers is already filled or read in a loop
DECLARE i : INTEGER
FOR i ← 0 TO LENGTH(numbers) - 1
  IF numbers[i] > threshold THEN
    total ← total + numbers[i]
    count ← count + 1
  ENDIF
NEXT i
IF count = 0 THEN
  OUTPUT "No values above threshold"
ELSE
  OUTPUT "Count = ", count
  OUTPUT "Average = ", total / count
ENDIF

# Python
numbers = [12, 4, 25, 7, 30]
threshold = int(input("Threshold: "))
total = 0
count = 0
for value in numbers:
    if value > threshold:
        total += value
        count += 1
if count == 0:
    print("No values above threshold")
else:
    print("Count =", count)
    print("Average =", total / count)

Amending an algorithm: small, safe changes

Exams commonly ask you to amend rather than rewrite: e.g. “Modify the algorithm so it also outputs the maximum value above the threshold.” The best approach is to add the minimum number of statements necessary, preserving structure and style.

• Add feature: track maximum
• Correct fault: off-by-one
• Improve efficiency: early exit

// CAIE Pseudocode (amendment)
DECLARE maxAbove : INTEGER
DECLARE foundAny : BOOLEAN ← FALSE
...
IF numbers[i] > threshold THEN
  total ← total + numbers[i]
  count ← count + 1
  IF foundAny = FALSE THEN
    maxAbove ← numbers[i]
    foundAny ← TRUE
  ELSE
    IF numbers[i] > maxAbove THEN
      maxAbove ← numbers[i]
    ENDIF
  ENDIF
ENDIF
...
IF count = 0 THEN
  OUTPUT "No values above threshold"
ELSE
  OUTPUT "Count = ", count
  OUTPUT "Average = ", total / count
  OUTPUT "Max above threshold = ", maxAbove
ENDIF

// CAIE Pseudocode (fix off-by-one)
FOR i ← 0 TO LENGTH(numbers) - 1
  // safe access: numbers[i]
NEXT i

// CAIE Pseudocode (early exit linear search)
DECLARE found : BOOLEAN ← FALSE
DECLARE i : INTEGER ← 0
WHILE i < LENGTH(numbers) AND found = FALSE DO
  IF numbers[i] = target THEN
    found ← TRUE
  ELSE
    i ← i + 1
  ENDIF
ENDWHILE
IF found = TRUE THEN
  OUTPUT "Found at index ", i
ELSE
  OUTPUT "Not found"
ENDIF

Deep Dive: Designing before coding

When time is limited, jumping straight into code seems faster, but it often leads to mistakes. A quick flowchart sketch or short pseudocode draft helps you choose sensible variables and control structures. Ask yourself: What are my inputs and outputs? What must be true before the loop (initialisation), and what must change each iteration so it terminates? Which boundary values should I test first? These questions prevent common errors like infinite loops and wrong averages.

Key terminology

• Sequence: instructions executed in order.
• Selection: choosing a path using a condition (e.g. IF ... THEN ... ELSE).
• Iteration: repeating a block (e.g. FOR, WHILE, REPEAT ... UNTIL).
• Accumulator: a variable that keeps a running total (e.g. total).
• Flag: a BOOLEAN variable used to record that an event has happened (e.g. found).
• Amend: to change an algorithm minimally to correct or extend it without breaking existing behaviour.