Representing algorithms — AQA GCSE Computer Science

Representing algorithms is a foundational topic in AQA GCSE Computer Science that bridges the gap between problem decomposition and writing executable code. It covers the core methods used to plan and document program logic: pseudocode, system flowcharts, and structured natural language.

This topic equips students with the analytical skills needed to trace algorithm execution, identify logic errors, and evaluate efficiency using trace tables. Mastering these concepts ensures students can express complex computational solutions clearly on paper during examinations without depending on a compiler.

• →Standard Flowchart Symbols: Terminator (start/end oval), Process (rectangle), Input/Output (parallelogram), Decision (diamond), Subroutine (rectangle with double borders).
• →Pseudocode Conventions: Language-independent notation using standard programming constructs like IF-THEN-ELSE, WHILE-ENDWHILE, and FOR-ENDFOR.
• →Trace Tables: Tabular method used for dry-running algorithms to record variable updates and condition outcomes step-by-step.
• →Algorithm Efficiency: Comparing different algorithmic solutions to the same problem in terms of steps required and logic clarity.

• Describes a systematic approach: identifying inputs, processing and outputs before designing the algorithm.
• Decomposes the problem into smaller sub-tasks or steps in a logical order.
• Produces a correct algorithm that solves the stated problem, with correct sequence, selection and iteration as needed.
• Represents the algorithm accurately in pseudo-code, using structured constructs and consistent indentation.
• Represents the algorithm accurately in program code that matches the intended logic.
• Represents the algorithm accurately in a flowchart using correct symbols and directional arrows.
• Explains how the chosen representation shows the logic, such as decisions as diamonds and loops as returning arrows.
• Checks or tests the algorithm against example inputs to confirm it produces the required output.

• 💡State your systematic stages briefly before presenting the algorithm so the approach is visible.
• 💡Keep pseudo-code and any flowchart consistent so the logic matches across representations.
• 💡Label decision branches and show loop returns clearly so selection and iteration are unambiguous.
• 💡Test your algorithm with a simple example input and state the expected output to demonstrate correctness.
• 💡In flowchart questions, always check that flow lines have arrowheads showing the exact direction of data flow; lines without arrows lose marks.
• 💡When asked to write pseudocode, use clear indentation for nested constructs like loops and selection to demonstrate structured logical thinking.
• 💡For trace table questions, work systematically line by line; never guess the end state or skip intermediate loop iterations.

• Jumping straight to code without identifying inputs, processing and outputs: correction — plan the stages first, then represent the algorithm.
• Mixing representations inconsistently, such as pseudo-code that does not match the flowchart logic: correction — ensure every representation expresses the same algorithm.
• Using incorrect flowchart symbols, such as a rectangle for a decision: correction — use a diamond for decisions and label both branches.
• Omitting iteration or selection where the problem requires it: correction — check the logic includes every needed construct.
• Leaving pseudo-code unstructured with no clear sequence: correction — use indentation and structured constructs to show the flow.
• Confusing assignment ('<-' or '=') with comparison ('=='). In pseudocode and flowcharts, assigning a value changes variable state, whereas comparison yields a Boolean result.
• Believing pseudocode has a single strict syntax like Python; while AQA has standard pseudocode guidelines, examiners award marks for correct logic rather than exact syntax memorisation.
• Assuming trace tables must have every variable written on every single row, which clutters the trace and leads to marking errors; variables should only be updated on the line their value changes.

1. 1Day 1-3: Memorise and practice drawing all standard flowchart symbols and complete 5 flowchart-to-pseudocode translation drills.
2. 2Day 4-6: Practice dry-running algorithms using past-paper trace tables involving count-controlled and condition-controlled loops.
3. 3Day 7-10: Write pseudocode solutions for common problem patterns (linear search, finding maximum/minimum, running totals, validation).
4. 4Day 11-14: Complete mixed-topic exam questions under timed conditions, cross-referencing answers with official AQA mark schemes.

• 📋Flowchart Completion: Adding missing symbols, conditions, or directional arrows to an incomplete flowchart.
• 📋Trace Table Construction: Dry-running a given pseudocode algorithm with test inputs and tracking variable states.
• 📋Pseudocode Writing: Designing an algorithm from a written scenario using sequence, selection, and iteration.
• 📋Error Identification / Correction: Spotting logic errors (such as off-by-one errors or incorrect relational operators) in a given algorithm.