Pseudocode and the exam reference language

Reading and writing your board's pseudocode, and translating it into Python.

F5.3AlgorithmsGCSE15 min

Pseudocode is a way of writing an algorithm that looks like code but is not tied to any one programming language. It is quicker to write than a flowchart and closer to a program, so it is how most algorithms are shared on paper. Exam boards each have their own style, and in written exams you read and write theirs. This lesson is about moving between pseudocode and Python.

The same algorithm, three ways

The robot steps towards the wall and reports whether it took an even or odd number of steps. Switch between the exam boards in the box below to see it in each board's pseudocode, and compare with Python.

In the exam

Choose your exam board to see its version of the algorithm.

OCR Exam Reference Language

steps = 0
while distance() > 30
    forward(10)
    steps = steps + 1
endwhile
if steps MOD 2 == 0 then
    print("even number of steps: " + str(steps))
else
    print("odd number of steps: " + str(steps))
endif

AQA pseudo-code

steps ← 0
WHILE distance() > 30
    forward(10)
    steps ← steps + 1
ENDWHILE
IF steps MOD 2 = 0 THEN
    OUTPUT 'even number of steps: ' + INT_TO_STRING(steps)
ELSE
    OUTPUT 'odd number of steps: ' + INT_TO_STRING(steps)
ENDIF

Edexcel program code

Edexcel shows algorithms as program code in Python, so its version is the Python below.

# the two lines every program starts with: the commands, then the robot
from bugbot import *
connect()

steps = 0
while distance() > 30:
    forward(50, distance=10)
    steps = steps + 1
if steps % 2 == 0:
    print("even number of steps: " + str(steps))
else:
    print("odd number of steps: " + str(steps))

Run this in the simulator

forward(10) in the pseudocode is not a real command: pseudocode lets you invent a clear name for a step and leave the details to whoever writes the program. That is the point of it.

Translating line by line

Most lines translate one for one. The differences to watch:

Idea	OCR Exam Reference Language	AQA pseudo-code	Python
assign	`x = 3`	`x ← 3`	`x = 3`
equal to	`==`	`=`	`==`
not equal	`!=`	`≠`	`!=`
remainder	`MOD`	`MOD`	`%`
whole-number divide	`DIV`	`DIV`	`//`
output	`print(x)`	`OUTPUT x`	`print(x)`
input	`x = input("prompt")`	`x ← USERINPUT`	`x = input("prompt")`
end of a block	`endif`, `endwhile`, `next i`	`ENDIF`, `ENDWHILE`, `ENDFOR`	indentation
count-controlled loop	`for i = 1 to 5` (includes 5)	`FOR i ← 1 TO 5` (includes 5)	`for i in range(1, 6)`
a procedure	`procedure name(x)` ... `endprocedure`	`SUBROUTINE name(x)` ... `ENDSUBROUTINE`	`def name(x):`

The count-controlled loop is where most translation mistakes happen: both pseudocodes include the end number, and Python's range does not.

Writing your own pseudocode

When an exam asks for pseudocode, it wants a clear algorithm, not perfect syntax. Examiners generally accept any sensible pseudocode, provided:

each step is clear and unambiguous,
the structure (sequence, selection, iteration) is shown with indentation and closing words,
variables are named and given values before they are used.

Writing the pseudocode first, then the Python underneath it, is also a good way to plan a program before touching the keyboard.

Python as pseudocode

Python reads so much like pseudocode that people sometimes call it executable pseudocode. That makes translation easy in one direction, but it also makes it tempting to use Python-only features in an exam answer, such as range with its excluded end, +=, or list slicing, where the board's own form would be clearer to the examiner.

In the exam

Questions give an algorithm in the board's pseudocode and ask you to follow it, complete it, correct an error in it, or rewrite it in a programming language. You can usually answer in the board's pseudocode or in a high-level language, but the question will say.

OCR 2.1.2

OCR publishes its Exam Reference Language in the specification. Paper 2 questions that give code use it, and you may answer in it or in a high-level language such as Python unless a question says otherwise.

AQA 3.1.1

AQA publishes its pseudo-code guide with the specification. Paper 1 is taken in the programming language your school chose, and questions also use the pseudo-code; you are expected to read it and to write algorithms in it.

Edexcel 1.2.2

Edexcel's written paper shows algorithms as flowcharts and program code rather than a pseudocode of its own, and Paper 2 is written in Python, so the important skill is turning an algorithm description into Python (6.1.3).

Task: steps from pseudocode

Translate the algorithm at the top of this lesson into Python, from the pseudocode for your board. The robot should step towards the wall in 10 cm steps while it is more than 30 cm away, then print whether it took an even or odd number of steps, in exactly the form even number of steps: 4.

# the two lines every program starts with: the commands, then the robot
from bugbot import *
connect()

steps = 0

Challenges

Write pseudocode for the password guard from lesson F5.2, in your board's style.
Translate this OCR loop into Python, and check it prints the same numbers: for i = 2 to 10 step 2 then print(i) then next i.
Find three things in a Python program of yours that would need changing to be good pseudocode for your board.