15-mark question lab · start here

From thirty days of BOD readings to a river pollution report.

Build the solution in a sensible order: understand the three parallel arrays, initialise the counting and totalling stores, capture the five river names and thirty days of readings, total and classify each river’s days, round the averages to two decimal places and crown the most polluted river. Learn the reasoning before revealing the complete program.

Parallel arrays2D arraysInclusive boundariesCountingFinding max15 marks

Learning targets

By the end, you should be able to explain the algorithm before writing it.

Lesson overview

01 · Understand

Identify the three parallel arrays — RiverNames[], RiverStats[] and DaysCount[] — the shared river index that links them, and the moderate and high pollution boundaries the question defines.

02 · Construct

Use nested loops to initialise the arrays, input the five names and 150 daily BOD readings, then total and classify each river’s readings with the correct inclusive and exclusive boundaries.

03 · Complete

Round each river’s average to two decimal places, output every river’s results with suitable messages, and find and output the river with the most highly polluted days.

How Cambridge awards the marks: the mark scheme gives AO2 a maximum of 9 marks and AO3 a maximum of 6 marks. It lists requirements R1–R5, but does not assign a separate fixed mark total to each R requirement. The stage-to-mark links in this guide show alignment, not invented stage marks.

Source question

Read the whole question first

Do not begin coding after the first paragraph. The three parallel arrays, the day-major capture order, the inclusive moderate boundary and the strictly greater high-pollution boundary all affect the structure of your solution.

Question 10 · 15 marks

Cambridge IGCSE Computer Science · 0478/23 · Question 10

Five rivers show signs of pollution and are to be monitored daily for a period of 30 days.

The one-dimensional (1D) array RiverNames[] stores the names of the rivers.

The two-dimensional (2D) array RiverStats[] stores the daily measurement of biological oxygen demand (BOD) for each river.

The two-dimensional (2D) array DaysCount[] stores the number of days each river is classed as moderately polluted and the number of days each river is classed as highly polluted.

The position of the data for any river is the same in all three arrays. For example, the data in index 2 of RiverStats[] belongs to the river in index 2 of RiverNames[].

Write a program for the following requirements:

Input and store the names of the rivers in the array RiverNames[]
For each river, input and store in the array RiverStats[], the daily BOD in milligrams per litre (mg / L) on each of the 30 days.
Once all the inputs for the 30 days have been completed, the following statistics are calculated, and when appropriate, stored:
- The average daily reading for each river, rounded to two decimal places.
- The number of days in which the BOD reading was between 2 mg / L and 8 mg / L inclusive (moderate pollution) for each river.
- The number of days in which the BOD reading was greater than 8 mg / L (high pollution) for each river.
Output for each river, the average daily BOD readings, the number of days with moderate pollution and the number of days with high pollution.
Find and output the name of the river that has the most days with high pollution.

The program does not need to identify more than one river with an equally high pollution reading.

You must use pseudocode or program code and add comments to explain how your code works.

Do not declare arrays, variables or constants for this algorithm; assume this has been done. You will need to initialise the arrays and any variables used for counting or totalling before they are used.

All inputs and outputs must contain suitable messages.

Before you move on

These are the five required techniques identified by the Cambridge mark scheme.

Mark-scheme map

Initialise RiverStats[] and the DaysCount[] counters, then input and store the five river names — initialisation, iteration, input.

Input the daily BOD reading for every river on each of the 30 days, stored day by day in RiverStats[] — nested iteration, input, output.

Total each river’s readings and calculate the average daily BOD rounded to two decimal places — totalling, rounding.

Count each river’s moderately polluted days (2 to 8 inclusive) and highly polluted days (greater than 8) in DaysCount[] — counting, selection.

Output every river’s average and counts, then find and output the river with the most highly polluted days — output, selection, finding max.

Use the tabs along the top to work through the seven stages. The complete solution is kept in its own tab, and the interactive visualisation is the final tab.

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3

🧠 Step-by-step thinking

Identify the inputs. This program inputs everything itself: five river names, then 150 daily BOD readings — five rivers times 30 days. Every input needs a suitable message.
Spot the three phases. Initialise and capture first (R1); the question insists the statistics are calculated only “once all the inputs for the 30 days have been completed”; then total, count and round (R2); then output every river’s results and crown the most polluted river (R3).
Translate the boundaries. “Between 2 mg / L and 8 mg / L inclusive” means >= 2 AND <= 8 — both endpoints are moderate. “Greater than 8” means > 8 strictly, so a reading of exactly 8 is never highly polluted, and readings below 2 fall in neither bucket.
Note the two array shapes. RiverStats[day, river] is 30 × 5 — the day index comes first. DaysCount[river, class] is 5 × 2 — the river index comes first. The capture loop and the statistics loop therefore use the two counters in opposite orders.
Build the order. initialise the arrays → input the names → input the readings day by day → for each river: total, count, round, output → scan for the most highly polluted river → output the winner.

Input: 5 names, 150 readingsBoundaries: 2–8 inclusive, > 8 strictIndexes: day-first vs river-firstChampion: most high days

❓ Guiding questions – think before revealing

Which phrase fixes when the statistics may be calculated?
How do the three arrays stay linked?
What does “the program does not need to identify more than one river with an equally high pollution reading” allow?

Reveal suggested reasoning

Which phrase fixes when the statistics may be calculated? “Once all the inputs for the 30 days have been completed.” Totalling, counting and rounding belong to a second, separate pass over the array — after the capture loops have finished, not inside them.

How do the three arrays stay linked? The position of each river’s data is the same in all three arrays: index 2 of RiverStats and index 2 of DaysCount belong to the river named in index 2 of RiverNames. The shared river index is the glue.

What does “the program does not need to identify more than one river with an equally high pollution reading” allow? A tie for the most highly polluted days can be broken simply. The mark scheme keeps the first river by using a strictly greater test — an equally high count later cannot take the title.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Phase 1 — capture (R1)
// initialise arrays, input 5 names,
// input 30 days × 5 rivers of readings

// Phase 2 — statistics (R2)
// for each river: total, average (2 d.p.),
// moderate count, high count

// Phase 3 — report and crown (R3)
// output each river's results,
// find and output the most polluted river

📖 Detailed explanation

“Input and store” appears in the first two requirements — this is a capture question, not a pre-stored-data question. The loops that fill RiverNames and RiverStats earn marks in their own right.

“Once all the inputs … have been completed” splits the program into two full passes over the data: capture first, analyse second. Candidates who average inside the input loop are answering a different question.

“Inclusive” and “greater than” are the two boundary words. The first keeps both endpoints (2 and 8); the second excludes the endpoint (8 is not high). The visualisation’s sample data tests exactly these values.

“When appropriate, stored” tells you the counts belong in DaysCount, not in loose variables — the array exists so the per-river counts survive to the final scan.

⚠️ Common mistakes

Starting to write code before listing the five required outcomes in order.
Reading “between 2 and 8 inclusive” as “greater than 2 and less than 8”, which wrongly drops readings of exactly 2 and exactly 8.
Calculating the averages while the readings are still being input, against the question’s explicit wording.
Treating the three arrays as unrelated, instead of sharing the river position across all of them.

💡 Exam hack / tip

Underline “once all the inputs … have been completed”, “inclusive”, “greater than 8” and “the most days with high pollution”. Those phrases reveal the whole structure: two separate passes, an inclusive band with a strict ceiling above it, and one final champion scan.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R3 · full requirement coverageAO3 · logical orderAO3 · comments explain purpose

This planning stage supports AO2 by identifying the full range of techniques required. It supports AO3 by establishing a logical sequence. These are alignment notes, not separately allocated marks.

Plan the data and the two index directions

Choose variables and arrays that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given names. RiverNames[], RiverStats[] and DaysCount[] are named by the question — your program must use them exactly. The mark scheme lists all three as the required data structures.
Get RiverStats’s index order right. RiverStats[day, river] is 30 × 5 and holds REAL values: the first index selects the day, the second the river. Day 1’s reading for river 3 is RiverStats[1, 3].
Get DaysCount’s index order right. DaysCount[river, class] is 5 × 2 and holds INTEGER counts: class 1 stores the moderately polluted days, class 2 the highly polluted days. The river comes first here.
Add the working variables. Two loop counters (Index1, Index2), TotalBOD and AverageBOD (REAL), and the champion pair MostPollution (INTEGER) and MostPollRiver (STRING) — exactly the set the mark scheme’s example answer declares.
Remember the declarations are not required. The question says “Do not declare arrays, variables or constants”. The DECLARE lines exist only to reveal the array shapes — candidates earn nothing by copying them and lose nothing by omitting them.

Given: RiverNames, RiverStats, DaysCountRiverStats: [day, river] 30 × 5DaysCount: [river, class] 5 × 2

❓ Guiding questions – think before revealing

Why do RiverStats and DaysCount take their indexes in opposite orders?
Which cell of RiverStats holds day 4’s reading for river 2, and where do that river’s counts sit?
If the declarations are not required, why does the mark scheme show them?

Reveal suggested reasoning

Why do RiverStats and DaysCount take their indexes in opposite orders? They answer different questions. RiverStats is organised by day because the readings arrive day by day; DaysCount is organised by river because the counts are produced and used per river. Neither order is wrong — but every access must respect its own array’s order.

Which cell of RiverStats holds day 4’s reading for river 2, and where do that river’s counts sit? RiverStats[4, 2] — the day index comes first. River 2’s moderate count is DaysCount[2, 1] and its high count is DaysCount[2, 2].

If the declarations are not required, why does the mark scheme show them? Only to make the array shapes visible to markers and teachers. The comment above them says so: “note that array and variable declarations are not required in candidate responses”.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Declarations are NOT required in the exam —
// shown here only to reveal the array shapes
DECLARE RiverStats : ARRAY[1:30, 1:5] OF REAL
DECLARE DaysCount : ARRAY[1:5, 1:2] OF INTEGER
DECLARE RiverNames : ARRAY[1:5] OF STRING
DECLARE Index1, Index2 : INTEGER
DECLARE TotalBOD : REAL
DECLARE AverageBOD : REAL
DECLARE MostPollution : INTEGER
DECLARE MostPollRiver : STRING

📖 Detailed explanation

One river, one position. River 3 is RiverNames[3]; its readings are RiverStats[day, 3] for every day; its counts are DaysCount[3, 1] and DaysCount[3, 2]. The shared index is what makes the parallel arrays work.

REAL is the right type for the readings. BOD is measured in mg / L to one decimal place in the sample — INTEGER would distort every average. The counts are INTEGER because days are whole.

The class index is a design choice. Class 1 moderate, class 2 high matches the order the question lists them — and the final scan reads DaysCount[river, 2], the high column, because the champion is the river with the most highly polluted days.

⚠️ Common mistakes

Swapping the indexes — storing the reading with the day index second in the capture loop but reading it back first in the statistics loop, which silently mixes rivers’ data.
Renaming the given arrays, which the mark scheme treats as not using the supplied data structures.
Using one column of DaysCount only, losing either the moderate or the high count.
Storing the counts in loose variables, so the final scan has nothing to compare.

💡 Exam hack / tip

Write the two shapes side by side in the margin: RiverStats[day, river] — 30 × 5 and DaysCount[river, class] — 5 × 2. Every array access in your program should match one of those two patterns exactly.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR1 · R2 · all three arrays used as givenAO3 · meaningful identifiers

The data plan supports AO2 because the three given arrays store exactly the required data, and AO3 because the working identifiers are meaningful. These are alignment notes, not separately allocated marks.

Initialise the arrays and the counters

The question demands it: every counting and totalling store needs a known start.

🧠 Step-by-step thinking

Read the question’s instruction. “You will need to initialise the arrays and any variables used for counting or totalling before they are used.” This is an explicit requirement — omitting initialisation costs marks here even where other questions hand you pre-stored data.
Zero RiverStats with nested loops. The mark scheme zeroes all 150 cells before any input: outer loop over the 30 days, inner loop over the 5 rivers, RiverStats[Index1, Index2] ← 0.
Zero each DaysCount row per river. The counts for river Index1 are reset at the top of that river’s statistics pass: DaysCount[Index1, 1] ← 0 and DaysCount[Index1, 2] ← 0, alongside TotalBOD ← 0.
Match the loop order to the array. The zeroing loops run day-major because RiverStats is day-first — the same order the capture pass will use.
See why it matters. A counter or total that starts with an unknown value corrupts every count, every average and the final champion. Initialisation is what makes the accumulations trustworthy.

Required: initialise before useRiverStats: zero all cellsDaysCount: zero per river

❓ Guiding questions – think before revealing

Why does the question tell you to initialise when it also tells you not to declare?
When exactly is DaysCount reset?
Must RiverStats really be zeroed if every cell is about to be input?

Reveal suggested reasoning

Why does the question tell you to initialise when it also tells you not to declare? Declaration creates the array; initialisation gives it known values. The question removes the declaration work but keeps the initialisation work — it is testing whether you know accumulators must start from zero before they are used.

When exactly is DaysCount reset? At the start of each river’s statistics pass — inside the river loop, before the day loop, beside TotalBOD ← 0. Resetting all of DaysCount once at the top would also work, because every cell is written before it is read; the mark scheme resets per river.

Must RiverStats really be zeroed if every cell is about to be input? The question asks for it and the mark scheme does it, so yes — include the nested zeroing loops. In the exam, follow the question’s explicit instructions even when you can argue a shortcut.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// initialising array
FOR Index1 ← 1 TO 30
    FOR Index2 ← 1 TO 5
        RiverStats[Index1, Index2] ← 0
    NEXT Index2
NEXT Index1

// later, at the top of each river's statistics pass
TotalBOD ← 0
DaysCount[Index1, 1] ← 0
DaysCount[Index1, 2] ← 0

📖 Detailed explanation

“Before they are used” is the timing rule: the zeroing must precede the first accumulation, not sit beside it as an afterthought.

The zeroing loops mirror the array shape. Day outside, river inside — 30 × 5 = 150 assignments that guarantee no reading starts from a leftover value.

The per-river reset travels with TotalBOD. TotalBOD ← 0 and the two DaysCount resets form one block at the top of the river loop — everything that belongs to a single river’s pass is reborn together.

⚠️ Common mistakes

Skipping the initialisation because “the inputs will overwrite it anyway” — the question explicitly asks for it.
Resetting TotalBOD outside the river loop, so every river’s average includes the rivers before it.
Zeroing only one column of DaysCount, leaving the other count starting from an unknown value.
Placing the initialisation after the loops it serves, which satisfies nobody — the stores must be ready before they are used.

💡 Exam hack / tip

Say it as a rule: whatever accumulates starts at zero, and it starts at zero immediately before its own loop. Then point at each store — the whole of RiverStats, each DaysCount row, TotalBOD — and name the loop it serves.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · initialisationAO2 · iterationR1 · arrays ready before useAO3 · reliable starting state

Initialisation supports AO2 because the arrays genuinely hold the required data from a known state, and AO3 because the logic starts reliably. These are alignment notes, not separately allocated marks.

Capture the names, then the daily readings

Five prompts for the names, then a day-major nested loop for the readings.

🧠 Step-by-step thinking

Capture the names first. One loop from 1 to 5: OUTPUT “Input the name of river ”, Index1 then INPUT RiverNames[Index1]. The names are needed by the very next loop’s prompts.
Choose the day-major order. The mark scheme’s answer runs the outer loop over the 30 days and the inner loop over the 5 rivers, storing RiverStats[Index1, Index2] — day first, matching the array’s shape.
Announce each day. OUTPUT “Day ”, Index1 before the river loop — a suitable message that keeps 150 inputs readable.
Prompt with the river’s name. OUTPUT “Input the reading for ”, RiverNames[Index2] — the prompt proves the program uses the names it captured.
Count the inputs. 5 name inputs plus 150 reading inputs, every one with a message. “All inputs and outputs must contain suitable messages” is a marking point.

Names first: 5 inputsDay-major: outer 30, inner 5Prompts use the names

❓ Guiding questions – think before revealing

Why does the reading loop prompt with RiverNames[Index2] rather than the river number?
Could the capture loop run river-major instead — outer 5, inner 30?
Where do the readings for day 7, river 4 land?

Reveal suggested reasoning

Why does the reading loop prompt with RiverNames[Index2] rather than the river number? The names are already stored, and using them makes each prompt self-explanatory — “Input the reading for Cam” is a suitable message in a way a bare number is not. It also demonstrates the parallel-array link the question describes.

Could the capture loop run river-major instead — outer 5, inner 30? Yes — RiverStats[day, river] simply needs the day index first in the access, so a river-major loop would store RiverStats[Index2, Index1]. The mark scheme chooses day-major; either is creditable as long as every cell is filled correctly.

Where do the readings for day 7, river 4 land? RiverStats[7, 4] — the first index is the day. Getting this backwards is the classic error: the statistics pass would then read every river’s data mixed with its neighbours’.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// input river names
FOR Index1 ← 1 TO 5
    OUTPUT "Input the name of river ", Index1
    INPUT RiverNames[Index1]
NEXT Index1

// input of daily BOD readings
FOR Index1 ← 1 TO 30
    OUTPUT "Day ", Index1
    FOR Index2 ← 1 TO 5
        OUTPUT "Input the reading for ", RiverNames[Index2]
        INPUT RiverStats[Index1, Index2]
    NEXT Index2
NEXT Index1

📖 Detailed explanation

Two loops, two jobs. The name loop runs five times; the reading loop runs 30 × 5 = 150 times. Nesting the river loop inside the day loop captures a whole day’s worth of readings before moving on.

The prompt order mirrors the storage order. Day banner, then each river by name, then the input — the console reads like the monitoring log it represents.

The names are working data. Capturing them first is not decoration: the reading prompts, the per-river outputs and the final champion line all print names looked up through RiverNames[].

⚠️ Common mistakes

Swapping the indexes in the INPUT statement so readings land in the wrong cells — the statistics pass then mixes rivers together.
Prompting with a bare number when the question demands suitable messages for all inputs and outputs.
Inputting the names inside the day loop, prompting for them 30 times over.
Starting the statistics before the capture loops finish, against the question’s “once all the inputs … have been completed”.

💡 Exam hack / tip

Read each INPUT aloud as a sentence with the array access: “day 7’s reading for river 4 goes into RiverStats[7, 4]”. If the sentence and the indexes disagree, the loop is the wrong way round.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · nested iterationAO2 · input with messagesR1 · names and readings storedAO3 · accurate day-first indexes

The capture loops are the clearest AO2 evidence of iteration and input, and correct day-first indexing is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Total, round and classify each river’s readings

The statistics pass — with the two counters transposed.

🧠 Step-by-step thinking

Transpose the counters. The statistics loop runs river-major: FOR Index1 ← 1 TO 5 outside, FOR Index2 ← 1 TO 30 inside — so the access becomes RiverStats[Index2, Index1], because RiverStats is always day-first.
Total as you walk. TotalBOD ← TotalBOD + RiverStats[Index2, Index1] inside the day loop, after TotalBOD ← 0 at the top of the river pass.
Apply the moderate band with both bounds inclusive. IF RiverStats[Index2, Index1] >= 2 AND RiverStats[Index2, Index1] <= 8 then increment DaysCount[Index1, 1] — exactly 2 and exactly 8 both count.
Apply the high test strictly. IF RiverStats[Index2, Index1] > 8 then increment DaysCount[Index1, 2] — 8.0 is not high; 8.1 is. Readings below 2 meet neither test and count nowhere.
Round to two decimal places. AverageBOD ← ROUND(TotalBOD / 30, 2) — this question wants 2 d.p., not the whole-number INT((x / y) + 0.5) idiom.

Transposed: RiverStats[Index2, Index1]Moderate: >= 2 AND <= 8High: > 8 strictlyRounding: ROUND(x, 2)

❓ Guiding questions – think before revealing

Why does the statistics loop read RiverStats[Index2, Index1]?
A reading of exactly 8.0 arrives — what happens?
Why two separate IF statements rather than IF … ELSE?

Reveal suggested reasoning

Why does the statistics loop read RiverStats[Index2, Index1]? Because the counters have swapped roles: Index1 now walks the 5 rivers and Index2 the 30 days. RiverStats keeps its day-first shape throughout, so the day counter — whichever variable holds it — must come first inside the brackets.

A reading of exactly 8.0 arrives — what happens? The moderate test 8.0 >= 2 AND 8.0 <= 8 is TRUE, so the moderate count increments. The high test 8.0 > 8 is FALSE, so the high count does not move. Exactly 8 is moderate — and only moderate.

Why two separate IF statements rather than IF … ELSE? A reading of 1.9 fails the moderate test but must not fall into an ELSE that counts it as high. Two independent tests leave room for the third outcome — below 2, in neither bucket — which IF … ELSE would erase.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// finding the average daily BOD and counting
// the moderately and highly polluted days
FOR Index1 ← 1 TO 5
    TotalBOD ← 0
    DaysCount[Index1, 1] ← 0
    DaysCount[Index1, 2] ← 0
    FOR Index2 ← 1 TO 30
        TotalBOD ← TotalBOD + RiverStats[Index2, Index1]
        IF RiverStats[Index2, Index1] >= 2 AND RiverStats[Index2, Index1] <= 8
          THEN
            DaysCount[Index1, 1] ← DaysCount[Index1, 1] + 1
        ENDIF
        IF RiverStats[Index2, Index1] > 8
          THEN
            DaysCount[Index1, 2] ← DaysCount[Index1, 2] + 1
        ENDIF
    NEXT Index2
    // calculating and rounding the average BOD to 2 dp
    AverageBOD ← ROUND(TotalBOD / 30, 2)
    ...
NEXT Index1

📖 Detailed explanation

The transposition is the heart of R2. The same two counters serve both passes — the skill being tested is keeping track of which variable currently means day and which means river.

The two boundaries do different jobs. “Inclusive” keeps the endpoints 2 and 8 inside the moderate band; “greater than” keeps 8 outside the high band. Together they sort every reading into moderate, high or neither.

ROUND(x, 2), not INT. Two decimal places is a different requirement from “nearest whole number”. Cambridge pseudocode supplies ROUND(value, 2) for exactly this — the sample data includes a river whose average is 6.1666… and rounds up to 6.17.

The counts are stored, not just printed. DaysCount exists precisely so the final scan can compare rivers — “when appropriate, stored” in the question’s own wording.

⚠️ Common mistakes

Reading RiverStats[Index1, Index2] in the statistics loop with the counters transposed, which totals day slices across all five rivers.
Using > 2 AND < 8 for the moderate band, dropping the exact boundary readings the question says are inclusive.
Using >= 8 for the high test, which double-counts readings of exactly 8 as both moderate and high.
Rounding with INT(TotalBOD / 30 + 0.5), which produces a whole number instead of the two decimal places required.

💡 Exam hack / tip

Draw the two tests as a number line in the margin: below 2 — neither · 2 to 8 inclusive — moderate · above 8 — high. Then check each operator against it: >= and <= for the band, > alone for the high side.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · countingAO2 · totalling and roundingR2 · averages and both day countsAO3 · correct boundaries and transposed indexes

This stage supplies the totalling, counting and rounding evidence for AO2, and the boundary and index correctness for AO3. These are alignment notes, not separately allocated marks.

Output every river’s results

Average, moderate days, high days — with suitable messages, river by river.

R2 · R3

🧠 Step-by-step thinking

Output inside the river loop. Each river’s results are printed as soon as its statistics pass finishes — after NEXT Index2, before NEXT Index1.
Lead with the name. OUTPUT RiverNames[Index1], “ has an average daily pollution rate of ”, AverageBOD — the shared index turns the position into the name.
Report both counts with labels. OUTPUT “with ”, DaysCount[Index1, 1], “ moderately polluted day(s)” and OUTPUT “and ”, DaysCount[Index1, 2], “ highly polluted day(s)”.
Print a blank line between rivers. The mark scheme’s OUTPUT “” separates one river’s block from the next — a small readability habit that also demonstrates control of output.
Check against the requirement. “Output for each river, the average daily BOD readings, the number of days with moderate pollution and the number of days with high pollution” — all three values, every river, in words.

Inside the river loopName lookup via RiverNames[]Messages: every line labelled

❓ Guiding questions – think before revealing

Why does the output sit after NEXT Index2?
Which stored values does each output line use?
What makes a message “suitable”?

Reveal suggested reasoning

Why does the output sit after NEXT Index2? The average and the counts are only complete once the day loop has visited all 30 readings. Printing inside the day loop would print a part-finished average thirty times.

Which stored values does each output line use? AverageBOD for the rounded average, and DaysCount[Index1, 1] / DaysCount[Index1, 2] for the counts — the same cells the final scan reads a moment later.

What makes a message “suitable”? It identifies the value: a river’s name, the words “average daily pollution rate”, “moderately polluted day(s)”, “highly polluted day(s)”. A console that prints bare numbers satisfies neither the question nor the marker.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// inside the river loop, after the day loop
OUTPUT RiverNames[Index1], " has an average daily pollution rate of ", AverageBOD
OUTPUT "with ", DaysCount[Index1, 1], " moderately polluted day(s)"
OUTPUT "and ", DaysCount[Index1, 2], " highly polluted day(s)"
OUTPUT ""
NEXT Index1

📖 Detailed explanation

One block per river. Name and average, then the moderate count, then the high count, then a blank line — the block repeats five times because it lives inside the river loop.

The name is a lookup, not a stored copy. No river name is ever kept in a separate variable; every appearance comes from RiverNames[Index1], which is what keeps the three arrays parallel in the marker’s eyes.

The counts come straight from DaysCount. Nothing is recalculated for the output — the array built during classification is the single source of the per-river counts.

⚠️ Common mistakes

Printing the results inside the day loop, so part-finished totals appear thirty times per river.
Outputting the river’s position number instead of its name.
Printing the two counts without labels, leaving the reader to guess which is which.
Moving the output after NEXT Index1, which prints only the last river’s block — the working values are overwritten on every pass.

💡 Exam hack / tip

Trace one river’s block with your finger and read it as a sentence: “Cam has an average daily pollution rate of 6.17, with 4 moderately polluted day(s) and 2 highly polluted day(s)”. If the block does not read like that, a message is missing.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · output with messagesR2 · R3 · per-river results reportedAO3 · suitable messages and placement

The reporting block is the R2 and R3 output evidence, and the suitable messages support AO3. These are alignment notes, not separately allocated marks.

Find and crown the most polluted river

Seed the champion from river 1, then scan rivers 2 to 5 with a strictly greater test.

🧠 Step-by-step thinking

Seed from the first river. MostPollRiver ← RiverNames[1] and MostPollution ← DaysCount[1, 2] — the champion starts as a real river with a real count, never an invented number.
Scan the rest. FOR Index1 ← 2 TO 5, testing IF DaysCount[Index1, 2] > MostPollution then update both champion variables.
Keep the test strictly greater. On a tie — two rivers with the same number of highly polluted days — > is FALSE, so the first river keeps the title. The question says the program does not need to identify more than one river with an equally high pollution reading, so this is exactly the behaviour wanted.
Update the pair together. MostPollution and MostPollRiver always move as one — updating only the count leaves the name pointing at the wrong river.
Output after the scan. OUTPUT “The most polluted river is ”, MostPollRiver and the count line, once, after NEXT Index1.

Seed: river 1Scan: strictly greaterOutput: once, after the loop

❓ Guiding questions – think before revealing

Why is the champion seeded from river 1 rather than from 0 or -1?
Two rivers finish level on highly polluted days — which one is output?
Why does the scan read DaysCount[Index1, 2] and not [Index1, 1]?

Reveal suggested reasoning

Why is the champion seeded from river 1 rather than from 0 or -1? The scan compares day counts, which can legitimately be 0 — a river with no highly polluted days could win if every river ties on zero. Seeding from river 1 gives the champion a valid river name from the start, which is what the mark scheme does.

Two rivers finish level on highly polluted days — which one is output? The first of them. When the second river’s count is compared, equal > equal is FALSE, so the champion does not change. The question explicitly permits this: it does not need to identify more than one river with an equally high reading.

Why does the scan read DaysCount[Index1, 2] and not [Index1, 1]? The champion is the river with the most highly polluted days, and class 2 holds the high count. Reading class 1 would crown the most moderately polluted river — a different, unasked question.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// finding and outputting the most polluted river
MostPollRiver ← RiverNames[1]
MostPollution ← DaysCount[1, 2]
FOR Index1 ← 2 TO 5
    IF DaysCount[Index1, 2] > MostPollution
      THEN
        MostPollution ← DaysCount[Index1, 2]
        MostPollRiver ← RiverNames[Index1]
    ENDIF
NEXT Index1
OUTPUT "The most polluted river is ", MostPollRiver
OUTPUT "It had ", MostPollution, " day(s) in the last 30 days with a high pollution reading"

📖 Detailed explanation

This is R3’s “finding max”. The mark scheme names the technique: selection and finding max. The scan is a loop, a comparison and a paired update — the standard maximum-finding pattern applied to a column of an array.

The seed makes the scan honest. Because the champion starts as river 1, the loop begins at 2 and every river is considered exactly once. Nothing is double-counted and no river is skipped.

The final output is a pair. The name and the count are printed together on two lines — “The most polluted river is …” and “It had … day(s) in the last 30 days with a high pollution reading” — completing the question’s last requirement.

⚠️ Common mistakes

Seeding MostPollution with 0 and MostPollRiver with nothing, then outputting an empty name when every river has zero high days.
Using >= in the champion test, which hands the title to the last river on a tie instead of the first.
Scanning DaysCount[Index1, 1] and crowning the most moderately polluted river.
Putting the final OUTPUT lines inside the scan loop, printing a champion after every comparison.

💡 Exam hack / tip

Champion questions come in pairs: the value and its owner. Every update writes both — MostPollution and MostPollRiver — and every tie keeps the earlier owner, because the test is strictly >.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · finding maxAO2 · selectionR3 · most polluted river identified and outputAO3 · correct champion logic and placement

The champion scan is the R3 finding-max evidence for AO2, and the strictly greater tie handling is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Cambridge assessment criteria

What does a high-level response look like?

The mark scheme assesses the answer across AO2 and AO3. Use these descriptors to check the whole program, not just one isolated code section.

9 AO2 + 6 AO3 = 15

AO2 · Apply knowledge and understandingMaximum 9 marks · programming techniques and data structures

Band	What the descriptor means
0	No creditable response.
1–3	At least one programming technique is used. Some data is stored, but not appropriately. Any use of iteration, selection, counting, totalling, input or output may be credited.
4–6	Some programming techniques are appropriate to the problem, with more than one technique applied. Some data structures are appropriate and store some of the required data.
7–9	The full range of techniques needed by the scenario is used appropriately. The chosen data structures are appropriate and store all the required data.

AO3 · Provide solutions to problemsMaximum 6 marks · comments, identifiers, logic and accuracy

Band	What the descriptor means
0	No creditable response.
1–2	Program seen without relevant comments. Some identifier names and some data-structure names are appropriate. The solution may be illogical or inaccurate in many places, but attempts at least one requirement.
3–4	Program seen with some relevant comments. The majority of identifiers and most data-structure names are meaningful. Parts may be illogical or inaccurate, but most requirements are met.
5–6	The program is fully commented. Suitable identifiers are meaningful throughout, and all data structures have meaningful names. The program is logical and accurate and meets all requirements; minor syntax errors are ignored.

How the seven stages contribute

These are links to the assessment criteria, not separate mark allocations.

R1–R5

Stage	Mark-scheme link	AO2 evidence	AO3 evidence
1 · Decode	R1–R3	Identifies the full set of required techniques, inputs and boundaries.	Establishes logical order and comments plan.
2 · Data	Required data structures	RiverNames, RiverStats and DaysCount used as given, with both index directions understood.	Meaningful identifiers throughout.
3 · Initialise	R1	RiverStats zeroed and every counting and totalling store given a known start.	Clear comments and reliable starting state.
4 · Capture	R1	Names input first, then all readings captured with nested iteration and prompts.	Correct day-first indexes in RiverStats.
5 · Classify	R2	Totalling, counting with both boundaries, and rounding to two decimal places.	Accurate inclusive 2-to-8 test and strict > 8 test.
6 · Report	R2, R3	Each river’s average, moderate days and high days output with suitable messages.	Outputs placed after the day loop, inside the river loop.
7 · Crown	R3	Most-polluted scan seeded from river 1; strictly greater keeps the first river on a tie.	Champion output once, after the scan.

Consolidated Cambridge pseudocode

Complete solution

The full answer is presented in one place after the seven stages. Try to construct it yourself before opening this tab during revision.

15-mark exemplar style

Read this carefully: this mirrors the official published mark scheme answer for 0478/23 May/June 2026 Question 10, lightly re-indented for the web. The question tells you not to declare the arrays, variables or constants — the DECLARE lines appear only to reveal the array shapes, and the mark scheme says so in its first comment. Watch the index directions carefully: RiverStats is day-first (30 × 5) while DaysCount is river-first (5 × 2), so the statistics loop transposes the counters and reads RiverStats[Index2, Index1].

QUESTION 10 · FULL PSEUDOCODECambridge 0478 style · 1-based indexing

// note that array and variable declarations are not required in candidate responses
DECLARE RiverStats : ARRAY[1:30, 1:5] OF REAL
DECLARE DaysCount : ARRAY[1:5, 1:2] OF INTEGER
DECLARE RiverNames : ARRAY[1:5] OF STRING
DECLARE Index1, Index2 : INTEGER
DECLARE TotalBOD : REAL
DECLARE AverageBOD : REAL
DECLARE MostPollution : INTEGER
DECLARE MostPollRiver : STRING

// initialising array
FOR Index1 ← 1 TO 30
    FOR Index2 ← 1 TO 5
        RiverStats[Index1, Index2] ← 0
    NEXT Index2
NEXT Index1

// input river names
FOR Index1 ← 1 TO 5
    OUTPUT "Input the name of river ", Index1
    INPUT RiverNames[Index1]
NEXT Index1

// input of daily BOD readings
FOR Index1 ← 1 TO 30
    OUTPUT "Day ", Index1
    FOR Index2 ← 1 TO 5
        OUTPUT "Input the reading for ", RiverNames[Index2]
        INPUT RiverStats[Index1, Index2]
    NEXT Index2
NEXT Index1

// finding the average daily BOD and counting the moderately and highly polluted days
FOR Index1 ← 1 TO 5
    TotalBOD ← 0
    DaysCount[Index1, 1] ← 0
    DaysCount[Index1, 2] ← 0
    FOR Index2 ← 1 TO 30
        TotalBOD ← TotalBOD + RiverStats[Index2, Index1]
        IF RiverStats[Index2, Index1] >= 2 AND RiverStats[Index2, Index1] <= 8
          THEN
            DaysCount[Index1, 1] ← DaysCount[Index1, 1] + 1
        ENDIF
        IF RiverStats[Index2, Index1] > 8
          THEN
            DaysCount[Index1, 2] ← DaysCount[Index1, 2] + 1
        ENDIF
    NEXT Index2
    // calculating and rounding the average BOD to 2 dp
    AverageBOD ← ROUND(TotalBOD / 30, 2)
    OUTPUT RiverNames[Index1], " has an average daily pollution rate of ", AverageBOD
    OUTPUT "with ", DaysCount[Index1, 1], " moderately polluted day(s)"
    OUTPUT "and ", DaysCount[Index1, 2], " highly polluted day(s)"
    OUTPUT ""
NEXT Index1

// finding and outputting the most polluted river
MostPollRiver ← RiverNames[1]
MostPollution ← DaysCount[1, 2]
FOR Index1 ← 2 TO 5
    IF DaysCount[Index1, 2] > MostPollution
      THEN
        MostPollution ← DaysCount[Index1, 2]
        MostPollRiver ← RiverNames[Index1]
    ENDIF
NEXT Index1
OUTPUT "The most polluted river is ", MostPollRiver
OUTPUT "It had ", MostPollution, " day(s) in the last 30 days with a high pollution reading"

Why this is a complete response

It covers the three mark-scheme requirements: RiverStats is initialised and the five names plus all 30 days of readings are input and stored (R1); each river’s readings are totalled, the average is rounded to two decimal places with ROUND(TotalBOD / 30, 2), and the moderate (2 to 8 inclusive) and highly polluted (greater than 8) days are counted into DaysCount (R2); every river’s results are output with suitable messages and the river with the most highly polluted days is found with a strictly greater scan and output by name (R3).

What to check before submitting

Check the initialisation of RiverStats and the DaysCount counters, the day-major capture order with day-first indexes, the transposed access RiverStats[Index2, Index1] in the statistics pass, the ROUND(TotalBOD / 30, 2) expression, the inclusive 2-to-8 moderate test against the strictly greater than 8 high test, the champion seeded from river 1, and the comments explaining the program.

Remember: the marks are awarded by judging the whole response: AO2 carries a maximum of 9 marks and AO3 a maximum of 6 marks, and each is awarded by best fit using the published bands. The R1–R3 labels are the technique requirements the mark scheme lists, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the program work.

Step through the first six days of the monitoring period. Watch the grid fill column by column as the readings arrive, each river’s days sort into moderate and high, the averages round to two decimal places, and the champion survive a tie to crown the most polluted river.

Last tab · Trace player

Sample input → expected results

This is the authentic 0478/23 May/June 2026 Question 10: five rivers monitored daily for 30 days. The walkthrough shrinks the monitoring period to the first 6 days so every step stays visible — in the demo the average divides by the 6 recorded days, while the real program divides by 30. The sample deliberately tests the boundaries: readings of exactly 2.0 and exactly 8.0 count as moderate because the band is inclusive, readings below 2 count in neither bucket, Cam’s average of 6.1666… rounds up to 6.17, and Cam and Dee tie on two highly polluted days each — the strictly greater test keeps the first river, Cam, exactly as the question permits. These are illustrative values, not data supplied by the examination question.

Sample window inputs 6 days × 5 rivers

River	Day 1	Day 2	Day 3	Day 4	Day 5	Day 6

Demo window: rows are rivers and columns are days — the real program captures 30 columns of readings and divides each average by 30; this walkthrough records 6 days and divides by the 6 recorded days.

Reveal expected river results and verdict

Expected river results After all calculations

River	Average BOD	Moderate days	High days

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Classification counters

Ready

Tip: use Next step slowly and watch Index1 and Index2 swap roles — day and river during the capture pass, river and day during the statistics pass — and watch the amber cell move down each column as the grid fills day by day. The classification counters tick up as each river’s days are counted into DaysCount.

Trace colours: blue row = current river; amber cell = current reading; orange cells = readings already processed — the program fills the grid column by column (day by day).

Boundary examples: Exe’s day 2 reading is exactly 8.0 — the moderate test >= 2 AND <= 8 is TRUE, so it counts as moderate, while Cam’s 8.1 fails that test and passes > 8 instead, counting as high. Cam’s six readings total 37.0, so 37.0 ÷ 6 = 6.1666… and ROUND(6.1666…, 2) gives 6.17 — the average rounds up at two decimal places.

From thirty days of BOD readings to a river pollution report.

Learning targets

01 · Understand

02 · Construct

03 · Complete

Read the whole question first

Before you move on

Decode the requirements

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Plan the data and the two index directions

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Initialise the arrays and the counters

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Capture the names, then the daily readings

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Total, round and classify each river’s readings

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Output every river’s results

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Find and crown the most polluted river

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

What does a high-level response look like?

How the seven stages contribute

Final self-check

Complete solution

Why this is a complete response

What to check before submitting

Visualisation: watch the program work.

Sample input → expected results

Sample window inputs 6 days × 5 rivers

Expected river results After all calculations

Execution trace

Initialisation

Live variable values

Classification counters