Rows & Columns

A two-dimensional (2D) array is a data structure that stores elements in rows and columns, forming a grid-like structure. Each element is uniquely identified by two indices: its row index and its column index. If a 1D array is a list, a 2D array is a table.

• Declaration specifies two index ranges separated by a comma: DECLARE matrix : ARRAY[1:3, 1:5] OF INTEGER.
• The first range 1:3 is the rows (1 to 3); the second range 1:5 is the columns (1 to 5).
• Total elements = rows × columns = 3 × 5 = 15.
• Typical uses: game boards (chess, tic-tac-toe), seating plans, spreadsheets and matrices.

Example: declare a 3 × 5 grid of integers

DECLARE matrix : ARRAY[1:3, 1:5] OF INTEGER
// 3 rows (1..3) and 5 columns (1..5) — 15 cells in total

Once a 2D array is declared, every cell starts empty. You can write a value into a single cell using an assignment statement, or read a value out of a cell into a variable.

• Assign: matrix[2, 4] <- 1985 writes 1985 into the cell at row 2, column 4.
• Access: value <- matrix[2, 3] reads the cell at row 2, column 3 and stores it in value.
• Row index always comes first, column index second — exactly the same order as the declaration.

Example: assign to one cell, then read from another

DECLARE matrix : ARRAY[1:3, 1:5] OF INTEGER
DECLARE value : INTEGER

matrix[2, 4] <- 1985   // Write 1985 into row 2, column 4
value <- matrix[2, 3]  // Read row 2, column 3 into 'value'
OUTPUT value           // Outputs whatever was stored at [2, 3]

matrix[3, 5] <- 42

value <- matrix[1, 2]

To populate every cell of a 2D array, use nested loops: an outer FOR loop walks through the rows, and an inner FOR loop walks through the columns of each row. The classic worked example builds a multiplication table by storing row * column in each cell.

Example: fill a 3 × 5 grid with a multiplication table

DECLARE matrix : ARRAY[1:3, 1:5] OF INTEGER
DECLARE row, col : INTEGER

FOR row <- 1 TO 3
  FOR col <- 1 TO 5
    matrix[row, col] <- row * col
  NEXT col
NEXT row

After the loops, the array holds the grid:

Trace Table — every step of the nested loops

This trace table shows each step of execution. There are 15 steps in total — one for every cell in the 3 × 5 grid.

How the nested loops work

• Row 1 starts → column goes 1 → 2 → 3 → 4 → 5 → Row 1 is now fully complete.
• Row 2 starts → column again goes 1 → 2 → 3 → 4 → 5 → Row 2 is now fully complete.
• Row 3 starts → column again goes 1 → 2 → 3 → 4 → 5 → Row 3 is now fully complete.
• Only when Row 3 finishes does the program stop.

Traversal is the operation of visiting every element of a 2D array in turn. We use the same nested-loop pattern as for populating — outer loop for rows, inner loop for columns — but the body of the inner loop outputs each cell instead of writing to it.

• Use an outer FOR loop for rows and an inner FOR loop for columns.
• In the inner loop, OUTPUT matrix[row, col], " " prints the current cell followed by a space.
• After the inner loop, an empty OUTPUT "" moves the cursor to a new line — so each row appears on its own line.
• This is called row-major traversal: all of row 1 is printed before any of row 2.

Example: print a 3 × 5 grid as a grid

DECLARE matrix : ARRAY[1:3, 1:5] OF INTEGER
DECLARE row, col : INTEGER
// ... (assume matrix is already filled) ...
FOR row <- 1 TO 3
  FOR col <- 1 TO 5
    OUTPUT matrix[row, col], " "
  NEXT col
  OUTPUT ""
NEXT row

If matrix holds the multiplication table from section 1.3, the output is:

1 2 3 4 5
2 4 6 8 10
3 6 9 12 15

DECLARE col : INTEGER
FOR col <- 1 TO 5
  OUTPUT matrix[2, col], " "
NEXT col

DECLARE row : INTEGER
FOR row <- 1 TO 3
  OUTPUT matrix[row, 3], " "
NEXT row

A common task is to fill a 2D array with random numbers. The syntax differs between IGCSE / O Level and AS Level — make sure you use the right one for your syllabus.

DECLARE Marks : ARRAY[1:3, 1:5] OF REAL
DECLARE x, y : INTEGER
FOR x <- 1 TO 3
  FOR y <- 1 TO 5
    Marks[x, y] <- RANDOM() * 100
  NEXT y
NEXT x

DECLARE Marks : ARRAY[1:3, 1:5] OF INTEGER
DECLARE x, y : INTEGER
FOR x <- 1 TO 3
  FOR y <- 1 TO 5
    Marks[x, y] <- RAND(101)
  NEXT y
NEXT x

A linear search of a 2D array uses two nested loops to scan every cell. A BOOLEAN flag called found records whether the target has been located. Initialise it to FALSE before the loops; if any cell matches, set it to TRUE and output the row and column. After the loops, if found is still FALSE, output a “not found” message.

Example: search a 5 × 5 array for a target value

DECLARE array : ARRAY[1:5, 1:5] OF INTEGER
DECLARE targetValue : INTEGER
DECLARE found : BOOLEAN
DECLARE row, col : INTEGER

targetValue <- 10
found <- FALSE

// Nested loops to search for the target value
FOR row <- 1 TO 5
  FOR col <- 1 TO 5
    IF array[row, col] = targetValue THEN
      found <- TRUE
      OUTPUT "Found at ROW ", row, " COLUMN: ", col
    END IF
  NEXT col
NEXT row

IF NOT found THEN
  OUTPUT "Target value not found in the array"
END IF

DECLARE Contacts : ARRAY[1:250, 1:2] OF STRING
DECLARE SearchName : STRING
DECLARE found : BOOLEAN
DECLARE i : INTEGER

OUTPUT "Enter contact name to search: "
INPUT SearchName
found <- FALSE

FOR i <- 1 TO 250
  IF Contacts[i, 1] = SearchName THEN
    found <- TRUE
    OUTPUT "Phone number: ", Contacts[i, 2]
  END IF
NEXT i

IF NOT found THEN
  OUTPUT "Contact not found"
END IF

DECLARE map : ARRAY[1:8, 1:8] OF STRING
DECLARE found : BOOLEAN
DECLARE row, col : INTEGER

found <- FALSE

FOR row <- 1 TO 8
  FOR col <- 1 TO 8
    IF map[row, col] = "Treasure" THEN
      found <- TRUE
      OUTPUT "Treasure found at Row ", row, ", Column ", col
    END IF
  NEXT col
NEXT row

IF NOT found THEN
  OUTPUT "No treasure found on the map."
END IF

DECLARE words : ARRAY[1:3, 1:5] OF STRING
DECLARE found : BOOLEAN
DECLARE row, col : INTEGER

found <- FALSE

FOR row <- 1 TO 3
  FOR col <- 1 TO 5
    IF words[row, col] = "Start" THEN
      found <- TRUE
      OUTPUT "Start found at Row ", row, ", Column ", col
    END IF
  NEXT col
NEXT row

IF NOT found THEN
  OUTPUT "Start not found in the array"
END IF

Key Points Summary