What is an array in programming, and why is it important in the Cambridge IGCSE Computer Science curriculum?

An array is a data structure used in programming to store a collection of elements, typically of the same data type, in a contiguous block of memory. Arrays are important in the Cambridge IGCSE Computer Science curriculum because they allow efficient storage and manipulation of data sets, enabling students to perform operations like searching, sorting, and iterating over elements, which are fundamental skills in programming.

How do you declare and initialize an array in a programming language?

To declare and initialize an array, you typically specify the data type of the elements, the array name, and the number of elements it can hold. For example, in Python, you can declare an array using a list: `my_array = [1, 2, 3, 4]`. In Java, you might use: `int[] myArray = new int[4];` followed by initialization: `myArray[0] = 1;`. Understanding these concepts is crucial for Cambridge IGCSE students as it forms the basis for more complex data manipulation tasks.

What are the common operations performed on arrays in programming?

Common operations on arrays include accessing elements by index, updating elements, iterating over elements using loops, searching for specific elements, and sorting the array. These operations are essential for solving computational problems and are a key focus in the Cambridge IGCSE Computer Science syllabus, as they help students develop logical thinking and problem-solving skills.

What are the differences between one-dimensional and multi-dimensional arrays?

A one-dimensional array is a linear list of elements, whereas a multi-dimensional array, such as a two-dimensional array, is an array of arrays, resembling a table with rows and columns. Multi-dimensional arrays are used to represent more complex data structures like matrices. Understanding these differences is important for Cambridge IGCSE students as it expands their ability to model and solve real-world problems using programming.

How do arrays differ from other data structures like lists or tuples in programming?

Arrays differ from lists or tuples primarily in terms of mutability and performance. In some languages, arrays have a fixed size and allow direct access to elements, making them more efficient for certain operations. Lists, however, are often dynamic and can grow or shrink, while tuples are immutable. These distinctions are crucial for Cambridge IGCSE students to understand as they choose the appropriate data structure for their programming tasks.

Why is "Using indexes outside the declared bounds" a common mistake in Arrays?

Why it happens: Students forget that `ARRAY[1:30]` only allows indexes 1 to 30. How to avoid it: Always loop from the LOWER BOUND to the UPPER BOUND of the declaration. Out-of-bounds access is a run-time error in most languages. Source: 0478 Examiner Reports 2022-2024

Why is "Storing different types in the same array" a common mistake in Arrays?

Why it happens: Students treat arrays like lists. How to avoid it: An array holds values of ONE TYPE. To mix types, you'd need a record/struct or a dynamic-typed list (Python). Cambridge pseudocode arrays are strict.

Why is "Stopping bubble sort after one pass" a common mistake in Arrays?

Why it happens: Students see one large value 'bubble up' and think the array is sorted. How to avoid it: Bubble sort requires multiple passes — up to n-1 passes for n elements. Implementations stop EARLY only if NO SWAPS were made on the last pass.

Why is "Initialising the Found flag inside a loop" a common mistake in Arrays?

Why it happens: Students put it in the wrong place. How to avoid it: Found ← FALSE goes BEFORE the loop. Inside the loop you only set it to TRUE if a match is found. Resetting it inside means a match in iteration 1 is forgotten by iteration 2.

ProgrammingCambridge IGCSE Computer Science (0478)

Arrays

Work through the notes, try the practice questions, then take the quiz. The report tells you exactly what to revise next.

Previous Next

Learn this Topic

Start with the slides for the quick version, then go deeper with the full study notes.

Short Study Notes in the form of Slides

Read the notes first. If the method in a worked example clicks, you're ready for the questions.

Page 1 / 0

Detailed Study Notes

Full prose, callouts and a recap — built for A* mastery, not just a quick scan.

Take these study notes with you

Download a branded PDF — full prose, callouts, recap and memorise list for Arrays, ready to print or save offline.

Arrays Study Notes — Cambridge IGCSE Computer Science 0478 (2026-2028 syllabus)

How to store many related values under one variable name. 1D and 2D arrays. Declaring, initialising, accessing and updating elements. The two standard array algorithms — linear search and bubble sort.

What you’ll learn

Mapped to the Cambridge IGCSE 0478 syllabus (2026-2028).

1.23.1 — Declare and use 1D and 2D arrays.
1.23.2 — Read from and write to array elements.
1.23.3 — Implement linear search.
1.23.4 — Implement bubble sort.

What an array is and why we use them

Many values of the same type stored under one name.

An array is a data structure that holds multiple values of the SAME data type, accessed by an index.

Without arrays — to store 30 student names you'd need 30 separate variables (Name1, Name2, ..., Name30). Reading them in: 30 lines of input. Looping over them: impossible.

With an array — one declaration holds all 30. Loops can process all of them in three lines.

Cambridge declaration syntax:

DECLARE Names : ARRAY[1:30] OF STRING

This creates a 1D array of 30 strings, indexed 1 to 30.

Reading and writing elements:

Names[5] ← "Aisha"        // write to position 5
OUTPUT Names[5]            // read from position 5

Why arrays matter.

One loop processes all elements — no per-variable code.
Algorithms like search and sort become possible.
Memory layout is contiguous — fast access.

Cambridge tip. Mark scheme expects students to DECLARE the array properly with size AND type. Missing either loses marks.

Array = N values, same type, one name.
Indexed access: Arr[i].
Cambridge arrays typically start at index 1.

See the full worked example for arrays →

1D vs 2D arrays

1D = list. 2D = grid (think rows and columns).

1D array. A linear sequence — a single row (or column) of values.

DECLARE Marks : ARRAY[1:30] OF INTEGER
Marks[5] ← 87

Access with ONE index: Marks[5].

2D array. A grid — values arranged in rows and columns. Used for tables, matrices, game boards, spreadsheets.

DECLARE Grid : ARRAY[1:5, 1:8] OF INTEGER
Grid[3, 4] ← 99

Access with TWO indexes: Grid[row, column].

Looping over a 2D array. Use NESTED FOR loops.

FOR Row ← 1 TO 5
  FOR Col ← 1 TO 8
    INPUT Grid[Row, Col]
  NEXT Col
NEXT Row

Cambridge tip. When a question asks for a 2D array, declare with TWO ranges, not two separate 1D arrays. Mark scheme distinguishes the two.

1D = single index.
2D = (row, column) pair.
Use nested loops to traverse 2D arrays.

Linear search

Check each element until found or end reached.

Linear search is the simplest search algorithm. Check element 1; if it's the target, stop. Otherwise check element 2. Repeat until found or the end is reached.

Cambridge pseudocode:

Found ← FALSE
INPUT Target
FOR Counter ← 1 TO N
  IF Array[Counter] = Target THEN
    Found ← TRUE
  ENDIF
NEXT Counter
IF Found = TRUE THEN
  OUTPUT 'Found'
ELSE
  OUTPUT 'Not found'
ENDIF

Strengths.

Simple to code.
Works on UNSORTED arrays.
Works on any data type that supports equality.

Weakness.

Worst-case O(n) — if the target is at the end (or not present), every element is checked. Slow on large arrays.

Optimisation. Stop the loop as soon as a match is found (break out of the loop). Some Cambridge questions accept this; others use the simpler 'flag-and-keep-looping' version.

Cambridge tip. Mark scheme always expects: an INITIALISED flag, a LOOP, an EQUALITY check, and an OUTPUT branch for both found and not-found cases.

Loop + equality check + flag.
Works on unsorted arrays.
O(n) worst-case.

See the full worked example for arrays →

Bubble sort

Compare adjacent pairs; swap if out of order; repeat.

Bubble sort orders an array by repeatedly comparing adjacent pairs and swapping them if they're in the wrong order.

The intuition. After ONE pass through the array, the largest element 'bubbles' to the end. After two passes, the largest TWO are at the end. After n-1 passes, the array is sorted.

Cambridge pseudocode:

FOR Pass ← 1 TO N-1
  FOR Counter ← 1 TO N-Pass
    IF Array[Counter] > Array[Counter+1] THEN
      Temp ← Array[Counter]
      Array[Counter] ← Array[Counter+1]
      Array[Counter+1] ← Temp
    ENDIF
  NEXT Counter
NEXT Pass

Why three lines for the swap. Without the temporary variable, the second assignment would overwrite the first value before it gets used.

Trace example. Sorting [5, 3, 8, 1, 6]:

Pass 1: [3, 5, 8, 1, 6] → [3, 5, 8, 1, 6] → [3, 5, 1, 8, 6] → [3, 5, 1, 6, 8]. Largest at end.
Pass 2: [3, 5, 1, 6, 8] → [3, 1, 5, 6, 8] → [3, 1, 5, 6, 8]. Second-largest in place.
Pass 3: [1, 3, 5, 6, 8] → [1, 3, 5, 6, 8]. Sorted.
Pass 4: no swaps. Done.

Strengths. Simple to code. Works on any comparable data type.

Weaknesses. Worst-case O(n²) — slow on large arrays. Real-world systems use quicksort, mergesort or built-in language sorts instead. Bubble sort is a TEACHING algorithm.

Optimisation. If a pass makes NO SWAPS, the array is already sorted — exit early.

Cambridge tip. Mark scheme rewards the SWAP using a TEMP variable explicitly. Three lines: temp ← A; A ← B; B ← temp.

Compare adjacent pairs; swap if wrong order.
n-1 passes worst case.
Swap requires a TEMP variable.
O(n²) — slow on large arrays.

See the full worked example for arrays →

How it’s examined

Arrays appear on every Paper 2. Most-tested questions: declare and read into an array (6 marks), linear search (8 marks), bubble sort (8-10 marks). Examiner reports flag missing array bounds in declarations and forgetting the temp variable in swaps as the most common errors.

Sources: Cambridge IGCSE Computer Science 0478 syllabus (2026-2028); 0478 Examiner Reports 2022-2024; 0478/22 May/Jun 2024 question paper and mark scheme. Last reviewed 2026-05-09.

Master this Topic

Worked examples, formulae, definitions and the mistakes examiners flag — everything you need to push from a pass to an A*.

Take this whole topic with you

Download a branded revision sheet — worked examples, formulae, definitions and common mistakes for Arrays, ready to print or save as PDF.

Step-by-step worked examples — Arrays

Step-by-step solutions to past-paper-style questions on arrays, written exactly the way a tutor would explain them at the board.

1Read into a 1D array (6 marks)
Extended• Adapted from 0478/22 May/Jun 2024 Q6• array, 1d
Question
Write pseudocode that declares a 1D array of 30 integers and reads 30 numbers into it. (6 marks)
Step-by-step solution
1. Step 1
  Declare (2 marks). DECLARE Numbers : ARRAY[1:30] OF INTEGER.
2. Step 2
  Loop and input (4 marks). Use a FOR loop with the counter as the array INDEX.
Answer
DECLARE Numbers : ARRAY[1:30] OF INTEGER FOR Counter ← 1 TO 30 INPUT Numbers[Counter] NEXT Counter
Examiner tip
Mark scheme rewards both correct DECLARATION (with size and type) and correct USE (indexing with the loop counter).
2Linear search in an array (8 marks)
Extended• array, search
Question
Write pseudocode that searches an array Names[1:50] for a target name. Output 'Found' if it exists, 'Not found' otherwise. (8 marks)
Step-by-step solution
1. Step 1
  Initialise (2 marks). Set a Found FLAG to FALSE; INPUT the target.
2. Step 2
  Loop and compare (4 marks). FOR Counter ← 1 TO 50: IF Names[Counter] = Target THEN Found ← TRUE ENDIF NEXT.
3. Step 3
  Output (2 marks). IF Found = TRUE THEN OUTPUT 'Found' ELSE OUTPUT 'Not found' ENDIF.
Answer
Found ← FALSE INPUT Target FOR Counter ← 1 TO 50 IF Names[Counter] = Target THEN Found ← TRUE ENDIF NEXT Counter IF Found = TRUE THEN OUTPUT 'Found' ELSE OUTPUT 'Not found' ENDIF
3Describe bubble sort (8 marks)
Extended• array, sort
Question
Describe how bubble sort works on an array. Use a 5-element example to illustrate one full pass. (8 marks)
Step-by-step solution
1. Step 1
  Algorithm overview (3 marks). Compare adjacent pairs from left to right; SWAP if they are in the wrong order. After one full pass, the largest element is at the right (it 'bubbles up'). Repeat for unsorted portion until no swaps are made.
2. Step 2
  Example pass — start (1 mark). Take [5, 3, 8, 1, 6].
3. Step 3
  Compare and swap (4 marks). (5,3) → swap → [3,5,8,1,6]. (5,8) → no swap → [3,5,8,1,6]. (8,1) → swap → [3,5,1,8,6]. (8,6) → swap → [3,5,1,6,8]. End of pass: largest (8) at right.
Answer
Compare adjacent pairs; swap if out of order; one pass moves the largest to the end. Repeat ignoring the now-sorted tail until no swaps. Worst-case complexity O(n²) — slow on large arrays but easy to code.

Key Definitions and Keywords — Arrays

Definitions to memorise and the exact keywords mark schemes credit for arrays answers — sharpened from recent examiner reports for the 2026 0478 sitting.

Array
Examiner keyword
A data structure that stores multiple values of the SAME data type under one variable name, accessed by index.
1D array
Examiner keyword
A linear array — a single row (or column) of values. Accessed with one index: Numbers[5].
2D array
Examiner keyword
A grid of values. Accessed with TWO indexes: Grid[row, column] or Grid[row][column].
Index
Examiner keyword
The position of an element in an array. Cambridge pseudocode arrays typically start at 1 (ARRAY[1:N]); some languages start at 0.
Linear search
Examiner keyword
A search algorithm that examines each element of an array in turn until the target is found or the end is reached. Worst-case O(n).
Bubble sort
Examiner keyword
A sort algorithm that repeatedly compares adjacent pairs and swaps them if out of order. Each pass moves the largest unsorted element to its final position. Worst-case O(n²).

Common Mistakes and Misconceptions — Arrays

The traps other students keep falling into on arrays questions — taken from recent Cambridge IGCSE 0478 examiner reports and mark schemes — and how to avoid them.

✕Using indexes outside the declared bounds
0478 Examiner Reports 2022-2024
Why it happens
Students forget that ARRAY[1:30] only allows indexes 1 to 30.
How to avoid it
Always loop from the LOWER BOUND to the UPPER BOUND of the declaration. Out-of-bounds access is a run-time error in most languages.
✕Storing different types in the same array
Why it happens
Students treat arrays like lists.
How to avoid it
An array holds values of ONE TYPE. To mix types, you'd need a record/struct or a dynamic-typed list (Python). Cambridge pseudocode arrays are strict.
✕Stopping bubble sort after one pass
Why it happens
Students see one large value 'bubble up' and think the array is sorted.
How to avoid it
Bubble sort requires multiple passes — up to n-1 passes for n elements. Implementations stop EARLY only if NO SWAPS were made on the last pass.
✕Initialising the Found flag inside a loop
Why it happens
Students put it in the wrong place.
How to avoid it
Found ← FALSE goes BEFORE the loop. Inside the loop you only set it to TRUE if a match is found. Resetting it inside means a match in iteration 1 is forgotten by iteration 2.

Practice questions

Exam-style questions with step-by-step worked solutions. Try one before checking the method.

Past paper style quiz

Get a report showing which sub-topics you've nailed and which ones still need work.

Arrays — frequently asked questions

The things students keep getting wrong in this sub-topic, answered.

Arrays

Short Study Notes in the form of Slides

Detailed Study Notes

What you’ll learn

How it’s examined

1Read into a 1D array (6 marks)

2Linear search in an array (8 marks)

3Describe bubble sort (8 marks)

Array

1D array

2D array

Index

Linear search

Bubble sort

✕Using indexes outside the declared bounds

✕Storing different types in the same array

✕Stopping bubble sort after one pass

✕Initialising the Found flag inside a loop

Practice questions

Past paper style quiz

Assess your understanding

Arrays — frequently asked questions