What is the importance of designing algorithms in Computer Science?

Designing algorithms is crucial in Computer Science because it involves creating step-by-step instructions to solve problems efficiently. It helps in breaking down complex problems into manageable parts, ensuring that solutions are logical, efficient, and can be implemented in programming. In the Cambridge IGCSE curriculum, understanding algorithm design is fundamental to developing problem-solving skills and writing effective code.

How do I start designing an algorithm for a given problem?

To start designing an algorithm, first clearly define the problem and understand the requirements. Break down the problem into smaller, manageable parts. Identify the inputs and desired outputs. Then, outline the steps needed to transform the inputs into outputs. This process often involves using flowcharts or pseudocode to visualize the logic before coding. Practicing these steps is essential for mastering algorithm design in the Cambridge IGCSE Computer Science course.

What are some common techniques used in algorithm design?

Common techniques in algorithm design include divide and conquer, dynamic programming, greedy algorithms, and backtracking. Divide and conquer involves breaking a problem into smaller subproblems, solving them independently, and combining their solutions. Dynamic programming is used for optimization problems by storing solutions to subproblems. Greedy algorithms make the best choice at each step, while backtracking involves exploring all possible solutions. These techniques are integral to the Cambridge IGCSE Computer Science curriculum.

How can I evaluate the efficiency of an algorithm?

The efficiency of an algorithm is evaluated based on its time and space complexity, which measure how the algorithm's resource usage grows with input size. Time complexity is often expressed using Big O notation, which describes the upper limit of execution time. Space complexity considers the memory usage. Understanding these concepts helps students in the Cambridge IGCSE Computer Science course to choose the most efficient algorithms for their problems.

What role do flowcharts and pseudocode play in designing algorithms?

Flowcharts and pseudocode are essential tools in designing algorithms. Flowcharts provide a visual representation of the algorithm's flow, making it easier to understand the logic and sequence of steps. Pseudocode, on the other hand, uses plain language to describe the algorithm's steps, bridging the gap between the problem and the actual code. Both tools help in planning and communicating the algorithm's design, which is a key skill in the Cambridge IGCSE Computer Science curriculum.

Why is "Writing pseudocode in a specific programming language" a common mistake in Designing Algorithms?

Why it happens: Students default to Python or Java syntax. How to avoid it: Pseudocode is LANGUAGE-INDEPENDENT. Use Cambridge keywords: INPUT, OUTPUT, IF...THEN...ELSE, FOR...NEXT, WHILE...ENDWHILE, REPEAT...UNTIL. Source: 0478 Examiner Reports 2022-2024

Why is "Skipping initial values in a trace table" a common mistake in Designing Algorithms?

Why it happens: Students start tracing from the first user input. How to avoid it: Show INITIAL values (often 0 or unset) in the first row. The trace must capture every change.

Why is "Using the wrong shape in a flowchart" a common mistake in Designing Algorithms?

Why it happens: Students don't memorise the standard set. How to avoid it: OVAL = start/end. RECTANGLE = process. PARALLELOGRAM = input/output. DIAMOND = decision. ARROWS connect them.

Why is "Confusing iteration with selection" a common mistake in Designing Algorithms?

Why it happens: Both involve a condition. How to avoid it: Selection (IF) checks condition ONCE. Iteration (WHILE/FOR/REPEAT) checks the condition repeatedly and loops back.

Cambridge IGCSE Computer Science (0478)

Designing Algorithms

0% Complete

3 tasks remaining

Short Notes - Designing Algorithms

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.

Designing Algorithms Study Notes — Cambridge IGCSE Computer Science 0478 (2026-2028 syllabus)

How to express an algorithm before coding it. Three notations — structured English, pseudocode, flowcharts. The three control structures. Trace tables for hand-checking algorithms. Why designing first is faster than coding-and-fixing.

At a glance

Algorithm = step-by-step instructions to solve a problem.
Three notations: structured English, pseudocode, flowcharts.
Three control structures: sequence, selection, iteration.
Cambridge pseudocode uses INPUT, OUTPUT, IF/THEN, FOR, WHILE.
Flowchart symbols: oval, rectangle, parallelogram, diamond.
Trace table = hand-trace each variable per step.
Design first → code is faster + better.
Iteration is for repetition; selection is for choice.

What you’ll learn

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

1.18.1 — Describe what an algorithm is.
1.18.2 — Express algorithms in pseudocode and flowcharts.
1.18.3 — Use sequence, selection and iteration.
1.18.4 — Use trace tables to dry-run algorithms.

Three ways to express an algorithm

Structured English, pseudocode, flowcharts — pick the right one for the audience.

An algorithm can be written in three standard ways. They convey the same meaning at different levels of formality.

Structured English. Plain English with structured indentation and key phrases.

Repeat for each student: Read the student's mark. If the mark is at least 40, add 1 to PassCount. Output PassCount.

Use when: explaining the algorithm to non-programmers.

Pseudocode. English-like keywords following a defined convention. Cambridge has its own conventions (INPUT, OUTPUT, IF...THEN...ELSE...ENDIF, FOR...NEXT, WHILE...ENDWHILE, REPEAT...UNTIL).

PassCount ← 0
FOR Counter ← 1 TO N
  INPUT Mark
  IF Mark >= 40 THEN
    PassCount ← PassCount + 1
  ENDIF
NEXT Counter
OUTPUT PassCount

Use when: communicating to programmers; about to translate into code.

Flowcharts. Diagrams with standard shapes connected by arrows. Use when: visualising flow with branches and loops; documenting for visual learners.

Four shapes plus arrows describe any algorithm. Branches at diamonds; sequential boxes connected by arrows.

Cambridge tip. Pseudocode in 0478 follows specific conventions. Use Cambridge keywords; don't write Python or Java.

Structured English for non-programmers.
Pseudocode for programmers.
Flowcharts for visual flow with branches.

See the full worked example for designing algorithms →

The three control structures

Sequence, selection, iteration — the only three ways code flows.

Every program is built from three control structures.

Sequence. Instructions executed one after another in order.

INPUT A
INPUT B
Sum ← A + B
OUTPUT Sum

Selection. Choose between alternatives based on a condition.

IF Mark >= 40 THEN
  OUTPUT "Pass"
ELSE
  OUTPUT "Fail"
ENDIF

Iteration. Repeat instructions. Three flavours:

Count-controlled (FOR loop) — repeat a fixed number of times.
Pre-condition (WHILE loop) — check condition first; loop while true.
Post-condition (REPEAT...UNTIL) — execute first; check at end; loop until condition true.

Cambridge tip. Mark scheme expects students to NAME the three structures and use the right keywords. Saying 'a loop' is too vague when a question asks 'name the type of iteration'.

Sequence — line by line.
Selection — IF / IF-ELSE / CASE.
Iteration — FOR / WHILE / REPEAT-UNTIL.

Flowchart symbols

Standard shapes mean specific things — use the right ones.

Flowcharts use standardised symbols. Mark schemes deduct for the wrong shapes.

Symbol	Shape	Use
Terminator	Oval	START or END of the algorithm.
Process	Rectangle	A processing step (calculation, assignment, command).
Input/Output	Parallelogram	Reading input or writing output.
Decision	Diamond	A condition with TRUE/FALSE branches.
Subroutine call	Rectangle with two extra vertical lines	Calls a named subroutine.
Connector	Small circle	Joins parts of a flowchart that don't fit on one page.
Flow	Arrow	Connects shapes; shows direction.

Cambridge tip. Always use ARROWS (not just lines). Decision diamonds have TWO outputs (TRUE and FALSE labelled). Process rectangles have ONE output.

Oval, rectangle, parallelogram, diamond.
Decision has TWO labelled outputs.
Always use arrows showing direction.

See the full worked example for designing algorithms →

Trace tables — debugging by hand

Step through your algorithm with paper and pen.

A trace table is a table that records the value of each variable at each step of an algorithm. Used to:

Check correctness BEFORE running the code.
Debug an algorithm that's giving the wrong output.
Answer 'what does this algorithm output for the given input' exam questions.

How to build one.

List ALL variables as columns. Add an OUTPUT column.
Set the initial values of variables (often 0 or undefined).
Step through the algorithm one line at a time. Whenever a variable changes, write the new value in its column for that row.
When OUTPUT happens, write the output in the output column.
Continue until the algorithm ends.

Example. For the algorithm

Total ← 0
INPUT N
WHILE N <> 0
  Total ← Total + N
  INPUT N
ENDWHILE
OUTPUT Total

with inputs 3, 5, 2, 0:

Step	Total	N	Output
Init	0	—
Input	0	3
Total	3	3
Input	3	5
Total	8	5
Input	8	2
Total	10	2
Input	10	0
Output	10	0	10

Cambridge tip. Mark scheme often awards method marks for a correct trace table even when the FINAL answer is wrong. Always show the trace.

Columns for variables + Output.
Update each variable as the algorithm runs.
Include initial values in the first row.

See the full worked example for designing algorithms →

Quick recap

Algorithm = step-by-step instructions.
Three notations: structured English, pseudocode, flowcharts.
Three control structures: sequence, selection, iteration.
Cambridge pseudocode has its own conventions — use them.
Trace tables track every variable at every step.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

Sequence, selection, iteration — the three control structures.
Cambridge pseudocode keywords: INPUT, OUTPUT, IF/THEN/ELSE/ENDIF, FOR/NEXT, WHILE/ENDWHILE, REPEAT/UNTIL.
Flowchart shapes: oval, rectangle, parallelogram, diamond.
Trace table records every variable at every step.

How it’s examined

Algorithm design dominates Paper 2. Most-tested questions: write pseudocode for a given task (6-10 marks), complete a trace table (6-8 marks), identify flowchart symbols (4 marks). Examiner reports flag use of language-specific syntax (Python, Java) instead of Cambridge pseudocode as the top reason for lost marks.

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 — Designing Algorithms

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

1Identify flowchart symbols (4 marks)
Getting started• flowchart
Question
Identify FOUR standard flowchart symbols and what they represent. (4 marks)
Step-by-step solution
1. Step 1
  Oval / terminator (1 mark). START or END of the algorithm.
2. Step 2
  Rectangle / process (1 mark). A processing step (calculation, assignment).
3. Step 3
  Parallelogram / input-output (1 mark). Reading input or writing output.
4. Step 4
  Diamond / decision (1 mark). A condition with TRUE/FALSE branches.
Answer
Oval (start/end), rectangle (process), parallelogram (I/O), diamond (decision). ARROWS connect them showing flow.
2Identify inputs, processes and outputs (3 marks)
Getting started• 0478 Paper 2 — style• pseudocode, ipo
Question
A program reads a temperature in Celsius, converts it to Fahrenheit, and displays the result. State the INPUT, the PROCESS and the OUTPUT of this program. (3 marks)
Step-by-step solution
1. Step 1
  Input (1 mark). The temperature in Celsius — the data supplied to the program.
2. Step 2
  Process (1 mark). Calculate Fahrenheit using F ← C * 9 / 5 + 32 — the manipulation that turns input into output.
3. Step 3
  Output (1 mark). Display the Fahrenheit value — the result returned to the user.
Answer
INPUT: temperature in Celsius. PROCESS: Fahrenheit ← Celsius * 9 / 5 + 32. OUTPUT: temperature in Fahrenheit. Every algorithm question can be decomposed this way — name the data going in, the calculation/decision done to it, and the result coming out.
Examiner tip
Examiners want the three stages clearly separated. A common error is to list the conversion as an 'output' — the calculation is the PROCESS; only the displayed value is the OUTPUT.
3Pseudocode for finding an average (6 marks)
Building confidence• Adapted from 0478/22 May/Jun 2024 Q4• pseudocode
Question
Write pseudocode that reads 10 numbers, calculates the average and outputs it. (6 marks)
Step-by-step solution
1. Step 1
  Initialise variables (1 mark). Total starts at 0; counter starts at 1.
2. Step 2
  Loop 10 times (2 marks). Use a FOR loop or WHILE loop with the counter.
3. Step 3
  Inside the loop (2 marks). INPUT a number, ADD it to the total.
4. Step 4
  After the loop (1 mark). DIVIDE total by 10 and OUTPUT.
Answer
Total ← 0 FOR Counter ← 1 TO 10 INPUT Number Total ← Total + Number NEXT Counter Average ← Total / 10 OUTPUT Average
Examiner tip
Mark scheme accepts FOR or WHILE loops. Initialisation, correct loop count, sum/divide, output — all stages must appear for full marks.
4Complete a trace table (6 marks)
Building confidence• trace-table
Question
Complete a trace table for this algorithm with INPUT 4, 7, 2, 9, -1.

Total ← 0 INPUT N WHILE N <> -1 Total ← Total + N INPUT N ENDWHILE OUTPUT Total

(6 marks)
Step-by-step solution
1. Step 1
  Set up columns (1 mark). Total | N | Output.
2. Step 2
  Trace each iteration (4 marks). Initial: Total=0, N=? After INPUT: N=4. Total=0+4=4, N=7. Total=4+7=11, N=2. Total=11+2=13, N=9. Total=13+9=22, N=-1. Loop exits.
3. Step 3
  Output (1 mark). Total=22 is output.
Answer
Total: 0, 4, 11, 13, 22. N: 4, 7, 2, 9, -1. Output: 22. The trace table reveals each variable's value at each step — invaluable for hand-checking algorithms.
5Find the largest of N numbers (7 marks)
Stretch• 0478 Paper 2 — style• pseudocode, max
Question
Write pseudocode that reads how many numbers will be entered, then reads that many numbers and outputs the LARGEST one. (7 marks)
Step-by-step solution
1. Step 1
  Read the count (1 mark). INPUT how many numbers (HowMany).
2. Step 2
  Seed the maximum (2 marks). INPUT the first number and store it as Largest — you cannot compare against an uninitialised variable, so the first value seeds it.
3. Step 3
  Loop the remaining numbers (2 marks). FOR from 2 TO HowMany, INPUT each number.
4. Step 4
  Compare and replace (1 mark). IF Number > Largest THEN Largest ← Number.
5. Step 5
  Output (1 mark). OUTPUT Largest after the loop.
Answer
INPUT HowMany INPUT Number Largest ← Number FOR Counter ← 2 TO HowMany INPUT Number IF Number > Largest THEN Largest ← Number ENDIF NEXT Counter OUTPUT Largest
Examiner tip
The classic trap is initialising Largest ← 0, which fails for all-negative data. Seeding with the first input is the safe technique. Looping from 2 (not 1) avoids re-reading the seed value.
6Count and total with a sentinel + validation (8 marks)
Stretch• 0478 Paper 2 — style• pseudocode, totalling, counting
Question
A teacher enters test marks (0 to 100). Entry stops when -1 is typed. Marks outside the 0–100 range must be rejected with a message and not counted. Output how many valid marks were entered and their average. (8 marks)
Step-by-step solution
1. Step 1
  Initialise (1 mark). Total ← 0 and Count ← 0 before any input.
2. Step 2
  Pre-condition loop with sentinel (2 marks). INPUT Mark first, then WHILE Mark <> -1. Reading before the loop lets the sentinel exit immediately.
3. Step 3
  Validate the range (2 marks). IF Mark >= 0 AND Mark <= 100 accept it; ELSE OUTPUT a rejection message.
4. Step 4
  Accumulate (1 mark). When valid: Total ← Total + Mark and Count ← Count + 1. INPUT the next Mark inside the loop.
5. Step 5
  Guard division and output (2 marks). After the loop, IF Count > 0 output Count and Total / Count, ELSE report that no valid marks were entered (avoids divide-by-zero).
Answer
Total ← 0 Count ← 0 INPUT Mark WHILE Mark <> -1 IF Mark >= 0 AND Mark <= 100 THEN Total ← Total + Mark Count ← Count + 1 ELSE OUTPUT "Mark rejected — must be 0 to 100" ENDIF INPUT Mark ENDWHILE IF Count > 0 THEN OUTPUT "Valid marks: ", Count OUTPUT "Average: ", Total / Count ELSE OUTPUT "No valid marks entered" ENDIF
Examiner tip
Full marks need the sentinel handled correctly (the -1 must NOT be added or counted), the range check using AND, and the divide-by-zero guard. AO3 design: candidates who divide by Count without checking Count > 0 lose the final mark.

Model Answers — Designing Algorithms

High-scoring sample answers for designing algorithms 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
State the THREE basic control structures used when designing an algorithm and give a brief description of each. (2 marks)
Model answer
Any TWO of the three, with description, score the 2 marks:

Sequence — instructions carried out one after another, in order Selection — choosing between paths based on a condition (IF / CASE) Iteration — repeating instructions (FOR / WHILE / REPEAT)
Why this scores
AO1 knowledge. 1 mark per correctly named structure WITH a description (max 2). Naming alone (e.g. just 'iteration') is insufficient — a description is required. Accept 'loop' for iteration and 'decision/branching' for selection.
Question 2
0478 Paper 2 — style4 marks
A vending machine works as follows: the user inserts coins, selects a drink, and if enough money has been inserted the drink is dispensed and any change is returned. Write this algorithm in structured English. (4 marks)
Model answer
INPUT the coins inserted INPUT the drink selected GET the price of the selected drink IF money inserted >= price THEN DISPENSE the drink CALCULATE change = money inserted - price RETURN the change ELSE RETURN all the inserted coins ENDIF
Why this scores
AO2 apply. Mark scheme: input coins + selection (1), retrieve/compare against price (1), dispense when sufficient and calculate change (1), reject/refund when insufficient (1). Structured English uses plain capitalised verbs, not full pseudocode syntax — both forms are credited here as long as the logic and the IF…ELSE decision are clear.
Question 3
0478 Paper 2 — style6 marks
Write pseudocode for an algorithm that inputs an integer and outputs its times table from 1 to 12 (e.g. for input 7 it outputs 7, 14, 21 … 84). (6 marks)
Model answer
DECLARE Number : INTEGER DECLARE Counter : INTEGER INPUT Number FOR Counter ← 1 TO 12 OUTPUT Number, " x ", Counter, " = ", Number * Counter NEXT Counter
Why this scores
AO2 apply. Marks: declare/INPUT the number (1), count-controlled loop 1 TO 12 (2), correct multiplication Number * Counter inside the loop (2), output inside the loop so all 12 lines appear (1). A frequent error is placing OUTPUT after NEXT, which prints only the last result.
Question 4
0478 Paper 2 — style8 marks
Write pseudocode that inputs 30 students' percentage marks. For each mark, output the grade using these rules: 70 or above = 'Distinction', 50 to 69 = 'Pass', below 50 = 'Fail'. Also output how many students achieved a Distinction. (8 marks)
Model answer
DistinctionCount ← 0 FOR Student ← 1 TO 30 INPUT Mark IF Mark >= 70 THEN OUTPUT "Distinction" DistinctionCount ← DistinctionCount + 1 ELSE IF Mark >= 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail" ENDIF ENDIF NEXT Student OUTPUT "Distinctions: ", DistinctionCount
Why this scores
AO2/AO3. Marks: initialise counter to 0 (1), count-controlled loop 1 TO 30 (1), INPUT inside loop (1), Distinction boundary >= 70 (1), Pass boundary 50–69 via nested IF/ELSE (2), increment counter only on Distinction (1), final OUTPUT of the count after the loop (1). Boundary errors (using > 70 instead of >= 70) are the most common mark loss; nested IF or CASE OF both accepted.
Question 5
0478 Paper 2 — style12 marks
A system stores a 4-digit PIN. Write pseudocode that lets the user enter a PIN. The user has up to THREE attempts. If the entered PIN matches the stored PIN the program outputs 'Access granted' and stops; otherwise it outputs 'Incorrect' and lets them try again. After three failed attempts the account is locked and 'Account locked' is output. Assume the correct PIN is held in a variable StoredPIN. (12 marks)
Model answer
DECLARE StoredPIN : INTEGER DECLARE EnteredPIN : INTEGER DECLARE Attempts : INTEGER DECLARE AccessGranted : BOOLEAN Attempts ← 0 AccessGranted ← FALSE REPEAT INPUT EnteredPIN Attempts ← Attempts + 1 IF EnteredPIN = StoredPIN THEN OUTPUT "Access granted" AccessGranted ← TRUE ELSE IF Attempts < 3 THEN OUTPUT "Incorrect" ENDIF ENDIF UNTIL AccessGranted = TRUE OR Attempts = 3 IF AccessGranted = FALSE THEN OUTPUT "Account locked" ENDIF
Why this scores
AO3 design. Mark scheme (max 12): declare/initialise Attempts ← 0 (1) and a Boolean/flag for success (1); post-condition loop chosen so input runs at least once (1); INPUT EnteredPIN inside loop (1); increment Attempts each pass (1); compare EnteredPIN to StoredPIN (1); output 'Access granted' and set flag on match (1); output 'Incorrect' on a failed non-final attempt (1); loop terminates on success OR on the 3rd attempt — both conditions correct (2); after the loop, output 'Account locked' only when access was never granted (1); overall logical correctness / no extra 'Incorrect' on the 3rd fail (1). A WHILE pre-condition loop is equally valid if the flag logic is right.
Question 6
0478 Paper 2 — style15 marks
Unseen scenario (15 marks). A car park has 200 spaces. Throughout the day the system records each event: a car arriving is logged as the letter A, a car leaving as the letter D, and the letter X marks the end of the day's events. Write pseudocode that processes the events one at a time and:
- keeps a running count of cars currently in the car park (it starts empty, with 0 cars);
- when a car arrives, only admits it if there is a free space — if the car park is already full it outputs 'Full' and does not admit the car;
- when a car leaves, reduces the count, but never lets the count go below 0 (it ignores a D when the car park is already empty);
- ignores any event letter that is not A, D or X and outputs 'Invalid event';
- stops when X is entered, then outputs the number of cars remaining and the total number of cars that were admitted during the day. (15 marks)
Model answer
DECLARE Spaces : INTEGER DECLARE CarsIn : INTEGER DECLARE TotalAdmitted : INTEGER DECLARE Event : CHAR CONSTANT Spaces = 200 CarsIn ← 0 TotalAdmitted ← 0 INPUT Event WHILE Event <> 'X' IF Event = 'A' THEN IF CarsIn < Spaces THEN CarsIn ← CarsIn + 1 TotalAdmitted ← TotalAdmitted + 1 ELSE OUTPUT "Full" ENDIF ELSE IF Event = 'D' THEN IF CarsIn > 0 THEN CarsIn ← CarsIn - 1 ENDIF ELSE OUTPUT "Invalid event" ENDIF ENDIF INPUT Event ENDWHILE OUTPUT "Cars remaining: ", CarsIn OUTPUT "Total admitted: ", TotalAdmitted
Why this scores
AO3 design — the full 15-mark scenario question (~30 min). Indicative mark scheme: declare variables / set Spaces to 200 (1); initialise CarsIn ← 0 (1) and TotalAdmitted ← 0 (1); read first Event before the loop and use a sentinel-controlled WHILE on 'X' (2); INPUT next Event inside the loop so it terminates (1); test Event = 'A' (1); admit only when CarsIn < Spaces — increment CarsIn (1) and TotalAdmitted (1); output 'Full' when no space (1); test Event = 'D' (1); decrement CarsIn only when CarsIn > 0 (2); 'Invalid event' for any other letter via the ELSE branch (1); final OUTPUT of CarsIn (1) and TotalAdmitted (1). A REPEAT…UNTIL or CASE OF structure earns equivalent credit. Marks are commonly lost by counting the 'X' as invalid (it must exit cleanly), letting CarsIn exceed 200, or incrementing TotalAdmitted on a rejected arrival.

Key Definitions and Keywords — Designing Algorithms

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

Algorithm
Examiner keyword
A step-by-step set of instructions to solve a problem or perform a task. Independent of any specific programming language.
Pseudocode
Examiner keyword
Algorithm description using English-like keywords (INPUT, OUTPUT, IF, WHILE, FOR) — close to code but readable by anyone.
Flowchart
Examiner keyword
A diagrammatic representation of an algorithm using standard shapes connected by arrows.
Sequence
Examiner keyword
Instructions executed one after another in order. The simplest control structure.
Selection
Examiner keyword
A control structure that chooses between alternatives based on a condition (IF / IF...ELSE / CASE).
Iteration
Examiner keyword
A control structure that repeats instructions. Count-controlled (FOR), pre-condition (WHILE), post-condition (REPEAT...UNTIL).
Trace table
Examiner keyword
A table used to dry-run an algorithm by hand, showing the value of each variable at each step.
Dry run
Working through an algorithm by hand (typically with a trace table) to check correctness without running it on a computer.

Common Mistakes and Misconceptions — Designing Algorithms

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

✕Writing pseudocode in a specific programming language
0478 Examiner Reports 2022-2024
Why it happens
Students default to Python or Java syntax.
How to avoid it
Pseudocode is LANGUAGE-INDEPENDENT. Use Cambridge keywords: INPUT, OUTPUT, IF...THEN...ELSE, FOR...NEXT, WHILE...ENDWHILE, REPEAT...UNTIL.
✕Skipping initial values in a trace table
Why it happens
Students start tracing from the first user input.
How to avoid it
Show INITIAL values (often 0 or unset) in the first row. The trace must capture every change.
✕Using the wrong shape in a flowchart
Why it happens
Students don't memorise the standard set.
How to avoid it
OVAL = start/end. RECTANGLE = process. PARALLELOGRAM = input/output. DIAMOND = decision. ARROWS connect them.
✕Confusing iteration with selection
Why it happens
Both involve a condition.
How to avoid it
Selection (IF) checks condition ONCE. Iteration (WHILE/FOR/REPEAT) checks the condition repeatedly and loops back.

Designing Algorithms — frequently asked questions

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

Symbol

Shape

Use

Terminator

Oval

START or END of the algorithm.

Process

Rectangle

A processing step (calculation, assignment, command).

Input/Output

Parallelogram

Reading input or writing output.

Decision

Diamond

A condition with TRUE/FALSE branches.

Subroutine call

Rectangle with two extra vertical lines

Calls a named subroutine.

Connector

Small circle

Joins parts of a flowchart that don't fit on one page.

Flow

Arrow

Connects shapes; shows direction.

Step

Total

Output

Init

—

Input

Total

Input

Total

Input

Total

Input

Output

Total ← 0 Count ← 0 INPUT Mark WHILE Mark <> -1 IF Mark >= 0 AND Mark <= 100 THEN Total ← Total + Mark Count ← Count + 1 ELSE OUTPUT "Mark rejected — must be 0 to 100" ENDIF INPUT Mark ENDWHILE IF Count > 0 THEN OUTPUT "Valid marks: ", Count OUTPUT "Average: ", Total / Count ELSE OUTPUT "No valid marks entered" ENDIF

INPUT the coins inserted INPUT the drink selected GET the price of the selected drink IF money inserted >= price THEN DISPENSE the drink CALCULATE change = money inserted - price RETURN the change ELSE RETURN all the inserted coins ENDIF

DistinctionCount ← 0 FOR Student ← 1 TO 30 INPUT Mark IF Mark >= 70 THEN OUTPUT "Distinction" DistinctionCount ← DistinctionCount + 1 ELSE IF Mark >= 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail" ENDIF ENDIF NEXT Student OUTPUT "Distinctions: ", DistinctionCount

DECLARE StoredPIN : INTEGER DECLARE EnteredPIN : INTEGER DECLARE Attempts : INTEGER DECLARE AccessGranted : BOOLEAN Attempts ← 0 AccessGranted ← FALSE REPEAT INPUT EnteredPIN Attempts ← Attempts + 1 IF EnteredPIN = StoredPIN THEN OUTPUT "Access granted" AccessGranted ← TRUE ELSE IF Attempts < 3 THEN OUTPUT "Incorrect" ENDIF ENDIF UNTIL AccessGranted = TRUE OR Attempts = 3 IF AccessGranted = FALSE THEN OUTPUT "Account locked" ENDIF

Unseen scenario (15 marks). A car park has 200 spaces. Throughout the day the system records each event: a car arriving is logged as the letter A, a car leaving as the letter D, and the letter X marks the end of the day's events. Write pseudocode that processes the events one at a time and:

keeps a running count of cars currently in the car park (it starts empty, with 0 cars);
when a car arrives, only admits it if there is a free space — if the car park is already full it outputs 'Full' and does not admit the car;
when a car leaves, reduces the count, but never lets the count go below 0 (it ignores a D when the car park is already empty);
ignores any event letter that is not A, D or X and outputs 'Invalid event';
stops when X is entered, then outputs the number of cars remaining and the total number of cars that were admitted during the day. (15 marks)

DECLARE Spaces : INTEGER DECLARE CarsIn : INTEGER DECLARE TotalAdmitted : INTEGER DECLARE Event : CHAR CONSTANT Spaces = 200 CarsIn ← 0 TotalAdmitted ← 0 INPUT Event WHILE Event <> 'X' IF Event = 'A' THEN IF CarsIn < Spaces THEN CarsIn ← CarsIn + 1 TotalAdmitted ← TotalAdmitted + 1 ELSE OUTPUT "Full" ENDIF ELSE IF Event = 'D' THEN IF CarsIn > 0 THEN CarsIn ← CarsIn - 1 ENDIF ELSE OUTPUT "Invalid event" ENDIF ENDIF INPUT Event ENDWHILE OUTPUT "Cars remaining: ", CarsIn OUTPUT "Total admitted: ", TotalAdmitted

Designing Algorithms

Short Notes - Designing Algorithms

Detailed Study Notes

At a glance

What you’ll learn

Three ways to express an algorithm

The three control structures

Flowchart symbols

Trace tables — debugging by hand

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Identify flowchart symbols (4 marks)

2Identify inputs, processes and outputs (3 marks)

3Pseudocode for finding an average (6 marks)

4Complete a trace table (6 marks)

5Find the largest of N numbers (7 marks)

6Count and total with a sentinel + validation (8 marks)

Algorithm

Pseudocode

Flowchart

Sequence

Selection

Iteration

Trace table

Dry run

✕Writing pseudocode in a specific programming language

✕Skipping initial values in a trace table

✕Using the wrong shape in a flowchart

✕Confusing iteration with selection

Designing Algorithms — frequently asked questions

Designing Algorithms

Short Notes - Designing Algorithms

Detailed Study Notes

At a glance

What you’ll learn

Three ways to express an algorithm

The three control structures

Flowchart symbols

Trace tables — debugging by hand

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Identify flowchart symbols (4 marks)

2Identify inputs, processes and outputs (3 marks)

3Pseudocode for finding an average (6 marks)

4Complete a trace table (6 marks)

5Find the largest of N numbers (7 marks)

6Count and total with a sentinel + validation (8 marks)

Algorithm

Pseudocode

Flowchart

Sequence

Selection

Iteration

Trace table

Dry run

✕Writing pseudocode in a specific programming language

✕Skipping initial values in a trace table

✕Using the wrong shape in a flowchart

✕Confusing iteration with selection

Designing Algorithms — frequently asked questions