AQA A-Level Computer Science Paper 1, June 2025: Question 5

✅ Acceptable Answers (Any Two)

• No brackets needed: Parentheses are completely unnecessary to determine order of execution.
• No operator precedence rules required: Evaluation order is strictly determined by position rather than BODMAS / BIDMAS rules.
• Linear evaluation / No backtracking: Expressions can be evaluated directly from left to right in a single pass.
• Simpler to evaluate by computer: Straightforward to implement using a stack data structure or write evaluation code for.
• Execution order matches syntax: Operators appear in the exact order in which calculations must be executed.

🧠 Exam Technique & Examiner Insight

• State the benefit clearly: Make sure your answer focuses on why RPN helps a computer execute instructions.
• Be precise with wording: Writing "easier for a machine to evaluate" is accepted, but writing "easier to understand" is explicitly rejected because RPN is notoriously harder for human humans to read than infix.
• "RPN expressions cannot be ambiguous" is awarded marks by benefit of doubt (BOD), but mentioning no brackets or no precedence rules is much safer.

💡 Key Knowledge: Infix vs RPN

In standard infix notation: (3 + 4) × 5 , a machine must store operators, detect brackets, and remember that multiplication has higher precedence than addition.

In RPN (postfix): 3 4 + 5 × , reading left-to-right immediately yields the operands and operators in execution order: add 3 and 4, then multiply the result by 5. No parenthetical grouping or operator priority lookahead is required.

❌ Common Errors to Avoid

• Saying "easier to read": Infix notation is designed for human readability; RPN is optimized for stack-based machine computation.
• Vague statements: Saying "it is faster" without qualifying that evaluation requires no backtracking or precedence checks.

✅ Mark Scheme Requirements

• Mark 1: Consists of key-value pairs (an associative array).
• Mark 2: Keys are unique
  OR a value is looked up / accessed by providing its key (rather than an integer index).

🧠 Exam Technique

To get both marks for definition questions like this:

1. State the foundational structure: "It stores data as key-value pairs..." [1 mark]
2. State an operational characteristic: "...where each key is unique and used as an identifier / index to look up its associated value." [1 mark]

💡 Key Knowledge: Dictionaries in Algorithms

In the context of the ConvertToRPN subroutine, an operator precedence dictionary maps operator symbols to integer priority levels:

Precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3}

Looking up Precedence['*'] returns 2 directly via key hashing.

❌ Common Errors to Avoid

• Confusing a dictionary with a standard array or list (forgetting to mention keys).
• Stating that keys can be duplicated — keys must be unique, even though multiple keys may share the same value (e.g. '+' and '-' both have precedence 1).

✅ Accepted Answers

• Stack
• Also accepted: LIFO / Last In, First Out

💡 Key Knowledge: Shunting-Yard Algorithm

When converting infix notation to RPN, operators are temporarily held until operators of higher or equal precedence are cleared. The most recently added operator must be accessed first — this classic Last-In, First-Out (LIFO) behavior is implemented using a Stack (via list operations like append() / push and pop() ).

❌ Common Errors to Avoid

• Writing Queue (FIFO) — operators must come off in reverse order of arrival, not arrival order.
• Writing List or Array — the question notes that a list was used to represent this abstract data type; you must identify the abstract type it models (Stack).

🧠 Top Tip

Whenever an exam question discusses RPN conversion or evaluation, the data structure being used behind the scenes is almost always a Stack.