Launching your learning experience…
Detailed notes on Programming for Cambridge IGCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.
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.
DECLARE Arr : ARRAY[1:N] OF TYPE syntax.Mapped to the Cambridge IGCSE 0478 syllabus (2026-2028).
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.
Cambridge tip. Mark scheme expects students to DECLARE the array properly with size AND type. Missing either loses marks.
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.
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.
Weakness.
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.
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]:
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.
Verbatim phrases and definitions Cambridge mark schemes credit.
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.
Step-by-step solutions to past-paper-style questions on arrays, written exactly the way a tutor would explain them at the board.
Question
Write pseudocode that declares a 1D array Scores that can hold 10 integers, then uses a FOR loop to read 10 numbers from the keyboard into it. (3 marks)
Step-by-step solution
Step 1
Declare (1 mark). Use DECLARE with the name, the bounds and the type: DECLARE Scores : ARRAY[1:10] OF INTEGER. The [1:10] means valid indexes are 1 to 10.
Step 2
Loop from lower to upper bound (1 mark). FOR Index ← 1 TO 10 matches the array bounds exactly — no off-by-one.
Step 3
Use the counter as the index (1 mark). INPUT Scores[Index] stores each value in the right slot. NEXT Index moves on.
Answer
DECLARE Scores : ARRAY[1:10] OF INTEGER
FOR Index ← 1 TO 10
INPUT Scores[Index]
NEXT Index
Examiner tip
The DECLARE line earns the first mark only if it gives BOTH the size and the data type. The remaining marks are for looping over the correct bounds and indexing with the loop counter.
Question
An array Names[1:5] is already filled. Write pseudocode to output every name on its own line. (2 marks)
Step-by-step solution
Step 1
Traverse with a FOR loop (1 mark). FOR Position ← 1 TO 5 visits each index in turn.
Step 2
Output the indexed element (1 mark). OUTPUT Names[Position] prints the value at that slot. Do NOT write OUTPUT Names — that would refer to the whole array, not one element.
Answer
FOR Position ← 1 TO 5
OUTPUT Names[Position]
NEXT Position
Examiner tip
A very common slip is outputting the index variable (OUTPUT Position) instead of the array element (OUTPUT Names[Position]). The mark is for the element.
Question
An array Marks[1:30] holds 30 exam marks. Write pseudocode to calculate and output the TOTAL of all marks and the HIGHEST mark. (6 marks)
Step-by-step solution
Step 1
Initialise running values (2 marks). Total ← 0 starts the sum at zero. For the maximum, set Highest ← Marks[1] (the first real element) — this is safer than starting at 0, which would fail if all marks were negative.
Step 2
Single traversal (1 mark). One FOR loop from 1 to 30 can do both jobs at once — no need for two separate loops.
Step 3
Accumulate the total (1 mark). Total ← Total + Marks[Index] adds each element to the running sum.
Step 4
Track the maximum (1 mark). IF Marks[Index] > Highest THEN Highest ← Marks[Index] ENDIF keeps the largest value seen so far.
Step 5
Output both results (1 mark). Output Total and Highest AFTER the loop ends, not inside it.
Answer
Total ← 0
Highest ← Marks[1]
FOR Index ← 1 TO 30
Total ← Total + Marks[Index]
IF Marks[Index] > Highest THEN
Highest ← Marks[Index]
ENDIF
NEXT Index
OUTPUT "Total = ", Total
OUTPUT "Highest = ", Highest
Examiner tip
Initialising Highest to the first element (not 0) is the mark-scheme-safe approach. Outputting inside the loop instead of after it is the most common error here.
Question
Write pseudocode that searches an array Names[1:50] for a target name input by the user. Output the POSITION where it is found, or 'Not found' if it is not in the array. (6 marks)
Step-by-step solution
Step 1
Initialise a flag and the input (2 marks). Found ← FALSE BEFORE the loop; INPUT Target. The flag records whether we have seen a match.
Step 2
Loop and compare (2 marks). FOR Index ← 1 TO 50, then IF Names[Index] = Target set Found ← TRUE and record Position ← Index.
Step 3
Report the result (2 marks). After the loop: IF Found = TRUE THEN OUTPUT Position ELSE OUTPUT 'Not found' ENDIF.
Answer
Found ← FALSE
INPUT Target
FOR Index ← 1 TO 50
IF Names[Index] = Target THEN
Found ← TRUE
Position ← Index
ENDIF
NEXT Index
IF Found = TRUE THEN
OUTPUT "Found at position ", Position
ELSE
OUTPUT "Not found"
ENDIF
Examiner tip
The Found flag MUST be set to FALSE before the loop, never inside it. Recording Position alongside the flag earns the 'identify location' marks.
Question
A 2D array Temps[1:7, 1:24] stores the temperature for each of 24 hours across 7 days (rows = days, columns = hours). Write pseudocode to find and output the highest temperature recorded across the whole week, and the day it occurred on. (6 marks)
Step-by-step solution
Step 1
Initialise from the first element (1 mark). Highest ← Temps[1, 1] and BestDay ← 1. Starting from a real reading avoids the all-negative trap.
Step 2
Outer loop over rows/days (1 mark). FOR Day ← 1 TO 7 walks down the 7 days.
Step 3
Inner loop over columns/hours (1 mark). FOR Hour ← 1 TO 24 walks across the 24 readings for that day. Two indexes are needed for a 2D array: Temps[Day, Hour].
Step 4
Compare and update (2 marks). IF Temps[Day, Hour] > Highest THEN Highest ← Temps[Day, Hour] and BestDay ← Day ENDIF.
Step 5
Output after both loops close (1 mark). Report Highest and BestDay once every cell has been checked.
Answer
Highest ← Temps[1, 1]
BestDay ← 1
FOR Day ← 1 TO 7
FOR Hour ← 1 TO 24
IF Temps[Day, Hour] > Highest THEN
Highest ← Temps[Day, Hour]
BestDay ← Day
ENDIF
NEXT Hour
NEXT Day
OUTPUT "Highest temperature = ", Highest
OUTPUT "On day ", BestDay
Examiner tip
A 2D array needs TWO nested loops and TWO indexes [row, column]. The inner loop's NEXT must close before the outer loop's NEXT. Initialising from Temps[1,1] is the mark-safe choice.
Question
Write pseudocode to sort an array List[1:n] of integers into ASCENDING order using bubble sort. Use a flag so the algorithm stops early once the array is sorted. (6 marks)
Step-by-step solution
Step 1
Outer control with a swap flag (2 marks). Repeat passes WHILE a swap was made on the previous pass. Set Swapped ← FALSE at the START of each pass; the loop continues only while swaps keep happening.
Step 2
Compare adjacent pairs (1 mark). Inner loop FOR Index ← 1 TO n - 1 compares List[Index] with List[Index + 1]. The upper bound is n-1 so that Index + 1 never goes out of bounds.
Step 3
Swap when out of order (2 marks). If the left value is greater than the right, swap them using a TEMP variable so neither value is lost, and set Swapped ← TRUE.
Step 4
Early stop (1 mark). If a whole pass makes no swaps, the array is already sorted and the WHILE loop ends.
Answer
Swapped ← TRUE
WHILE Swapped = TRUE
Swapped ← FALSE
FOR Index ← 1 TO n - 1
IF List[Index] > List[Index + 1] THEN
Temp ← List[Index]
List[Index] ← List[Index + 1]
List[Index + 1] ← Temp
Swapped ← TRUE
ENDIF
NEXT Index
ENDWHILE
Examiner tip
The inner loop MUST stop at n-1 to keep List[Index + 1] in bounds. A three-line TEMP swap is required — assigning List[Index] ← List[Index+1] first would overwrite and lose a value.
High-scoring sample answers for arrays on the Cambridge IGCSE 0478 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.
An array Prices[1:8] is already filled with the prices of 8 items. Write pseudocode to output the price stored in the FIFTH position of the array. [2]
Model answer
OUTPUT Prices[5]
Why this scores
AO3 (1 mark) correct array name with the index in square brackets; AO3 (1 mark) using the literal index 5, not a variable, and OUTPUT (not INPUT). One line is all that is needed — the array is already filled.
Write pseudocode that declares an array Ages[1:20] of integers and uses a loop to read 20 ages from the user into the array. [4]
Model answer
DECLARE Ages : ARRAY[1:20] OF INTEGER
FOR Counter ← 1 TO 20
INPUT Ages[Counter]
NEXT Counter
Why this scores
AO3 (1) DECLARE with bounds [1:20]; AO3 (1) OF INTEGER data type; AO3 (1) FOR loop over the correct bounds 1 TO 20; AO3 (1) INPUT into Ages[Counter] using the loop counter as the index. Marks for both correct declaration and correct use.
An array Rainfall[1:12] holds the rainfall (mm) for each of 12 months. Write pseudocode to calculate and output the TOTAL annual rainfall and the AVERAGE monthly rainfall. [6]
Model answer
Total ← 0
FOR Month ← 1 TO 12
Total ← Total + Rainfall[Month]
NEXT Month
Average ← Total / 12
OUTPUT "Total rainfall = ", Total
OUTPUT "Average rainfall = ", Average
Why this scores
AO3 (1) initialise Total ← 0 before the loop; AO2/AO3 (1) FOR loop over 1 TO 12; AO3 (1) accumulate Total ← Total + Rainfall[Month]; AO2 (1) compute Average = Total / 12 AFTER the loop; AO3 (2) output both Total and Average. Common error: dividing inside the loop.
An array Times[1:100] stores 100 race times. Write pseudocode to find and output the FASTEST (smallest) time and its POSITION in the array. [8]
Model answer
Lowest ← Times[1]
Position ← 1
FOR Index ← 2 TO 100
IF Times[Index] < Lowest THEN
Lowest ← Times[Index]
Position ← Index
ENDIF
NEXT Index
OUTPUT "Fastest time = ", Lowest
OUTPUT "At position ", Position
Why this scores
AO3 (1) initialise Lowest ← Times[1]; AO3 (1) initialise Position ← 1; AO2 (1) start the loop at 2 (first already used); AO3 (1) loop to upper bound 100; AO3 (2) IF Times[Index] < Lowest comparison and update of Lowest; AO2 (1) update Position alongside; AO3 (1) output both values. Initialising from the first element avoids the all-large-values trap.
A 2D array Sales[1:4, 1:6] stores the sales made by 4 staff (rows) across 6 days (columns). Write pseudocode to calculate and output the TOTAL sales for EACH member of staff, and the name of the BEST staff member (highest total). Staff names are stored in StaffNames[1:4]. [12]
Model answer
DECLARE StaffTotal : ARRAY[1:4] OF INTEGER
BestIndex ← 1
BestTotal ← 0
FOR Person ← 1 TO 4
StaffTotal[Person] ← 0
FOR Day ← 1 TO 6
StaffTotal[Person] ← StaffTotal[Person] + Sales[Person, Day]
NEXT Day
OUTPUT StaffNames[Person], " total = ", StaffTotal[Person]
IF StaffTotal[Person] > BestTotal THEN
BestTotal ← StaffTotal[Person]
BestIndex ← Person
ENDIF
NEXT Person
OUTPUT "Best staff member: ", StaffNames[BestIndex]
OUTPUT "With total: ", BestTotal
Why this scores
AO3 (1) declare StaffTotal array; AO3 (1) outer loop over the 4 rows; AO3 (1) reset each StaffTotal to 0 at the start of each person; AO3 (2) inner loop over 6 columns with correct two-index access Sales[Person, Day]; AO3 (1) accumulate into StaffTotal[Person]; AO3 (1) output each staff total with the matching name; AO2 (2) track BestTotal / BestIndex with an IF comparison; AO3 (1) output the best name via StaffNames[BestIndex]; AO1/AO2 (2) overall correct nested-loop structure and indexing. The reset of StaffTotal[Person] ← 0 inside the outer loop (not before it) is essential.
Unseen scenario. A school records the marks of students in a test. The marks are stored in a 1D array Marks[1:N], where N is the number of students (N has already been input and the array is already filled). Names are stored in StudentNames[1:N].
Write an algorithm, using pseudocode, that:
"No matches" if none did). [15]Model answer
// Pass 1 — total and average
Total ← 0
FOR Index ← 1 TO N
Total ← Total + Marks[Index]
NEXT Index
Average ← Total / N
OUTPUT "Class average = ", Average
// Pass 2 — count below average and find the highest
BelowCount ← 0
Highest ← Marks[1]
TopIndex ← 1
FOR Index ← 1 TO N
IF Marks[Index] < Average THEN
BelowCount ← BelowCount + 1
ENDIF
IF Marks[Index] > Highest THEN
Highest ← Marks[Index]
TopIndex ← Index
ENDIF
NEXT Index
OUTPUT BelowCount, " students scored below average"
OUTPUT "Top student: ", StudentNames[TopIndex], " with ", Highest
// Pass 3 — search for an exact target mark
INPUT Target
MatchFound ← FALSE
FOR Index ← 1 TO N
IF Marks[Index] = Target THEN
OUTPUT StudentNames[Index]
MatchFound ← TRUE
ENDIF
NEXT Index
IF MatchFound = FALSE THEN
OUTPUT "No matches"
ENDIF
Why this scores
Maps to the four sub-tasks. Average (AO3): initialise Total ← 0 (1), accumulate over 1 TO N (1), Average = Total / N and output (1). Below-average count (AO2/AO3): initialise BelowCount ← 0 (1), IF Marks[Index] < Average increment (1), output count (1). Highest name (AO2/AO3): initialise Highest ← Marks[1] and TopIndex ← 1 (1), IF comparison updates both (1), output StudentNames[TopIndex] (1). Linear search for target (AO3): INPUT Target (1), flag MatchFound ← FALSE before loop (1), IF Marks[Index] = Target output the name and set flag (2), handle no-match with the flag after the loop (1). Overall structure/logic with correct array bounds 1 TO N and no out-of-bounds access (AO1/AO2, 2). Outputting matches inside the loop while using a flag for the no-match case is the clean approach.
Definitions to memorise and the exact keywords mark schemes credit for arrays answers — sharpened from recent examiner reports for the 2026 0478 sitting.
A data structure that stores multiple values of the SAME data type under one variable name, accessed by index.
A linear array — a single row (or column) of values. Accessed with one index: Numbers[5].
A grid of values. Accessed with TWO indexes: Grid[row, column] or Grid[row][column].
The position of an element in an array. Cambridge pseudocode arrays typically start at 1 (ARRAY[1:N]); some languages start at 0.
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).
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²).
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.
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.
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 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 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.
The things students keep getting wrong in this sub-topic, answered.