15-mark question lab · start here

From ten rounds on the range to a qualification verdict.

Build the solution in a sensible order: understand the two arrays, plan the nested input loop, validate every score between 0 and 30 inclusive, track the highest and lowest while the rounds are entered, discard both to leave the 8-score overall, band it into next competition, reserve or does not qualify, and report the three counts. Learn the reasoning before revealing the complete program.

2D arrayInput validationMax/min trackingDiscard arithmeticThree-way bands15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify CompetitorName[] and CompetitorScore[,], the shared competitor index, the 10-round structure and the 0–30 validity rule every entered score must pass.

02 · Construct

Use nested loops to input and validate each round score while tracking the highest, the lowest and the running total for every competitor.

03 · Complete

Discard the two extremes to compute the 8-score overall, band it at 210 and 180, output every name and outcome, and report the three counts.

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 discard rule, the inclusive 0–30 validation and the three outcome counters all affect the structure of your solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/21 · Question 11

The scores for each competitor in an archery competition are recorded. The one-dimensional (1D) array CompetitorName[] is used to store the names of the competitors. The maximum number of competitors is 30.

There are 10 rounds in the competition with a maximum score of 30 per round. The two-dimensional (2D) array CompetitorScore[] stores the score in each of the 10 rounds for each competitor. The first index of the array CompetitorScore[] is the same as the index of the competitor in CompetitorName[].

After the 10 rounds have been completed, the highest score and the lowest score for each competitor are discarded. The overall score for each competitor is the total of the remaining 8 scores (after discarding the highest and lowest scores).

A competitor with an overall score of 210 or more moves onto the next competition. A competitor with an overall score between 180 and 209 inclusive becomes a reserve competitor. A competitor with an overall score below 180 does not qualify.

Write a program that meets the following requirements:

inputs the total score (out of 30) for each competitor in each round
validates each input is between 0 and 30 inclusive
calculates the overall score for each competitor discarding the highest and lowest scores
outputs the name of each competitor and if they move onto the next competition, are a reserve or do not qualify
calculates and outputs the number of competitors who:
- have qualified for the next competition
- are reserve competitors
- do not qualify.

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; 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 each competitor’s total score (out of 30) for every one of the 10 rounds, with a prompt that names the competitor and the round.

Validate every entered score, re-prompting while it is below 0 or above 30, so the boundary values 0 and 30 themselves are accepted.

Calculate the overall score for each competitor by discarding the highest and the lowest — the row total minus both extremes.

Output each competitor’s name and whether they move onto the next competition, are a reserve or do not qualify.

Count and output the numbers of competitors who qualified, became reserves or did not qualify.

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. The program must process every competitor, so an outer loop repeats from competitor 1 to the maximum of 30.
Identify the repeated work inside each competitor. Every competitor has 10 round scores to enter, so an inner loop visits each round, inputs the score and validates it between 0 and 30 inclusive.
Spot the discard rule. The overall score is not the total of 10 rounds: the highest and the lowest are discarded, so the overall is the total of the remaining 8 — the row total minus the highest minus the lowest.
Translate the bands. “210 or more” means >= 210; “between 180 and 209 inclusive” is the middle band; “below 180” is the final ELSE case. Each band also needs its own counter.
Build the order. assign the three counters 0 → competitor loop → input and validate round 1, seed the trackers → rounds 2–10 loop (prompt, input, validate, store, total, track) → overall = total − highest − lowest → banded output + counter → after the loop, output the three counts.

Outer loop: 30 competitorsInner loop: 10 roundsValidation: 0 to 30 inclusiveThree outcome bands

❓ Guiding questions – think before revealing

Which words tell you the program is input-driven?
Why is the overall score not simply the row total?
What does the program output in total?

Reveal suggested reasoning

Which words tell you the program is input-driven? “Inputs the total score (out of 30) for each competitor in each round” — nothing is pre-stored, so the program fills CompetitorScore[,] itself and must validate each score as it arrives.

Why is the overall score not simply the row total? After the 10 rounds the highest and the lowest are discarded, so only 8 scores count. Tracking the highest and lowest while the rounds are entered lets you compute the overall as RoundTotal − MaxScore − MinScore.

What does the program output in total? One outcome message per competitor (name plus next competition, reserve or does not qualify), then three count outputs after the loop. Every input and output needs a suitable message.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Assign the three outcome counters to 0
FOR CompetitorCounter ← 1 TO 30
    // Input and validate round 1, seed the trackers from it
    FOR RoundCounter ← 2 TO 10
        // prompt, input, validate 0-30, store
        // total the row, track highest and lowest
    NEXT RoundCounter
    // OverallScore ← RoundTotal - MaxScore - MinScore
    // banded outcome: output name + message, update counter
NEXT CompetitorCounter

// Output the three counts:
// qualified, reserve, do not qualify

📖 Detailed explanation

“For each competitor in each round” fixes the loop shape: the round loop nests inside the competitor loop, filling all 300 cells of the real array.

“Validates each input is between 0 and 30 inclusive” makes validation per score: anything below 0 or above 30 is rejected and must be entered again.

“Discarding the highest and lowest scores” tells you two trackers are needed — and that exactly one highest and one lowest are dropped, leaving 8 counting scores.

“The number of competitors who…” tells you three counters must run alongside the outputs and be reported once at the end.

⚠️ Common mistakes

Totalling all 10 rounds and comparing that total with the bands — the discard rule is the heart of the question.
Validating with > 0 and < 30, which wrongly rejects scores of exactly 0 and exactly 30.
Outputting outcomes but never counting them, so the final three numbers cannot be produced.
Planning outputs without messages, when the question demands suitable messages on every input and output.

💡 Exam hack / tip

Underline “between 0 and 30 inclusive”, “discarding the highest and lowest scores”, “210 or more”, “between 180 and 209 inclusive” and “below 180”. Those phrases reveal the whole program: a validated input loop, two trackers, one subtraction, and a three-way selection with counters.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R5 · full requirement coverageAO3 · logical orderAO3 · discard 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 and arrays that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given names. CompetitorName[] and CompetitorScore[,] are supplied — the first index of CompetitorScore[] is the same as the index of the competitor in CompetitorName[].
Add two loop counters. CompetitorCounter walks the rows; RoundCounter walks the rounds inside the current row.
Add the discard trackers. MaxScore and MinScore remember the highest and lowest score of the current competitor; RoundTotal accumulates all 10 scores.
Add the derived value and the counters. OverallScore holds the 8-score total; QualifiedTotal, ReserveTotal and NotQualifiedTotal count the three outcomes.
Note the declaration rule. This question says declarations are assumed, so no DECLARE statements are needed — but every identifier must still be meaningful and the counters must still be assigned 0.

Given: CompetitorName[] and CompetitorScore[,]Trackers: MaxScore, MinScore, RoundTotalCounters: three outcome totals

❓ Guiding questions – think before revealing

Why do the arrays share an index?
Which values belong to one competitor only?
Do the counters need initialising at all?

Reveal suggested reasoning

Why do the arrays share an index? The question states that the first index of CompetitorScore[] is the same as the index of the competitor in CompetitorName[], so CompetitorName[i] names the competitor whose scores sit in row i.

Which values belong to one competitor only? MaxScore, MinScore and RoundTotal. They are re-seeded inside the outer loop for every competitor. The three outcome counters must not be reset there.

Do the counters need initialising at all? Yes. “Assume declarations have been done” does not mean “assume values” — the counters must still be assigned 0 before the loop, or the counts start from an unknown value.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question (declarations assumed):
// CompetitorName[]   CompetitorScore[,]

// Loop counters
// CompetitorCounter   RoundCounter

// Per-competitor working values (re-seeded every pass)
// MaxScore   MinScore   RoundTotal

// Derived value and outcome counters (assigned once)
// OverallScore
// QualifiedTotal   ReserveTotal   NotQualifiedTotal

📖 Detailed explanation

The 2D array is addressed row-first. CompetitorScore[CompetitorCounter, RoundCounter] means “the current competitor’s score for the current round” — competitor index first, round index second.

Trackers are per competitor. MaxScore and MinScore must never survive from one competitor to the next — they are re-seeded from the new competitor’s first round.

Counters span the whole run. The three outcome counters are assigned 0 once, before the loop, and incremented inside the banded selection.

⚠️ Common mistakes

Reusing one counter variable for both loops, which breaks the nesting immediately.
Letting MaxScore and MinScore keep the previous competitor’s values.
Inventing extra arrays for the outcomes — three simple counters are all the question needs.
Renaming the given arrays, which the mark scheme treats as not using the supplied data.

💡 Exam hack / tip

Borrow the question’s own words: CompetitorCounter, RoundTotal, MaxScore, MinScore, OverallScore, QualifiedTotal. An examiner should map every identifier 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 every round score

Round 1 is entered first and seeds the trackers; rounds 2 to 10 follow.

R1 · R2

🧠 Step-by-step thinking

Nest the round loop inside the competitor loop. For each competitor, round 1 is entered and validated on its own, then the inner loop handles rounds 2 to 10.
Prompt with a suitable message. The prompt names the competitor and the round, e.g. “Enter the score for round 3 for Priya”.
Validate with a WHILE loop. Reject while the score is < 0 OR > 30; the boundary values 0 and 30 themselves must be accepted.
Store into the 2D array. Each validated score is stored in CompetitorScore[CompetitorCounter, RoundCounter].
Rejection loops, not IFs. A WHILE keeps re-asking until a valid score arrives; a single IF would accept the second value unchecked.

Nested iterationValidation: WHILE < 0 OR > 30Prompt names competitor and round

❓ Guiding questions – think before revealing

Why WHILE and not IF for the validation?
Why is the test < 0 OR > 30 and not <= 0 AND >= 30?
Where is the validated score kept?

Reveal suggested reasoning

Why WHILE and not IF for the validation? The user could enter invalid values repeatedly. WHILE re-tests every re-entry until the condition is FALSE, so whatever leaves the loop is guaranteed to lie inside 0 to 30.

Why is the test < 0 OR > 30 and not <= 0 AND >= 30? “Between 0 and 30 inclusive” means 0 and 30 are valid scores. The loop must continue only while the score is outside the range, so the rejection test is score < 0 OR score > 30.

Where is the validated score kept? Straight into CompetitorScore[CompetitorCounter, RoundCounter] — the array the discard calculation reads next.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR CompetitorCounter ← 1 TO 30
    // Round 1 is entered first and seeds the trackers
    OUTPUT "Enter the score for round 1 for " ,
        CompetitorName[CompetitorCounter]
    INPUT CompetitorScore[CompetitorCounter, 1]
    WHILE CompetitorScore[CompetitorCounter, 1] < 0
       OR CompetitorScore[CompetitorCounter, 1] > 30
        OUTPUT "Invalid score - enter a value between 0 and 30 inclusive"
        INPUT CompetitorScore[CompetitorCounter, 1]
    ENDWHILE
    MaxScore ← CompetitorScore[CompetitorCounter, 1]
    MinScore ← CompetitorScore[CompetitorCounter, 1]
    RoundTotal ← CompetitorScore[CompetitorCounter, 1]
    // FOR RoundCounter ← 2 TO 10 repeats the same pattern
    ...
NEXT CompetitorCounter

📖 Detailed explanation

The prompt is an output. It names the competitor through CompetitorName[CompetitorCounter] and the round through RoundCounter — exactly the “suitable messages” the question demands.

Seeding happens once round 1 is valid. MaxScore, MinScore and RoundTotal all start from the same real score, so every later comparison is against genuine data.

Rounds 2 to 10 repeat the pattern. The inner loop reuses the prompt, input and validation for every remaining round of the same competitor.

⚠️ Common mistakes

Using >= 0 AND <= 30 as the rejection test, which accepts everything and validates nothing.
Validating with a single IF, so a second invalid entry slips through unchecked.
Storing the score in a separate variable and never copying it into CompetitorScore[,].
Seeding the trackers before the first score is validated, so a rejected 35 could become the “highest”.

💡 Exam hack / tip

Say the boundary sentence aloud: 0 and 30 are scores; −1 and 31 are not. Write the WHILE test as < 0 OR > 30 and the boundaries look after themselves.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · input with validationR1 · R2 · every score entered and checkedAO3 · correct boundary logic

The input loop is the AO2 evidence of iteration and validation, and the inclusive boundary test is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Track the highest and lowest scores

Two trackers and a running total grow inside the round loop.

🧠 Step-by-step thinking

Track while the rounds are entered. Inside the inner loop, each validated score is compared with MaxScore and MinScore and added to RoundTotal.
Update with the right comparisons. A score replaces MaxScore when it is > the current highest; it replaces MinScore when it is < the current lowest.
Seed from the first round. Because the trackers start from round 1’s real score, the first comparison is always meaningful.
Total all 10. RoundTotal accumulates every score, including the two that will later be discarded.
Only one of each is discarded. If the highest score is shot twice, the tracker method still removes just one instance — the overall is always the total of 8 scores.

Maximum tracking: >Minimum tracking: <Totalling: all 10 rounds

❓ Guiding questions – think before revealing

Why seed the trackers from round 1 rather than from 0 and 31?
Why can the discard not happen during the loop?
What does RoundTotal contain at the end of the loop?

Reveal suggested reasoning

Why seed the trackers from round 1 rather than from 0 and 31? Seeding from the first real score guarantees both trackers hold genuine data before the first comparison, and neither tracker can misfire whatever scores arrive. Sentinel values such as −1 and 31 also work, but round-1 seeding is the safer habit.

Why can the discard not happen during the loop? You cannot know a score is disposable until all 10 are in — a later round can tie or beat it. The subtraction RoundTotal − MaxScore − MinScore happens only after NEXT RoundCounter.

What does RoundTotal contain at the end of the loop? The sum of all 10 validated scores. The two discards are subtracted from it in the next stage, leaving exactly the 8 counting scores.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Inside the inner loop, after the score is validated and stored
RoundTotal ← RoundTotal +
    CompetitorScore[CompetitorCounter, RoundCounter]

IF CompetitorScore[CompetitorCounter, RoundCounter] > MaxScore
THEN
    MaxScore ← CompetitorScore[CompetitorCounter, RoundCounter]
ENDIF

IF CompetitorScore[CompetitorCounter, RoundCounter] < MinScore
THEN
    MinScore ← CompetitorScore[CompetitorCounter, RoundCounter]
ENDIF

📖 Detailed explanation

Two independent IFs. A score cannot be both a new highest and a new lowest, but the two tests stay separate so either tracker can update on its own round.

The trackers follow the data. By the time the loop ends, MaxScore and MinScore hold exactly the two scores the question says must be discarded.

The total is deliberately complete. RoundTotal includes the extremes; subtracting them removes exactly one highest and one lowest, leaving 8 scores.

⚠️ Common mistakes

Updating only MaxScore and forgetting MinScore, so the lowest score is never discarded.
Trying to delete the extreme scores from the array — subtraction achieves the discard with no array surgery.
Subtracting the extremes inside the round loop, before the real highest and lowest are known.
Forgetting to re-seed the trackers for the next competitor, so one archer’s extremes contaminate the next.

💡 Exam hack / tip

The discard is arithmetic, not deletion: OverallScore ← RoundTotal − MaxScore − MinScore. Ten scores minus two extremes always leaves eight — no second array required.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · maximum and minimum trackingR3 · discard logicAO3 · correct comparisons

This stage supplies the maximum- and minimum-tracking evidence for AO2 and the comparison correctness for AO3. These are alignment notes, not separately allocated marks.

Calculate the overall score from the remaining 8

One subtraction line, placed after the round loop closes.

🧠 Step-by-step thinking

Wait for NEXT RoundCounter. The overall is calculated only when all 10 scores are in and both trackers are final.
One subtraction line. OverallScore ← RoundTotal − MaxScore − MinScore produces the total of the remaining 8 scores.
Check the arithmetic on a boundary. A row totalling 263 with a highest of 29 and a lowest of 24 leaves exactly 210 — the lowest qualifying overall.
No rounding is needed. Every score is a whole number, so the overall is a whole number — no INT() trick appears in this solution.
Keep it per competitor. The calculation sits inside the outer loop, between the two NEXT statements.

Discard: total − max − minPosition: after NEXT RoundCounterWhole-number arithmetic

❓ Guiding questions – think before revealing

Why is the calculation placed after the inner loop?
How do you know the result is the “total of the remaining 8 scores”?
Could the overall be computed a second way?

Reveal suggested reasoning

Why is the calculation placed after the inner loop? RoundTotal, MaxScore and MinScore are only complete once all 10 rounds are processed. Computing earlier would use part-finished trackers.

How do you know the result is the “total of the remaining 8 scores”? The row total counts all 10; removing the highest and the lowest once each leaves exactly 8 scores’ worth. 263 − 29 − 24 = 210 is exactly such an 8-score total.

Could the overall be computed a second way? Yes — by totalling only the non-extreme scores in a second pass. The subtraction method needs no second loop and cannot miscount ties, because each tracker holds its extreme once.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

    NEXT RoundCounter

    // The 8 scores left after discarding the highest and the lowest
    OverallScore ← RoundTotal - MaxScore - MinScore
    // e.g. 263 - 29 - 24 = 210

📖 Detailed explanation

Position is everything. The line sits after NEXT RoundCounter and before the outcome selection — the row is finished, the banding has not started.

The examiners’ wording maps directly. “The total of the remaining 8 scores (after discarding the highest and lowest scores)” is exactly RoundTotal − MaxScore − MinScore.

Whole-number arithmetic. Scores are integers, so no rounding function appears anywhere in this solution — do not invent one.

⚠️ Common mistakes

Using the 10-score total in the band tests, which inflates every competitor’s outcome.
Subtracting the highest twice when two rounds tie for highest — the tracker holds the value once.
Forgetting to re-seed RoundTotal for the next competitor, so totals accumulate across rows.
Dividing by 8 to produce an average — the question never asks for one.

💡 Exam hack / tip

Sanity-check with a boundary: 263 − 29 − 24 = 210. If a hand trace cannot reproduce a boundary overall exactly, the discard arithmetic is wrong somewhere.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · derived calculationR3 · 8-score overallAO3 · accurate arithmetic

The discard subtraction is the R3 evidence and its placement after the inner loop is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Band the overall score and output each outcome

A three-way selection tests 210 first, then 180, then nothing.

R4 · R5

🧠 Step-by-step thinking

Test the top band first. IF OverallScore >= 210 catches every competitor who moves onto the next competition — including exactly 210.
Nest the reserve test in the ELSE. IF OverallScore >= 180 inside the ELSE branch catches 180–209, because anything 210 or above has already been taken.
The final ELSE is “does not qualify”. Anything below 180 lands there — no third condition is needed.
Output the name with the outcome. The message reads the name from CompetitorName[CompetitorCounter] and states the outcome in words.
Increment the matching counter. Each branch adds 1 to QualifiedTotal, ReserveTotal or NotQualifiedTotal.

Bands: >= 210, >= 180, ELSENested IF inside ELSECounter inside each branch

❓ Guiding questions – think before revealing

Why test >= 210 before >= 180?
What happens to an overall of exactly 180?
Why update the counter inside the branch?

Reveal suggested reasoning

Why test >= 210 before >= 180? The bands are ordered: 210 or more qualifies, 180 to 209 is reserve, below 180 does not qualify. Testing the top band first means the ELSE branch only ever sees scores below 210, so >= 180 there means exactly 180 to 209.

What happens to an overall of exactly 180? It fails >= 210, passes >= 180 and becomes a reserve competitor — “between 180 and 209 inclusive” includes both ends. The sample includes an archer on exactly 180 to test this.

Why update the counter inside the branch? The counter must match the message. Incrementing outside the selection, or in the wrong branch, desynchronises the counts from the outputs.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

IF OverallScore >= 210
THEN
    OUTPUT CompetitorName[CompetitorCounter] ,
        " moves onto the next competition"
    QualifiedTotal ← QualifiedTotal + 1
ELSE
    IF OverallScore >= 180
    THEN
        OUTPUT CompetitorName[CompetitorCounter] ,
            " is a reserve competitor"
        ReserveTotal ← ReserveTotal + 1
    ELSE
        OUTPUT CompetitorName[CompetitorCounter] ,
            " does not qualify"
        NotQualifiedTotal ← NotQualifiedTotal + 1
    ENDIF
ENDIF

📖 Detailed explanation

Boundary wording becomes operators. “210 or more” is >= 210; “between 180 and 209 inclusive” is handled by >= 180 in the ELSE; “below 180” needs no operator at all.

Nested selection is the expected shape. A three-way band is written as an IF inside the ELSE of the first test — the shape Cambridge mark schemes expect.

Every output carries a message. The name alone is not a “suitable message” — the outcome must be stated in words beside it.

⚠️ Common mistakes

Testing > 210, which wrongly drops exactly-210 competitors into the reserve band.
Testing the reserve band as > 180, so an overall of exactly 180 does not qualify.
Writing three separate top-level IFs and letting an overall of 215 match two branches.
Counting the outcomes but forgetting to output each competitor’s name and outcome.

💡 Exam hack / tip

Walk each boundary through your selection with a finger: 210 → branch 1, 209 → branch 2, 180 → branch 2, 179 → branch 3. Four checks, four correct landings.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · three-way selectionR4 · R5 · outcomes output and countedAO3 · boundary correctness

The banded selection is the AO2 selection evidence, and the >= boundaries with in-branch counting are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Close the loop and output the three counts

After the loop, report qualified, reserve and do-not-qualify once.

🧠 Step-by-step thinking

Close the outer loop. NEXT CompetitorCounter ends each competitor’s processing only when the outcome and its counter update are done.
Output the three counts once. After the loop, QualifiedTotal, ReserveTotal and NotQualifiedTotal are final.
Label every count. Each number needs a message naming its group — “Reserve competitors: ”, for example.
Check they total the field. The three counts must sum to 30 in the real program (2 + 2 + 1 = 5 in the sample) — a quick self-test.
Nothing follows the summary. The counts are the last outputs; nothing is left inside the loop by mistake.

Loop closureThree labelled countsSelf-test: counts sum to the field

❓ Guiding questions – think before revealing

Why must the counts be output after NEXT CompetitorCounter?
What does a suitable count message look like?
How can you self-test the counts?

Reveal suggested reasoning

Why must the counts be output after NEXT CompetitorCounter? The counters only reach their final values once every competitor has been banded. Outputting inside the loop would print half-finished totals thirty times.

What does a suitable count message look like? For example: OUTPUT "Reserve competitors: " , ReserveTotal — the label names the group and the value completes it.

How can you self-test the counts? Add the three outputs: they must equal the number of competitors processed — 30 in the real program, 5 in the sample (2 + 2 + 1).

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

NEXT CompetitorCounter

// Every competitor has been banded - the counters are final
OUTPUT "Competitors who qualified for the next competition: " ,
    QualifiedTotal
OUTPUT "Reserve competitors: " , ReserveTotal
OUTPUT "Competitors who do not qualify: " , NotQualifiedTotal

📖 Detailed explanation

Loop closure completes the structure. Everything per competitor — input, validation, tracking, overall, outcome, counting — sits between FOR and NEXT CompetitorCounter.

Three outputs, three labels. The question lists the counts as three separate groups, so three labelled outputs are the faithful response.

The summary mirrors the bullets. Checking the final outputs against the bullet list is the fastest completeness test in the exam.

⚠️ Common mistakes

Leaving the count outputs inside the competitor loop, printing running totals after every competitor.
Outputting bare numbers with no message, losing the “suitable messages” requirement.
Reporting only two of the three groups — the question asks for all three.
Resetting the counters after the loop instead of before it.

💡 Exam hack / tip

Final-read the bullets against your last lines: qualified — reserve — do not qualify. If each group has a labelled output after the loop, the last requirement is complete.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · summary outputsR5 · three counts reportedAO3 · loop closure and messages

The summary delivers the remaining R5 outputs, and its position after the loop 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–R5	Identifies input, validation, discard, banding and counting.	Establishes logical order and comments plan.
2 · Data	Required data structures	Trackers, running total, overall value and three outcome counters.	Meaningful identifiers; given arrays reused exactly.
3 · Input	R1, R2	Nested input loops with WHILE validation storing into CompetitorScore[,].	Correct 0–30 inclusive boundary test.
4 · Discard	R3	Highest and lowest tracked during the rounds, seeded from round 1.	Correct > and < comparisons.
5 · Overall	R3	OverallScore as RoundTotal − MaxScore − MinScore after the round loop.	Accurate arithmetic in the right position.
6 · Outcome	R4, R5	Three-band selection outputs name + outcome and updates counters.	>= 210 and >= 180 boundaries correct.
7 · Summary	R5	Loop closed; three labelled counts output once.	Suitable messages on every output.

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

// Declarations are assumed (question instruction) - CompetitorName[] and
// CompetitorScore[,] are the given arrays and are filled by this program.
// The three outcome counters start at zero before any competitor is processed.
QualifiedTotal ← 0
ReserveTotal ← 0
NotQualifiedTotal ← 0

// Process every competitor (the maximum is 30)
FOR CompetitorCounter ← 1 TO 30
    // Input and validate round 1, then seed the trackers from that score
    OUTPUT "Enter the score for round 1 for " , CompetitorName[CompetitorCounter]
    INPUT CompetitorScore[CompetitorCounter, 1]
    WHILE CompetitorScore[CompetitorCounter, 1] < 0 OR CompetitorScore[CompetitorCounter, 1] > 30
        OUTPUT "Invalid score - enter a value between 0 and 30 inclusive"
        INPUT CompetitorScore[CompetitorCounter, 1]
    ENDWHILE
    MaxScore ← CompetitorScore[CompetitorCounter, 1]    // highest so far
    MinScore ← CompetitorScore[CompetitorCounter, 1]    // lowest so far
    RoundTotal ← CompetitorScore[CompetitorCounter, 1]  // total of rounds so far

    // Rounds 2 to 10: input, validate, total, and track highest and lowest
    FOR RoundCounter ← 2 TO 10
        OUTPUT "Enter the score for round " , RoundCounter , " for " , CompetitorName[CompetitorCounter]
        INPUT CompetitorScore[CompetitorCounter, RoundCounter]
        WHILE CompetitorScore[CompetitorCounter, RoundCounter] < 0 OR CompetitorScore[CompetitorCounter, RoundCounter] > 30
            OUTPUT "Invalid score - enter a value between 0 and 30 inclusive"
            INPUT CompetitorScore[CompetitorCounter, RoundCounter]
        ENDWHILE
        RoundTotal ← RoundTotal + CompetitorScore[CompetitorCounter, RoundCounter]
        IF CompetitorScore[CompetitorCounter, RoundCounter] > MaxScore THEN
            MaxScore ← CompetitorScore[CompetitorCounter, RoundCounter]   // new highest
        ENDIF
        IF CompetitorScore[CompetitorCounter, RoundCounter] < MinScore THEN
            MinScore ← CompetitorScore[CompetitorCounter, RoundCounter]   // new lowest
        ENDIF
    NEXT RoundCounter

    // Discard the highest and the lowest: the overall is the total of the other 8 scores
    OverallScore ← RoundTotal - MaxScore - MinScore

    // Band the overall score, output the outcome and update the matching counter
    IF OverallScore >= 210 THEN
        OUTPUT CompetitorName[CompetitorCounter] , " moves onto the next competition"
        QualifiedTotal ← QualifiedTotal + 1
    ELSE
        IF OverallScore >= 180 THEN
            OUTPUT CompetitorName[CompetitorCounter] , " is a reserve competitor"
            ReserveTotal ← ReserveTotal + 1
        ELSE
            OUTPUT CompetitorName[CompetitorCounter] , " does not qualify"
            NotQualifiedTotal ← NotQualifiedTotal + 1
        ENDIF
    ENDIF
NEXT CompetitorCounter

// Every competitor has been banded - output the three required counts
OUTPUT "Competitors who qualified for the next competition: " , QualifiedTotal
OUTPUT "Reserve competitors: " , ReserveTotal
OUTPUT "Competitors who do not qualify: " , NotQualifiedTotal

Why this is a complete response

It covers the five mark-scheme requirements: every round score is input with a suitable prompt (R1), each entry is validated between 0 and 30 inclusive and re-entered until valid (R2), the overall score discards the highest and lowest to leave the total of the remaining 8 (R3), each competitor’s name and outcome is output with a suitable message (R4), and the three counts are calculated and output after the loop (R5).

What to check before submitting

Check the WHILE validation accepts 0 and 30, the trackers are re-seeded for every competitor, the subtraction happens after NEXT RoundCounter, the >= 210 and >= 180 boundaries, the counter updates inside the matching branches, 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 competition. Watch each score pass the 0–30 gate, the highest and lowest trackers change hands, the extremes get discarded, and each overall land in one of the three bands.

Last tab · Trace player

Sample input → expected results

Five sample competitors each shoot 10 rounds (Competitors = 5 in this trace; the real program loops to the maximum of 30, and every score is out of 30). The sample deliberately tests both boundaries: Priya’s discards leave exactly 210, the lowest overall that moves onto the next competition, and Marcus’s leave exactly 180, the lowest reserve score. Chen’s first entry of 35 for round 1 is rejected by the 0–30 validation and re-entered as 27. These are illustrative values, not data supplied by the examination question.

Input arrays CompetitorName[] and CompetitorScore[,]

Competitor	Round 1	Round 2	Round 3	Round 4	Round 5	Round 6	Round 7	Round 8	Round 9	Round 10

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

Reveal expected competitor results and outcome summary

Expected competitor results After all 10 rounds are processed

Competitor	Round total	Highest	Lowest	Overall	Outcome

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Outcome counters

Ready

Tip: use Next step slowly and watch MaxScore, MinScore and RoundTotal climb during the round loop. The trackers are re-seeded for every competitor, but the three outcome counters never reset.

Trace colours: blue row = current competitor; amber cell = the round score being entered; green cells = rounds already input and processed.

Boundary examples: Priya’s 10 rounds total 263, so discarding the 29 and the 24 leaves 263 − 29 − 24 = 210 — exactly on the qualified boundary because the test is >= 210. Marcus’s 225 − 27 − 18 = 180 lands on the reserve boundary because “between 180 and 209 inclusive” includes 180. Chen’s first entry of 35 fails 35 > 30 and is re-entered as 27.

From ten rounds on the range to a qualification verdict.

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

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Track the highest and lowest scores

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Calculate the overall score from the remaining 8

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Band the overall score and output each outcome

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Close the loop and output the three counts

🧠 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 10 rounds are processed

Execution trace

Initialisation

Live variable values

Outcome counters