15-mark question lab · start here

From two players’ random numbers to a crowned game winner.

Build the solution in a sensible order: validate both names, fill NumberGenerated with random numbers for each player, award the points round by round, store the totals, settle any tied game with fresh numbers, then report the results in descending order. Learn the reasoning before revealing the complete program.

2D arrayInput validationRANDOM generationPer-round pointsWHILE tie-break15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the two dimensions of NumberGenerated[,], the point rules for higher and equal numbers, and the tie-break condition that repeats until one fresh number is higher.

02 · Construct

Validate both names against empty entries, generate the numbers with RANDOM(1, 6) into the array, and award points inside a round loop with a nested IF/ELSE.

03 · Complete

Store the totals, repeat the tie-break until the fresh numbers differ, then output both names and totals in descending order 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 empty-name rule, the exact point awards for higher and equal numbers, and the descending-order output all affect the structure of your solution.

Question 10 · 15 marks

Cambridge IGCSE Computer Science · 0478/23 · Question 10

A number game has two players. Random whole numbers are generated for each player. The numbers are compared and players are given points based on the result of the comparison.

The two-dimensional (2D) array NumberGenerated[] stores each number generated for each player. The first dimension stores the player number and the second dimension stores the random whole numbers generated.

The game is played as follows:

100 random whole numbers between 1 and 6 inclusive are generated for player 1 and stored in the array.
100 random whole numbers between 1 and 6 inclusive are generated for player 2 and stored in the array.
The first number generated for each player is compared and the player with the higher number is awarded 2 points. If the two numbers are the same, both players are awarded 1 point each.
The comparisons repeat for all 100 numbers generated.
The player with the higher total number of points is output as the winner.
If the players have the same total number of points, a new random whole number is generated for each player and compared. This is repeated until one player has a higher number than the other player. 2 points are added to that player’s total number of points, making this player the winner.

Write a program that meets the following requirements:

input and validate the names of the two players
generate 100 random whole numbers between 1 and 6 inclusive for each player and store them in the array NumberGenerated[]
calculate and store the total number of points for each player
output the name and total number of points for each player in descending order of total number of points.

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 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 and validate the names of the two players, rejecting an empty entry until a real name is supplied.

Generate 100 random whole numbers between 1 and 6 inclusive for each player and store them in NumberGenerated[].

Compare the numbers round by round — 2 points for the higher number, 1 point to each player when equal — and calculate and store each player’s total.

Output each player’s name and total number of points in descending order of total number of points.

Settle a level game with fresh random numbers, repeating until one is higher, and add 2 points to that player.

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

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Spot the two phases. The program first sets the game up (validated names, then 100 random numbers per player) and only then plays it (compare, award, tie-break, report). Two clear phases, in that order.
Identify the repeated unit. The comparison “repeats for all 100 numbers”, so a round loop runs from 1 to 100, comparing the two players’ numbers for the same position.
Translate the point rules. “The player with the higher number is awarded 2 points” and “if the two numbers are the same, both players are awarded 1 point each” — a three-way selection: higher for player 1, higher for player 2, or a draw.
Treat the tie-break as its own loop. “This is repeated until one player has a higher number” is condition-controlled: a WHILE loop on the level totals, drawing fresh numbers until they differ.
Build the order. validate both names → generate and store 100 numbers per player → initialise totals → round loop (compare, award) → tie-break loop → descending output.

Two phases: set-up then gameRound loop: 1 to 100Selection: 2 or 1-and-1Tie-break: WHILE level

❓ Guiding questions – think before revealing

Which phrases tell you where the loops go?
Why is the tie-break a loop rather than one extra comparison?
What does “descending order of total number of points” demand?

Reveal suggested reasoning

Which phrases tell you where the loops go? “The comparisons repeat for all 100 numbers generated” fixes the round loop. “100 random whole numbers… are generated for player 1” and “…for player 2” fix the generation loop over the array’s second dimension.

Why is the tie-break a loop rather than one extra comparison? The question says the fresh numbers are compared and “this is repeated until one player has a higher number” — the fresh pair can also be equal, so the drawing must repeat. A WHILE loop on the level totals expresses that exactly.

What does “descending order of total number of points” demand? The player with more points is output first. With two players, one comparison (and a parallel swap if needed) puts the higher total into position 1 before the outputs print.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Phase 1: set the game up
// Input and validate both player names
FOR PlayerCounter ← 1 TO 2
    // read a name, repeat while it is empty
NEXT PlayerCounter

// Generate and store the random numbers
FOR PlayerCounter ← 1 TO 2
    FOR NumberCounter ← 1 TO 100
        NumberGenerated[PlayerCounter, NumberCounter] ← RANDOM(1, 6)
    NEXT NumberCounter
NEXT PlayerCounter

// Phase 2: play the game
// Round loop: compare, award 2 or 1-and-1
// Tie-break loop: WHILE the totals are level
// Output names and totals in descending order

📖 Detailed explanation

“Input and validate” is one bullet but two jobs: reading the name, then rejecting an empty entry until a real one arrives.

“Store them in the array NumberGenerated[]” means the generation loop must write each draw into the array as it happens — a number that is never stored cannot be compared later.

“Calculate and store the total” means the totals live in variables that survive the round loop, not in a value recomputed at the end.

“Descending order” is the last bullet and the easiest to forget — the outputs must print the larger total first, every time.

⚠️ Common mistakes

Starting to write code before listing the four required bullets and the two game phases.
Treating the tie-break as a single extra comparison, which fails when the fresh numbers are also equal.
Outputting the players in player-number order (1 then 2) instead of descending order of points.
Forgetting that the range 1 to 6 is inclusive, so 1 and 6 are both legal draws.

💡 Exam hack / tip

Underline “validate”, “store them in the array”, “this is repeated until” and “descending order”. Those four phrases map onto the four techniques: a validation loop, array storage, a WHILE tie-break and an ordered output.

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 array exactly. NumberGenerated[,] is supplied: the first dimension is the player number (1 or 2), the second holds that player’s numbers. Every access must keep that order.
Store the names and totals in parallel arrays. Name[1..2] and TotalPoints[1..2] keep player 1’s name and points in position 1 — the same indexing idea as the 2D array.
Add the loop counters. PlayerCounter walks the players; NumberCounter walks the 100 numbers; RoundCounter walks the comparisons.
Add the tie-break and swap variables. FreshOne and FreshTwo hold the fresh numbers; TempName and TempPoints make the descending-order swap possible.
Declarations are not required. The question says to assume every array and variable is already declared — spend the saved lines on comments instead, and say so in one.

Given: NumberGenerated[,]Parallel: Name[] and TotalPoints[]Tie-break and swap variables

❓ Guiding questions – think before revealing

Why keep names and totals in arrays rather than two loose variables?
Why does the tie-break not need new array space?
Do you still mention declarations?

Reveal suggested reasoning

Why keep names and totals in arrays rather than two loose variables? The output needs the name and the total that belong together, and the descending-order swap must move both. Parallel positions — Name[1] with TotalPoints[1] — make the pairing and the swap mechanical.

Why does the tie-break not need new array space? The fresh numbers are used once and discarded: FreshOne and FreshTwo are overwritten on every pass of the WHILE loop. They must not be appended to NumberGenerated, whose second dimension is reserved for the game’s 100 numbers per player.

Do you still mention declarations? One comment is enough: the question’s closing line says the arrays and variables are already declared. Writing DECLARE lines is not wrong here, but the question has removed the need — comments earn the AO3 credit instead.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Already declared, as the question allows:
// NumberGenerated[1..2, 1..100]   // the random numbers
// Name[1..2]                      // the validated player names
// TotalPoints[1..2]               // the point totals

// Added by the solution:
// PlayerCounter  NumberCounter  RoundCounter : INTEGER
// FreshOne  FreshTwo : INTEGER        // tie-break numbers
// TempName : STRING  TempPoints : INTEGER  // descending swap

📖 Detailed explanation

First dimension = player number. NumberGenerated[2, 37] is player 2’s 37th number — never NumberGenerated[37, 2].

Parallel arrays share the player index. Position 1 always means player 1 — in Name[], in TotalPoints[] and in the first dimension of NumberGenerated.

The swap needs a temporary pair. Overwriting TotalPoints[1] before copying it would destroy player 1’s total — TempPoints (and TempName) hold the values during the exchange.

⚠️ Common mistakes

Swapping the dimensions to NumberGenerated[NumberCounter, PlayerCounter], which reads the array across the grain.
Renaming the given array NumberGenerated[] to something shorter — the mark scheme treats that as not using the supplied structure.
Inventing a results array or a third row that the question never asks for.
Forgetting TempName in the swap, so the totals are ordered but the names no longer match.

💡 Exam hack / tip

Say each access aloud: NumberGenerated[player, number]. Player first — the question fixes the dimension order, so every index pair you write should follow it.

Reveal the Cambridge mark-scheme and rubric connection

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

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

Input and validate the two player names

An empty entry is rejected until a real name is supplied.

🧠 Step-by-step thinking

Read a name, then check it. INPUT the name, then test it before accepting: WHILE PlayerName = "" keeps asking while the entry is blank.
Repeat the structure for both players. The validation is identical for player 1 and player 2, so the whole input-and-validate block sits inside FOR PlayerCounter ← 1 TO 2.
Store the accepted name. Name[PlayerCounter] ← PlayerName files the name against the player number the rest of the program uses.
Make the rejection message suitable. “All outputs must contain suitable messages” — the error line should say what was wrong and what to do next.
Validation is input-loop work, not arithmetic. No totals, no number arrays — just a read-check-accept pattern that both players pass through.

Pattern: read, check, re-readLoop: WHILE PlayerName = ""Store: Name[PlayerCounter]

❓ Guiding questions – think before revealing

What does “validate” mean for a name?
Why a WHILE loop rather than a single IF?
Why keep the working variable PlayerName separate from Name[PlayerCounter]?

Reveal suggested reasoning

What does “validate” mean for a name? The only rule the paper states is that the two players have names — an empty entry is not a name. So the validation loop rejects the empty string and asks again. LENGTH(PlayerName) > 0 and PlayerName <> "" are the same test written differently.

Why a WHILE loop rather than a single IF? A single IF rejects one blank and accepts whatever comes next — including another blank. The loop keeps rejecting until a non-empty name is entered, which is what “validate” requires.

Why keep the working variable PlayerName separate from Name[PlayerCounter]? The validated value is what gets stored. Writing straight into Name[PlayerCounter] would work, but a named working variable keeps the validation test and the storage step distinct — and makes the comment easier to write.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Input and validate the two player names
FOR PlayerCounter ← 1 TO 2
    OUTPUT "Player ", PlayerCounter, ", enter your name: "
    INPUT PlayerName
    WHILE PlayerName = ""        // empty entry is not a name
        OUTPUT "A name cannot be empty - enter it again: "
        INPUT PlayerName
    ENDWHILE
    Name[PlayerCounter] ← PlayerName   // store the validated name
NEXT PlayerCounter

📖 Detailed explanation

Priming read, then loop. The first INPUT happens before the WHILE so the condition has a value to test — the classic read-check-repeat pattern.

The message is part of the answer. Inside the loop the program explains the rejection; a silent re-read leaves the user guessing and loses the “suitable messages” point.

One block, two players. Because the block sits inside the player loop, both names are validated by the same code — no duplicated sections to fall out of step.

⚠️ Common mistakes

Forgetting the second INPUT inside the loop, which traps the program repeating the message forever.
Storing the name before validation, so an empty string can end up in Name[].
Writing a bare INPUT PlayerName with no prompt, giving the user nothing to respond to.
Validating only the first player’s name — the bullet says both players.

💡 Exam hack / tip

Validation questions reward the pattern read → WHILE bad → message → read again → ENDWHILE → store. Write the six steps in the margin and tick them off in the code.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · input and validationR1 · both names validatedAO3 · suitable messages

The validation loop is the AO2 evidence for structured input handling, and the clear messages are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Generate the random numbers and store them

Two nested loops fill NumberGenerated[,] — 100 numbers per player.

🧠 Step-by-step thinking

Nest the number loop inside the player loop. For each player, the inner loop runs from 1 to 100, drawing one number per pass.
Draw with RANDOM(1, 6). RANDOM(1, 6) gives a whole number from 1 to 6 inclusive — both boundaries legal, exactly as the bullet says.
Store on the spot. NumberGenerated[PlayerCounter, NumberCounter] ← RANDOM(1, 6) writes each draw straight into the array — the bullet says “store them in the array”.
Keep the dimension order. Player number first, number position second — the question fixes both dimensions.
The demo shows 20; the answer writes 100. The real game stores 100 numbers per player, so the loop bound is 100 in the solution — the visualisation only scales the game down.

Nesting: player outer, number innerDraw: RANDOM(1, 6)Store: two-index assignment

❓ Guiding questions – think before revealing

Why is the loop bound 100 and not the round count of the demo?
Why store each number immediately?
Why does the player loop come first, not the number loop?

Reveal suggested reasoning

Why is the loop bound 100 and not the round count of the demo? The bullet is explicit: 100 random whole numbers per player. The visualisation scales the game down to 20 rounds to keep the trace readable, but the answer must loop 1 TO 100.

Why store each number immediately? The comparisons later need both players’ numbers for the same position. If a draw is never stored, round NumberCounter cannot be replayed — the array is the game’s memory.

Why does the player loop come first, not the number loop? The first dimension is the player number. Nesting player-outer, number-inner fills NumberGenerated[1, 1] to NumberGenerated[1, 100], then player 2’s row — filling the array along its rows.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Generate and store 100 random numbers for each player
FOR PlayerCounter ← 1 TO 2
    FOR NumberCounter ← 1 TO 100
        // RANDOM(1, 6) draws a whole number from 1 to 6 inclusive
        NumberGenerated[PlayerCounter, NumberCounter] ← RANDOM(1, 6)
    NEXT NumberCounter
NEXT PlayerCounter

📖 Detailed explanation

The nesting mirrors the array. Two rows (players) × 100 columns (numbers) are filled in the same order the nested loops visit them.

RANDOM(1, 6) is the whole draw. The function is given the range directly, so no INT wrapper is needed — and the comment states the range so the examiner sees the 1-to-6 rule is deliberate.

Storage is a bullet of its own. A number drawn into a loose variable and never written to NumberGenerated fails the “store them in the array” requirement even if the game still plays.

⚠️ Common mistakes

Writing NumberGenerated[NumberCounter, PlayerCounter], which puts the round in the player dimension.
Using RANDOM(0, 6) or RANDOM(1, 7), giving a range the question never asked for.
Generating only player 1’s numbers, or drawing both players’ numbers inside one inner loop with a single index.
Drawing the numbers inside the comparison loop instead of storing them first — the bullets separate generation from comparison.

💡 Exam hack / tip

Read the bullet as an instruction to the loop: 100 numbers → FOR NumberCounter ← 1 TO 100; between 1 and 6 → RANDOM(1, 6); store them → assign to NumberGenerated[PlayerCounter, NumberCounter].

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration and array storageR2 · 100 numbers 1–6 storedAO3 · correct range and indexes

The nested generation loop is the clearest AO2 evidence of iteration with 2D storage, and the correct range and index order are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Compare each round and award the points

One three-way selection per round: 2 points, or 1 point each.

🧠 Step-by-step thinking

Initialise the totals before the loop. TotalPoints[1] ← 0 and TotalPoints[2] ← 0 — both totals start empty before round 1.
Loop over the shared round index. FOR RoundCounter ← 1 TO 100 — both players’ numbers for the same position are compared together.
Test player 1 first. IF NumberGenerated[1, RoundCounter] > NumberGenerated[2, RoundCounter] — strictly greater means 2 points to player 1.
Nest the second test in the ELSE branch. ELSE IF NumberGenerated[2, RoundCounter] > NumberGenerated[1, RoundCounter] gives 2 points to player 2; the inner ELSE is the draw — 1 point to each player.
Accumulate, do not overwrite. TotalPoints[…] ← TotalPoints[…] + 2 adds to the running total — assigning a bare 2 would forget every earlier round.

Three cases: two IFs, one ELSEShared index: RoundCounter twiceTotals: accumulate in the loop

❓ Guiding questions – think before revealing

Why is the higher-number test strictly >?
Why does a draw award 1 point to both players?
When are the totals complete?

Reveal suggested reasoning

Why is the higher-number test strictly >? The points rule splits into three cases: higher (2 points), lower (the other player’s 2), equal (1 each). Using > in the first test and > again in the nested test leaves equality to fall through to the ELSE — exactly one award per round.

Why does a draw award 1 point to both players? The bullet says “both players are awarded 1 point each” — two separate additions, not one shared point. Forgetting either line corrupts that player’s total from the first drawn round onwards.

When are the totals complete? Only after NEXT RoundCounter. Every award between FOR and NEXT adds to a still-growing total — the tie-break and the outputs must wait for the loop to finish.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

TotalPoints[1] ← 0
TotalPoints[2] ← 0

// Compare the two numbers for each round
FOR RoundCounter ← 1 TO 100
    IF NumberGenerated[1, RoundCounter] >
        NumberGenerated[2, RoundCounter]
    THEN
        // player 1 has the higher number: 2 points
        TotalPoints[1] ← TotalPoints[1] + 2
    ELSE
        IF NumberGenerated[2, RoundCounter] >
            NumberGenerated[1, RoundCounter]
        THEN
            // player 2 has the higher number: 2 points
            TotalPoints[2] ← TotalPoints[2] + 2
        ELSE
            // equal numbers: 1 point to each player
            TotalPoints[1] ← TotalPoints[1] + 1
            TotalPoints[2] ← TotalPoints[2] + 1
        ENDIF
    ENDIF
NEXT RoundCounter

📖 Detailed explanation

Three cases, one nested IF. Higher for player 1, higher for player 2, equal — the nested ELSE chain leaves no fourth case and no overlap.

Both accesses share RoundCounter. The comparison is round by round: NumberGenerated[1, RoundCounter] against NumberGenerated[2, RoundCounter] — the same second index in both rows.

The totals live in variables, ready for the tie-break. “Calculate and store the total” means the WHILE loop and the outputs can read TotalPoints[1] and TotalPoints[2] once the round loop ends.

⚠️ Common mistakes

Awarding 2 points to both players for a draw instead of 1 point each.
Using >= in the first test, which swallows equal numbers into player 1’s 2-point branch and never reaches the draw case.
Comparing NumberGenerated[1, RoundCounter] with NumberGenerated[2, PlayerCounter] — mixing the two dimension names.
Writing TotalPoints[1] ← 2 inside the loop, so the final total is just the last round’s award.

💡 Exam hack / tip

Say the three cases as a decision tree before coding: P1 higher → +2; P2 higher → +2; otherwise both +1. Two strictly-greater tests and one ELSE cover all 100 rounds.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selection and totallingR3 · correct point awardsAO3 · accurate boundaries

The round-by-round selection and accumulation supply the AO2 evidence, and the strict greater-than boundaries are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Break a tied total with fresh numbers

A WHILE loop repeats the draw until one fresh number is higher.

🧠 Step-by-step thinking

Test the right condition. WHILE TotalPoints[1] = TotalPoints[2] — the tie is between the totals, so that is what the loop watches.
Draw one fresh number per player. FreshOne ← RANDOM(1, 6) and FreshTwo ← RANDOM(1, 6) — a new pair on every pass of the loop.
Award only when they differ. IF FreshOne > FreshTwo adds 2 to player 1; the nested ELSE IF FreshTwo > FreshOne adds 2 to player 2; an equal fresh pair awards nothing.
Why nothing on an equal pair. The totals stay level, so the WHILE condition is still TRUE and the loop draws again — “this is repeated until one player has a higher number”.
The loop must be able to end. Each pass draws new random numbers, so an unequal pair eventually arrives and the totals part — the loop terminates with a winner.

Guard 1: WHILE totals levelGuard 2: IF fresh numbers differAward: +2 to the higher

❓ Guiding questions – think before revealing

Why watch the totals and not the fresh numbers in the WHILE condition?
Why must an equal fresh pair award nothing?
Where do the fresh numbers go?

Reveal suggested reasoning

Why watch the totals and not the fresh numbers in the WHILE condition? Because equal fresh numbers must redraw without awarding. Testing the totals makes the award itself the exit route: as soon as 2 points land on one side, the totals differ and the loop ends.

Why must an equal fresh pair award nothing? If the ELSE handed 2 points to player 2 whenever FreshOne > FreshTwo failed, an equal pair 4-and-4 would crown player 2 without a higher number — breaking the rule the question states.

Where do the fresh numbers go? Nowhere permanent. FreshOne and FreshTwo are ordinary variables, overwritten each pass — NumberGenerated’s second dimension stays reserved for the game’s 100 numbers per player.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Tie-break: repeat while the totals remain level
WHILE TotalPoints[1] = TotalPoints[2]
    FreshOne ← RANDOM(1, 6)   // fresh number for player 1
    FreshTwo ← RANDOM(1, 6)   // fresh number for player 2
    IF FreshOne > FreshTwo
    THEN
        TotalPoints[1] ← TotalPoints[1] + 2
    ELSE
        IF FreshTwo > FreshOne
        THEN
            TotalPoints[2] ← TotalPoints[2] + 2
        ENDIF
        // equal fresh numbers: nothing awarded, loop repeats
    ENDIF
ENDWHILE

📖 Detailed explanation

Post-game, pre-output. The tie-break sits between the round loop and the outputs: it needs the finished totals, and its result changes what the outputs print.

Two guards protect the rule. The outer WHILE guards the level totals; the inner IF guards the unequal-fresh-numbers rule. Removing either breaks the game.

The award mirrors the game rule. 2 points — not 1, not 20 — go to the player with the higher fresh number, exactly as the sixth game bullet says.

⚠️ Common mistakes

Writing the loop condition as FreshOne = FreshTwo before any fresh numbers exist — uninitialised variables would decide the game.
Awarding 2 points in the bare ELSE, so an equal fresh pair hands the win to player 2.
Drawing only one fresh number per pass, leaving the other player’s number from the previous attempt.
Forgetting the tie-break entirely and outputting a “winner” for a game whose totals are level.

💡 Exam hack / tip

Read the sixth bullet backwards: 2 points to the higher → so the award needs an unequal pair → so equal pairs must be re-drawn → so the loop condition is the level totals. Each phrase justifies the line above it.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · condition-controlled loopR5 · tie-break repeats until unequalAO3 · reliable exit logic

The WHILE tie-break supplies the condition-controlled-iteration evidence for AO2, and the double guard is AO3 reliability evidence. These are alignment notes, not separately allocated marks.

Order the results and output them

Descending points first, then both names and totals with messages.

🧠 Step-by-step thinking

Guarantee the order before outputting. After the tie-break the totals differ, so one comparison settles it: if TotalPoints[2] > TotalPoints[1], swap both parallel entries.
Swap names and totals together. TempPoints and TempName hold the values during the exchange, so position 1 keeps the winner’s name and total aligned.
Output with suitable messages. Every OUTPUT line says what it shows — a heading, the winner’s line and the runner-up’s line, each naming its values.
Print the stored names. The outputs show Name[1] and Name[2] — the validated names, not player numbers.
Check the four bullets against the outputs. Names validated (Stage 3), numbers generated and stored (Stage 4), totals calculated and stored (Stage 5), descending output — the console should show all four.

One IF: totals cannot be equalParallel swap: six assignmentsMessages on every line

❓ Guiding questions – think before revealing

Why is a single IF enough to order two players?
Why swap both arrays together?
What makes an output message suitable?

Reveal suggested reasoning

Why is a single IF enough to order two players? After the tie-break the totals cannot be equal, so only two orders exist. If position 2 holds the larger total, one parallel swap fixes it; otherwise position 1 is already the winner.

Why swap both arrays together? The name and the total travel as a pair. Swapping only the totals would print Aisha’s name with Marcus’s 22 points — the classic parallel-array fault.

What makes an output message suitable? It says what the number is. OUTPUT "In descending order of total points:" heads the block; the winner’s line names the player, the word “winner” and the points.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// The tie-break guarantees the totals differ, so one
// comparison is enough to put the higher total first
IF TotalPoints[2] > TotalPoints[1]
THEN
    // swap the parallel entries: position 1 becomes the winner
    TempPoints ← TotalPoints[1]
    TotalPoints[1] ← TotalPoints[2]
    TotalPoints[2] ← TempPoints
    TempName ← Name[1]
    Name[1] ← Name[2]
    Name[2] ← TempName
ENDIF

OUTPUT "In descending order of total points:"
OUTPUT Name[1], " is the winner with ", TotalPoints[1], " points"
OUTPUT Name[2], " scored ", TotalPoints[2], " points"

📖 Detailed explanation

The swap is the descending order. With the larger total in position 1, the two OUTPUT lines print the players in the order the bullet demands.

Parallel arrays swap in step. Six assignment lines — three per array — keep every name glued to its total.

The winner line does double duty. The game rules ask for the winner to be output; the bullet asks for names and totals in descending order. One well-worded line satisfies both.

⚠️ Common mistakes

Outputting player 1 then player 2 unconditionally, which breaks the descending rule whenever player 2 wins.
Swapping TotalPoints without swapping Name, splitting each player from their score.
Printing bare numbers with no message — OUTPUT TotalPoints[1] alone fails “all outputs must contain suitable messages”.
Swapping with no temporary variable, so one of the values is overwritten before it can be copied.

💡 Exam hack / tip

End-of-question checklist: names validated, numbers stored, totals stored, descending output, message on every line. Tick the four bullets in the margin as you find each one in your code.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · complete outputsR4 · descending order outputAO3 · suitable messages

The ordered outputs deliver the remaining R4 requirement, and the message quality is AO3 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 the two phases, the round loop, the point rules and the tie-break.	Establishes logical order and comments plan.
2 · Data	Required data structures	NumberGenerated[,] plus parallel name and totals arrays, counters, fresh-number and swap variables.	Meaningful identifiers throughout.
3 · Names	R1	Both names input and validated with an empty-entry loop.	Clear prompts, rejection message and loop structure.
4 · Generate	R2	Nested loops fill NumberGenerated[,] with 100 RANDOM(1, 6) values per player.	Correct two-index storage and inclusive range.
5 · Compare	R3	Round-by-round selection awards 2 points or 1-and-1; totals calculated and stored.	Correct nested IF/ELSE and strict boundaries.
6 · Tie-break	R5	WHILE the totals are level: fresh numbers, repeat until unequal, +2 to the winner.	Reliable double-guard loop-exit logic.
7 · Summary	R4	Descending order via a parallel swap; both names and totals output with messages.	Suitable messages and clean closure.

Consolidated Cambridge pseudocode

Complete solution

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

15-mark exemplar style

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

// Arrays and variables are already declared, as the question allows
// Input and validate both player names, then generate their numbers
FOR PlayerCounter ← 1 TO 2
    OUTPUT "Player ", PlayerCounter, ", enter your name: "
    INPUT PlayerName
    WHILE PlayerName = ""                  // empty entry is not a name
        OUTPUT "A name cannot be empty - enter it again: "
        INPUT PlayerName
    ENDWHILE
    Name[PlayerCounter] ← PlayerName       // store the validated name
NEXT PlayerCounter
FOR PlayerCounter ← 1 TO 2
    FOR NumberCounter ← 1 TO 100
        NumberGenerated[PlayerCounter, NumberCounter] ← RANDOM(1, 6)   // whole number 1 to 6
    NEXT NumberCounter
NEXT PlayerCounter
// Calculate and store the total points for each player
TotalPoints[1] ← 0
TotalPoints[2] ← 0
FOR RoundCounter ← 1 TO 100
    IF NumberGenerated[1, RoundCounter] > NumberGenerated[2, RoundCounter]
    THEN
        TotalPoints[1] ← TotalPoints[1] + 2    // higher number: 2 points
    ELSE
        IF NumberGenerated[2, RoundCounter] > NumberGenerated[1, RoundCounter]
        THEN
            TotalPoints[2] ← TotalPoints[2] + 2    // higher number: 2 points
        ELSE
            TotalPoints[1] ← TotalPoints[1] + 1    // equal numbers: 1 each
            TotalPoints[2] ← TotalPoints[2] + 1
        ENDIF
    ENDIF
NEXT RoundCounter
// Tie-break: repeat while the totals are level until one fresh pair differs
WHILE TotalPoints[1] = TotalPoints[2]
    FreshOne ← RANDOM(1, 6)
    FreshTwo ← RANDOM(1, 6)
    IF FreshOne > FreshTwo
    THEN
        TotalPoints[1] ← TotalPoints[1] + 2    // player 1 wins the tie-break
    ELSE
        IF FreshTwo > FreshOne
        THEN
            TotalPoints[2] ← TotalPoints[2] + 2    // player 2 wins the tie-break
        ENDIF   // equal fresh pair: nothing awarded, the loop repeats
    ENDIF
ENDWHILE
// Descending output: the tie-break guarantees the totals differ
IF TotalPoints[2] > TotalPoints[1]
THEN
    TempPoints ← TotalPoints[1]
    TotalPoints[1] ← TotalPoints[2]
    TotalPoints[2] ← TempPoints
    TempName ← Name[1]
    Name[1] ← Name[2]
    Name[2] ← TempName
ENDIF
OUTPUT "In descending order of total points:"
OUTPUT Name[1], " is the winner with ", TotalPoints[1], " points"
OUTPUT Name[2], " scored ", TotalPoints[2], " points"

Why this is a complete response

It covers the five mark-scheme requirements: both names input and validated against empty entries (R1), 100 random whole numbers between 1 and 6 generated per player and stored in NumberGenerated[] (R2), round-by-round comparisons awarding 2 points or 1 point each with totals calculated and stored (R3), both names and totals output in descending order of points (R4), and a level game settled by fresh random numbers repeated until one is higher, adding 2 points to that player (R5).

What to check before submitting

Check the WHILE PlayerName = "" validation loops, the RANDOM(1, 6) range, the two-index accesses NumberGenerated[PlayerCounter, NumberCounter], the nested IF/ELSE point awards, the tie-break that awards nothing on an equal fresh pair, the parallel swap, 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 game. Watch the names validated, the random numbers generated into the array, each round award 2 points or a drawn 1-and-1, the tie-break redraw until a winner emerges, and the final report print in descending order.

Last tab · Trace player

Sample input → expected results

Two sample players each hold 20 random whole numbers between 1 and 6 — the real game generates 100 numbers per player, so this run is scaled down to 20 rounds (the solution still writes 100). The sample deliberately tests: a blank second name that fails validation and is re-entered; four drawn rounds (rounds 3, 8, 15 and 20) worth 1 point to each player; totals that finish level at 20–20, forcing the tie-break; and a tie-break whose first fresh pair is also equal (4 and 4), so the WHILE loop repeats before the 6-beats-2 pair settles the game. These are illustrative values, not data supplied by the examination question.

Input array NumberGenerated[,] · 20 rounds per player

Player	R1	R2	R3	R4	R5	R6	R7	R8	R9	R10	R11	R12	R13	R14	R15	R16	R17	R18	R19	R20

The row number is the player number — the first dimension of NumberGenerated[,] — and each column is one round of the sample game.

Reveal expected totals and the final report

Expected results After 20 rounds and the tie-break

Player	Total points	Outcome

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Game counters

Ready

Tip: use Next step slowly and watch RoundCounter, TotalPoints[1] and TotalPoints[2]. Each round adds 2 points to one side or 1 point to both, and the tie-break counter only moves once the totals are level.

Trace colours: blue row = the player whose numbers are being validated or generated; amber cell = the round currently being compared; green cells = rounds already compared.

Worked examples: round 6 is a win for Marcus — NumberGenerated[1, 6] holds 2 and NumberGenerated[2, 6] holds 6, so 6 > 2 is TRUE and his total rises by 2 to 7. Round 15 is drawn: both players draw 5, so each gains 1 point. After round 20 the totals are level at 20–20, so the tie-break loop starts — the first fresh pair, 4 and 4, is equal, so nothing is awarded and the loop repeats; the second pair, 2 and 6, is unequal, so Marcus gains 2 points and wins 22–20.

From two players’ random numbers to a crowned game winner.

Learning targets

01 · Understand

02 · Construct

03 · Complete

Read the whole question first

Before you move on

Decode the requirements

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Plan the data and identifiers

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input and validate the two player names

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Generate the random numbers and store them

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Compare each round and award the points

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Break a tied total with fresh numbers

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Order the results and output them

🧠 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 array NumberGenerated[,] · 20 rounds per player

Expected results After 20 rounds and the tie-break

Execution trace

Initialisation

Live variable values

Game counters