IB CS Pseudocode Reference — Approved Notation

Introduction

IB Computer Science uses a standardised pseudocode notation for all exam questions and internal assessments. This notation is designed to be language-neutral — it does not favour students who know Python, Java, or any specific programming language. Using Python or Java syntax in your exam answers will lose marks.

This guide provides the complete IB pseudocode notation with worked examples and side-by-side Python comparisons to help you avoid these mistakes.

Basic Syntax

Variable Assignment

IB pseudocode uses the left arrow ← for assignment. This means “assign the value on the right to the variable on the left”.

IB Pseudocode:

x ← 10
name ← "Alice"
total ← total + 5

Python Equivalent:

x = 10
name = "Alice"
total = total + 5

Output

Use the output keyword to display a value or message.

IB Pseudocode:

output "Hello, world!"
output total
output "The sum is: ", sum

Python Equivalent:

print("Hello, world!")
print(total)
print("The sum is:", sum)

Input

Use the input keyword to read a value from the user.

IB Pseudocode:

input name
input age

Python Equivalent:

name = input()
age = int(input())

Comments

Use // for single-line comments.

IB Pseudocode:

// This is a comment
x ← 10 // Assign 10 to x

Python Equivalent:

# This is a comment
x = 10  # Assign 10 to x

Arithmetic Operators

Comparison and Logical Operators

Comparison Operators

Logical Operators

IB Pseudocode:

if age ≥ 18 and hasLicense = true then
    output "You can drive"
end if

Python Equivalent:

if age >= 18 and hasLicense == True:
    print("You can drive")

Control Structures

IF Statement

IB Pseudocode:

if condition then
    // statements
end if

With ELSE:

if condition then
    // statements when true
else
    // statements when false
end if

With ELSE IF:

if condition1 then
    // statements
else if condition2 then
    // statements
else
    // statements
end if

if x > 0 then
    output "positive"

if x > 0 then
    output "positive"
end if

input score
if score ≥ 90 then
    grade ← "A"
else if score ≥ 80 then
    grade ← "B"
else if score ≥ 70 then
    grade ← "C"
else if score ≥ 60 then
    grade ← "D"
else
    grade ← "F"
end if
output grade

score = int(input())
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

Loops

IB pseudocode has three types of loops, each with a distinct structure.

LOOP WHILE

Repeats while a condition is true. The condition is checked before each iteration.

IB Pseudocode:

loop while condition
    // statements
end loop

Example:

count ← 1
loop while count ≤ 5
    output count
    count ← count + 1
end loop

Python Equivalent:

count = 1
while count <= 5:
    print(count)
    count = count + 1

LOOP UNTIL

Repeats until a condition becomes true. The condition is checked after each iteration, so the loop body always runs at least once.

IB Pseudocode:

loop until condition
    // statements
end loop

Example:

input password
loop until password = "secret"
    output "Incorrect. Try again."
    input password
end loop
output "Access granted"

Python Equivalent:

password = input()
while password != "secret":
    print("Incorrect. Try again.")
    password = input()
print("Access granted")

LOOP FROM…TO

A counted loop that repeats a fixed number of times. The loop variable automatically increments by 1 each iteration.

IB Pseudocode:

loop variable from start to end
    // statements
end loop

Example:

loop i from 1 to 10
    output i
end loop

This is equivalent to:

i ← 1
loop while i ≤ 10
    output i
    i ← i + 1
end loop

Python Equivalent:

for i in range(1, 11):  # Note: range(1, 11) produces 1 to 10
    print(i)

total ← 0
loop i from 1 to 100
    total ← total + i
end loop
output total

total = 0
for i in range(1, 101):
    total = total + i
print(total)

Arrays

IB arrays are 1-based — the first element is arr[1], not arr[0].

Array Declaration and Access

IB Pseudocode:

arr ← [5, 10, 15, 20]
output arr[1]  // Outputs 5
arr[3] ← 99

Python Equivalent (0-based):

arr = [5, 10, 15, 20]
print(arr[0])  # Outputs 5
arr[2] = 99

Array Length

Use length(arr) to get the number of elements.

IB Pseudocode:

arr ← [3, 7, 2, 9]
n ← length(arr)  // n = 4

Python Equivalent:

arr = [3, 7, 2, 9]
n = len(arr)  # n = 4

Traversing an Array

IB Pseudocode:

arr ← [10, 20, 30, 40, 50]
loop i from 1 to length(arr)
    output arr[i]
end loop

Python Equivalent:

arr = [10, 20, 30, 40, 50]
for i in range(len(arr)):
    print(arr[i])

2D Arrays

A 2D array is accessed using two indices: grid[row][col]. Both indices are 1-based.

IB Pseudocode:

grid[1][1] ← 5
grid[2][3] ← 9
output grid[1][1]  // Outputs 5

Traversing a 2D Array

IB Pseudocode:

rows ← 3
cols ← 4
loop i from 1 to rows
    loop j from 1 to cols
        output grid[i][j]
    end loop
end loop

Python Equivalent (0-based):

rows = 3
cols = 4
for i in range(rows):
    for j in range(cols):
        print(grid[i][j])

Collections

IB defines a Collection as an abstract data structure with specific methods for adding and iterating over items. Collections are not the same as arrays — they are dynamic and unordered.

Collection Methods

names ← new Collection()
names.addItem("Alice")
names.addItem("Bob")
names.addItem("Carol")

names.resetNext()
loop while names.hasNext()
    current ← names.getNext()
    output current
end loop

Alice
Bob
Carol

names = []
names.append("Alice")
names.append("Bob")
names.append("Carol")

for current in names:
    print(current)

Stacks

A stack is a Last-In, First-Out (LIFO) data structure. Items are added and removed from the top only.

Stack Methods

IB Pseudocode:

s ← new Stack()
s.push(10)
s.push(20)
s.push(30)
output s.pop()  // Outputs 30
output s.pop()  // Outputs 20

Queues

A queue is a First-In, First-Out (FIFO) data structure. Items are added at the back and removed from the front.

Queue Methods

IB Pseudocode:

q ← new Queue()
q.enqueue(10)
q.enqueue(20)
q.enqueue(30)
output q.dequeue()  // Outputs 10
output q.dequeue()  // Outputs 20

Sub-programs (Methods)

IB pseudocode uses the METHOD keyword to define sub-programs (functions/procedures). Methods can take parameters and return a value.

Method Declaration

IB Pseudocode:

METHOD methodName(parameter1, parameter2)
    // statements
    return value
END METHOD

Method Call

result ← methodName(arg1, arg2)

METHOD calculateArea(width, height)
    area ← width * height
    return area
END METHOD

// Calling the method
result ← calculateArea(5, 10)
output result  // Outputs 50

def calculateArea(width, height):
    area = width * height
    return area

# Calling the function
result = calculateArea(5, 10)
print(result)  # Outputs 50

METHOD printGreeting(name)
    output "Hello, ", name
END METHOD

printGreeting("Alice")  // Outputs: Hello, Alice

def printGreeting(name):
    print("Hello,", name)

printGreeting("Alice")  # Outputs: Hello, Alice

Side-by-Side Comparisons

Example 1: Find the Maximum of Two Numbers

Example 2: Sum of Array Elements

Note: In Python, arr[i] works directly because range(len(arr)) produces 0-based indices matching Python’s 0-based arrays. To match IB’s 1-based arrays, you’d need range(1, len(arr)+1) and access arr[i-1].

Example 3: User Input Validation

Worked Algorithm Examples

1. Linear Search

Problem: Search for a target value in an unsorted array. Return the index if found, or -1 if not found.

IB Pseudocode:

METHOD linearSearch(arr, target)
    found ← false
    index ← 1
    loop while index ≤ length(arr) and found = false
        if arr[index] = target then
            found ← true
        else
            index ← index + 1
        end if
    end loop
    if found = true then
        return index
    else
        return -1
    end if
END METHOD

Python Equivalent:

def linearSearch(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

2. Bubble Sort

Problem: Sort an array in ascending order using bubble sort.

IB Pseudocode:

METHOD bubbleSort(arr)
    n ← length(arr)
    loop i from 1 to n - 1
        loop j from 1 to n - i
            if arr[j] > arr[j + 1] then
                temp ← arr[j]
                arr[j] ← arr[j + 1]
                arr[j + 1] ← temp
            end if
        end loop
    end loop
END METHOD

Python Equivalent:

def bubbleSort(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

3. Binary Search

Problem: Search for a target value in a sorted array using binary search. Return the index if found, or -1 if not found.

Pre-condition: The array must be sorted in ascending order.

IB Pseudocode:

METHOD binarySearch(arr, target)
    low ← 1
    high ← length(arr)
    found ← false
    loop while low ≤ high and found = false
        mid ← (low + high) div 2
        if arr[mid] = target then
            found ← true
        else if arr[mid] < target then
            low ← mid + 1
        else
            high ← mid - 1
        end if
    end loop
    if found = true then
        return mid
    else
        return -1
    end if
END METHOD

Python Equivalent:

def binarySearch(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

4. Recursive Factorial

Problem: Calculate the factorial of a non-negative integer $n$ using recursion.

$n! = n \times (n-1) \times (n-2) \times \ldots \times 2 \times 1$

$0! = 1 \text{ (by definition)}$

IB Pseudocode:

METHOD factorial(n)
    if n = 0 then
        return 1
    else
        return n * factorial(n - 1)
    end if
END METHOD

Python Equivalent:

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

Common Syntax Errors Summary

Practice Questions

METHOD sumArray(arr)
    total ← 0
    loop i from 1 to length(arr)
        total ← total + arr[i]
    end loop
    return total
END METHOD

METHOD countOccurrences(arr, target)
    count ← 0
    loop i from 1 to length(arr)
        if arr[i] = target then
            count ← count + 1
        end if
    end loop
    return count
END METHOD

METHOD reverseArray(arr)
    n ← length(arr)
    loop i from 1 to n div 2
        temp ← arr[i]
        arr[i] ← arr[n - i + 1]
        arr[n - i + 1] ← temp
    end loop
END METHOD

METHOD isSorted(arr)
    n ← length(arr)
    sorted ← true
    i ← 1
    loop while i < n and sorted = true
        if arr[i] > arr[i + 1] then
            sorted ← false
        else
            i ← i + 1
        end if
    end loop
    return sorted
END METHOD

METHOD findMin(arr)
    min ← arr[1]
    loop i from 2 to length(arr)
        if arr[i] < min then
            min ← arr[i]
        end if
    end loop
    return min
END METHOD

METHOD fibonacci(n)
    if n = 0 then
        return 0
    else if n = 1 then
        return 1
    else
        return fibonacci(n - 1) + fibonacci(n - 2)
    end if
END METHOD

Exam Strategy Tips