Fundamentals of algorithms — AQA GCSE Computer Science

Fundamentals of algorithms is the bedrock of computer science, covering how to design step-by-step solutions to problems. This topic introduces the concept of an algorithm as a precise, unambiguous set of instructions that can be followed to complete a task or solve a problem. You'll learn about key building blocks like sequence, selection, and iteration, and how to represent algorithms using pseudocode and flowcharts. Understanding algorithms is essential because they form the logic behind every program you'll write, and they help you think computationally—breaking down complex problems into manageable steps.

In the AQA GCSE specification, this topic is assessed both in written exams and through the non-exam assessment (NEA). You'll need to be able to design, interpret, and correct algorithms, as well as trace their execution to determine outputs. The skills you develop here—logical reasoning, problem decomposition, and systematic thinking—are transferable to many other areas of computing, including programming, data structures, and even network protocols. Mastering algorithms early gives you a strong foundation for the rest of the course.

Algorithms are everywhere in the real world: from search engines using sorting algorithms to GPS systems using shortest-path algorithms. By studying this topic, you'll understand how computers process data and make decisions. You'll also learn to evaluate algorithm efficiency, which is crucial for writing code that runs quickly and uses memory wisely. This topic isn't just about passing exams—it's about becoming a better problem solver in the digital age.

• →Decomposition: Breaking a complex problem into smaller, more manageable sub-problems, each of which can be solved independently.
• →Abstraction: Removing unnecessary details to focus on the essential features of a problem, making it easier to design an algorithm.
• →Algorithmic thinking: The ability to define clear steps to solve a problem, using sequence (order of steps), selection (making decisions with IF/ELSE), and iteration (repeating steps with loops).
• →Representation: Using pseudocode (a simplified programming language) and flowcharts (diagrams with standard symbols) to design and communicate algorithms.
• →Efficiency: Considering how many steps an algorithm takes (time complexity) and how much memory it uses (space complexity), often measured in terms of input size.

• Definition of an algorithm as a sequence of steps to complete a task
• Distinction between an algorithm and a computer program
• Definition and application of decomposition to break down problems
• Definition and application of abstraction to remove unnecessary detail
• Correct use of AQA standard pseudocode
• Identification of inputs, processing, and outputs within an algorithm
• Use of trace tables to determine the purpose and logic of an algorithm

• 💡Always check the required format for the response (e.g., pseudocode, flowchart, or program code) as specified in the question
• 💡When using trace tables, ensure every variable change is recorded step-by-step to avoid logic errors
• 💡Practice identifying inputs, processes, and outputs in real-world scenarios to build intuition
• 💡Use the official AQA pseudocode guide for all written responses
• 💡When tracing algorithms, always create a trace table with columns for each variable and the output. Update values step by step—this helps avoid mistakes and shows the examiner your method.
• 💡For algorithm design questions, use clear, unambiguous language. If using pseudocode, stick to the AQA pseudocode guide (e.g., use 'INPUT', 'OUTPUT', 'IF...THEN...ELSE', 'WHILE...DO'). Avoid vague terms like 'repeat until done'.
• 💡Always check your algorithm with a simple test case (e.g., small numbers or a short list) to verify it works. This catches logical errors and demonstrates thoroughness.

• Confusing an algorithm with a computer program
• Failing to identify all inputs, processing steps, or outputs in a given algorithm
• Incorrectly applying trace tables, leading to errors in determining the algorithm's purpose
• Using non-standard or ambiguous pseudocode syntax
• Misconception: An algorithm must be written in a programming language. Correction: Algorithms are language-independent; they can be expressed in plain English, pseudocode, or flowcharts. The key is precision, not syntax.
• Misconception: A flowchart is the same as a program. Correction: A flowchart is a visual representation of an algorithm's logic, not executable code. It helps you plan before coding.
• Misconception: Selection (IF statements) can only have two outcomes. Correction: Selection can handle multiple conditions using ELSE IF or nested IFs, allowing for complex decision-making.