15-mark question lab · start here

From double-checked times to prizes and certificates.

Build the solution in a sensible order: understand the parallel arrays, input every time twice and verify the pair, sort both arrays together in ascending order of time, award First, Second and Third, then fill MemberCertificate[] with its own counter and report how many certificates to print. Learn the reasoning before revealing the complete program.

Parallel arraysInput verificationAscending sortStrict boundary < 240Building an array15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the pre-stored MemberName[], the MemberTime[] your program fills, and the MemberCertificate[] your program builds, all sharing one index until the sort moves them.

02 · Construct

Wrap each time in a REPEAT...UNTIL double-input check, then bubble-sort MemberTime[] and MemberName[] together, ascending, swapping both arrays on every exchange.

03 · Complete

Read the podium straight off positions 1 to 3 as First, Second and Third, pack the under-240 names into MemberCertificate[] with a counter of its own, and output the certificate count in a message.

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 parallel-array swap, the direction of the sort, the strict under-240 boundary and the certificate array’s own counter all decide whether your answer earns the marks.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/21 · Question 11

A running club has 200 members who compete in a 1-kilometre running competition every month.
Members’ names are stored in the one-dimensional (1D) array MemberName[]
Each member’s time, in seconds, for the 1-kilometre run will be stored in another one-dimensional (1D) array MemberTime[]
The position of each member’s data in the two arrays is the same. For example, the member stored at index 10 in MemberName[] and at index 10 in MemberTime[] is the same.

The running club awards a small prize to the members who have the top three times. The club also awards certificates to all members with a time under 240 seconds.

Write a program that meets the following requirements:

allows members’ times to be input twice and verifies that the inputs match
sorts the arrays MemberTime[] and MemberName[] in ascending order of time
outputs the member names and times of the members with the top three times and identifies them as First, Second and Third
stores the names of all the members who will receive a certificate in the array MemberCertificate[]
outputs a message stating the number of certificates to be printed.

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

You do not need to initialise the data in the array MemberName[]

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 every member’s time twice and repeat until the two entries match, storing only verified times into MemberTime[].

Sort MemberTime[] and MemberName[] together in ascending order of time, swapping both arrays on every exchange.

Output the names and times at positions 1 to 3 after the sort, identified as First, Second and Third.

Store the names of every member with a time under 240 seconds in MemberCertificate[], packed tight with its own counter.

Output a message stating the number of certificates to be printed.

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 three arrays and who fills them. MemberName[] arrives pre-stored with all 200 names; MemberTime[] is filled by your verified inputs; MemberCertificate[] is built by your final loop. One shared index joins the first two — until the sort moves them together.
Spot the verification requirement. Times are input twice and the inputs are verified to match — a REPEAT...UNTIL loop whose condition compares the two entries. Only a matching pair escapes the loop and reaches the array.
Spot the sort and its direction. Both arrays must be sorted in ascending order of time. Ascending means smallest first — and in a race the smallest number of seconds is the fastest runner, so the winners end up at positions 1, 2 and 3.
Translate the award rules. The prize goes to the top three times — the first three rows after the sort. Certificates go to every time under 240 seconds — strictly less than, so exactly 240 misses out.
Build the order. verify each time into MemberTime[] → sort both arrays ascending → output First/Second/Third from positions 1–3 → fill MemberCertificate[] with its own counter → output the certificate count.

Input: twice, verifiedSort: ascending, parallelSelection: strictly under 240Output: First/Second/Third

❓ Guiding questions – think before revealing

Which arrays does the program input, and which does it only read or build?
What does “top three times” mean when times are in seconds?
Why does the certificate rule need care at exactly 240?

Reveal suggested reasoning

Which arrays does the program input, and which does it only read or build? MemberTime[] is the only array filled by INPUT. MemberName[] is pre-stored and only read; MemberCertificate[] is written by the certificate loop and never input.

What does “top three times” mean when times are in seconds? The three fastest runs, which are the three smallest numbers. An ascending sort puts them at positions 1 to 3. Sorting descending instead would crown the slowest runners — a classic misread of this question.

Why does the certificate rule need care at exactly 240? “Under 240 seconds” is a strict test: 240 < 240 is FALSE. A member who runs exactly 240 seconds receives no certificate — the sample deliberately includes such a runner.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Fill MemberTime[] with verified times
FOR MemberCounter ← 1 TO 200
    // input the time twice; repeat until the pair matches
    // store the verified time
NEXT MemberCounter

// Sort MemberTime[] and MemberName[] together, ascending
// Output positions 1, 2 and 3 as First, Second, Third
// Fill MemberCertificate[] with names under 240 seconds
// Output how many certificates to print

📖 Detailed explanation

“Input twice and verifies that the inputs match” is a loop with a built-in comparison: enter, re-enter, compare, and repeat the whole pair on a mismatch.

“Sorts the arrays … in ascending order of time” means both arrays move together — every swap in MemberTime[] needs a mirror swap in MemberName[].

“Identifies them as First, Second and Third” is satisfied by putting those words inside the three output messages.

“Stores the names … in the array MemberCertificate[]” demands writing into a new array — and because only some members qualify, that array needs a counter of its own.

“Outputs a message stating the number of certificates” is one final output — words and number together, after the loop.

⚠️ Common mistakes

Starting to write code before listing the five required behaviours.
Sorting only MemberTime[] and leaving MemberName[] behind, so names no longer match their times.
Reading “top three times” as the three largest numbers and sorting descending.
Forgetting that the closing lines remove the usual chores: names are pre-stored and nothing needs declaring.

💡 Exam hack / tip

Underline “input twice”, “ascending order of time”, “First, Second and Third”, “in the array MemberCertificate[]” and “under 240 seconds”. Those five phrases are the whole mark scheme: a verification loop, a parallel ascending sort, three labelled outputs, a filled array and a counted message.

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

Required data structures

🧠 Step-by-step thinking

Use the given names. MemberName[], MemberTime[] and MemberCertificate[] are named by the question — your program must use them exactly, creating and filling the certificate array under that name.
Note what is already stored. MemberName[] is pre-loaded with all 200 names — the question says you do not need to initialise it. MemberTime[] starts empty: your verification loop fills it position by position.
Add the loop counters. MemberCounter walks the members when times are input and again when certificates are collected; IndexCounter compares adjacent positions inside the sort.
Add the verify and swap variables. TimeFirst and TimeSecond hold the double input; TempTime and TempName hold values mid-swap; Swapped lets the sort stop early.
Give the certificate array its own counter. CertCount counts qualifying members and indexes MemberCertificate[]. It is not the member loop counter — only some members qualify, so the two counts drift apart.

Given: MemberName[] · MemberTime[] · MemberCertificate[]Counters: MemberCounter, IndexCounter, CertCountWorking: TimeFirst, TimeSecond, TempTime, TempName, Swapped

❓ Guiding questions – think before revealing

Why does MemberCertificate[] need its own counter?
Why do TempTime and TempName both exist?
Why can’t the time be stored straight into MemberTime[]?

Reveal suggested reasoning

Why does MemberCertificate[] need its own counter? Only members under 240 seconds belong in it. If you indexed it with MemberCounter, a non-qualifier’s slot would sit inside the list with gaps around it. CertCount advances only when a name is stored, so the qualifiers are packed into slots 1 to CertCount.

Why do TempTime and TempName both exist? A swap overwrites one cell before that cell can be copied onward, so each array needs its own temporary holder. Two temporaries keep the time swap and the name swap independent and impossible to interleave wrongly.

Why can’t the time be stored straight into MemberTime[]? Until the second entry has confirmed the first, the value is unverified. Storing before the match check would put an unchecked time into the array that the loop might never correct.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// The question says declarations are already done — but plan them anyway:
// MemberCounter, IndexCounter : INTEGER   loop counters
// TimeFirst, TimeSecond       : INTEGER   the double input
// TempTime                    : INTEGER   swap holder for times
// TempName                    : STRING    swap holder for names
// Swapped                     : BOOLEAN   sort early-exit flag
// CertCount                   : INTEGER   next free slot in MemberCertificate[]

// Given/assumed by the question:
// MemberName[]   MemberTime[]   MemberCertificate[]

📖 Detailed explanation

MemberCertificate[] is written, never read. The question asks you to store names into it and then report how many — its contents never feed a later calculation, so a simple counter is all it needs.

The two input variables make verification possible. TimeFirst and TimeSecond must both exist to be compared; that comparison is the verification the first bullet demands.

Swapped turns a fixed pass count into a smart loop. The array may finish sorting before 199 passes. The flag lets REPEAT ... UNTIL Swapped = FALSE stop as soon as a pass makes no swap.

⚠️ Common mistakes

Indexing MemberCertificate[] with the member counter, leaving gaps where members missed the cut.
Overwriting TimeFirst with the second input before the two have been compared.
Using one temporary for both arrays in the same swap sequence and losing a name or a time.
Renaming the arrays (for example Times[]), which the mark scheme treats as not using the given structures.

💡 Exam hack / tip

Borrow the question’s own words for identifiers: MemberCounter, TimeFirst, TempName, CertCount. 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.

Initialise the flag and the certificate counter

The question strips the usual set-up work away — start only what your own loops need.

R2 · R4

🧠 Step-by-step thinking

Initialise almost nothing — deliberately. The closing lines remove the usual chores: MemberName[] is pre-stored and no declarations are needed. Say so in a comment so the examiner sees you noticed.
Reset the sort flag every pass. Swapped ← FALSE at the top of each pass. It must not remember a swap from an earlier pass, or the sort never terminates.
Start the certificate counter at zero. CertCount ← 0 immediately before the certificate loop — a stale count would send every stored name to the wrong slot.
No totals exist in this question. Nothing is summed or averaged — a rare question with no running total. Do not invent one to look busy.
MemberTime[] fills itself. Position MemberCounter receives a verified time each pass; pre-filling it would be wasted effort that invites errors.

Given: MemberName[] pre-storedEvery pass: Swapped ← FALSEBefore its loop: CertCount ← 0

❓ Guiding questions – think before revealing

Why is there no total to initialise?
Where exactly does CertCount ← 0 go?
Why reset Swapped inside the sort loop rather than once before it?

Reveal suggested reasoning

Why is there no total to initialise? The question counts, sorts and copies — it never adds times together. The only accumulator is CertCount, and it is set immediately before the loop that uses it.

Where exactly does CertCount ← 0 go? Just before the certificate loop. It must be correct when the first qualifying name is stored, and nothing else in the program uses it.

Why reset Swapped inside the sort loop rather than once before it? Each pass needs a fresh answer to “did this pass swap anything?”. A flag left TRUE from the previous pass would keep the loop running forever after the array is already sorted.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Nothing to declare and no names to initialise — the question says so:
// MemberName[] arrives already stored with all 200 names.

// The sort manages its own fresh start on every pass
REPEAT
    Swapped ← FALSE                    // a clean flag for every pass
    FOR IndexCounter ← 1 TO 199
        // compare and maybe swap; Swapped ← TRUE on any swap
    NEXT IndexCounter
UNTIL Swapped = FALSE

// The certificate counter starts immediately before its loop
CertCount ← 0                           // no certificates stored yet

📖 Detailed explanation

“Once” versus “every pass” still applies, just smaller: CertCount is set once before its loop; Swapped is reborn at the top of every sort pass.

Saying what you did NOT do earns credit. A one-line comment — names pre-stored, declarations assumed — shows the examiner your omissions are choices, not oversights.

An empty start state is still a start state. CertCount ← 0 and Swapped ← FALSE are the whole initialisation; both are load-bearing.

⚠️ Common mistakes

Inventing a grand total or average that the question never asks for.
Setting CertCount ← 0 inside the certificate loop, so every store lands in slot 1.
Leaving Swapped ← TRUE from the previous pass, so the sort never terminates.
Pre-filling MemberTime[] with zeros — harmless here but pointless code that can hide a real error.

💡 Exam hack / tip

This question inverts the usual advice: the safest initialisation is the smallest possible. Point at each variable and ask “who sets this first?” — if the answer is “a loop that runs before any read”, you are done.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR2 · R4 · flag and counter setAO3 · reliable logic

Initialisation supports AO2 because the flag and counter genuinely store the required state, and AO3 because the logic starts from a reliable position. These are alignment notes, not separately allocated marks.

Input every time twice and verify the pair

A REPEAT...UNTIL loop guards the door to MemberTime[].

🧠 Step-by-step thinking

Wrap the double input in REPEAT...UNTIL. INPUT the time, INPUT it again, and UNTIL TimeFirst = TimeSecond repeats the whole pair on a mismatch.
Output a prompt before every input. “All inputs and outputs must contain suitable messages” — each INPUT needs a message naming the member whose time is expected.
Reject with a message, not silence. On a mismatch, an OUTPUT inside the loop tells the user to try again. That message is what makes the word verifies visible to the examiner.
Store only after the loop. MemberTime[MemberCounter] ← TimeFirst sits after UNTIL, so only verified data ever reaches the array.
Names are never input. The prompt reads the name from MemberName[MemberCounter] — but the name itself is not input; the question says it is already stored.

REPEAT...UNTIL TimeFirst = TimeSecondSuitable messages on every INPUTStore after UNTIL, never before

❓ Guiding questions – think before revealing

Why REPEAT...UNTIL rather than WHILE...ENDWHILE?
What exactly is compared, and what happens on a mismatch?
Why not store the first input immediately?

Reveal suggested reasoning

Why REPEAT...UNTIL rather than WHILE...ENDWHILE? The pair must be entered at least once, and a mismatch sends you straight back for another pair. REPEAT ... UNTIL TimeFirst = TimeSecond expresses “enter, check, repeat until matching” with no duplicated INPUT statements outside the loop. A WHILE with a priming read also earns credit.

What exactly is compared, and what happens on a mismatch? The two most recent entries. If TimeFirst <> TimeSecond, output a suitable “do not match” message; the UNTIL condition is still FALSE, so the loop runs the whole pair again.

Why not store the first input immediately? Until the second entry matches it, the first input is unverified. Storing early would put an unchecked value into MemberTime[] that the loop may never correct — and a later re-entry would overwrite nothing.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR MemberCounter ← 1 TO 200
    REPEAT
        OUTPUT "Enter the time in seconds for ", MemberName[MemberCounter]
        INPUT TimeFirst
        OUTPUT "Re-enter the time for ", MemberName[MemberCounter], " to verify"
        INPUT TimeSecond
        IF TimeFirst <> TimeSecond
        THEN
            OUTPUT "Inputs do not match - please enter the time again"
        ENDIF
    UNTIL TimeFirst = TimeSecond
    MemberTime[MemberCounter] ← TimeFirst   // verified only
NEXT MemberCounter

📖 Detailed explanation

The UNTIL condition is the verification. The loop only ends when the two entries are equal, so every stored time has been confirmed twice — exactly what “verifies that the inputs match” asks for.

The IF gives the mismatch its message. Without it a mismatch loops again silently. The loop would still work, but the required evidence — a suitable message — would be missing.

The prompt reuses the shared index. MemberName[MemberCounter] personalises each message and proves you understood that position i in both arrays is the same member.

⚠️ Common mistakes

Comparing TimeFirst with itself, or with MemberTime[MemberCounter], instead of with the second input.
Placing MemberTime[MemberCounter] ← TimeFirst inside the loop before UNTIL.
Forgetting the mismatch message — the loop works but the verification is invisible.
Inputting the member’s name as well as the time.

💡 Exam hack / tip

Trace the loop with a mismatch on paper: 218 then 281 → message → 218 then 218 → match → store. If your pencil ever escapes the loop with two different numbers, the UNTIL condition is wrong.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration with validationR1 · double input verifiedAO3 · suitable messages on inputs

The verification loop is the AO2 evidence for validation, and the prompt messages are the AO3 evidence for suitable communication. These are alignment notes, not separately allocated marks.

Sort both arrays in ascending order of time

A parallel bubble sort — every swap moves a time and its name together.

🧠 Step-by-step thinking

Sort ascending: smallest first. A time in seconds is a speed in disguise — the smallest number is the fastest runner. Ascending order puts the winner at position 1.
Swap both arrays or ruin them. Whenever MemberTime[i] and MemberTime[i + 1] swap, MemberName[i] and MemberName[i + 1] must swap too, or names detach from their times.
Use two temporaries. TempTime protects one time during its swap; TempName does the same for the name. The six swap lines form one atomic block.
Let a flag end the sort. Swapped ← FALSE at the top of each pass, TRUE on any swap; REPEAT ... UNTIL Swapped = FALSE stops after the first pass with no swaps.
200 members means 199 comparisons per pass. The pass compares each adjacent pair from 1 to 199; every pass leaves the largest remaining time settled at the end.

Direction: ascending (fastest first)Parallel swap: time + nameEarly exit: Swapped flag

❓ Guiding questions – think before revealing

Why must the name swap mirror the time swap?
Why does ascending order put the prize winners first?
How does the flag improve a fixed pass count?

Reveal suggested reasoning

Why must the name swap mirror the time swap? The question’s arrays are parallel — index 10 in both is the same member. Sorting the times alone shuffles times past their owners, and First place would be awarded to the wrong name. The two swaps are one operation.

Why does ascending order put the prize winners first? “Top three times” in a race means fastest, which is smallest in seconds. After an ascending sort those three are MemberTime[1..3] — the question then literally asks for the first three rows.

How does the flag improve a fixed pass count? Without it you would always run 199 passes. With it, a pass that makes no swap proves every adjacent pair is ordered, so the loop can stop — the sample below finishes sorting after two passes.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

REPEAT
    Swapped ← FALSE
    FOR IndexCounter ← 1 TO 199
        IF MemberTime[IndexCounter] > MemberTime[IndexCounter + 1]
        THEN
            TempTime ← MemberTime[IndexCounter]
            MemberTime[IndexCounter] ← MemberTime[IndexCounter + 1]
            MemberTime[IndexCounter + 1] ← TempTime
            TempName ← MemberName[IndexCounter]
            MemberName[IndexCounter] ← MemberName[IndexCounter + 1]
            MemberName[IndexCounter + 1] ← TempName
            Swapped ← TRUE
        ENDIF
    NEXT IndexCounter
UNTIL Swapped = FALSE

📖 Detailed explanation

Adjacent-pair comparison is the bubble. Each pass lets a too-large time drift rightwards one comparison at a time until it settles; after pass 1 the largest time is guaranteed to be at the end.

The six swap lines are one atomic unit. All six must sit inside the same THEN branch — swapping times in one place and names in another leaves the arrays inconsistent mid-sort.

Strict > keeps equal times in place. Equal times do not swap, which also keeps the sort stable for members with identical runs.

⚠️ Common mistakes

Using < in the comparison, which sorts descending and crowns the slowest runners.
Swapping MemberName[] but not MemberTime[], or the other way round.
Looping IndexCounter to 200 and comparing MemberTime[200] with MemberTime[201] — past the end of the array.
Forgetting Swapped ← TRUE inside the swap, so the loop stops after one pass with the array unsorted.

💡 Exam hack / tip

Say the swap aloud: time, time, time — name, name, name — flag. Six lines, one branch, always together. If your six lines are not contiguous inside the same IF, the parallel arrays have already diverged.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · sorting with parallel arraysR2 · ascending order of timeAO3 · atomic swap block

The sort is the AO2 evidence for the hardest technique in the question, and the parallel swap block is the AO3 evidence for careful, consistent logic. These are alignment notes, not separately allocated marks.

Output the top three as First, Second and Third

The ascending sort has already lined up the podium.

🧠 Step-by-step thinking

The sort has already done the work. After ascending sorting, positions 1, 2 and 3 hold the three fastest times — no searching and no champion variables are needed.
Output name and time together. Each line needs MemberName[1] with MemberTime[1], and so on — both arrays read through the same index.
Use the words First, Second and Third. The question says the outputs must identify the members as First, Second and Third — put those words inside the messages.
Three outputs, not a search. A FOR loop from 1 to 3 that looks up an array of place names also earns credit, but three explicit OUTPUT lines are simplest and cannot mislabel a place.
Say the unit. Times are stored in seconds, so the messages should say “seconds” — suitable messages carry meaning, not just numbers.

Positions 1–3 = podiumName + time, same indexLabels inside the messages

❓ Guiding questions – think before revealing

Why are no champion variables needed here?
What would a descending sort have cost you?
Do the top three also get certificates?

Reveal suggested reasoning

Why are no champion variables needed here? The ascending sort is the search: the minimum is at position 1, the second minimum at 2, the third at 3. Re-finding them with trackers would repeat work the sort has already done.

What would a descending sort have cost you? The winners would sit at positions 200, 199 and 198, and the certificate stage would lose its tidy shape too. The direction of the sort is the hinge of the whole question.

Do the top three also get certificates? Usually yes — the fastest runners are under 240 seconds. But the two awards are independent: the prize comes from positions 1–3, the certificates from the strict under-240 test.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// The arrays are now sorted ascending by time
OUTPUT "First: ", MemberName[1], " with a time of ", MemberTime[1], " seconds"
OUTPUT "Second: ", MemberName[2], " with a time of ", MemberTime[2], " seconds"
OUTPUT "Third: ", MemberName[3], " with a time of ", MemberTime[3], " seconds"

📖 Detailed explanation

Position 1 is the champion. Ascending order means the smallest time — the fastest run — is first. The question’s “top three” and the sort direction agree.

The messages do the identifying. “Identifies them as First, Second and Third” is satisfied by the words inside the OUTPUT strings — the requirement is about communication, not computation.

Name and time share an index. Because both arrays were swapped in parallel, MemberName[2] is exactly the member whose time is MemberTime[2].

⚠️ Common mistakes

Outputting positions 198–200 after sorting ascending, which awards the slowest runners.
Printing the time without the name, or the name without the time — the bullet asks for both.
Omitting the words First, Second and Third from the messages.
Outputting the top three before the sort has finished.

💡 Exam hack / tip

Write 1 → First, 2 → Second, 3 → Third in the margin beside your sort. The moment the sort is ascending, the podium is simply the first three rows of both arrays.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · direct array accessR3 · podium named and timedAO3 · messages match the bullet

The podium outputs are the R3 evidence, and wording them with the question’s own labels is AO3 communication evidence. These are alignment notes, not separately allocated marks.

Fill MemberCertificate[] and report the count

Members under 240 seconds — stored with a counter of their own.

R4 · R5

🧠 Step-by-step thinking

One loop fills and counts. Walk the sorted array; every time under 240 seconds earns its member a name in MemberCertificate[] and advances CertCount.
MemberCertificate[] gets its own index. MemberCertificate[CertCount] ← MemberName[MemberCounter] — the certificate array is packed tight from slot 1, skipping non-qualifiers entirely.
The boundary is strict. MemberTime[MemberCounter] < 240 — exactly 240 is not under 240, so it stores nothing and counts nothing.
The sort helps, but keep the test simple. Because the array is sorted, all qualifiers sit in a prefix — but a plain IF test on all 200 positions is impossible to get wrong and is the standard answer.
Finish with the message. After the loop, OUTPUT the count in words: the bullet asks for a message stating the number of certificates to be printed.

Strict test: < 240Own counter: CertCountFinal output: message + count

❓ Guiding questions – think before revealing

Why use CertCount rather than MemberCounter as the index?
Why is exactly 240 refused?
Could the loop stop early?

Reveal suggested reasoning

Why use CertCount rather than MemberCounter as the index? MemberCounter counts every member, including those who miss the cut. CertCount counts only names actually stored, so MemberCertificate[1..CertCount] ends up holding exactly the qualifiers with no gaps.

Why is exactly 240 refused? “Under 240 seconds” is strict: 240 < 240 is FALSE. A runner of exactly 240 seconds misses a certificate by nothing — the sample’s boundary case.

Could the loop stop early? Yes — after sorting, the first time of 240 or more marks the end of the qualifiers, so a WHILE MemberTime[MemberCounter] < 240 loop could stop there. The FOR-plus-IF version visits all 200 positions but is the safest standard answer.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

CertCount ← 0   // MemberCertificate[] needs its own counter
FOR MemberCounter ← 1 TO 200
    IF MemberTime[MemberCounter] < 240
    THEN
        CertCount ← CertCount + 1
        MemberCertificate[CertCount] ← MemberName[MemberCounter]
    ENDIF
NEXT MemberCounter
OUTPUT "Number of certificates to be printed: ", CertCount

📖 Detailed explanation

Two counters, two meanings. MemberCounter answers “which member am I testing?”; CertCount answers “how many names are in the certificate list so far?”. Conflating them is the classic error in this question.

The message is a required output. The last bullet asks for a message stating the number — the words and the number together, printed once, after the loop.

The certificate array is the program’s product. MemberName[] arrived ready-made; MemberCertificate[] is what your program actually built — treat it as the evidence that R4 was met.

⚠️ Common mistakes

Storing MemberTime[...] into MemberCertificate[] — the bullet asks for names.
Using MemberCounter as the certificate index, leaving gaps for non-qualifiers.
Writing <= 240, which hands a certificate to exactly-240 runners.
Outputting CertCount bare, with no message around it.

💡 Exam hack / tip

Test the boundary by hand: is 239 a certificate? Yes. Is 240? No. Write < 240 and annotate it “under, strict”. One character is the difference between a right and a wrong certificate list.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selection and array buildingR4 · R5 · names stored and countedAO3 · strict boundary and suitable message

The certificate loop supplies the selection, array-building and counting evidence for AO2, and the strict boundary plus final message support 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 full set of required techniques.	Establishes logical order and comments plan.
2 · Data	Required data structures	Parallel arrays plus verify, swap and certificate variables.	Meaningful identifiers throughout.
3 · Initialise	R2, R4	Sort flag and certificate counter started correctly; no invented totals.	Clear comments and reliable starting state.
4 · Verify	R1	Double-input REPEAT...UNTIL verification with suitable messages.	Store happens only after the match.
5 · Sort	R2	Ascending adjacent-pair sort swapping both arrays together.	Correct comparison direction and two temporaries.
6 · Top three	R3	First three positions output by name and time with place labels.	Messages contain First, Second and Third.
7 · Awards	R4, R5	Under-240 test fills MemberCertificate[] and the count is output.	Own counter for MemberCertificate[]; strict boundary.

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

// MemberName[] already holds the 200 members' names.
// MemberTime[] is filled in by this program; MemberCertificate[] is built here.
// No declarations or initialisation of given data are needed (see question).

// ----- Input each time twice and verify that the inputs match -----
FOR MemberCounter ← 1 TO 200
    REPEAT
        OUTPUT "Enter the time in seconds for ", MemberName[MemberCounter]
        INPUT TimeFirst
        OUTPUT "Re-enter the time for ", MemberName[MemberCounter], " to verify"
        INPUT TimeSecond
        IF TimeFirst <> TimeSecond
        THEN
            OUTPUT "The two inputs do not match - please enter the time again"
        ENDIF
    UNTIL TimeFirst = TimeSecond      // only a matching pair escapes the loop
    MemberTime[MemberCounter] ← TimeFirst   // store the verified time
NEXT MemberCounter

// ----- Sort MemberTime[] and MemberName[] ascending by time -----
// Bubble sort: on each pass the largest remaining time sinks to the end.
// Every swap of times carries the matching swap of names with it.
REPEAT
    Swapped ← FALSE
    FOR IndexCounter ← 1 TO 199       // compare each adjacent pair
        IF MemberTime[IndexCounter] > MemberTime[IndexCounter + 1]
        THEN
            // swap the times ...
            TempTime ← MemberTime[IndexCounter]
            MemberTime[IndexCounter] ← MemberTime[IndexCounter + 1]
            MemberTime[IndexCounter + 1] ← TempTime
            // ... and the names, so each name keeps its own time
            TempName ← MemberName[IndexCounter]
            MemberName[IndexCounter] ← MemberName[IndexCounter + 1]
            MemberName[IndexCounter + 1] ← TempName
            Swapped ← TRUE
        ENDIF
    NEXT IndexCounter
UNTIL Swapped = FALSE                 // a pass with no swap means sorted

// ----- Output the top three (first three after an ascending sort) -----
OUTPUT "First: ", MemberName[1], " with a time of ", MemberTime[1], " seconds"
OUTPUT "Second: ", MemberName[2], " with a time of ", MemberTime[2], " seconds"
OUTPUT "Third: ", MemberName[3], " with a time of ", MemberTime[3], " seconds"

// ----- Store certificate names and output the number to print -----
CertCount ← 0                         // MemberCertificate[] needs its own counter
FOR MemberCounter ← 1 TO 200
    IF MemberTime[MemberCounter] < 240   // strictly under 240 seconds
    THEN
        CertCount ← CertCount + 1
        MemberCertificate[CertCount] ← MemberName[MemberCounter]
    ENDIF
NEXT MemberCounter
OUTPUT "Number of certificates to be printed: ", CertCount

Why this is a complete response

It covers the five requirements: each time input twice with the pair verified before storing (R1), MemberTime[] and MemberName[] sorted ascending together with parallel swaps (R2), the top three output by name and time and identified as First, Second and Third (R3), qualifying names stored in MemberCertificate[] using its own counter (R4), and a message stating the number of certificates to be printed (R5).

What to check before submitting

Check that the UNTIL condition compares the two inputs, that both arrays swap together inside the same branch, that the sort is ascending, that the under-240 test is strict, that MemberCertificate[] is indexed by CertCount, and that every input and output carries a suitable message.

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 run with six of the club’s members. Watch each time being entered twice and verified, the parallel sort trade positions, the podium take First, Second and Third, and the certificate counter pass Oscar by at exactly 240 seconds.

Last tab · Trace player

Sample input → expected results

Six sample members run the club’s 1-kilometre competition (the real club has 200 members; the sample is scaled to 6 so the trace stays readable). The sample deliberately tests a mismatched double input (Tilly’s 218 s and 281 s are rejected and re-entered), a boundary time of exactly 240 seconds (Oscar — not under 240, so no certificate), and an ascending sort traced comparison by comparison. These are illustrative values, not data supplied by the examination question.

Input arrays MemberName[] (given) and MemberTime[] (built by the program)

Member	1st input (s)	2nd input (s)	Stored time (s)

The row number is the array position shared by MemberName[] and MemberTime[] before the sort. Tilly’s row shows her rejected first pair — the trace re-enters and verifies her time.

Reveal expected results and club awards

Expected results After the sort, in ascending order of time

Place	Member	Time (s)	Award

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Program counters

Ready

Tip: use Next step slowly and watch MemberCounter during verification, ComparePos during the sort, and the certificate counter while the 240-second boundary decides Oscar’s fate.

Trace colours: blue row = current member or position; amber cell = the value being entered, compared or tested; green cells = work already completed.

Boundary example: Oscar’s time is exactly 240 seconds, and the certificate test is MemberTime[MemberCounter] < 240 — 240 < 240 is FALSE, so he receives no certificate. Verification example: Tilly’s first pair (218 and 281) fails the = test, so the loop re-enters the whole pair before anything is stored.

From double-checked times to prizes and certificates.

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

Initialise the flag and the certificate counter

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input every time twice and verify the pair

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Sort both arrays in ascending order of time

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Output the top three as First, Second and Third

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Fill MemberCertificate[] and report the count

🧠 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 MemberName[] (given) and MemberTime[] (built by the program)

Expected results After the sort, in ascending order of time

Execution trace

Initialisation

Live variable values

Program counters