15-mark question lab · start here

From five event scores to tournament medals.

Build the solution in a sensible order: understand the three arrays, plan the nested input loop, validate every score between 0 and 100, accumulate each competitor’s total into Points[], award the five event medals with ties included, and crown the overall champion(s). Learn the reasoning before revealing the complete program.

2D arrayInput validationPer-event maximumTie handlingTotalling15 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, the competitor index shared by CompetitorName[] and CompetitorScore[,], and the 0–100 validity rule every entered score must pass.

02 · Construct

Use nested loops to input and validate each score, accumulate totals into Points[], and track the highest score in every event column.

03 · Complete

Output each event’s medal winner(s) including ties, find the highest total, and crown the champion or champions with suitable messages.

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 0–100 validation, the tie rule hidden in “the competitor or the competitors”, and the two separate medal searches all shape the structure of the solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/21 · Question 11

The one-dimensional (1D) array CompetitorName[] contains the names of 25 competitors in a tournament that includes five events.

Another two-dimensional (2D) array CompetitorScore[] contains the points scored by each competitor in the five events. The first dimension of this array contains the index of the competitor from CompetitorName[] and the second dimension contains their scores.

Each competitor receives a score out of 100 for each event. These scores are manually entered into CompetitorScore[].

Medals are awarded to the competitor or the competitors who have:

the highest points scored in each of the five events
the highest total points scored for all five events.

The one-dimensional (1D) array Points[] stores the total number of points scored for each competitor.

Write a program that meets the following requirements:

takes as input, valid scores (between 0 and 100), for each competitor in each of the five events
calculates the highest points scored for each event
outputs the names of the competitors who receive a medal for the highest points scored
calculates the highest total points scored for the five events
outputs the names of the competitors with the highest total points scored for the five events.

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.
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

Take a score for every competitor in every event, rejecting anything below 0 or above 100 until a valid score is entered.

Calculate the highest points scored in each of the five events with a column-by-column maximum scan.

Output the names of the competitors who receive a medal — every competitor whose score equals the event maximum.

Accumulate each competitor’s five validated scores into Points[] and find the highest total.

Output the names of the competitors with the highest total points — the overall champion(s).

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

Identify the repeated unit. A score must be entered for every competitor in every event, so nested loops run over the 25 rows and 5 columns of CompetitorScore[,].
Separate the three phases. Phase 1 inputs and validates every score while building Points[]. Phase 2 awards the five event medals. Phase 3 crowns the overall champion(s). A medal cannot be awarded in phase 1, because a later competitor can still tie or beat an earlier score.
Notice the two kinds of medal. Five event medals come from the highest value in one column of CompetitorScore[,]; the champion medal comes from the highest value in Points[]. Both use the same maximum-and-list pattern.
Translate command words. “Takes as input” means INPUT with validation; “calculates the highest” means maximum tracking; “outputs the names” means a lookup through CompetitorName[]; “between 0 and 100” sets the validation range.
Build the order. competitor loop → event loop (prompt, input, validate, accumulate) → event loop (find column maximum, output medalist names) → totals scan (find highest total, output champion names).

Nested loop: competitors × eventsValidation: 0 to 100Ties share medalsTwo maximum scans

❓ Guiding questions – think before revealing

Which phrase warns you that ties must be handled?
Why can the event medals not be awarded while the scores are being input?
What does the program output in total?

Reveal suggested reasoning

Which phrase warns you that ties must be handled? “Medals are awarded to the competitor or the competitors who have…” — the singular-or-plural wording tells you more than one competitor can share a medal, in an event and for the overall total.

Why can the event medals not be awarded while the scores are being input? The highest score in an event is only known once all 25 competitors have entered that event. Any medal decided early could be beaten or tied later, so the medal scans run after all the input is complete.

What does the program output in total? One announcement per event naming its medalist(s) — five announcements — plus the champion announcement naming every competitor on the highest total. Every input and every output needs a suitable message.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Phase 1 — input and validate all scores, totalling as you go
FOR CompetitorCounter ← 1 TO Competitors
    Points[CompetitorCounter] ← 0
    FOR EventCounter ← 1 TO Events
        // prompt, input, reject outside 0-100, accumulate into Points[]
    NEXT EventCounter
NEXT CompetitorCounter

// Phase 2 — for each event: find the highest score, output the names on it
// Phase 3 — find the highest total in Points[], output the champion name(s)

📖 Detailed explanation

“For each competitor in each of the five events” fixes the loop shape: the event loop nests inside the competitor loop, visiting all 125 cells of the real array.

“Manually entered” tells you the program is input-driven — nothing is pre-stored, so validation must happen as each score arrives.

“The competitor or the competitors” appears twice, once for event medals and once for the total. Both winners’ lists must be built with an equality test, not by storing a single name.

“Points[] stores the total” tells you a 1D array must be built from the 2D scores — the champion search reads it later.

⚠️ Common mistakes

Awarding each event medal during the input loop, before every competitor has entered that event.
Reading the bullets once and forgetting the second medal list — the overall champion(s) — entirely.
Ignoring the tie wording and outputting only one name per event.
Planning outputs without messages, when the question demands suitable messages on every input and output.

💡 Exam hack / tip

Underline “between 0 and 100”, “the highest points… in each of the five events”, “the competitor or the competitors” and “Points[] stores the total”. Those phrases reveal the whole program: a validated input loop, five column maximum scans, equality-based name lists, and a totals array.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R5 · full requirement coverageAO3 · logical phase orderAO3 · tie rule identified

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 that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given names. CompetitorName[], CompetitorScore[,] and Points[] are supplied by the question — your program must use them exactly. CompetitorScore[CompetitorCounter, EventCounter] addresses one cell.
Add two loop counters. CompetitorCounter walks the rows; EventCounter walks the five event columns inside the current row.
Add the working trackers. HighestScore holds the current event’s top score; HighestTotal holds the top value in Points[] during the champion scan.
Note the declaration rule. This question says you do not need to declare any arrays or variables — so spend the saved lines on clear comments instead.
Check for unnecessary data. No extra arrays are needed: the input loop builds Points[] and every other result is a simple variable.

Given: CompetitorName[] and CompetitorScore[,]Built: Points[] totalsTrackers: HighestScore, HighestTotal

❓ Guiding questions – think before revealing

Which dimension of CompetitorScore[,] is the competitor?
Why is Points[] needed at all?
Do you declare the arrays?

Reveal suggested reasoning

Which dimension of CompetitorScore[,] is the competitor? The question states the first dimension contains the index of the competitor and the second contains their scores, so CompetitorScore[CompetitorCounter, EventCounter] is competitor CompetitorCounter’s score in event EventCounter.

Why is Points[] needed at all? The champion search compares finished totals long after each competitor’s scores were entered. Simple variables would be overwritten, so the question supplies Points[] to store one total per competitor.

Do you declare the arrays? No — the closing line says you do not need to declare any arrays or variables. Use the given names and comment their roles instead.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question (no declarations required):
// CompetitorName[1..25]   CompetitorScore[1..25, 1..5]   Points[1..25]

CONSTANT Competitors = 25   // names stored in CompetitorName[]
CONSTANT Events = 5         // events per competitor

// Chosen working variables (INTEGER throughout):
// CompetitorCounter, EventCounter — loop counters
// HighestScore — top score in the event being scanned
// HighestTotal — top value in Points[] during the champion search

📖 Detailed explanation

The two dimensions have different meanings. Row = competitor (linked to CompetitorName[]), column = event. Swapping them reads the array across the grain and mixes competitors’ data.

Named constants avoid magic numbers. Competitors and Events make every loop header read like the question and make the program easy to adapt.

Trackers are single values. HighestScore is rewritten for each event scan and HighestTotal for the totals scan — neither needs to be an array.

⚠️ Common mistakes

Renaming the arrays (for example Names[] instead of CompetitorName[]), which the mark scheme treats as not using the given data.
Writing CompetitorScore[EventCounter, CompetitorCounter] and addressing the array the wrong way round.
Declaring fresh arrays to copy scores into, which wastes lines and adds risk.
Forgetting Points[] until the champion stage, then having no totals to compare.

💡 Exam hack / tip

Map every identifier back to the question: CompetitorName names the rows, CompetitorScore fills the grid, Points[] totals each row, HighestScore and HighestTotal power the two medal scans. If an examiner cannot trace a variable back to the question, rename it.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR2 · R4 · trackers chosenAO3 · 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 every score

Prompt, input, reject anything outside 0 to 100, then accumulate.

R1 · R4

🧠 Step-by-step thinking

Prompt with a useful message. The prompt names the competitor through CompetitorName[CompetitorCounter] and the event number, because the question requires suitable messages.
Reject with a compound condition. < 0 OR > 100 catches both ends of the range in one WHILE test — an AND would make the condition impossible.
Loop until valid. A WHILE loop re-inputs the score; a single IF would accept a second bad entry. The loop condition is the exact opposite of a valid score.
Accept the boundaries. “Between 0 and 100” is treated as inclusive: 0 and 100 are valid scores, so the rejection test is < 0 OR > 100.
Accumulate after validation. Only the validated score is added to Points[CompetitorCounter] — a rejected 101 must never reach the total.

WHILE: invalid re-entryTest: < 0 OR > 100Accumulate: validated only

❓ Guiding questions – think before revealing

Why WHILE rather than IF?
Why OR rather than AND in the rejection test?
Where does the validated score go?

Reveal suggested reasoning

Why WHILE rather than IF? The replacement entry can be invalid too. WHILE … ENDWHILE keeps testing until a valid score arrives, which a single IF cannot guarantee.

Why OR rather than AND in the rejection test? A score cannot be below 0 and above 100 at once, so score < 0 AND score > 100 is never TRUE and nothing would ever be rejected. OR rejects anything outside either end.

Where does the validated score go? Two places: it is stored in CompetitorScore[CompetitorCounter, EventCounter] and added to the running total Points[CompetitorCounter] for the champion search later.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR CompetitorCounter ← 1 TO Competitors
    Points[CompetitorCounter] ← 0
    FOR EventCounter ← 1 TO Events
        OUTPUT "Enter the score for ", CompetitorName[CompetitorCounter],
            " in event ", EventCounter
        INPUT CompetitorScore[CompetitorCounter, EventCounter]
        // Repeat until the score lies inside 0 to 100 inclusive
        WHILE CompetitorScore[CompetitorCounter, EventCounter] < 0
           OR CompetitorScore[CompetitorCounter, EventCounter] > 100
            OUTPUT "Invalid score. Enter a value between 0 and 100"
            INPUT CompetitorScore[CompetitorCounter, EventCounter]
        ENDWHILE
        Points[CompetitorCounter] ← Points[CompetitorCounter] +
            CompetitorScore[CompetitorCounter, EventCounter]
    NEXT EventCounter
NEXT CompetitorCounter

📖 Detailed explanation

The rejection condition mirrors validity. A score is valid when it is >= 0 and <= 100, so the re-entry loop runs while it is < 0 or > 100 — a matched pair of tests.

The prompt uses the shared index. CompetitorName[CompetitorCounter] turns row 7 into a name, so the operator knows whose score is being entered.

Input overwrites the same cell. The rejected value sits in the array cell only until the next INPUT replaces it — nothing invalid survives the loop.

⚠️ Common mistakes

Using AND between the two range tests, so invalid scores sail through unvalidated.
Validating with a single IF, which fails the moment the second entry is also bad.
Rejecting exactly 0 or exactly 100, when both boundary scores are valid.
Accumulating the score before the WHILE loop, so a rejected 101 inflates the total.

💡 Exam hack / tip

Say the range aloud as two gates: not below 0, not above 100. The WHILE loop opens again whenever either gate fails. Then check the boundary scores 0 and 100 by hand — they must walk straight through.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · input with validation loopR1 · every competitor × eventAO3 · correct range boundaries

The input loop is the R1 evidence for complete, validated data entry, and the exact boundary handling is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Build Points[] as the scores arrive

One total per competitor, ready for the champion search.

🧠 Step-by-step thinking

Reset the total per competitor. Points[CompetitorCounter] ← 0 runs inside the outer loop, so each competitor starts from a clean total.
Add one score per inner pass. Each validated score is added immediately, so the total is complete the moment NEXT EventCounter runs.
Keep the reset outside the inner loop. Resetting inside the event loop would wipe the total four times per competitor.
Alternative: a second pass. Totalling in a separate loop over the finished row is equally correct — but accumulating during input needs no extra loop.
Remember why the totals exist. Points[] is not an output in itself; it is the data the champion search reads in Stage 6.

Reset: once per competitorAccumulate: one add per scorePurpose: champion search data

❓ Guiding questions – think before revealing

Why reset Points[CompetitorCounter] inside the competitor loop?
When is Points[CompetitorCounter] final?
Could you total in a separate loop later?

Reveal suggested reasoning

Why reset Points[CompetitorCounter] inside the competitor loop? Each competitor has their own total. The reset must run once per pass of the outer loop — outside it the totals would pile competitor onto competitor, inside the inner loop they would never grow past one event.

When is Points[CompetitorCounter] final? After the fifth NEXT EventCounter for that competitor — exactly the point the row-complete step of the trace shows.

Could you total in a separate loop later? Yes — a second FOR EventCounter loop after the input would sum the stored row into Points[] and is equally acceptable. Accumulating during input simply saves that extra pass.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Inside the competitor loop, before the event loop
Points[CompetitorCounter] ← 0

// Inside the event loop, after validation
Points[CompetitorCounter] ← Points[CompetitorCounter] +
    CompetitorScore[CompetitorCounter, EventCounter]

// After NEXT EventCounter: Points[CompetitorCounter] holds
// the total of all five validated scores for this competitor

📖 Detailed explanation

Accumulation is a three-line pattern. Reset before the inner loop, add inside it, read the finished value after it — the same rhythm as any Cambridge total.

The 1D and 2D arrays share the row index. Points[CompetitorCounter] belongs to the same competitor as row CompetitorCounter of CompetitorScore[,].

Rejected scores never contribute. Because the add sits after the WHILE loop, only values that passed validation reach the total.

⚠️ Common mistakes

Placing Points[CompetitorCounter] ← 0 inside the event loop, so the total only ever holds one event.
Placing the reset before the outer loop, so totals accumulate across competitors.
Adding the score before the validation loop, letting a rejected 101 into the total.
Totalling into a plain variable that is overwritten by the next competitor instead of into Points[].

💡 Exam hack / tip

Trace one competitor by hand: total starts 0, five adds, total read after NEXT EventCounter. If your three lines do not sit exactly at the reset / add / read positions, the totals are wrong for every competitor after the first.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · accumulation into an arrayR4 · totals stored in Points[]AO3 · correct reset position

Storing totals in the given array supports AO2 data handling, and the reset/add/read positions are AO3 logic evidence. These are alignment notes, not separately allocated marks.

Award each event’s medal(s)

Find the column maximum, then list every competitor on it.

R2 · R3

🧠 Step-by-step thinking

Scan one column at a time. The event loop is now the outer loop; the competitor loop visits rows 1 to Competitors of that column.
Seed from the first cell. HighestScore ← CompetitorScore[1, EventCounter] starts from a real score; rows 2 upwards are compared with a strict >.
Collect ties with a second scan. A fresh competitor loop outputs every name whose score = HighestScore — the equality test is what makes medals shareable.
Output names, not indexes. CompetitorName[CompetitorCounter] converts the row into the name the question asks for.
Announce with a message. The question requires suitable messages, so the medal line names the event and the winning score.

Column scan per eventSeed + strict > maximumEquality test shares medals

❓ Guiding questions – think before revealing

Why are two scans needed per event?
Why seed from CompetitorScore[1, EventCounter] rather than 0?
What happens when two competitors share the top score?

Reveal suggested reasoning

Why are two scans needed per event? The first finds how high the winning score is; the second finds who is on it. One scan cannot do both, because a later competitor can still tie the current leader.

Why seed from CompetitorScore[1, EventCounter] rather than 0? It is a reliable habit that works for any data range. Here scores cannot be below 0, so seeding at 0 would also work — but the first-cell seed survives even if the rules change.

What happens when two competitors share the top score? The strict > scan keeps HighestScore unchanged, and the equality scan outputs both names — exactly the “competitor or the competitors” behaviour the question describes.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR EventCounter ← 1 TO Events
    // Pass 1: find the highest score in this event
    HighestScore ← CompetitorScore[1, EventCounter]
    FOR CompetitorCounter ← 2 TO Competitors
        IF CompetitorScore[CompetitorCounter, EventCounter] > HighestScore
        THEN
            HighestScore ← CompetitorScore[CompetitorCounter, EventCounter]
        ENDIF
    NEXT CompetitorCounter
    // Pass 2: every competitor on the top score earns a medal
    OUTPUT "Medals for event ", EventCounter,
        " go to competitors scoring ", HighestScore
    FOR CompetitorCounter ← 1 TO Competitors
        IF CompetitorScore[CompetitorCounter, EventCounter] = HighestScore
        THEN
            OUTPUT CompetitorName[CompetitorCounter]
        ENDIF
    NEXT CompetitorCounter
NEXT EventCounter

📖 Detailed explanation

The pattern is find-then-list. Maximum first, equality second. Reversing them is impossible — you cannot test = HighestScore before HighestScore is known.

Strict > keeps the scan simple. During pass 1 an equal score does not overwrite the champion; the value of HighestScore ends the same either way, and pass 2 catches everyone on it.

The event loop resets the scan. Each new event re-seeds HighestScore from its own column, so no score leaks from one event into the next.

⚠️ Common mistakes

Scanning rows instead of columns — totalling a competitor and calling it an event maximum.
Outputting the competitor found by the > scan only, missing later competitors who tie the same score.
Forgetting to re-seed HighestScore per event, so event 2 inherits event 1’s maximum.
Outputting CompetitorCounter instead of CompetitorName[CompetitorCounter].

💡 Exam hack / tip

Memorise the couplet: strictly greater finds the height, equals finds the names. Every Cambridge ‘winner or winners’ question — medals, champions, top scores — is solved with those two scans.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · maximum tracking with tiesR2 · R3 · per-event winners outputAO3 · correct operator choice

The two-pass medal scan is the clearest AO2 evidence of maximum tracking and selection, and the operator choices are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Crown the overall champion(s)

Apply the same two-pass pattern to the totals in Points[].

R4 · R5

🧠 Step-by-step thinking

Read the totals, do not rebuild them. Points[] already holds every competitor’s total, so the champion scan compares array values only.
Seed from Points[1]. HighestTotal ← Points[1], then rows 2 to Competitors are compared with a strict >.
List every name on the top total. The equality scan outputs all competitors whose total equals HighestTotal — a shared title is possible.
Output the total with the names. A message that states the winning total, followed by each name, keeps the output self-explanatory.
This is the last required output. After the champion names, the program has satisfied every bullet — nothing else is needed.

Scan: Points[] totalsSeed: Points[1]Output: champion name(s)

❓ Guiding questions – think before revealing

Why scan Points[] instead of the 2D array again?
What if two competitors share the highest total?
How is this stage different from the medal scan?

Reveal suggested reasoning

Why scan Points[] instead of the 2D array again? The totals are already stored. Re-adding the five scores would duplicate work and risk a different result if any score changed in the meantime.

What if two competitors share the highest total? The equality scan outputs both names. The sample trace happens to have a single champion, but the code does not depend on that — a tie prints as many names as match.

How is this stage different from the medal scan? Only the array changes: Points[CompetitorCounter] replaces CompetitorScore[CompetitorCounter, EventCounter], and there is no event loop because there is one championship.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Pass 1: find the highest total
HighestTotal ← Points[1]
FOR CompetitorCounter ← 2 TO Competitors
    IF Points[CompetitorCounter] > HighestTotal
    THEN
        HighestTotal ← Points[CompetitorCounter]
    ENDIF
NEXT CompetitorCounter

// Pass 2: every competitor on the highest total is a champion
OUTPUT "The overall champion(s), with ", HighestTotal, " points:"
FOR CompetitorCounter ← 1 TO Competitors
    IF Points[CompetitorCounter] = HighestTotal
    THEN
        OUTPUT CompetitorName[CompetitorCounter]
    ENDIF
NEXT CompetitorCounter

📖 Detailed explanation

Reuse beats recalculation. The champion scan is the medal scan with one index fewer — recognising that keeps the program short and consistent.

The seed is a stored total. Points[1] is a real value, so the first comparison in the scan behaves correctly even if competitor 1 turns out to be the champion.

Both passes run after every competitor is finished. Placed at the end of the program, the scans see the final Points[] values.

⚠️ Common mistakes

Re-totaling the five events inside the champion scan instead of reading Points[].
Seeding HighestTotal from 0 — harmless with 0–100 scores, but only by luck, and it breaks if totals could ever be negative.
Outputting only the first competitor whose total equals HighestTotal, dropping shared champions.
Announcing the champion inside a loop over events — there is one championship, not five.

💡 Exam hack / tip

Spot the symmetry: medals scan a column, the champion scans Points[]. Write the medal scan once, understand it properly, and the champion scan is a free copy with the array swapped.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · maximum scan over Points[]R4 · R5 · champions outputAO3 · consistent pattern reuse

Reusing the maximum-and-list pattern over Points[] supports AO2 efficiency, and the complete champion output is the R4/R5 evidence. These are alignment notes, not separately allocated marks.

Assemble the program and check the outputs

Three phases, five medal announcements, one champion line — all with messages.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Order the phases. Input + validation (with totals) → five event medal scans → champion scan. Phases 2 and 3 must follow phase 1 or the data is incomplete.
Count the required outputs. One medal announcement per event naming its winner(s), plus the champion announcement naming the competitor(s) with the highest total.
Check every message. Prompts name the competitor and event; the rejection message states the valid range; medal and champion lines state the event or the total.
Check names come from CompetitorName[]. No output should show a raw index — every required output is a name with its context.
Rehearse the tie path. Ask of your own code: if two competitors tie on 92 in event 1, do both names print? If totals tie, do both print?

Three phases in orderSix announcements in the sampleNames through CompetitorName[]

❓ Guiding questions – think before revealing

What is the quickest completeness check before submitting?
How many output blocks does the sample run produce?
What makes a message “suitable”?

Reveal suggested reasoning

What is the quickest completeness check before submitting? Point at each of the five question bullets and find the lines that satisfy it. If a bullet has no lines, the program is incomplete — most often it is the champion output.

How many output blocks does the sample run produce? Six: five event announcements (with six name lines because event 1 is tied) and one champion block. In the real program the same structure serves all 25 competitors.

What makes a message “suitable”? It tells the operator what is happening: whose score is wanted, why an entry was rejected, which event the medals belong to, and what the printed total means.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Phase 1 — input, validate, total (Stages 3 and 4)
FOR CompetitorCounter ← 1 TO Competitors
    Points[CompetitorCounter] ← 0
    FOR EventCounter ← 1 TO Events
        // prompt, INPUT, WHILE reject outside 0-100, accumulate
    NEXT EventCounter
NEXT CompetitorCounter

// Phase 2 — five event medal scans (Stage 5)
FOR EventCounter ← 1 TO Events
    // seed HighestScore, strict > scan, then output every name on it
NEXT EventCounter

// Phase 3 — champion scan over Points[] (Stage 6)
// seed HighestTotal, strict > scan, then output every name on it

📖 Detailed explanation

The skeleton is the answer’s spine. Writing these three phase blocks first — then filling them — keeps indentation and loop closures correct under exam pressure.

Every bullet maps to a phase. Bullet 1 → phase 1; bullets 2 and 3 → phase 2; bullets 4 and 5 → phase 3. Nothing is orphaned.

The sample run proves the logic. Twenty valid scores, one rejected 101, six medals across five events and a single champion — each visible in the trace console.

⚠️ Common mistakes

Leaving the validation loop out of the final program after planning it, losing the R1 marks.
Printing medal names without saying which event they belong to.
Outputting the arrays themselves instead of selected names.
Forgetting that the champion list, like each medal list, must be built with an equality test.

💡 Exam hack / tip

Final 30 seconds: run a finger down the five bullets ticking each one against your code, then check the closing lines — comments explain the code, no declarations were needed, and every INPUT and OUTPUT carries a message.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · complete working programR1–R5 · every bullet satisfiedAO3 · commented, messaged outputs

The assembled program provides the AO2 completeness evidence and the commented, messaged outputs provide AO3 communication 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–R5	Identifies validated input, per-event maxima, medal outputs and the champion search.	Establishes the three-phase order and comments the plan.
2 · Data	Required data structures	CompetitorName[], CompetitorScore[,] and Points[] plus counters and trackers.	Meaningful identifiers; no unnecessary arrays or declarations.
3 · Validate	R1	Prompts, inputs and re-inputs every score until it lies between 0 and 100.	WHILE loop with OR condition; inclusive boundaries accepted.
4 · Totals	R4	Accumulates each competitor’s five validated scores into Points[].	Reset per competitor; totals ready for the champion search.
5 · Medals	R2, R3	Finds each event’s highest score and lists every competitor on it.	Seed from the first cell; strict > scan; equality collects ties.
6 · Champions	R4, R5	Finds the highest total in Points[] and outputs the champion name(s).	Same two-pass pattern applied to the totals.
7 · Summary	R1–R5	Assembles the phases and checks every required output appears.	Names looked up through CompetitorName[]; suitable messages throughout.

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 11 · FULL PSEUDOCODECambridge 0478 style · 1-based indexing

// CompetitorName[] holds 25 names. CompetitorScore[,] holds one score
// per competitor per event. Points[] will hold each competitor total.
CONSTANT Competitors = 25
CONSTANT Events = 5

// ---- Phase 1: input and validate every score, totalling as we go ----
FOR CompetitorCounter ← 1 TO Competitors
    // Each competitor total starts from zero
    Points[CompetitorCounter] ← 0
    FOR EventCounter ← 1 TO Events
        // Ask for the score, naming the competitor and the event
        OUTPUT "Enter the score for ", CompetitorName[CompetitorCounter],
            " in event ", EventCounter
        INPUT CompetitorScore[CompetitorCounter, EventCounter]
        // Reject any score outside the 0-100 range and ask again
        WHILE CompetitorScore[CompetitorCounter, EventCounter] < 0
           OR CompetitorScore[CompetitorCounter, EventCounter] > 100
            OUTPUT "Invalid score. Enter a value between 0 and 100"
            INPUT CompetitorScore[CompetitorCounter, EventCounter]
        ENDWHILE
        // Add the validated score to the running total
        Points[CompetitorCounter] ← Points[CompetitorCounter] +
            CompetitorScore[CompetitorCounter, EventCounter]
    NEXT EventCounter
NEXT CompetitorCounter

// ---- Phase 2: award each event medal or medals ----
FOR EventCounter ← 1 TO Events
    // First scan of the column: find the highest score in this event
    HighestScore ← CompetitorScore[1, EventCounter]
    FOR CompetitorCounter ← 2 TO Competitors
        IF CompetitorScore[CompetitorCounter, EventCounter] > HighestScore
        THEN
            HighestScore ← CompetitorScore[CompetitorCounter, EventCounter]
        ENDIF
    NEXT CompetitorCounter
    // Second scan: every competitor on the top score earns a medal
    OUTPUT "Medals for event ", EventCounter,
        " go to competitors scoring ", HighestScore
    FOR CompetitorCounter ← 1 TO Competitors
        IF CompetitorScore[CompetitorCounter, EventCounter] = HighestScore
        THEN
            OUTPUT CompetitorName[CompetitorCounter]
        ENDIF
    NEXT CompetitorCounter
NEXT EventCounter

// ---- Phase 3: crown the overall champion or champions ----
// First scan of Points[]: find the highest total
HighestTotal ← Points[1]
FOR CompetitorCounter ← 2 TO Competitors
    IF Points[CompetitorCounter] > HighestTotal
    THEN
        HighestTotal ← Points[CompetitorCounter]
    ENDIF
NEXT CompetitorCounter
// Second scan: every competitor on the highest total is a champion
OUTPUT "The overall champion(s), with ", HighestTotal, " points:"
FOR CompetitorCounter ← 1 TO Competitors
    IF Points[CompetitorCounter] = HighestTotal
    THEN
        OUTPUT CompetitorName[CompetitorCounter]
    ENDIF
NEXT CompetitorCounter

Why this is a complete response

It covers the five requirements: validated input of every competitor’s score in all five events (R1), the highest score calculated for each event (R2), medal winner names output for every event including ties (R3), totals accumulated into Points[] and the highest total calculated (R4), and the champion name(s) output with a suitable message (R5).

What to check before submitting

Check the WHILE validation condition (0 and 100 must be accepted), the reset of Points[] per competitor, the two-pass medal pattern (strictly greater to find, equals to list), the champion search over Points[], and the comments explaining the program.

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 program work.

Step through a sample tournament. Watch each score pass the 0–100 gate, the totals build in Points[], the event medals change hands, and the champion take the title.

Last tab · Trace player

Sample input → expected results

Four competitors take five events (Competitors = 4; Events = 5 — the real paper has 25 competitors and the same five events). Every entered score is validated between 0 and 100: Bilal’s first entry of 101 for event 2 is rejected and re-entered as 71, while Dev’s exactly-100 in event 5 tests the upper boundary. Event 1 ends in a 92 tie so two medals are awarded, and each total in Points[] is accumulated from the validated scores. These are illustrative values, not data supplied by the examination question.

Input arrays CompetitorName[] and CompetitorScore[,]

Competitor	Event 1	Event 2	Event 3	Event 4	Event 5

The row number is the competitor position used by both arrays.

Reveal expected competitor results and tournament summary

Expected competitor results After all inputs are validated

Competitor	Total points	Event medals	Overall champion

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Tournament counters

Ready

Tip: use Next step slowly and watch CompetitorCounter, EventCounter and PointsTotal. The event counter returns to 1 for each new competitor, HighestScore is re-seeded for each event scan, and Points[] never loses a finished total.

Trace colours: blue row = current competitor; amber cell = the score being entered or compared; green cells = scores already validated and stored.

Boundary examples: Bilal’s first entry of 101 for event 2 fails 101 > 100, so the message is output and the score is re-entered; Dev’s 100 in event 5 passes because only < 0 OR > 100 is rejected. Event 1’s medal is shared because 92 = HighestScore is TRUE for both Bilal and Cleo, and Cleo’s 426 total crowns her overall champion.

From five event scores to tournament medals.

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 every score

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Build Points[] as the scores arrive

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Award each event’s medal(s)

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Crown the overall champion(s)

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Assemble the program and check the outputs

🧠 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

Input arrays CompetitorName[] and CompetitorScore[,]

Expected competitor results After all inputs are validated

Execution trace

Initialisation

Live variable values

Tournament counters