Paper 2: Algorithms and Programming (H446/02)

This lesson covers everything you need to know about OCR A-Level Computer Science Paper 2 — the structure, question types, pseudocode conventions, trace table technique, common algorithm questions, and how to approach design questions. Paper 2 is heavily practical in focus, and the skills tested here require regular coding practice as well as theoretical understanding.

---

Paper 2 Structure and Format

Paper 2 is a written exam lasting 2 hours 30 minutes with a total of 140 marks. It accounts for 40% of your A-Level. The paper tests the following areas of the specification:

Section	Topic Area
2.1	Elements of computational thinking
2.2	Problem solving and programming
2.3	Algorithms

Unlike Paper 1, which is primarily theoretical, Paper 2 is focused on problem solving, algorithms, and programming. You will be asked to read code, trace code, write code, design algorithms, and analyse the efficiency of solutions.

Key Point: Paper 2 questions are cumulative — concepts from 2.1 (computational thinking) underpin the problem-solving in 2.2, which in turn requires the algorithmic knowledge from 2.3. Revise these sections as a connected whole, not as isolated topics.

---

Question Types on Paper 2

Pseudocode Tracing (4-8 marks)

You are given a section of pseudocode and asked to determine the output, complete a trace table, or identify the purpose of the code.

Algorithm Writing (5-15 marks)

You are asked to write an algorithm in pseudocode or a named programming language to solve a given problem. This can range from a simple function to a multi-part solution involving data structures.

Code Analysis and Correction (3-6 marks)

You are given code that contains errors (logic errors, syntax errors, or both) and asked to identify and correct them.

Algorithm Comparison (4-8 marks)

You are asked to compare algorithms in terms of time complexity, space complexity, suitability for different data sets, or practical advantages and disadvantages.

Design Questions (8-20 marks)

These are extended questions where you must design a complete algorithm or data structure solution for a described scenario. They may require you to justify your design choices.

Computational Thinking Questions (2-6 marks)

Questions about abstraction, decomposition, pattern recognition, and algorithmic thinking applied to real-world scenarios.

---

OCR Pseudocode Conventions

OCR has specific pseudocode conventions that appear on the exam paper. You should be familiar with these so you can read the questions fluently and write answers that examiners can follow.

Variable Assignment and Output

Assignment uses the equals sign. Output uses the print keyword.

x = 5
name = "Alice"
print(x)
print("Hello " + name)

Selection (IF Statements)

if condition then
    // statements
elseif condition then
    // statements
else
    // statements
endif

Iteration (Loops)

For loop:

for i = 0 to 9
    print(i)
next i

While loop:

while condition
    // statements
endwhile

Do-while loop:

do
    // statements
until condition

Arrays

Arrays are zero-indexed in OCR pseudocode. You declare and access them using square brackets.

array names[5]
names[0] = "Alice"
names[1] = "Bob"

To iterate through an array:

for i = 0 to names.length - 1
    print(names[i])
next i

Functions and Procedures

Procedure (does not return a value):

procedure greet(name)
    print("Hello " + name)
endprocedure

Function (returns a value):

function add(a, b)
    return a + b
endfunction

String Operations

x = "Hello"
x.length          // returns 5
x.substring(0, 3) // returns "Hel" (start index, length)
ASC("A")           // returns 65
CHR(65)            // returns "A"

File Handling

myFile = openRead("data.txt")
line = myFile.readLine()
myFile.close()

myFile = openWrite("output.txt")
myFile.writeLine("Hello")
myFile.close()

Exam Tip: You do not have to memorise every pseudocode convention — the key ones are printed on the exam paper. However, being fluent with them means you can read and write pseudocode quickly, saving valuable time.

---

Trace Table Technique

Trace tables are one of the most frequently examined skills on Paper 2. A systematic approach avoids careless errors.

Step-by-Step Technique

1. Read the entire code first. Do not start tracing immediately. Understand the overall purpose and identify all variables.
2. Set up the table. Create a column for each variable, plus a column for any output. Include a column for loop counters.
3. Work through line by line. For each line of code, update only the variable(s) that change. Leave other columns blank (do not repeat unchanged values).
4. Handle loops carefully. Write the loop counter value at the start of each iteration. Check the loop condition at the correct point (start for while loops, end for do-until loops).
5. Record output when it occurs. Write it in the output column on the same row as the print statement.

Worked Example

Consider this pseudocode:

x = 10
y = 3
while x > 0
    x = x - y
    y = y + 1
    print(x)
endwhile

Trace table:

x	y	x > 0?	Output
10	3
7	4	true	7
3	5	true	3
-2	6	true	-2
		false

The output is: 7, 3, -2

Exam Tip: The most common error in trace tables is getting the loop termination wrong. Always check the condition at the correct point in the loop. For a while loop, the condition is checked BEFORE the body executes. For a do-until loop, the condition is checked AFTER the body executes.

---

Common Algorithm Questions

Sorting Algorithms

You must know the following sorting algorithms in detail — how they work step by step, their time complexity, and when each is most suitable.

Bubble Sort:

• Repeatedly compare adjacent elements and swap if they are in the wrong order
• One pass guarantees the largest unsorted element reaches its correct position
• Best case: O(n) when already sorted (with optimisation flag)
• Worst/average case: O(n^2)
• Space: O(1) — in-place