Problem-solving — AQA A-Level Computer Science
Problem-solving in AQA A-Level Computer Science encompasses computational thinking techniques including abstraction, decomposition, algorithmic thinking, and problem recognition. It forms the foundational methodology required to design, test, and evaluate robust algorithmic solutions to complex real-world and theoretical computational problems.
Problem-solving explained
This statement asks you to check whether a proposed solution to a simple logic problem is correct.
Read the full explanation
Checking means testing the solution against the conditions of the problem, rather than simply accepting that it looks plausible. For a logic problem, you might be given a set of statements and a candidate answer. To check it, substitute the candidate into each statement and confirm that every condition holds at once. For example, if a rule states that a light is on when switch A is up and switch B is down, and the proposed state is A up and B down, the light should be on. If the answer produces a false result for any condition, the solution is wrong. Checking also involves testing edge cases, such as the situations where one input changes.
Your focus
- Be able to check solutions to simple logic
Which command word is this?
Set out purposes or reasons, make the relationships between things clear, provide the why and/or how and support with relevant evidence and technical context.
Problem-solving exam tips
Topic Overview
Problem-solving in AQA A-Level Computer Science covers the formal computational methodologies used to analyse problems and formulate algorithmic solutions. This encompasses core computational thinking concepts: representational abstraction, abstraction by generalisation, procedural and data abstraction, decomposition, problem recognition, and composition.
Mastery of these principles underpins both Paper 1 algorithmic evaluation and the Non-Exam Assessment (NEA). Developing rigorous problem-solving capabilities ensures students can not only write functional code, but also assess algorithmic efficiency, select appropriate paradigms, and design scalable, maintainable architectures.
Key Concepts
- →Abstraction: The separation of essential logical qualities from physical implementations, including representational abstraction and abstraction by generalisation.
- →Decomposition: Breaking down a complex problem or system into smaller, modular sub-problems that can be independently developed, tested, and reasoned about.
- →Algorithmic Strategies: Understanding paradigms such as Divide and Conquer (e.g. Binary Search, Merge Sort) and Backtracking (e.g. depth-first traversal, puzzle solving).
- →Problem Recognition and Reduction: Identifying structural patterns in computational problems to map them onto established algorithmic models (e.g. graph traversal, shortest path).
- →Automation and Composition: Building computational models from algorithms and data structures, and combining simpler procedures into integrated software systems.
Marking Points
- Substitutes the candidate solution into every condition of the problem
- Checks each condition separately rather than relying on a single test
- Identifies the specific condition that a wrong solution fails
- Tests boundary or edge cases where inputs change
- Confirms that the solution gives the required output for all relevant inputs
Examiner Tips
- 💡Work through each condition in order and write down the result of each substitution.
- 💡Use a truth table when several inputs interact, so that no combination is missed.
- 💡State clearly which condition fails when you reject a candidate solution.
- 💡Always contextualise definitions: If an exam question asks how abstraction is used in a navigation app, do not provide an abstract textbook definition alone; identify specific details removed (e.g. roadside trees, building heights) and retained (e.g. road connections, distances).
- 💡Use formal Big-O notation when asked to evaluate problem-solving strategies to substantiate your comparative arguments with theoretical proof.
- 💡Distinguish clearly between procedural abstraction (which hides execution steps behind a procedure call) and data abstraction (which encapsulates how data structures are stored behind operations).
Common Mistakes
- Accepts a solution because it satisfies only the first condition; check every condition before concluding.
- Tests only one set of inputs and assumes the solution is correct; test further cases, including edge cases.
- Confuses a plausible answer with a verified one; substitute values and evaluate each statement.
- Equating 'decomposition' with merely writing functions: Students often believe simply breaking code into procedures is decomposition, whereas decomposition begins at the analysis and design stage to partition system responsibilities conceptually before coding.
- Thinking abstraction means making code shorter: Abstraction is not about reducing code line count; it is about managing cognitive complexity and hiding underlying implementation details behind accessible interfaces.
- Assuming divide and conquer and decrease and conquer are identical: Divide and conquer breaks a problem into two or more independent sub-problems of similar size (e.g. Merge Sort), whereas decrease and conquer reduces a problem by a single constant factor or element at each step (e.g. Binary Search).
Revision Plan
- 1Week 1 (Days 1-3): Review theoretical definitions of abstraction, decomposition, and problem recognition; practice writing precise, scenario-based explanations.
- 2Week 1 (Days 4-7): Analyse core algorithmic paradigms: trace Divide and Conquer (Merge Sort) and Backtracking (n-Queens/maze traversal) step-by-step on paper.
- 3Week 2 (Days 1-4): Practice Paper 1 exam questions focusing on 6-to-9 mark design and comparison scenarios, paying attention to specific command words.
- 4Week 2 (Days 5-7): Complete self-timed active recall tests on terminology and review mark schemes to identify recurring examiner phrasing.
Exam Question Types
- 📋Scenario-based scenario analysis: Questions presenting a real-world scenario (e.g. flight simulator, delivery route) asking how specific abstractions or decompositions apply.
- 📋Algorithm trace and evaluation: Stepping through recursive, backtracking, or divide-and-conquer algorithms with trace tables or call trees.
- 📋Extended response design questions (6-9 marks): Designing an algorithmic strategy for an unseen problem, justifying the choice of data structures and problem-solving techniques.
Command Word Expectations (AQA)
Explain
Set out purposes or reasons, make the relationships between things clear, provide the why and/or how and support with relevant evidence and technical context.
Evaluate
Review information then bring it together to form a conclusion, drawing on evidence, including strengths, weaknesses, alternative methods, and relevant complexities.
Describe
State the points of a topic or give characteristics and main features without requiring deep analytical justification or weighing of alternatives.
How Students Lose Marks (Examiner Pitfalls)
Pitfall: Confusing representational abstraction with abstraction by generalisation, or giving vague definitions such as 'simplifying a problem'.
❌ Weak Answer (Loses Marks):Abstraction is just removing unnecessary details to make a problem simpler to understand.
Example improved answer:Representational abstraction is the process of removing unnecessary detail while retaining the essential characteristics required to solve a problem. Abstraction by generalisation groups common characteristics together to identify a hierarchical relationship or create a generic blueprint, such as defining an abstract superclass in object-oriented programming.
Examiner Tip: Explicitly identify the specific type of abstraction being asked about and state what is retained versus what is removed in the context of the given scenario.
Pitfall: Failing to trace backtracking algorithms systematically, resulting in omitted visited states or incorrect recursion depth.
❌ Weak Answer (Loses Marks):Backtracking tries paths and goes back when it hits a dead end until it finds the exit.
Example improved answer:Backtracking is an algorithmic paradigm that systematically searches a state space tree by incrementally building candidates towards a solution, abandoning a candidate (backtracking to the previous state) immediately when it is determined that the candidate cannot lead to a valid solution. In a maze search, unvisited adjacent cells are explored recursively, and if a dead end is reached, the current cell is un-marked or left as dead-end and control returns to the prior branching node.
Examiner Tip: When tracing backtracking or pathfinding algorithms on paper, construct a formal state-space tree or call stack table indicating values of variables at each recursive push and pop.
Step-by-Step Worked Solutions
Question: A logistics firm needs an algorithm to calculate the shortest path between distribution hubs represented as a weighted graph. (a) State why Dijkstra's algorithm is preferred over a brute-force approach. (b) Explain how the concept of decomposition is applied when developing the software system to manage this routing.
- 1.Step 1: Evaluate computational complexity. A brute-force search evaluates all permutation paths, leading to factorial time complexity O(V!), which is computationally intractable for large numbers of vertices. Dijkstra's algorithm uses a greedy approach with a priority queue, operating in O((V + E) log V) time, ensuring tractability.
- 2.Step 2: Define decomposition in the context of system design. Decomposition involves breaking down a complex problem into smaller, self-contained sub-problems that are easier to solve, test, and maintain independently.
- 3.Step 3: Apply decomposition specifically to the logistics software scenario by identifying distinct modules: 1. Graph construction/data parsing module, 2. Pathfinding execution engine (Dijkstra implementation), 3. User interface/route display component, and 4. Vehicle dispatch scheduling module.
Final Answer: Dijkstra is preferred because it resolves in polynomial time O((V + E) log V), avoiding the intractable factorial complexity O(V!) of brute force. Decomposition breaks the software into manageable modules: graph representation, algorithmic calculation, input parsing, and UI rendering.
Active Recall Memory Test
What is the difference between representational abstraction and abstraction by generalisation?
Key Fact: Representational abstraction removes unnecessary implementation detail to retain only critical features; abstraction by generalisation groups common properties to create a generic category or inheritance hierarchy.
What three phases constitute the 'divide and conquer' problem-solving paradigm?
Key Fact: Divide (break the problem into independent sub-problems), Conquer (solve sub-problems recursively, or directly if base case), and Combine (merge sub-problem solutions into the final solution).
How does data abstraction protect the integrity of underlying data structures?
Key Fact: It encapsulates data representation details behind an interface of access methods (e.g. push/pop for a stack), preventing client programs from directly altering internal data.
What defines a backtracking algorithm?
Key Fact: A depth-first search strategy that abandons partial solutions ('backtracks') as soon as they are determined to be invalid, pruning the state-space tree.
Frequently Asked Questions
What is the difference between decomposition and abstraction in A-Level Computer Science?
Decomposition is the process of breaking down a complex problem into smaller, self-contained sub-problems that are easier to understand, code, and test independently. Abstraction is the process of hiding or removing irrelevant detail while retaining the essential features necessary to solve a problem. In short: decomposition divides a system into components, while abstraction filters out unnecessary information within those components.
Why is problem reduction considered an important problem-solving strategy?
Problem reduction involves transforming an unfamiliar or complex computational problem into an instance of an already solved, well-understood problem. For example, many scheduling and mapping problems can be reduced to graph colouring or shortest path algorithms. By reducing a problem, developers can reuse proven algorithms and mathematical proofs rather than devising solutions from scratch.
How does backtracking differ from a brute-force search?
A brute-force search explores all possible candidate solutions across the entire search space without discrimination. Backtracking, however, constructs candidate solutions incrementally and evaluates them against constraints at each step. As soon as a partial candidate cannot possibly be extended to a valid solution, the algorithm backtracks immediately, pruning extensive branches of the search tree and saving significant computational time.
What is the role of automation in computational problem solving?
Automation is the execution of computational models and algorithms on physical hardware to solve problems without ongoing manual intervention. It involves implementing abstract algorithms into concrete code, binding them to actual data structures, and executing them on a computer system to process inputs and generate verified outputs.
How should I structure a 9-mark essay question on problem-solving strategies in Paper 1?
Begin with precise, accurate definitions of the concepts mentioned in the prompt (e.g. abstraction, decomposition, divide and conquer). In the main body, apply these concepts directly to the context provided in the question scenario, explicitly weighing advantages and limitations (such as space/time complexity trade-offs or implementation difficulty). Conclude with a justified evaluative judgement that answers the specific core dilemma posed in the prompt.