How do I convert Cambridge pseudocode into Python?

Replace arrow assignment (←) with equals (=), map OUTPUT to print(), map INPUT to input(), convert 1-based array indexes to 0-based lists, and translate FOR TO NEXT loops to Python range().

How does a Cambridge 1-based array convert to a Python 0-based list?

Cambridge arrays start at index 1 by default (e.g. ARRAY[1:10]). In Python, lists start at index 0, so accessing element index i in pseudocode corresponds to index i - 1 in Python, or you can allocate a dummy 0th element.

How is a REPEAT...UNTIL loop written in Python?

Python does not have a native post-condition do-while loop. To emulate REPEAT...UNTIL condition, use while True: with the loop body, followed by if condition: break at the end.

Is Cambridge pseudocode identical to Python syntax?

No. Cambridge Paper 2 strictly penalizes Python syntax such as def, print(), == assignment, or zero-indexed array assumptions. Cambridge exams require DECLARE, ←, OUTPUT, and explicit uppercase keywords.

Cambridge IGCSE (0478) · O-Level (2210) · A-Level (9618)

Pseudocode to Python Converter & Translation Guide

Translate Cambridge pseudocode into clean, executable Python 3 instantly. Learn how loops, 1-based arrays, subroutines, and file I/O map between both languages.

✍️ By Aneesh Shinde (Founder) • 📅 Verified for 2026–2028 Exams • ⚡ 100% Free Client-Side Tool

📋 Cambridge Pseudocode

🐍 Generated Python 3

1. Quick Reference: Cambridge Pseudocode to Python 3 Syntax Table

Algorithmic Operation	Cambridge Pseudocode Syntax	Equivalent Python 3 Syntax	Core Semantic Distinction
Console Output	`OUTPUT "Score: ", Score`	`print("Score:", score)`	Python adds space between args; pseudocode specifies exact comma concatenation.
User Input	`INPUT Name`	`name = input()`	Python `input()` always returns a string; requires `int()` or `float()` cast.
Variable Assignment	`Count ← Count + 1`	`count += 1` or `count = count + 1`	Cambridge Paper 2 requires left arrow `←`; single `=` is an examiner trap.
Variable Declaration	`DECLARE Total : INTEGER`	`total: int = 0`	Python is dynamically typed; type annotations are optional hints.
Integer Division	`Result ← Value DIV 2`	`result = value // 2`	Truncates decimals towards negative infinity in Python.
Modulo Remainder	`Rem ← Value MOD 2`	`rem = value % 2`	Yields the integer remainder of division.
Inequality	`IF Score <> -1 THEN`	`if score != -1:`	Cambridge uses `<>`; Python uses standard `!=`.
Definite Loop (FOR)	`FOR i ← 1 TO 10 ... NEXT i`	`for i in range(1, 11):`	Python `range(start, stop)` is exclusive of `stop`, requiring `+ 1`.
Post-Condition Loop	`REPEAT ... UNTIL cond`	`while True: ... if cond: break`	Python lacks a do-while loop; emulated via infinite loop + break guard.
Fixed 1D Array	`DECLARE Marks : ARRAY[1:30] OF INTEGER`	`marks = [0] * 30`	Cambridge arrays default to 1-based indexing; Python lists are strictly 0-indexed.
Subroutine Procedure	`PROCEDURE Display(x BYVAL : INTEGER)`	`def display(x):`	Python passes object references; immutable types (int, str) behave like BYVAL.

2. Converting 1-Based Cambridge Arrays to 0-Based Python Lists

The single most dangerous friction point between Cambridge pseudocode and Python is array indexing conventions:

Cambridge Pseudocode: Arrays declared with explicit lower and upper bounds, typically ARRAY[1:N]. The first element is stored at index 1. Attempting to access index 0 on an array declared 1:N is flagged as an out-of-bounds syntax violation in Paper 2 mark schemes.
Python 3: Lists are strictly 0-indexed. A list with N elements contains items from index 0 to N - 1. Accessing index N raises an IndexError.

                # Method A: Offset all indexes by 1 in Python

                # Pseudocode: Scores[Index] ← 85

                scores[index - 1] = 85

                # Method B: Allocate a dummy 0th slot (cleanest for 1:1 trace table dry-runs)

                # For DECLARE Scores : ARRAY[1:30] OF INTEGER

                scores = [0] * 31  # Index 1 through 30 correspond exactly to student numbers!

When running past paper algorithms inside PseudoStudio IDE, our compiler enforces genuine 1-based array semantics natively without requiring zero-offset gymnastics.

3. Pre-Condition (WHILE) and Post-Condition (REPEAT UNTIL) Loops

Cambridge Paper 2 differentiates between three iteration constructs. When translating to Python:

FOR Loop (Count-Controlled): FOR i ← 1 TO 10 STEP 2 maps directly to for i in range(1, 11, 2):. Remember to increment the upper bound by 1 so the loop executes through the final index.
WHILE Loop (Pre-Condition): Evaluates the condition before entering the body. Translates directly to while condition:. If the initial condition is false, the loop body executes 0 times.
REPEAT ... UNTIL (Post-Condition): Evaluates the condition after the body executes. It is guaranteed to run at least once. Because Python lacks a do...while keyword, always use:
```
while True:
    # loop body executes at least once
    val = int(input("Enter number: "))
    if val > 0:
        break  # UNTIL condition met
```

4. BYVAL vs. BYREF Parameter Passing in Python

In Cambridge pseudocode subroutines:

BYVAL (By Value): Passes a separate local copy of the parameter. Changes inside the procedure do not alter the caller's variable.
BYREF (By Reference): Passes a pointer directly to the caller's memory address. Mutating the parameter updates the original variable in the calling scope.

Python does not have explicit byval or byref keywords; it uses call-by-object-reference. Integers, floats, and strings are immutable (acting like BYVAL), whereas lists and dictionaries are mutable (acting like BYREF). When converting a Cambridge BYREF procedure modifying an integer, Python programs must explicitly return the new value: return new_val.

5. Common Examiner Pitfalls When Translating Algorithms

⚠️ Exam Warning: While Python is excellent for verifying algorithm logic on your laptop, writing Python syntax on Cambridge Paper 2 will lose all syntax and algorithm marks. Cambridge examiners penalize print(), len(), == assignment, and 0-indexed loops.

Equals vs Left Arrow: In Python, Total = 0 assigns a value. In Cambridge pseudocode, you must write Total ← 0. A single equals sign in pseudocode is reserved for boolean comparison checks.
String Functions: Python's len(s) and s[1:4] must be written as LENGTH(s) and SUBSTRING(s, 2, 3) in official Cambridge pseudocode. Note that Cambridge SUBSTRING uses 1-based start positions and string length parameters!
File Handling: Python's with open("data.txt") as f: translates to the explicit Cambridge sequence: OPENFILE "data.txt" FOR READ, READFILE "data.txt", LineData, and CLOSEFILE "data.txt".

6. Frequently Asked Questions: Pseudocode to Python Conversion

Can I use this tool to convert my Cambridge past paper code to Python?

Yes! Simply paste your pseudocode into the translator box above. It automatically handles loops, condition structures, arithmetic operators, variable declarations, and array boundaries.

How do I test my pseudocode before converting it to Python?

You can run your pseudocode directly inside the PseudoStudio Online Compiler. Our cloud engine compiles and executes Cambridge syntax with live terminal INPUT prompts and trace table logs.

Does Cambridge allow Python in Paper 2 exams?

No. Cambridge IGCSE (0478), O-Level (2210), and A-Level (9618) Paper 2 strictly test pseudocode. Python, Java, and Visual Basic are only tested in A-Level Paper 4 (Practical Programming).

What is the difference between DIV in pseudocode and // in Python?

Both perform integer division by returning the quotient without decimals. For positive numbers, 17 DIV 5 and 17 // 5 both evaluate to 3.

Practice Exam Questions in Cambridge Pseudocode

Sharpen your algorithm skills with 200+ exam questions, automated trace table validation, and instant AI grading.

Open AI Practice Workspace ➔ Generate Trace Table ➔