Hardest A Level Computer Science Questions & How to Answer Them

Feeling confident with the basics but worried about the brutal questions near the end of the paper? You are not imagining it. The hardest A Level Computer Science questions are usually high mark, multi-topic, and written to reward students who can stay precise under pressure.

As an A Level Computer Science teacher who has supported OCR and AQA students through the exact question styles that decide A and A* grades, I see the same pattern every year. The students who do best are not the ones who “know the most”, they are the ones who can turn knowledge into mark scheme shaped answers.

Here’s the positive part. These questions follow patterns. Once you know what examiners are looking for and you practise a repeatable method, the “hardest” questions become predictable and manageable.

If you want to lock in the fundamentals first, start with the Save My Exams A Level course hub and your board-specific course pages.

This guide breaks down the hardest question types you will meet in OCR H446 and AQA 7517, with realistic exam-style examples, model answers, and examiner-focused techniques.

Key Takeaways

• Hard questions test whether you can combine topics and apply ideas in unfamiliar contexts

• Students lose marks by rushing, skipping working, or misreading the command word

• Success comes from reading carefully, breaking problems down, using precise vocabulary, and showing method

• The toughest areas often include algorithm efficiency, recursion, finite state machines, and extended response on computer systems

• Examiners reward what they can see: clear steps, correct terminology, and justified conclusions

Why Some A Level Computer Science Questions Are Difficult

Not all questions are created equal. Lower tariff questions mostly check recall. The hardest ones check whether you can think like a computer scientist, under time pressure, in a way that is markable.

Multiple topics in one question

A common OCR and AQA pattern is to blend areas, for example, data structures plus Big O, or CPU behaviour plus performance. This is where revision that stays too siloed starts to fall apart. You need to practise connecting concepts, not just memorising them.

Deep logic and abstract thinking

Recursion, tracing, and algorithm behaviour questions punish “half thinking”. One incorrect step early on can cascade. That is why examiners reward slow, explicit working, even when the final answer is not perfect.

Technical language matters

At the top end, vague language caps marks. “It is faster” becomes “it has O(n log n) time complexity”. “The CPU stores it” becomes “the address in the PC is copied to the MAR”. Precision is not snobbery, it is how marks are awarded.

If terminology is your weak point, active recall works. Save My Exams Computer Science flashcards are built for quick keyword accuracy.

Full justification required

Many high-mark questions are not a single fact, they are an argument. “Evaluate” and “justify” demand trade-offs, context, and a conclusion that follows from your points. Listing is not enough.

How To Approach Hard A Level Computer Science Questions

When you hit a hard question, panic is the enemy. Use a method that forces clarity.

Step 1: Identify what is being tested

Read once for context, read again for command words. Then write a tiny plan based on the marks.

A quick command word reminder:

• Describe: what it is, key features

• Explain: how or why, with cause and effect

• Compare: similarities and differences

• Evaluate: balanced points, trade-offs, reasoned conclusion

Step 2: Break it into parts

Hard questions hide multiple marking points. Aim for one clear point per mark, not one paragraph for the entire question.

Step 3: Use pseudocode or diagrams as working

For algorithms and logic, working is your safety net. Even when the final output is wrong, the correct method often earns marks.

Quick pseudocode note: OCR and AQA conventions differ slightly. Practise the style your board expects, and keep it consistent in answers.

Step 4: Reference specific concepts

Swap vague phrasing for spec language: stack frame, base case, state transition, opcode, operand, time complexity, pipelining, cache, throughput.

Step 5: Keep it logical and easy to mark

Write in clear steps. Show every stage of calculations. Make the examiner’s job easy, because that is how you protect marks.

For practice with fast feedback on longer answers, Smart Mark is built for this. It gives mark scheme style guidance on what you wrote, not just whether it was right.

Hardest A Level Computer Science Questions With Model Answers

These examples are exam style, aligned to OCR and AQA content, but they are not copied from copyrighted papers.

Question 1: Algorithm Efficiency And Big O Notation

Question

Two algorithms perform the same task. Algorithm A has time complexity O(n²) and Algorithm B has time complexity O(n log n).

They are tested with 100 items, then with 10,000 items.

a) Calculate the approximate number of operations for each algorithm with 10,000 items. (4 marks)
b) Explain which algorithm would be more suitable for a system processing large datasets and justify your answer. (3 marks)

Model answer

a)

Algorithm A (O(n²)):
Operations = n²
For n = 10,000: 10,000² = 100,000,000

Algorithm B (O(n log n)):
Operations = n log₂(n)
For n = 10,000: 10,000 × log₂(10,000) ≈ 10,000 × 13.29 ≈ 132,900

b) Algorithm B is more suitable for large datasets because the number of operations grows much more slowly as n increases. At 10,000 items, Algorithm A requires vastly more operations, which translates to slower execution time and greater CPU demand when processing large volumes of data.

Examiner tip

In part (b), explicitly refer back to your numbers from part (a). That link is where marks usually live.

Question 2: Recursion And Stack Frames

Question (Python)

def mystery(n):

    if n <= 1:

        return 1

    else:

        return n * mystery(n - 2)

a) Trace the function call mystery(5), showing all recursive calls and return values. (5 marks)
b) Explain what would happen if the base case was changed to if n == 1. (2 marks)

Model answer

a)

Call 1: mystery(5)
5 > 1 so returns 5 × mystery(3)

Call 2: mystery(3)
3 > 1 so returns 3 × mystery(1)

Call 3: mystery(1)
1 ≤ 1 so returns 1

Unwinding returns:
mystery(1) = 1
mystery(3) = 3 × 1 = 3
mystery(5) = 5 × 3 = 15

Final output: 15

b) If the base case is only n == 1, the function fails for even starting values because n decreases by 2 and may never hit 1. For example mystery(4) calls mystery(2), then mystery(0), then mystery(-2), and continues indefinitely, causing infinite recursion.

Examiner tip

If recursion scrambles your brain, write each call on a new line, then draw a line and unwind from the bottom. Method beats hope.

Question 3: Finite State Machines

Question

A vending machine accepts 10p and 20p coins. An item costs 30p. The machine should accept coins until 30p or more is inserted, then dispense the item. No change is given.

a) Draw a finite state machine diagram, showing states, transitions, and outputs. (6 marks)
b) Explain why an FSM is a suitable model for this problem. (2 marks)

Model answer

a) States (label by total inserted):

• S0: 0p (start)

• S1: 10p

• S2: 20p

• S3: 30p or more (dispense)

Transitions (inputs and outputs can be shown on arrows):

From S0:

• 10p → S1

• 20p → S2

From S1:

• 10p → S2

• 20p → S3 (dispense)

From S2:

• 10p → S3 (dispense)

• 20p → S3 (dispense)

From S3:

• reset → S0

b) An FSM is suitable because the machine has a finite set of distinct states and the next state depends only on the current state and the input coin. This is exactly the kind of deterministic, state-dependent system FSMs are designed to model.

Examiner tip

Labels win marks. Even if your diagram is messy, clear state names and clearly labelled transitions keep it markable.

Question 4: Pseudocode Programming Challenge

Question

Write an algorithm in pseudocode that accepts a list of integers and returns the second largest value. Your algorithm must:

• handle lists with at least two elements

• work correctly even if there are duplicate values

• use appropriate validation
  (8 marks)

Model answer

FUNCTION FindSecondLargest(numbers)

    IF LENGTH(numbers) < 2 THEN

        RETURN "Error: list must contain at least 2 elements"

    ENDIF

    largest = numbers[0]

    secondLargest = NONE

    FOR each number IN numbers DO

        IF number > largest THEN

            secondLargest = largest

            largest = number

        ELSE IF number != largest AND (secondLargest == NONE OR number > secondLargest) THEN

            secondLargest = number

        ENDIF

    ENDFOR

    IF secondLargest == NONE THEN

        RETURN "Error: no second largest value"

    ELSE

        RETURN secondLargest

    ENDIF

END FUNCTION

Explanation of logic

• largest stores the biggest value seen so far

• secondLargest stores the biggest value that is not equal to largest

• If we find a new largest value, the old largest becomes second largest

• If we find a value that is smaller than largest but bigger than secondLargest, we update secondLargest

• If every value is identical, secondLargest never gets a real value, so we return an error

Quick dry run

• Input: [5, 2, 8, 3] → output 5

• Input: [8, 8, 2] → output 2

• Input: [7, 7, 7] → error, no second largest value exists

Examiner tip

Before you commit, dry run your own algorithm on a tiny list like [5, 2, 8, 3] and one with duplicates like [8, 8, 2]. That catches most logic bugs.

Question 5: System Architecture Extended Response

Question

Explain how the fetch-decode-execute cycle allows a CPU to process instructions. Include the role of key registers and describe each stage. (9 marks)

Model answer

The fetch-decode-execute cycle is the repeating process a CPU uses to retrieve and run program instructions from main memory.

Fetch: The Program Counter (PC) holds the address of the next instruction. This address is copied to the Memory Address Register (MAR). The CPU requests the instruction from RAM, and the fetched instruction is placed into the Memory Data Register (MDR). The instruction is then copied into the Current Instruction Register (CIR). The PC is incremented to point to the next instruction address.

Decode: The Control Unit interprets the instruction in the CIR by splitting it into an opcode and operand, then prepares the CPU components needed for that instruction, for example, selecting ALU operations or setting up data movement.

Execute: The instruction is carried out. This might involve the ALU performing a calculation, registers transferring data, or reading and writing to memory. If the instruction is a branch or jump, the PC is updated to a new address rather than simply incremented.

This cycle repeats continuously, allowing the CPU to run whole programs as a sequence of individual instructions.

Examiner tip

For an extended response, sequence matters. If you describe execute before fetch, or you forget register names, you usually lose the top band marks.

What The Mark Scheme Expects

This is the part students underestimate. You are not being marked on how much you know, you are being marked on what you show.

For coding and logic questions

• correct, consistent structure and indentation

• clear method, with intermediate steps shown

• validation and edge cases where required

For explanation questions

• precise, specification language

• clear cause and effect links, not just statements

• points tied to the scenario in the question

For evaluation questions

• balanced points on both sides

• decisions justified using technical reasons

• a conclusion that follows from your argument

If you want targeted practice by topic with worked answers, use your board’s question bank:

OCR A Level Computer Science topic questions

AQA A Level Computer Science past papers

Tips For Practising The Hardest Questions

Time yourself on past papers

Use full papers to build stamina and timing. Save My Exams organises them by board: 

AQA A Level Computer Science past papers

OCR A Level Computer Science past papers

Use Smart Mark to fix writing habits

Smart Mark is most useful when you already “kind of” know the topic, but your answers are not exam-shaped. It flags missing detail and weak justification early.

Use Target Test for weakness-driven practice

If you keep losing marks on the same topics, stop guessing what to do next. Target Test builds focused practice based on gaps.

Practise converting between code and English

Explain an algorithm in plain English, then write it in pseudocode, then test it. That exact translation skill is what these questions assess.

Review mistakes like a scientist

Keep a short error log: what you did, why it was wrong, what the mark scheme wanted, what you will do next time. This is one of the fastest grade lifters.

Frequently Asked Questions

What A Level Computer Science Topics Have The Hardest Questions?

The topics that consistently produce high mark, high difficulty questions are:

• algorithms and complexity

• recursion and tracing

• finite state machines

• networking and protocols

• computer architecture and performance

These are hard because they require slow, careful reasoning plus precise language, not memorisation.

How Can I Improve At Pseudocode And Algorithms?

Write algorithms from scratch regularly, then test them with inputs. Do not just read worked solutions. Use topic questions to build range, then switch to past papers to build timing.

For OCR specific exam technique, the Save My Exams exam technique topic hub is a good place to consolidate how to answer different question types.

What’s The Best Way To Revise For High Mark Questions?

Use mark schemes actively. Study what earns marks, then practise writing in that style under time. If you need a structured plan, this Learning Hub guide gives a clear approach to how to revise for A Level Computer Science.

Final Thoughts

Hard A Level Computer Science questions can feel brutal in the moment, but they are not random. They reward structure, precision, and visible working. Build the habit of slowing down, chunking the problem, using specification language, and justifying every judgement. With consistent practice, the hardest questions become the most reliable place to pick up marks.

References

• AQA, A Level Computer Science (7517) specification (opens in a new tab)

• OCR, A Level Computer Science (H446) specification (opens in a new tab)

• Save My Exams, A Level Computer Science resources

• Save My Exams, OCR A Level Computer Science revision notes

• Save My Exams, AQA A Level Computer Science course

Note: The example questions in this article are original exam-style practice prompts inspired by common OCR and AQA formats. For authentic past paper questions, use official OCR and AQA papers and mark schemes, or the Save My Exams past paper collections linked above.