• What an array actually is, and why it exists (fixed-size, single data type, ordered).
• The index war: Python starts counting at 0, CIE pseudocode starts counting at 1.
• How to declare, access, and modify elements in a 1D array — in both pseudocode and Python.
• Using len() / a length variable to find how many elements are in an array.
• Iterating through a 1D array with a FOR...NEXT loop.
• 2D arrays — thinking of them as a grid with rows and columns, and how to navigate row-first, then column.
• Declaring, accessing, and modifying elements in a 2D array — pseudocode uses [row, col], Python uses [row][col].
• Nested FOR...NEXT loops to iterate through every cell of a 2D array.

Imagine you need to store the test scores of 5 students. You create five separate variables — score1, score2, score3, score4, score5 — but that's clunky, and it falls apart completely if you have 500 students instead of 5. You'd need 500 variable names, and looping through them would be impossible because you can't easily say "give me variable number 347" in a loop.

An array solves this. Think of it like a strip of numbered pigeonholes bolted to a wall. The whole strip has one name (say, scores), and each pigeonhole has a position number. To get a value out, you don't need a new variable name — you just say "give me the value in pigeonhole 3."

Formally, an array is defined by three properties, and all three matter for exam answers:

• Ordered — every element has a fixed position (an index), so the array always keeps the same sequence unless you explicitly change it.
• Static / fixed-size — once you declare an array to hold, say, 5 elements, it always has exactly 5 slots. You can't stretch it to hold a 6th value without creating a new array. (This is different from a Python , which can grow — but for IGCSE purposes, arrays are treated as fixed-size.)
• Single data type — an array of integers can only hold integers. You can't mix a string into an array of numbers.

Visualising a 1D array

Here's the array ["B","E","A","D","S"] drawn out — notice this uses zero-indexing (the Python/most-languages convention):

Array length is 5 · First element is at index 0 · The 4th element ("D") sits at index 3

There are three things you'll always be asked to do with an array: create it, read (access) a value from it, and write (modify) a value in it. Let's go through the exact syntax for each, side by side in both languages.

Creating an array

You can also declare a blank array and fill it slot by slot with assignment statements — this is exactly what happens in the worked example below.

Accessing a single element

Modifying a single element

Notice pseudocode uses a left-pointing arrow ← for assignment, while Python uses a single equals sign =. This is consistent across all of CIE pseudocode, not just arrays — always keep it straight in your head.

Finding the length

Python has a handy built-in function, len(array), that instantly tells you how many elements are in an array. CIE pseudocode has no built-in length function — you either already know the size from the DECLARE statement, or you store it yourself in a variable.

Full worked example — building and using MyArray

// Creating a one-dimensional array
DECLARE MyArray : ARRAY[1:5] OF INTEGER
MyArray[1] ← 1
MyArray[2] ← 2
MyArray[3] ← 3
MyArray[4] ← 4
MyArray[5] ← 5

// Accessing elements
OUTPUT MyArray[1]      // Output: 1
OUTPUT MyArray[3]      // Output: 3

// Modifying an element
MyArray[2] ← 10
// MyArray is now: [1, 10, 3, 4, 5]

// Iterating over the array
DECLARE Index : INTEGER
FOR Index ← 1 TO 5
  OUTPUT MyArray[Index]
NEXT Index
// Output: 1, 10, 3, 4, 5

// Length of the array
DECLARE Length : INTEGER
Length ← 5
OUTPUT Length          // Output: 5

# Creating a one-dimensional array
array = [1, 2, 3, 4, 5]

# Accessing elements
print(array[0])   # Output: 1
print(array[2])   # Output: 3

# Modifying an element
array[1] = 10
print(array)  # [1, 10, 3, 4, 5]

# Iterating over the array
for element in array:
    print(element)
# Output: 1, 10, 3, 4, 5


# Length of the array
length = len(array)
print(length)   # Output: 5

A 1D array is a single strip of pigeonholes. A 2D array is what you get when you stack several of those strips on top of each other — now you have rows columns, exactly like a spreadsheet or a table.

The most natural way to think about a 2D array is as a grid: the row index tells you which strip (which row) to look in, and the column index tells you which pigeonhole along that strip to open.

Visualising a 2D array

Here's a 3×5 grid of letters spelling a hidden word, read row by row:

The left index picks the row. The right index picks the column. So position [1,2] (row 1, column 2) gives you the letter V.

Declaring a 2D array

Worked example — building the "players" 2D array

Four players, each with a name and a score, stored as a 4-row, 2-column array:

// 4 rows, 2 columns (name and score)
DECLARE players : ARRAY[1:4, 1:2] OF STRING

// Assign values to each player
players[1,1] ← "Alice"
players[1,2] ← "25"
players[2,1] ← "Bob"
players[2,2] ← "30"
players[3,1] ← "Charlie"
players[3,2] ← "22"
players[4,1] ← "Daisy"
players[4,2] ← "28"

# Each player: [name, score]
players = [
    ["Alice", 25],
    ["Bob", 30],
    ["Charlie", 22],
    ["Daisy", 28]
]

Notice Python is happy to mix a string and an integer inside ["Alice", 25] because that's just a small nested inside a bigger list — Python lists are more flexible than the strict "array" definition CIE pseudocode uses. But in strict pseudocode terms, everything has to be declared as one type (STRING here), which is why the score is stored as the text "25" rather than the number 25.

Modifying an element in a 2D array

Charlie is the 3rd person, so pseudocode row index is 3 (1-indexed); Python's row index is 2 (0-indexed). The name is the 1st item in each row, so pseudocode column is 1; Python column is 0.

Full worked example — a 3×3 numeric grid

DECLARE Array2D : ARRAY[1:3, 1:3] OF INTEGER
Array2D[1,1] ← 1
Array2D[1,2] ← 2
Array2D[1,3] ← 3
Array2D[2,1] ← 4
Array2D[2,2] ← 5
Array2D[2,3] ← 6
Array2D[3,1] ← 7
Array2D[3,2] ← 8
Array2D[3,3] ← 9

// Accessing elements
OUTPUT Array2D[1,1]   // Output: 1
OUTPUT Array2D[2,3]   // Output: 6

array_2d = [[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]]

# Accessing elements
print(array_2d[0][0])  # Output: 1
print(array_2d[1][2])  # Output: 6

To visit every single element of a 2D array, one loop isn't enough — you need a loop a loop, called a nested loop. Think of it like reading a book: the outer loop moves you down through the pages (rows), and for every page, the inner loop reads every word on that page (columns) before moving to the next page.

DECLARE Row : INTEGER
DECLARE Col : INTEGER
FOR Row ← 1 TO 3
  FOR Col ← 1 TO 3
    OUTPUT Array2D[Row, Col]
  NEXT Col
NEXT Row

for row in array_2d:
    for item in row:
        print(item, end=" ")
    print()  # newline after each row

Worked example — the TV-watching table

A parent records minutes of TV watched by 4 children (Quinn, Lyla, Harry, Elias) across 5 days, stored in a 2D array called minsWatched using Python-style zero-indexing, rows = days, columns = children:

Worked step-by-step: "Elias watched 78 minutes of TV on Monday" — how do we know?

• Identify the row for Monday → Row 0
• Identify the column for Elias → Column 3
• Look up minsWatched[0][3] → value is 78 ✓

• I can state the full definition of an array (ordered, static, single data type).
• I know pseudocode indexes start at 1, and Python indexes start at 0.
• I can write the DECLARE statement to create a 1D array in pseudocode.
• I can access and modify a single element of a 1D array in both pseudocode and Python.
• I can use len() in Python, and explain why pseudocode has no equivalent function.
• I can write a FOR...NEXT loop (or Python for loop) to iterate through every element of a 1D array.
• I understand a 2D array as a grid, and know you navigate rows first, then columns.
• I can write the DECLARE statement to create a 2D array in pseudocode.
• I can access and modify a single element of a 2D array using [row, col] and [row][col].
• I can write a nested FOR...NEXT loop to iterate through every element of a 2D array.
• I always check the exam question's example before assuming which index means row vs column.