What is an algorithm in the context of Cambridge IGCSE Computer Science?

In Cambridge IGCSE Computer Science, an algorithm is a step-by-step procedure or formula for solving a problem. It is a sequence of instructions that are followed to achieve a specific goal or perform a task. Algorithms are fundamental to computer science as they form the basis for writing programs and solving computational problems.

How do I write an algorithm for a given problem?

To write an algorithm for a given problem, start by clearly understanding the problem requirements. Break down the problem into smaller, manageable parts. Then, outline the steps needed to solve each part, ensuring they are logical and sequential. Use pseudocode or flowcharts to represent these steps clearly. Finally, review the algorithm to ensure it addresses all aspects of the problem and is efficient.

What are common errors to look for when writing algorithms?

Common errors in writing algorithms include logical errors, where the steps do not correctly solve the problem; syntax errors, if using pseudocode or a programming language; and runtime errors, which occur when the algorithm is executed. It's important to test the algorithm with different inputs to ensure it handles all possible scenarios and produces the correct output.

How can I identify and fix errors in my algorithm?

To identify and fix errors in your algorithm, start by tracing the algorithm with sample inputs to see where it fails. Check each step for logical consistency and correctness. Use debugging techniques such as adding print statements or using a debugger tool if coding. Once an error is identified, revise the algorithm to correct the mistake, and retest to ensure the issue is resolved.

Why is it important to test algorithms thoroughly in Cambridge IGCSE Computer Science?

Testing algorithms thoroughly is crucial in Cambridge IGCSE Computer Science because it ensures the algorithm works correctly under all expected conditions. Thorough testing helps identify any logical, syntax, or runtime errors that could lead to incorrect results. It also verifies that the algorithm is efficient and meets the problem's requirements, which is essential for achieving high marks in assessments.

Why is "Writing `Total ← Number` instead of `Total ← Total + Number`" a common mistake in Writing Algorithms and Identifying Errors?

Why it happens: Students forget that an accumulator MUST add to itself. How to avoid it: Running totals: `Total ← Total + Number`. Counters: `Count ← Count + 1`. The variable references itself on the right-hand side. Source: 0478 Examiner Reports 2022-2024

Why is "Initialising Max/Min to 0 when finding the maximum or minimum" a common mistake in Writing Algorithms and Identifying Errors?

Why it happens: 0 feels like a 'safe' starting value. How to avoid it: If inputs could be NEGATIVE (temperatures, balances) — or all positive when finding a minimum — initialising to 0 returns 0 instead of the real extreme. Initialise to the FIRST INPUT, then loop from 2.

Why is "Off-by-one errors in loops (wrong condition or bound)" a common mistake in Writing Algorithms and Identifying Errors?

Why it happens: Confusion over inclusive ranges and over `>` vs `>=` in loop exits. How to avoid it: Cambridge `FOR Counter ← 1 TO 20` runs 20 times INCLUSIVE. For WHILE/REPEAT, trace the exit condition at its boundary value. `UNTIL Count > 5` runs one extra time versus `UNTIL Count >= 5`.

Why is "Infinite loop — the loop condition can never become false" a common mistake in Writing Algorithms and Identifying Errors?

Why it happens: The counter is not incremented, or a sentinel input is never re-read inside the loop. How to avoid it: Every WHILE/REPEAT loop must change something each pass that moves it toward its exit: increment the counter, or re-`INPUT` the value the condition tests.

Why is "Reporting / outputting a search result INSIDE the loop" a common mistake in Writing Algorithms and Identifying Errors?

Why it happens: It seems natural to print as soon as you compare an element. How to avoid it: Use a flag: set it during the loop, then report ONCE after the loop. Printing inside the loop produces 'Not found' on every non-matching element.

Why is "Trying to debug an algorithm by reading without tracing" a common mistake in Writing Algorithms and Identifying Errors?

Why it happens: Tracing feels slow. How to avoid it: When stuck, BUILD A TRACE TABLE. Step through with sample inputs and watch each variable. Mark scheme often awards method marks for trace tables even when the final answer is wrong.

Cambridge IGCSE Computer Science (0478)

Writing Algorithms and Identifying Errors

0% Complete

3 tasks remaining

Short Notes - Writing Algorithms and Identifying Errors

Detailed Study Notes

Detailed notes on Algorithm design and problem-solving for Cambridge IGCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Writing Algorithms and Identifying Errors Study Notes — Cambridge IGCSE Computer Science 0478 (2026-2028 syllabus)

The patterns Paper 2 actually tests: input-process-output, totalling, counting, finding the max/min, search and sort. Plus how to spot errors in algorithms by reading carefully and tracing systematically.

At a glance

Initialisation matters — Total ← 0, Max ← first input.
Running total = Total ← Total + Number.
Counter = Count ← Count + 1.
Find max: initialise to FIRST input, not 0.
Linear search: loop + flag variable.
Bubble sort: compare adjacent pairs; swap if wrong order.
Trace tables for spotting errors.
Cambridge pseudocode keywords — use them.

What you’ll learn

Mapped to the Cambridge IGCSE 0478 syllabus (2026-2028).

1.21.1 — Write pseudocode for common patterns (sum, count, max, min, search, sort).
1.21.2 — Identify errors in given algorithms.
1.21.3 — Use trace tables to debug.

Common algorithm patterns

Sum, count, max/min, search, sort — all show up on Paper 2.

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.

Find-max pattern: seed Max with the first input, then compare every subsequent input and update when bigger.

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.

Running total: Total ← Total + Number.
Counter: Count ← Count + 1.
Max: initialise to FIRST input, not 0.
Average: total / count.

See the full worked example for writing algorithms and identifying errors →

Search and sort

Linear search and bubble sort are the two standard algorithms.

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.

Linear search: loop + flag.
Bubble sort: nested loop + swap.
Both are O(n²) worst-case (sort) or O(n) (search).

Identifying errors in algorithms

Read carefully; trace; check edge cases.

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.

Read the intent. Trace systematically.
Check initialisation, loop bounds, body, output.
Always pair the error with a correction.

See the full worked example for writing algorithms and identifying errors →

Quick recap

Memorise patterns: running total, counter, max/min, average.
Linear search + bubble sort — the two standard algorithms.
When debugging, check initialisation, loop bounds, body, output.
Trace tables reveal errors that reading misses.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

Running total = Total ← Total + Number.
Counter = Count ← Count + 1.
Max init = FIRST input, not 0.
Linear search = flag + loop.
Bubble sort = nested loop + swap.

How it’s examined

Algorithm-writing dominates Paper 2. Most-tested questions: write pseudocode for a stated task (8-10 marks), identify errors in an algorithm (6 marks), trace an algorithm (6-8 marks). Examiner reports flag overwrite-instead-of-accumulate and Max-initialised-to-0 as the two most common errors.

Sources: Cambridge IGCSE Computer Science 0478 syllabus (2026-2028); 0478 Examiner Reports 2022-2024; 0478/22 May/Jun 2024 question paper and mark scheme. Last reviewed 2026-05-09.

Take this whole topic with you

Step-by-step worked examples — Writing Algorithms and Identifying Errors

Step-by-step solutions to past-paper-style questions on writing algorithms and identifying errors, written exactly the way a tutor would explain them at the board.

1Getting started: spot & fix one error (2 marks)
Getting started• 0478 Paper 2 — style• debugging, loop
Question
The algorithm below should output the numbers 1 to 5, but it never stops running. Identify the error and state the correction. (2 marks)

Counter ← 1 WHILE Counter <= 5 OUTPUT Counter ENDWHILE
Step-by-step solution
1. Step 1
  Read the loop condition (AO3 design). The loop continues WHILE Counter <= 5. Inside the loop, Counter is never changed — so the condition stays true forever. This is a classic infinite loop.
2. Step 2
  Fix it. Add Counter ← Counter + 1 inside the loop so the counter advances toward 5 and the condition eventually becomes false.
Answer
Counter ← 1 WHILE Counter <= 5 OUTPUT Counter Counter ← Counter + 1 ENDWHILE
Examiner tip
1 mark for identifying the infinite loop (counter never updated), 1 mark for the correct fix (Counter ← Counter + 1 inside the loop). The most common control-flow bug examiners test.
2Getting started: correct a wrong condition (2 marks)
Getting started• 0478 Paper 2 — style• debugging, condition
Question
This algorithm should output "Pass" for a mark of 50 or more and "Fail" otherwise, but a mark of exactly 50 prints "Fail". Identify and correct the error. (2 marks)

INPUT Mark IF Mark > 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail" ENDIF
Step-by-step solution
1. Step 1
  Test the boundary (AO3). The pass threshold is '50 or more', i.e. >= 50. With Mark > 50, the value 50 falls to the ELSE branch and prints "Fail". This is a wrong relational operator error at the boundary.
2. Step 2
  Fix it. Change the condition from Mark > 50 to Mark >= 50 so that 50 is treated as a pass.
Answer
INPUT Mark IF Mark >= 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail" ENDIF
Examiner tip
1 mark for spotting the operator (> should be >=), 1 mark for the corrected condition. Always test conditions at the boundary value — that is where off-by-operator bugs hide.
3Building confidence: count items meeting a condition (6 marks)
Building confidence• pseudocode, count
Question
Write pseudocode that reads 50 exam marks and outputs how many were a pass (>= 40). (6 marks)
Step-by-step solution
1. Step 1
  Initialise PassCount to 0 (1 mark). The counter must start at 0 before any marks are read — a missing initialisation is a common error.
2. Step 2
  Loop 50 times (2 marks). FOR Counter ← 1 TO 50 runs inclusively 50 times.
3. Step 3
  Inside the loop (2 marks). INPUT Mark, then IF Mark >= 40 THEN PassCount ← PassCount + 1 ENDIF.
4. Step 4
  Output (1 mark). After the loop, OUTPUT PassCount.
Answer
PassCount ← 0 FOR Counter ← 1 TO 50 INPUT Mark IF Mark >= 40 THEN PassCount ← PassCount + 1 ENDIF NEXT Counter OUTPUT PassCount
Examiner tip
Initialise the counter (1), loop the right number of times (2), test the condition correctly with >= (2), output after the loop (1). Outputting inside the loop is a frequent error — it must come after NEXT.
4Building confidence: find the maximum of N numbers (8 marks)
Building confidence• Adapted from 0478/22 May/Jun 2024 Q5• pseudocode, max
Question
Write pseudocode that reads 20 numbers and outputs the largest. The numbers may be negative. (8 marks)
Step-by-step solution
1. Step 1
  Initialise from the FIRST input (2 marks). INPUT Number then Max ← Number. Initialising Max to 0 is a classic bug — for an all-negative list it would wrongly return 0.
2. Step 2
  Loop the remaining 19 (3 marks). FOR Counter ← 2 TO 20: INPUT Number, then IF Number > Max THEN Max ← Number ENDIF.
3. Step 3
  Compare correctly (2 marks). The IF Number > Max test keeps the largest value seen so far. Using < instead would find the minimum — a wrong-operator error.
4. Step 4
  Output (1 mark). After the loop, OUTPUT Max.
Answer
INPUT Number Max ← Number FOR Counter ← 2 TO 20 INPUT Number IF Number > Max THEN Max ← Number ENDIF NEXT Counter OUTPUT Max
Examiner tip
Initialising Max to the FIRST input (not 0) handles all-negative lists and is the mark-scheme expectation. Note the loop starts at 2 because the first number is already read.
5Stretch: identify and correct three errors (6 marks)
Stretch• 0478 Paper 2 — style• debugging, trace-table
Question
This algorithm should read 10 numbers and output their average, but it produces the wrong result. Identify THREE errors and state the correction for each. (6 marks)

Total ← 0 FOR Counter ← 1 TO 10 INPUT Number Total ← Number NEXT Counter Average ← Total * 10 OUTPUT Avrage
Step-by-step solution
1. Step 1
  Error 1 — accumulation (2 marks). Total ← Number OVERWRITES the total each iteration, leaving only the last number. It should be Total ← Total + Number so each value is added to the running total.
2. Step 2
  Error 2 — wrong operator (2 marks). Average ← Total * 10 multiplies. The average is the sum DIVIDED by the count, so it must be Average ← Total / 10.
3. Step 3
  Error 3 — identifier typo (2 marks). OUTPUT Avrage references an undeclared name. It should be OUTPUT Average to match the variable assigned above.
Answer
Total ← 0 FOR Counter ← 1 TO 10 INPUT Number Total ← Total + Number NEXT Counter Average ← Total / 10 OUTPUT Average
Examiner tip
2 marks per error: each mark pair = correctly IDENTIFYING the error AND giving the fix. A trace table with sample inputs exposes Error 1 (Total only ever holds the last number) immediately.
6Stretch: write & refine a linear search with a flag (8 marks)
Stretch• 0478 Paper 2 — style• pseudocode, search, flag, array
Question
An array Names[1:100] holds 100 names. Write pseudocode that inputs a name to search for and outputs its position if found, or "Not found" if it is not in the array. Use a flag so the search reports correctly. (8 marks)
Step-by-step solution
1. Step 1
  Declare and initialise (2 marks). Input the SearchName, set Found ← FALSE and Position ← 0. The flag records whether a match has occurred.
2. Step 2
  Loop the whole array (2 marks). FOR Index ← 1 TO 100: compare Names[Index] with SearchName.
3. Step 3
  Set the flag on a match (2 marks). IF Names[Index] = SearchName THEN Found ← TRUE and Position ← Index. Storing the index lets us report WHERE it was found.
4. Step 4
  Report after the loop (2 marks). IF Found = TRUE THEN OUTPUT Position ELSE OUTPUT "Not found". Reporting after the loop (not inside) avoids printing 'Not found' on every non-matching element.
Answer
INPUT SearchName Found ← FALSE Position ← 0 FOR Index ← 1 TO 100 IF Names[Index] = SearchName THEN Found ← TRUE Position ← Index ENDIF NEXT Index IF Found = TRUE THEN OUTPUT Position ELSE OUTPUT "Not found" ENDIF
Examiner tip
Flag initialised before the loop (2), full traversal (2), flag + position set on match (2), single report after the loop (2). The flag pattern is the standard refinement that turns a broken 'prints Not found repeatedly' search into a correct one.

Model Answers — Writing Algorithms and Identifying Errors

High-scoring sample answers for writing algorithms and identifying errors on the Cambridge IGCSE 0478 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
0478 Paper 2 — style2 marks
Identify the error in the algorithm below and state the correction. [2 marks]
```
Count ← 0
REPEAT
  INPUT Value
  Count ← Count + 1
UNTIL Count > 5
OUTPUT Count
```
The algorithm is meant to read exactly 5 values, but it reads 6.
Model answer
Error: the loop condition UNTIL Count > 5 stops only once Count reaches 6, so the body runs one extra time (an off-by-one error).

Correction: change the condition to UNTIL Count >= 5 (equivalently UNTIL Count = 5).

Count ← 0 REPEAT INPUT Value Count ← Count + 1 UNTIL Count >= 5 OUTPUT Count
Why this scores
1 mark — identify the off-by-one / wrong condition. 1 mark — correct it (> 5 → >= 5 or = 5). AO3: testing the loop at its exit boundary reveals the extra iteration.
Question 2
0478 Paper 2 — style4 marks
Identify TWO errors in this algorithm and state a correction for each. [4 marks]

The algorithm should read 8 temperatures and output the lowest.
```
INPUT Temp
Min ← 0
FOR Counter ← 1 TO 8
  INPUT Temp
  IF Temp > Min THEN
    Min ← Temp
  ENDIF
NEXT Counter
OUTPUT Min
```
Model answer
Error 1 — wrong initialisation. Min ← 0 should be Min ← Temp (the first input). With Min fixed at 0, any list of positive temperatures returns 0; the minimum must start from a real value.

Error 2 — wrong operator. IF Temp > Min finds the LARGEST value. To find the lowest it must be IF Temp < Min.

Also the loop should run from 2 (the first value is already read), giving:

INPUT Temp Min ← Temp FOR Counter ← 2 TO 8 INPUT Temp IF Temp < Min THEN Min ← Temp ENDIF NEXT Counter OUTPUT Min
Why this scores
2 marks for Error 1 (identify Min ← 0 is wrong + fix to first input), 2 marks for Error 2 (identify > finds max + fix to <). AO3: a minimum/maximum search must be seeded from a real data value, not a literal.
Question 3
0478 Paper 2 — style6 marks
Write pseudocode that reads 30 numbers, then outputs both their total and their average. [6 marks]
Model answer
Total ← 0 FOR Counter ← 1 TO 30 INPUT Number Total ← Total + Number NEXT Counter Average ← Total / 30 OUTPUT Total OUTPUT Average
Why this scores
AO3 mark map: initialise Total ← 0 (1); correct FOR loop 1 TO 30 (1); INPUT Number inside loop (1); running total Total ← Total + Number (1); average Total / 30 after the loop (1); output both Total and Average (1).
Question 4
0478 Paper 2 — style8 marks
A 4-digit PIN must be re-entered until it matches a stored PIN. Write pseudocode that repeatedly inputs a PIN and compares it with StoredPIN, outputting "Access granted" once they match. After 3 failed attempts it must output "Account locked" and stop asking. [8 marks]
Model answer
Attempts ← 0 Granted ← FALSE REPEAT INPUT EnteredPIN Attempts ← Attempts + 1 IF EnteredPIN = StoredPIN THEN Granted ← TRUE ENDIF UNTIL Granted = TRUE OR Attempts = 3 IF Granted = TRUE THEN OUTPUT "Access granted" ELSE OUTPUT "Account locked" ENDIF
Why this scores
AO3 mark map: initialise Attempts ← 0 (1) and flag Granted ← FALSE (1); REPEAT loop with INPUT (1); increment Attempts each try (1); compare with StoredPIN and set flag (1); compound exit condition Granted = TRUE OR Attempts = 3 (2); correct final output of granted vs locked (1). The OR condition is the key design step — exit on success OR on the 3rd failure.
Question 5
0478 Paper 2 — style12 marks
A class votes for one of three options A, B or C. Votes are entered one at a time as the character A, B or C, and the value X ends the voting. Write pseudocode that counts the votes for each option, ignores any invalid entry, and at the end outputs the three totals and the winning option (the one with the most votes). [12 marks]
Model answer
CountA ← 0 CountB ← 0 CountC ← 0 INPUT Vote WHILE Vote <> "X" CASE OF Vote "A": CountA ← CountA + 1 "B": CountB ← CountB + 1 "C": CountC ← CountC + 1 OTHERWISE OUTPUT "Invalid vote ignored" ENDCASE INPUT Vote ENDWHILE OUTPUT "A: ", CountA OUTPUT "B: ", CountB OUTPUT "C: ", CountC IF CountA >= CountB AND CountA >= CountC THEN OUTPUT "Winner is A" ELSE IF CountB >= CountC THEN OUTPUT "Winner is B" ELSE OUTPUT "Winner is C" ENDIF ENDIF
Why this scores
AO3 mark map: initialise three counters to 0 (1); prime INPUT before the loop (1); WHILE loop ending on "X" sentinel (1); re-INPUT inside the loop so it advances (1); CASE/selection on the vote (1); increment the correct counter for A/B/C (3 — one each); OTHERWISE/ELSE ignores invalid entries (1); output the three totals (1); correct nested comparison to find the winner (1). The sentinel-controlled WHILE plus CASE is the standard 12-mark structure.
Question 6
0478 Paper 2 — style15 marks
A car park has 200 spaces. A program records each car as it arrives or leaves. For every event the operator enters either IN (a car arrives) or OUT (a car leaves); entering CLOSE ends the day. The program must: reject an IN when the car park is already full (output "Full") and reject an OUT when it is already empty (output "Empty"); ignore any entry that is not IN, OUT or CLOSE; and when CLOSE is entered, output the number of cars still parked and the total number of cars that were admitted during the day. Write an algorithm, using pseudocode, to complete this task. [15 marks]
Model answer
DECLARE Spaces : INTEGER DECLARE Admitted : INTEGER DECLARE Event : STRING Spaces ← 0 // cars currently in the car park Admitted ← 0 // total cars admitted today INPUT Event WHILE Event <> "CLOSE" CASE OF Event "IN": IF Spaces >= 200 THEN OUTPUT "Full" ELSE Spaces ← Spaces + 1 Admitted ← Admitted + 1 ENDIF "OUT": IF Spaces <= 0 THEN OUTPUT "Empty" ELSE Spaces ← Spaces - 1 ENDIF OTHERWISE OUTPUT "Invalid entry ignored" ENDCASE INPUT Event ENDWHILE OUTPUT "Cars still parked: ", Spaces OUTPUT "Total cars admitted: ", Admitted
Why this scores
AO3 design — 15-mark mark map: declare/initialise Spaces ← 0 (1) and Admitted ← 0 (1); prime INPUT before the loop (1); sentinel-controlled WHILE Event <> "CLOSE" (1); re-INPUT inside the loop so it terminates (1); selection on the event type via CASE/IF (1); handle IN — full check Spaces >= 200 (1) outputting "Full" (1), else increment Spaces (1) AND increment Admitted (1); handle OUT — empty check Spaces <= 0 (1) outputting "Empty" (1), else decrement Spaces (1); OTHERWISE ignores invalid entries (1); on close, output cars still parked and total admitted (1). Key design insight: Admitted counts only SUCCESSFUL arrivals (incremented inside the ELSE), so rejected/Full events do not inflate the daily total.

Key Definitions and Keywords — Writing Algorithms and Identifying Errors

Definitions to memorise and the exact keywords mark schemes credit for writing algorithms and identifying errors answers — sharpened from recent examiner reports for the 2026 0478 sitting.

Pseudocode
Examiner keyword
Algorithm description using English-like keywords. Cambridge has its own conventions (UPPERCASE keywords, ← assignment, INPUT, OUTPUT, IF...THEN...ELSE...ENDIF, FOR...NEXT, WHILE...ENDWHILE, REPEAT...UNTIL, CASE...ENDCASE).
Counter variable
A variable that increments by 1 each iteration of a loop. Common in FOR loops; tracks which iteration we're on. Must be advanced inside a WHILE/REPEAT loop or the loop never ends.
Running total
Examiner keyword
A variable that accumulates a sum as a loop runs. Initialised to 0; updated as Total ← Total + Number each iteration.
Flag variable
A boolean variable used to record whether something has happened (e.g. 'item found'). Initialised to FALSE before the loop, set TRUE during it, and tested after it so the algorithm reports once.
Sentinel / rogue value
Examiner keyword
A special input value (e.g. X or CLOSE) that signals the end of data, used to control a WHILE or REPEAT loop. The input is 'primed' before the loop and re-read inside it.
Off-by-one error
Examiner keyword
A logic error where a loop runs one time too many or too few — usually from a wrong loop condition (> 5 vs >= 5) or starting/ending bound. Caught by tracing the first and last iterations.
Debugging
Examiner keyword
The process of finding and fixing errors in code. Involves reading code carefully, using trace tables, breakpoints and tests.

Common Mistakes and Misconceptions — Writing Algorithms and Identifying Errors

The traps other students keep falling into on writing algorithms and identifying errors questions — taken from recent Cambridge IGCSE 0478 examiner reports and mark schemes — and how to avoid them.

✕Writing Total ← Number instead of Total ← Total + Number
0478 Examiner Reports 2022-2024
Why it happens
Students forget that an accumulator MUST add to itself.
How to avoid it
Running totals: Total ← Total + Number. Counters: Count ← Count + 1. The variable references itself on the right-hand side.
✕Initialising Max/Min to 0 when finding the maximum or minimum
Why it happens
0 feels like a 'safe' starting value.
How to avoid it
If inputs could be NEGATIVE (temperatures, balances) — or all positive when finding a minimum — initialising to 0 returns 0 instead of the real extreme. Initialise to the FIRST INPUT, then loop from 2.
✕Off-by-one errors in loops (wrong condition or bound)
Why it happens
Confusion over inclusive ranges and over > vs >= in loop exits.
How to avoid it
Cambridge FOR Counter ← 1 TO 20 runs 20 times INCLUSIVE. For WHILE/REPEAT, trace the exit condition at its boundary value. UNTIL Count > 5 runs one extra time versus UNTIL Count >= 5.
✕Infinite loop — the loop condition can never become false
Why it happens
The counter is not incremented, or a sentinel input is never re-read inside the loop.
How to avoid it
Every WHILE/REPEAT loop must change something each pass that moves it toward its exit: increment the counter, or re-INPUT the value the condition tests.
✕Reporting / outputting a search result INSIDE the loop
Why it happens
It seems natural to print as soon as you compare an element.
How to avoid it
Use a flag: set it during the loop, then report ONCE after the loop. Printing inside the loop produces 'Not found' on every non-matching element.
✕Trying to debug an algorithm by reading without tracing
Why it happens
Tracing feels slow.
How to avoid it
When stuck, BUILD A TRACE TABLE. Step through with sample inputs and watch each variable. Mark scheme often awards method marks for trace tables even when the final answer is wrong.

Writing Algorithms and Identifying Errors — frequently asked questions

The things students keep getting wrong in this sub-topic, answered.

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

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.

INPUT SearchName Found ← FALSE Position ← 0 FOR Index ← 1 TO 100 IF Names[Index] = SearchName THEN Found ← TRUE Position ← Index ENDIF NEXT Index IF Found = TRUE THEN OUTPUT Position ELSE OUTPUT "Not found" ENDIF

Attempts ← 0 Granted ← FALSE REPEAT INPUT EnteredPIN Attempts ← Attempts + 1 IF EnteredPIN = StoredPIN THEN Granted ← TRUE ENDIF UNTIL Granted = TRUE OR Attempts = 3 IF Granted = TRUE THEN OUTPUT "Access granted" ELSE OUTPUT "Account locked" ENDIF

CountA ← 0 CountB ← 0 CountC ← 0 INPUT Vote WHILE Vote <> "X" CASE OF Vote "A": CountA ← CountA + 1 "B": CountB ← CountB + 1 "C": CountC ← CountC + 1 OTHERWISE OUTPUT "Invalid vote ignored" ENDCASE INPUT Vote ENDWHILE OUTPUT "A: ", CountA OUTPUT "B: ", CountB OUTPUT "C: ", CountC IF CountA >= CountB AND CountA >= CountC THEN OUTPUT "Winner is A" ELSE IF CountB >= CountC THEN OUTPUT "Winner is B" ELSE OUTPUT "Winner is C" ENDIF ENDIF

DECLARE Spaces : INTEGER DECLARE Admitted : INTEGER DECLARE Event : STRING Spaces ← 0 // cars currently in the car park Admitted ← 0 // total cars admitted today INPUT Event WHILE Event <> "CLOSE" CASE OF Event "IN": IF Spaces >= 200 THEN OUTPUT "Full" ELSE Spaces ← Spaces + 1 Admitted ← Admitted + 1 ENDIF "OUT": IF Spaces <= 0 THEN OUTPUT "Empty" ELSE Spaces ← Spaces - 1 ENDIF OTHERWISE OUTPUT "Invalid entry ignored" ENDCASE INPUT Event ENDWHILE OUTPUT "Cars still parked: ", Spaces OUTPUT "Total cars admitted: ", Admitted

Writing Algorithms and Identifying Errors

Short Notes - Writing Algorithms and Identifying Errors

Detailed Study Notes

At a glance

What you’ll learn

Common algorithm patterns

Search and sort

Identifying errors in algorithms

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Getting started: spot & fix one error (2 marks)

2Getting started: correct a wrong condition (2 marks)

3Building confidence: count items meeting a condition (6 marks)

4Building confidence: find the maximum of N numbers (8 marks)

5Stretch: identify and correct three errors (6 marks)

6Stretch: write & refine a linear search with a flag (8 marks)

Pseudocode

Counter variable

Running total

Flag variable

Sentinel / rogue value

Off-by-one error

Debugging

✕Writing Total ← Number instead of Total ← Total + Number

✕Initialising Max/Min to 0 when finding the maximum or minimum

✕Off-by-one errors in loops (wrong condition or bound)

✕Infinite loop — the loop condition can never become false

✕Reporting / outputting a search result INSIDE the loop

✕Trying to debug an algorithm by reading without tracing

Writing Algorithms and Identifying Errors — frequently asked questions

Writing Algorithms and Identifying Errors

Short Notes - Writing Algorithms and Identifying Errors

Detailed Study Notes

At a glance

What you’ll learn

Common algorithm patterns

Search and sort

Identifying errors in algorithms

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Getting started: spot & fix one error (2 marks)

2Getting started: correct a wrong condition (2 marks)

3Building confidence: count items meeting a condition (6 marks)

4Building confidence: find the maximum of N numbers (8 marks)

5Stretch: identify and correct three errors (6 marks)

6Stretch: write & refine a linear search with a flag (8 marks)

Pseudocode

Counter variable

Running total

Flag variable

Sentinel / rogue value

Off-by-one error

Debugging

✕Writing Total ← Number instead of Total ← Total + Number

✕Initialising Max/Min to 0 when finding the maximum or minimum

✕Off-by-one errors in loops (wrong condition or bound)

✕Infinite loop — the loop condition can never become false

✕Reporting / outputting a search result INSIDE the loop

✕Trying to debug an algorithm by reading without tracing

Writing Algorithms and Identifying Errors — frequently asked questions

✕Writing `Total ← Number` instead of `Total ← Total + Number`

✕Writing `Total ← Number` instead of `Total ← Total + Number`