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.

Algorithm design and problem-solvingCambridge IGCSE Computer Science (0478)

Designing Algorithms

Work through the notes, try the practice questions, then take the quiz. The report tells you exactly what to revise next.

Previous Next

Learn this Topic

Start with the slides for the quick version, then go deeper with the full study notes.

Short Study Notes in the form of Slides

Read the notes first. If the method in a worked example clicks, you're ready for the questions.

Page 1 / 0

Detailed Study Notes

Full prose, callouts and a recap — built for A* mastery, not just a quick scan.

Take these study notes with you

Download a branded PDF — full prose, callouts, recap and memorise list for Designing Algorithms, ready to print or save offline.

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.

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.

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 →

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.

Master this Topic

Worked examples, formulae, definitions and the mistakes examiners flag — everything you need to push from a pass to an A*.

Take this whole topic with you

Download a branded revision sheet — worked examples, formulae, definitions and common mistakes for Designing Algorithms, ready to print or save as PDF.

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.

1Pseudocode for finding an average (6 marks)
Extended• 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.
2Identify flowchart symbols (4 marks)
Core• 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.
3Complete a trace table (6 marks)
Extended• 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.

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.

Practice questions

Exam-style questions with step-by-step worked solutions. Try one before checking the method.

Past paper style quiz

Get a report showing which sub-topics you've nailed and which ones still need work.

Designing Algorithms — frequently asked questions

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

Designing Algorithms

Short Study Notes in the form of Slides

Detailed Study Notes

What you’ll learn

How it’s examined

1Pseudocode for finding an average (6 marks)

2Identify flowchart symbols (4 marks)

3Complete a trace table (6 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

Practice questions

Past paper style quiz

Assess your understanding

Designing Algorithms — frequently asked questions