Arrays - Advanced

• A 2D array has rows and columns — think of it as a table or grid.
• Declaration uses two index ranges separated by a comma: DECLARE Grid : ARRAY[1:3, 1:4] OF INTEGER.
• Access a single element with two indices: Grid[2, 3] means row 2, column 3.
• Typical uses: matrices, game boards, spreadsheets and seating plans.

Example: declare and fill a 3×4 grid

DECLARE Grid : ARRAY[1:3, 1:4] OF INTEGER
DECLARE Row, Col : INTEGER
FOR Row <- 1 TO 3
  FOR Col <- 1 TO 4
    OUTPUT "Enter value for [", Row, ",", Col, "]: "
    INPUT Grid[Row, Col]
  NEXT Col
NEXT Row

• Access a specific cell with Grid[Row, Col].
• To print every element, use two nested FOR loops: outer for rows, inner for columns.
• An empty OUTPUT "" after the inner loop moves the cursor to the next line.
• To access a specific row, fix the row index and loop through columns. To access a specific column, fix the column index and loop through rows.

Example: print all elements of a 3×4 grid

FOR Row <- 1 TO 3
  FOR Col <- 1 TO 4
    OUTPUT Grid[Row, Col], " "
  NEXT Col
  OUTPUT ""
NEXT Row

DECLARE Col : INTEGER
FOR Col <- 1 TO 4
  OUTPUT Grid[2, Col], " "
NEXT Col

DECLARE Row : INTEGER
FOR Row <- 1 TO 3
  OUTPUT Grid[Row, 3], " "
NEXT Row

• Use nested loops to walk through every cell of the grid.
• Initialise Total to 0 once, before both loops start.
• Accumulate with Total <- Total + Grid[Row, Col] inside both loops.
• For row sums, reset RowSum to 0 at the start of each row and output it after the inner loop. For column sums, swap the loop roles.

Example: sum of all elements in a 3×4 grid

DECLARE Total : INTEGER
Total <- 0
FOR Row <- 1 TO 3
  FOR Col <- 1 TO 4
    Total <- Total + Grid[Row, Col]
  NEXT Col
NEXT Row
OUTPUT "Total: ", Total

• A linear search through a 2D array uses two nested loops to scan every cell.
• Declare a Found flag (BOOLEAN) and two position variables FoundRow and FoundCol (INTEGER).
• When Grid[Row, Col] = SearchVal, set Found <- TRUE and record the position.
• After the loops, use IF Found to decide whether to print the position or “Not found”.

Example: search for a value in a 3×4 grid

DECLARE SearchVal : INTEGER
DECLARE Found : BOOLEAN
DECLARE FoundRow, FoundCol : INTEGER
Found <- FALSE
OUTPUT "Enter value to search: "
INPUT SearchVal
FOR Row <- 1 TO 3
  FOR Col <- 1 TO 4
    IF Grid[Row, Col] = SearchVal THEN
      Found <- TRUE
      FoundRow <- Row
      FoundCol <- Col
    ENDIF
  NEXT Col
NEXT Row
IF Found THEN
  OUTPUT "Found at [", FoundRow, ",", FoundCol, "]"
ELSE
  OUTPUT "Not found"
ENDIF

• Bubble sort repeatedly compares adjacent elements and swaps them if they are out of order.
• After each pass, the largest unsorted element “bubbles” to its correct position at the end.
• Sorting n elements needs at most n - 1 passes.
• Swapping requires a Temp variable to hold one value while the other is overwritten.

Example: bubble sort 5 elements into ascending order

DECLARE Numbers : ARRAY[1:5] OF INTEGER
DECLARE I, J : INTEGER
DECLARE Temp : INTEGER
FOR I <- 1 TO 5
  OUTPUT "Enter number: "
  INPUT Numbers[I]
NEXT I
FOR I <- 1 TO 4
  FOR J <- 1 TO 5 - I
    IF Numbers[J] > Numbers[J + 1] THEN
      Temp <- Numbers[J]
      Numbers[J] <- Numbers[J + 1]
      Numbers[J + 1] <- Temp
    ENDIF
  NEXT J
NEXT I
OUTPUT "Sorted:"
FOR I <- 1 TO 5
  OUTPUT Numbers[I]
NEXT I

A powerful way to fill a 2D array is with a formula based on the row and column indices. The classic example stores row * column in each cell — this builds a multiplication table. Understanding how many times the assignment runs and being able to produce a trace table is an essential exam skill.

Populate by formula — a 3×5 multiplication table:

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

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

// The grid now looks like this:
// Row 1:  1  2  3  4  5
// Row 2:  2  4  6  8 10
// Row 3:  3  6  9 12 15

Trace table — each step of the nested loop execution:

Random population — IGCSE vs AS Level:

You can also fill a 2D array with random numbers. The function depends on the level:

Marks[x, y] <- ROUND(RANDOM() * 100)

Marks[x, y] <- RAND(101)

Activity 1 — Contacts search: A 2D array Contacts stores 250 contacts: column 1 = name, column 2 = phone number. Input a name, search the array, and output the matching phone number (or “Contact not found”).

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

found <- FALSE
INPUT SearchName

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

IF NOT found THEN
  OUTPUT "Contact not found"
ENDIF

Activity 2 — Treasure Hunt: An 8×8 array map contains “Treasure” or “Empty” in each cell. Search for the first treasure and output its position (or “No treasure found on the map”).

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

found <- FALSE

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

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