15-mark question lab · start here

From match records to the cricket league champions.

Build the solution in a sensible order: input and validate the matches played, take every club’s name and results, re-enter any trio that does not add up, award the points into Points[], and crown the club or clubs with the highest total. Learn the reasoning before revealing the complete program.

1D + 2D arraysInput validationRe-entry loopsPoints accumulationTied winners15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the three arrays and their shared club index, and see that this program inputs every value itself: the matches played, the club names and each club’s won, drawn and lost figures.

02 · Construct

Build the two validation loops: Matches against the 22-match maximum, and each club’s trio against Matches with full re-entry until they match.

03 · Complete

Award 12 points per win and 5 per draw into Points[], then find the highest total and output every club that reaches it, with wins and points.

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 shared club index, the exact-match validation and the “club or clubs” wording all shape the structure of your answer.

Question 10 · 15 marks

Cambridge IGCSE Computer Science · 0478/21 · Question 10

The one-dimensional (1D) array Clubs[] is used to store the names of 12 cricket clubs in a local sports league.

The two-dimensional (2D) array Statistics[] is used to store, for each cricket club, the number of:

matches won
matches drawn
matches lost.

The 1D array Points[] is used to store the total number of points each cricket club has been awarded.

The position of any cricket club’s data is the same in all three arrays. For example, the data in index 2 of Statistics[] and index 2 of Points[] belongs to the cricket club in index 2 of Clubs[]

The variable Matches stores the number of matches played by each team. Each team plays the same number of matches.

Points are awarded for:

a win – 12 points
a draw – 5 points
a loss – 0 points.

Write a program that meets the following requirements:

allows the number of matches played to be input and stored, with a maximum of 22 matches
validates the number of matches played
allows the names of the cricket clubs to be input and stored
allows the number of matches won, drawn and lost to be input and stored for each team
validates the number of matches won, drawn or lost against the number of matches played
asks the user to re-enter the number of matches won, drawn or lost if the total does not match the number of matches played
calculates and stores the total number of points for each club
finds the cricket club or clubs with the highest number of points
outputs the name or names of the winning club or clubs, the number of wins and the total number of points awarded.

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

You do not need to declare any arrays or variables; you may assume that this has already been done.

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

Input the number of matches played into Matches and validate it against the maximum of 22 before any club data is taken.

Input the 12 club names into Clubs[] and each club’s won, drawn and lost figures into Statistics[].

Validate each club’s trio against Matches and make the user re-enter all three figures until they total Matches exactly.

Calculate each club’s points (wins × 12 + draws × 5, losses score 0) and store it in Points[] at the shared index.

Find the highest value in Points[], then output every club that reaches it with its name, number of wins and total points.

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 · R4 · R5

🧠 Step-by-step thinking

Spot that this program inputs its own data. Unlike questions that supply stored data, every value here is typed in at run time — Matches, the club names and each trio of results — so INPUT statements with prompt messages drive the whole program.
Find the two validation loops. Matches must be checked against the maximum of 22. Each club’s won + drawn + lost must be checked against Matches, and the question says the user must be asked to re-enter the figures when they do not match.
Identify the per-club repeated unit. For each of the 12 clubs the program takes a name, takes three figures, validates them, then stores points — one outer loop with every per-club job inside it.
Separate accumulation from champion hunting. Points[] is filled club by club inside the main loop. The highest total is only found after that loop finishes, in a comparison pass over the finished array.
Translate command words. “Validates” means a check with re-entry; “calculates and stores” means an assignment into an array cell; “club or clubs” means ties must survive; “outputs” means display with suitable messages.

Input-driven programTwo validation loopsAccumulate Points[]Tied champions possible

❓ Guiding questions – think before revealing

Why must Matches be input before the club loop starts?
What does “club or clubs” tell you about the ending?
Which outputs does the final summary need?

Reveal suggested reasoning

Why must Matches be input before the club loop starts? Every club’s trio is validated against Matches, so the season length has to be known and trusted before the first club’s figures are taken.

What does “club or clubs” tell you about the ending? Two clubs can finish level on points. Finding the maximum first and then sweeping Points[] for every club equal to it handles the tie automatically.

Which outputs does the final summary need? For each winning club: its name from Clubs[], its number of wins from Statistics[] and its total from Points[] — each introduced by a suitable message.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// 1. Input + validate Matches (maximum 22)
// 2. FOR each of the 12 clubs:
//      input name into Clubs[]
//      input won, drawn, lost into Statistics[]
//      REPEAT the three inputs until they total Matches
//      calculate and store Points[]
// 3. Find the highest value in Points[]
// 4. Output every club with that total:
//      name, wins, points

📖 Detailed explanation

“Allows the number of matches played to be input” puts an INPUT before everything else — nothing about a club can be checked until Matches exists.

“Validates … against the number of matches played” is a comparison between the stored trio and Matches, so the three figures must already sit in Statistics[] when the check runs.

“Asks the user to re-enter” forbids a one-off IF. Only a loop (REPEAT … UNTIL or WHILE … ENDWHILE) keeps asking until the figures match.

“The club or clubs with the highest number of points” means the last output line can appear more than once — the ending must collect every club at the top, not stop at the first.

⚠️ Common mistakes

Writing the points calculation before the validation, awarding points to figures that are about to be rejected.
Treating the trio check as a single IF with no re-entry loop, which fails the “asks the user to re-enter” bullet.
Outputting only the first club at the top of the table, losing tied champions.
Forgetting that every prompt and message is required — silent inputs cost the “suitable messages” line.

💡 Exam hack / tip

Underline “maximum of 22”, “does not match”, “calculates and stores” and “club or clubs”. Those four phrases reveal the whole shape: a range check first, an equality loop per club, an array of totals, and a tie-safe final sweep.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R5 · 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 identifiers

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

Required data structures

🧠 Step-by-step thinking

Use the given names. Clubs[], Statistics[], Points[] and Matches are supplied by the question — your program must use them exactly, and need not declare them.
Fix the Statistics column order. Column 1 holds matches won, column 2 matches drawn, column 3 matches lost — decide that now and comment it, because both the validation and the points formula depend on it.
Add one loop counter. Counter walks the 12 clubs; the same index is used by Clubs[], Statistics[] and Points[], keeping the arrays parallel.
Add the champion tracker. HighestPoints remembers the largest total found while sweeping the finished Points[].
Name the scoring values. Constants WinPoints = 12 and DrawPoints = 5 make the formula self-explanatory; a loss scores 0 and therefore adds nothing.

Given: Clubs[], Statistics[,], Points[], MatchesCounter: one shared indexConstants: 12 per win, 5 per draw

❓ Guiding questions – think before revealing

Why does one Counter serve all three arrays?
Why input straight into the Statistics cells?
Is a second array needed for the winners?

Reveal suggested reasoning

Why does one Counter serve all three arrays? The question states that a club’s data sits at the same position in Clubs[], Statistics[] and Points[], so Counter addresses a club’s name, figures and points in step.

Why input straight into the Statistics cells? The figures are validated and scored in exactly those cells, so inputting directly avoids a copying step and the risk of mixing indexes.

Is a second array needed for the winners? No. The final output sweep re-reads Points[] and looks up each winner’s name and wins through the shared index, so no extra storage is required.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Supplied by the question (declarations assumed):
// Clubs[1..12]              club names
// Statistics[1..12, 1..3]   won, drawn, lost for each club
// Points[1..12]             points total for each club
// Matches                   matches played by every team

CONSTANT WinPoints  = 12
CONSTANT DrawPoints = 5
// a loss scores 0 points, so it adds nothing to a total

// Working values the program adds for itself:
// Counter        - walks the 12 clubs through all three arrays
// HighestPoints  - largest total found in Points[] in the final passes

📖 Detailed explanation

The 2D array is addressed with two indexes. Statistics[Counter, 1] means “the current club’s matches won” — row first, then column.

The league size is fixed. The question stores 12 clubs and provides no count variable, so the loop bound is the literal 12 with a comment explaining it.

Scope follows purpose. Counter lives inside the loops; HighestPoints must survive from one sweep position to the next, so it is assigned once before the comparison pass.

⚠️ Common mistakes

Renaming the given arrays or variable, which the mark scheme treats as not using the supplied data.
Swapping the column order — scoring draws as wins silently corrupts every total.
Declaring fresh arrays to hold the winners, which duplicates storage the shared index already provides.
Using a different counter for each array so the three stop being parallel.

💡 Exam hack / tip

Borrow the question’s own words for identifiers: WinPoints, DrawPoints, HighestPoints. An examiner should be able to map every variable back to a phrase in the question.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR1–R5 · given names reusedAO3 · meaningful identifiers

The data plan supports AO2 because the chosen variables store exactly the required data, and AO3 because every identifier is meaningful. These are alignment notes, not separately allocated marks.

Input and validate the matches played

Trust the season length before any club data is taken.

🧠 Step-by-step thinking

Prompt, then input, then check. The value is requested with a message, stored in Matches, and only then compared with the limits — there is nothing to test until the user has typed one.
Test the stated maximum. The bullet sets a maximum of 22 matches, so the upper bound of the accept condition is Matches >= 1 AND Matches <= 22.
Reject impossible values too. A season cannot contain 0 or negative matches, so the lower bound of 1 is sensible practice examiners reward alongside the stated maximum.
Loop with REPEAT … UNTIL. The inputs must run at least once, and the program must keep asking while the value is unacceptable — exactly the prompt → check → re-prompt shape.
Put the message inside the loop. The IF that prints the rejection sits between REPEAT and UNTIL, so every bad value earns an explanation.

Range check: 1–22REPEAT ... UNTIL re-entryMessages on every path

❓ Guiding questions – think before revealing

Why does the matches input come before the club loop?
Why REPEAT rather than WHILE?
Which condition belongs after UNTIL?

Reveal suggested reasoning

Why does the matches input come before the club loop? Every trio is validated against Matches, so the season length must be known and trusted before the first club’s figures are taken — otherwise a corrected value would invalidate all the earlier checks.

Why REPEAT rather than WHILE? The body must run at least once — there is nothing to test until the user types a value. REPEAT … UNTIL runs the inputs first and checks afterwards.

Which condition belongs after UNTIL? The accept condition: Matches >= 1 AND Matches <= 22. The loop repeats while the value is unacceptable, so UNTIL needs the opposite of the reject test.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

REPEAT
    OUTPUT "Enter the number of matches played (maximum 22): "
    INPUT Matches
    IF Matches < 1 OR Matches > 22
    THEN
        OUTPUT "Invalid - matches must be between 1 and 22"
    ENDIF
UNTIL Matches >= 1 AND Matches <= 22

📖 Detailed explanation

The UNTIL condition is the accept condition. UNTIL Matches >= 1 AND Matches <= 22 leaves the loop only for a legal season length; a WHILE wrapper would need the reject condition instead.

One variable, one validation. Matches describes every team — the question says each team plays the same number — so a single check covers the whole league.

The message quotes the rule. “Maximum 22” in the prompt and “between 1 and 22” in the error satisfy the “suitable messages” requirement on both paths.

⚠️ Common mistakes

Validating Matches after the clubs have been entered, so a corrected season length invalidates every trio already accepted.
Writing UNTIL Matches > 22 alone, which quietly accepts 0 and negative values.
Swapping the conditions — UNTIL takes the accept test; a WHILE loop would take the reject test.
Forgetting the error message inside the loop, leaving the user facing a silent re-prompt.

💡 Exam hack / tip

Say the shape aloud: prompt, input, reject-message, UNTIL accepted. If your four lines read in that order, the validation bullet is already satisfied.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · input and validationR1 · matches validatedAO3 · correct range and messages

The range check supports AO2 validation, and the accept-condition logic plus messages support AO3 accuracy. These are alignment notes, not separately allocated marks.

Take each club’s name and results

One outer loop fills Clubs[] and Statistics[].

🧠 Step-by-step thinking

Loop once per club. FOR Counter ← 1 TO 12 visits every position — the array stores 12 clubs, so 12 passes are needed.
Store the name at the shared index. Clubs[Counter] holds the name; Statistics[Counter, …] and Points[Counter] reuse the same Counter, keeping the three arrays parallel.
Take the three figures straight into the array. Statistics[Counter, 1], [Counter, 2] and [Counter, 3] receive won, drawn and lost — no spare variables needed.
Prompt with the name just stored. OUTPUT “Matches won by ”, Clubs[Counter] shows which club is being asked about — the question demands suitable messages.
Keep every per-club job inside the loop. Name, trio, validation and points all sit between FOR and NEXT so each pass completes one club.

FOR Counter ← 1 TO 12Direct input into Statistics[,]Prompts name the club

❓ Guiding questions – think before revealing

Why is the club count written as 12?
Why prompt with Clubs[Counter] rather than the club number?
What happens if NEXT Counter comes too early?

Reveal suggested reasoning

Why is the club count written as 12? The question fixes the league at 12 clubs and supplies no count variable, so the loop bound is the literal 12 with a comment saying why.

Why prompt with Clubs[Counter] rather than the club number? The name was stored one line earlier; echoing it in the prompts tells the user exactly whose figures are expected — a suitable message in the question’s own terms.

What happens if NEXT Counter comes too early? Anything still undone — validation, points — would run for the wrong club or not at all; moving NEXT too early is how parallel arrays fall out of step.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR Counter ← 1 TO 12
    OUTPUT "Enter the name of club number ", Counter, ": "
    INPUT Clubs[Counter]

    // the three figures for this club are taken
    // and re-taken inside the validation loop (Stage 5)
    OUTPUT "Matches won by ", Clubs[Counter], ": "
    INPUT Statistics[Counter, 1]
    OUTPUT "Matches drawn by ", Clubs[Counter], ": "
    INPUT Statistics[Counter, 2]
    OUTPUT "Matches lost by ", Clubs[Counter], ": "
    INPUT Statistics[Counter, 3]
    ...
NEXT Counter

📖 Detailed explanation

The nesting mirrors the data layout. Row Counter of Statistics[] belongs to the club named in Clubs[Counter], so one loop index drives both.

Direct array input is expected. Cambridge wants the given structures used; typing into Statistics[Counter, 1] puts each figure where the later stages read it.

The column order is a decision, not a guess. Commenting “column 1 = won, 2 = drawn, 3 = lost” turns the 2D array into documented storage the examiner can follow.

⚠️ Common mistakes

Storing the names in a separate variable and copying them later, which risks misaligned arrays.
Using Statistics[1, Counter] — indexes the wrong way round, mixing columns and clubs.
Prompting with bare numbers like “club 3” when the club’s name is already available.
Closing the loop before the validation and points stages, so later clubs are never processed.

💡 Exam hack / tip

Read the 2D access aloud as a sentence: “row Counter, column 1/2/3”. If the sentence does not name the value you want, the indexes are the wrong way round.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration and array storageR2 · names and figures storedAO3 · parallel indexes

The input loop is the clearest AO2 evidence of iteration and storage, and the shared index is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Check the trio against Matches

Re-enter all three figures until they total the matches played.

🧠 Step-by-step thinking

Total the three stored cells. Statistics[Counter, 1] + Statistics[Counter, 2] + Statistics[Counter, 3] is the number of matches the club’s figures account for.
Compare for exact equality. The bullet says re-entry is needed “if the total does not match” — the accept test is = Matches, nothing looser.
Wrap the three INPUTs in the REPEAT. On a mismatch the user re-enters the whole trio, so the loop must reach back above the first INPUT statement.
Print the error before UNTIL re-tests. The IF … <> Matches inside the loop shows a message; UNTIL then decides whether to go round again.
Keep the loop inside the club loop. Each club gets its own validation pass — one REPEAT per Counter value.

Exact test: = MatchesRe-entry: whole trioError message inside loop

❓ Guiding questions – think before revealing

Why re-enter all three figures?
Why <> inside the loop but = after UNTIL?
Where does this loop sit?

Reveal suggested reasoning

Why re-enter all three figures? The question says to ask for the won, drawn or lost numbers to be re-entered when the total does not match. Re-taking the trio is the simplest response that always satisfies it — the user cannot tell which single figure is wrong.

Why <> inside the loop but = after UNTIL? The IF only prints the error when the total is wrong (<> Matches). UNTIL repeats while the accept condition is FALSE, so it needs the opposite: = Matches.

Where does this loop sit? Inside the club loop, after the three prompts are set up and before the points calculation — each pass validates exactly one club’s figures.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

REPEAT
    OUTPUT "Matches won by ", Clubs[Counter], ": "
    INPUT Statistics[Counter, 1]
    OUTPUT "Matches drawn by ", Clubs[Counter], ": "
    INPUT Statistics[Counter, 2]
    OUTPUT "Matches lost by ", Clubs[Counter], ": "
    INPUT Statistics[Counter, 3]
    IF Statistics[Counter, 1] + Statistics[Counter, 2]
       + Statistics[Counter, 3] <> Matches
    THEN
        OUTPUT "Total does not match ", Matches,
            " matches - re-enter all three figures"
    ENDIF
UNTIL Statistics[Counter, 1] + Statistics[Counter, 2]
   + Statistics[Counter, 3] = Matches

📖 Detailed explanation

The equality test is the bullet. “If the total does not match the number of matches played” translates directly to <> Matches for the message and = Matches for the exit.

Re-entering the trio is deliberate. A club’s won, drawn and lost figures are one record; re-taking all three keeps Statistics[] internally consistent instead of patching one cell.

The stored cells are re-used. Each re-entry overwrites the same row, so after UNTIL passes, the row is guaranteed to total Matches — the points stage can trust it.

⚠️ Common mistakes

Validating inside a plain IF, so a mismatch is reported once and the bad figures are still scored.
Testing > Matches instead of <> Matches, which accepts a trio that under-reports the season.
Re-entering only one figure, leaving the other two stale.
Placing the REPEAT outside the club loop so the first bad trio blocks every later club.

💡 Exam hack / tip

Two operators, one rule: <> for the message, = for the exit. If the UNTIL line does not read “= Matches”, the loop either never ends or ends too early.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · validation with re-entryR3 · trio checked against MatchesAO3 · exact-equality logic

The re-entry loop supplies the AO2 validation evidence, and the paired operators plus message support AO3 accuracy. These are alignment notes, not separately allocated marks.

Award the points and fill Points[]

Twelve per win, five per draw, nothing for a loss.

🧠 Step-by-step thinking

Wait for the UNTIL to pass. Points are only awarded once the trio is trusted — the calculation sits immediately after the validation loop.
Score wins and draws only. Points[Counter] ← Statistics[Counter, 1] * WinPoints + Statistics[Counter, 2] * DrawPoints. A loss scores 0, so it never appears in the formula.
Store at the shared index. Points[Counter] keeps the total beside the name and figures that produced it.
No initialisation pass needed. Every one of the 12 cells is assigned exactly once by the loop, so Points[] never needs clearing first.
Watch a worked example. 9 wins and 3 draws give 9 × 12 = 108 plus 3 × 5 = 15, so Points[Counter] holds 123.

Formula: wins * 12 + draws * 5Store into Points[Counter]Losses score 0

❓ Guiding questions – think before revealing

Why does the formula not include losses?
Why must this line be inside the club loop?
Why is there no clearing loop for Points[]?

Reveal suggested reasoning

Why does the formula not include losses? A loss awards 0 points, and adding zero changes nothing. Writing * 0 is harmless but noise — a comment explaining the omission earns the understanding instead.

Why must this line be inside the club loop? Each club’s total depends on its own row of Statistics[]. Outside the loop only the last club’s figures would still be there.

Why is there no clearing loop for Points[]? The FOR loop assigns all 12 cells exactly once, so every position starts life with its correct value — initialising first would be redundant, though not wrong.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// a loss scores 0 points, so only wins and draws are added
Points[Counter] ← Statistics[Counter, 1] * WinPoints
                + Statistics[Counter, 2] * DrawPoints
// example: 9 wins, 3 draws -> 9 * 12 + 3 * 5 = 123

📖 Detailed explanation

“Calculates and stores” is one assignment. The expression is evaluated, then written into the array cell — both halves of the bullet in a single line.

The constants carry the meaning. WinPoints and DrawPoints make the formula read like the question’s scoring list; the comment records that losses add nothing.

The index chain is complete. Name in Clubs[Counter], figures in row Counter, total in Points[Counter] — the champion sweep can later look everything up from one position.

⚠️ Common mistakes

Awarding points before the validation loop, scoring figures that are about to be replaced.
Using 12 and 5 but multiplying the losses column as well, which still works here only because the value is 0 — the comment should say so.
Storing the total in a plain variable, which is overwritten by the next club and never reaches Points[].
Adding to Points[Counter] across clubs instead of assigning, so totals accumulate down the table.

💡 Exam hack / tip

One line, two jobs: calculate then store. If the line does not start with Points[Counter] ←, the “and stores” half of the bullet is missing.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · arithmetic and storageR4 · points calculated and storedAO3 · accurate expressions

The points formula is the R4 evidence for AO2, and the accurate use of the scoring values supports AO3. These are alignment notes, not separately allocated marks.

Crown the club or clubs at the top

Two passes over Points[] find the maximum and every tie.

🧠 Step-by-step thinking

Seed from the data. HighestPoints ← Points[1] starts the hunt from a real total, so the first comparison is valid for any league table.
Sweep with strictly greater. FOR Counter ← 2 TO 12 with IF Points[Counter] > HighestPoints keeps the first club to reach the maximum.
Sweep again with equality. The question asks for the club or clubs with the highest total, so a final pass prints every club whose Points[Counter] = HighestPoints.
Output all three required facts. Each winner line gives the name from Clubs[], the wins from Statistics[Counter, 1] and the points from Points[Counter] — all under a suitable message.
Keep both sweeps after the main loop. Points[] is only complete once the twelfth club has been processed.

Pass 1: strictly greaterPass 2: equality finds tiesOutput: name, wins, points

❓ Guiding questions – think before revealing

Why two sweeps rather than one?
Why does the equality sweep need no winner counter?
What if two clubs finish on 123 points?

Reveal suggested reasoning

Why two sweeps rather than one? No club can be compared against the maximum until the maximum is known. The first sweep finds the total; the second collects every club that reached it — ties included.

Why does the equality sweep need no winner counter? Each qualifying club is printed as it is found, so nothing extra is stored; the sweep cannot come back empty because at least one club holds HighestPoints.

What if two clubs finish on 123 points? Both pass the = HighestPoints test and both lines are printed — exactly the “club or clubs” behaviour the bullet demands.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// find the highest points total in the league
HighestPoints ← Points[1]
FOR Counter ← 2 TO 12
    IF Points[Counter] > HighestPoints
    THEN
        HighestPoints ← Points[Counter]
    ENDIF
NEXT Counter

// output every club that reaches the highest total
OUTPUT "Club(s) with the highest number of points:"
FOR Counter ← 1 TO 12
    IF Points[Counter] = HighestPoints
    THEN
        OUTPUT Clubs[Counter], " - wins: ",
            Statistics[Counter, 1], " - points: ", Points[Counter]
    ENDIF
NEXT Counter

📖 Detailed explanation

The first sweep is a maximum hunt. Seeding from Points[1] and using strictly > means the tracker never leaves the loop empty-handed.

The second sweep is the tie handler. Equality, not strict inequality, is what lets a second champion through — the difference between the two tests is the whole trick.

The outputs answer the bullet word for word. Name or names, number of wins, total points — one line per winning club, each piece looked up through the shared index.

⚠️ Common mistakes

Running the champion sweeps inside the club loop, comparing half-finished totals.
Seeding HighestPoints from a guessed value instead of Points[1].
Using = in the first sweep, so HighestPoints ends up holding the last club’s total rather than the largest.
Outputting only the first club at the top, dropping any tied champion — the most common loss on this question.

💡 Exam hack / tip

Remember the pairing: > to find the top, = to share it. Two short sweeps after the loop are cheaper and safer than any clever single pass.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · max tracking and outputR5 · champions and ties reportedAO3 · two-pass logic

The two sweeps and final outputs deliver R5 for AO2, and the tie-safe logic supports AO3. 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–R5	Identifies the input-driven structure, both validations and the tie-safe ending.	Establishes logical order and comments plan.
2 · Data	Required data structures	Uses Clubs[], Statistics[,], Points[] and Matches; adds Counter and HighestPoints.	Meaningful identifiers and scoring constants.
3 · Matches	R1	Inputs Matches with a prompt and validates the 22-match maximum with re-entry.	Correct REPEAT ... UNTIL accept condition.
4 · Teams	R2	Outer loop takes every club name and trio straight into the arrays.	Shared Counter keeps the three arrays parallel.
5 · Validate	R3	Totals the trio and re-enters all three figures until they equal Matches.	Exact-equality test with a clear error message.
6 · Points	R4	Calculates 12 per win plus 5 per draw and stores the total in Points[].	Accurate expression; losses explained as zero.
7 · Champions	R5	Finds the highest total, then outputs every club equal to it with wins and points.	Two-pass logic keeps tied champions safe.

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

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

// Clubs[], Statistics[], Points[] and Matches are assumed to be declared
// Statistics columns: 1 = won, 2 = drawn, 3 = lost
CONSTANT WinPoints  = 12
CONSTANT DrawPoints = 5

// R1: input and validate the number of matches played (maximum 22)
REPEAT
    OUTPUT "Enter the number of matches played by each team (maximum 22): "
    INPUT Matches
    IF Matches < 1 OR Matches > 22
    THEN
        OUTPUT "Invalid - matches must be between 1 and 22"
    ENDIF
UNTIL Matches >= 1 AND Matches <= 22

// R2 + R3: input each club's name and results, validating the trio
FOR Counter ← 1 TO 12
    OUTPUT "Enter the name of club number ", Counter, ": "
    INPUT Clubs[Counter]

    // re-enter all three figures until they total Matches
    REPEAT
        OUTPUT "Matches won by ", Clubs[Counter], ": "
        INPUT Statistics[Counter, 1]
        OUTPUT "Matches drawn by ", Clubs[Counter], ": "
        INPUT Statistics[Counter, 2]
        OUTPUT "Matches lost by ", Clubs[Counter], ": "
        INPUT Statistics[Counter, 3]
        IF Statistics[Counter, 1] + Statistics[Counter, 2] + Statistics[Counter, 3] <> Matches
        THEN
            OUTPUT "Total does not match ", Matches, " matches - re-enter all three"
        ENDIF
    UNTIL Statistics[Counter, 1] + Statistics[Counter, 2] + Statistics[Counter, 3] = Matches

    // R4: calculate and store this club's points (a loss scores 0)
    Points[Counter] ← Statistics[Counter, 1] * WinPoints + Statistics[Counter, 2] * DrawPoints
NEXT Counter

// R5: find the highest points total in the league
HighestPoints ← Points[1]
FOR Counter ← 2 TO 12
    IF Points[Counter] > HighestPoints
    THEN
        HighestPoints ← Points[Counter]
    ENDIF
NEXT Counter

// output every club that reaches the highest total (ties included)
OUTPUT "Club(s) with the highest number of points:"
FOR Counter ← 1 TO 12
    IF Points[Counter] = HighestPoints
    THEN
        OUTPUT Clubs[Counter], " - wins: ", Statistics[Counter, 1], " - points: ", Points[Counter]
    ENDIF
NEXT Counter

Why this is a complete response

It covers the mark-scheme requirements: Matches input and validated against the maximum of 22 (R1), club names and results taken into Clubs[] and Statistics[] (R2), trio validation with re-entry until the figures match Matches (R3), points calculated as wins × 12 + draws × 5 and stored in Points[] (R4), and the highest total found with every level club — not just the first — output with name, wins and points (R5).

What to check before submitting

Check that the two REPEAT loops re-prompt with suitable messages, that Counter indexes all three arrays in step, that the points line uses WinPoints and DrawPoints with losses scoring 0, that the final sweep tests = HighestPoints so ties survive, and that comments explain every block.

Remember: the AO2 and AO3 marks are awarded by judging the whole response. The individual R1–R5 labels are the technique requirements, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the league program run.

Step through a sample season. Watch each club’s figures arrive, see the mismatched trio rejected and re-entered, follow Points[] filling club by club, and watch the champion pass crown the club with the highest total.

Last tab · Trace player

Sample input → expected results

Five sample clubs are shown (the real league stores 12) and each plays Matches = 15 games; a win scores 12 points, a draw 5 and a loss 0. The sample deliberately tests a rejected trio — Colton CC is first entered as 8 + 4 + 4 = 16, which does not match 15, so all three figures are re-entered — a clear single champion (Ashgrove CC with 123 points from 9 wins), and Denby CC’s 5-5-5 record to show that losses add nothing. These are illustrative values, not data supplied by the examination question.

Input arrays Clubs[] and Statistics[,]

Club	Won	Drawn	Lost

The row number is the index shared by Clubs[], Statistics[,] and Points[].

Reveal expected Points[] and champion summary

Expected league results After all calculations

Club	Wins	Points	Outcome

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

League counters

Ready

Tip: use Next step slowly and watch Counter, TrioTotal and HighestPoints. The trio total must land exactly on Matches before Points[] can be filled, and the title is only decided after every club is processed.

Trace colours: blue row = current club; amber cell = current figure being entered; green cells = figures already stored.

Boundary example: Colton CC’s first entry fails because 8 + 4 + 4 <> 15, so all three figures are re-entered until they total exactly 15. Ashgrove CC’s title comes from 9 * 12 + 3 * 5 = 123, while Denby CC’s 5-5-5 record gives 5 * 12 + 5 * 5 = 85 — a loss adds nothing.

From match records to the cricket league champions.

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 identifiers

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input and validate the matches played

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Take each club’s name and results

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Check the trio against Matches

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Award the points and fill Points[]

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Crown the club or clubs at the top

🧠 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 league program run.

Sample input → expected results

Input arrays Clubs[] and Statistics[,]

Expected league results After all calculations

Execution trace

Initialisation

Live variable values

League counters