15-mark question lab · start here

A ten-move hunt for the secret cell in a 5 × 5 grid.

Build the solution in a sensible order: empty the grid and hide the X in a random cell that is never Grid[1,1], place the player at the top left with 10 moves, validate every one-cell move against the edge of the grid, then test for the win before the loss. Learn the reasoning before revealing the complete program.

2D array gameRandom placementBounds validationGame loop with two exitsState tracking15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the one-off set-up jobs, the repeating turn, and the two conditions that can end the game.

02 · Construct

Hide the X with INT(RANDOM() * 5) + 1, then validate each direction against the edge of the grid before applying the move.

03 · Complete

Test the secret cell before the move counter so the tenth move can still win, and message the player at every input and output.

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 start diagram, the 10-move limit and the rule that every move must stay within the grid all shape the loop you are about to write.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 11

A one-player game uses the two-dimensional (2D) array Grid[] to store the location of a secret cell to be found by the player in 10 moves. Each row and column has 5 cells.

Start Grid[1,1]

Start Grid[1,1]

At the start of the game:

The program places an ‘X’ in a random cell (not in Grid[1,1]) and empties all the other cells in the grid.
The player starts at the top left of the grid.
The player has 10 moves.

During the game:

The player can move left, right, up or down by one cell and the move must be within the grid.
“You Win” is displayed if the player moves to the cell with ‘X’ and has played 10 moves or less.
“You Lose” is displayed if the player has made 10 moves without finding the ‘X’.

Write a program that meets these requirements.

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

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

All inputs and outputs must contain suitable messages.

Before you move on

These are the five required techniques identified by the Cambridge mark scheme.

Mark-scheme map

Empty all 25 cells, then place the secret X in a random cell drawn with INT(RANDOM() * 5) + 1 that is never Grid[1,1].

Start the player at the top left cell Grid[1,1] with a move budget of 10, counted by MovesUsed.

Accept left, right, up and down as one-cell moves and validate each against rows and columns 1 to 5 before applying it.

Display “You Win” the moment the player steps onto the X, provided no more than 10 moves have been played.

Display “You Lose” after the tenth accepted move completes without the X being found.

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 two phases. Every game needs a set-up phase — empty the grid, hide one X, place the player — and a play phase of repeated moves until the game is decided.
Spot the loop and its two exits. The play phase repeats “input a move, apply it, test it” until either the X is found or the tenth move is used. A WHILE loop driven by a finished flag handles both exits.
Translate command words. “Places an ‘X’ in a random cell” means RANDOM() with INT(); “must be within the grid” means bounds validation before the move is applied; “10 moves or less” means the win test runs before the lose test.
Notice what does not count. A move that would leave the grid is rejected — it must not move the player and must not use up one of the 10 moves.
Build the order. empty grid → place X (never Grid[1,1]) → player to Grid[1,1] with 10 moves → loop: input move → validate → apply and count → test X → test 10 moves → game over.

Set-up phase: grid + random XPlay loop: two exitsBounds validationMessages on every input and output

❓ Guiding questions – think before revealing

Which phrases tell you the game needs a loop?
Why must the X be placed before the loop starts?
What does “the move must be within the grid” change?

Reveal suggested reasoning

Which phrases tell you the game needs a loop? The player keeps moving until something ends the game — the X is found or the tenth move is played. “During the game” signals repetition with two exit conditions, so a WHILE loop with a finished flag is the natural shape.

Why must the X be placed before the loop starts? Set-up happens once; the loop repeats moves. Putting the random placement inside the loop would move the X during the game — a classic misreading of “at the start of the game”.

What does “the move must be within the grid” change? Each requested move needs validation against rows and columns 1 to 5 before anything is updated, plus a suitable rejection message when the test fails.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// SET-UP (runs once)
// Empty all 25 cells of Grid[]
// Place X at random, never in Grid[1,1]
// Player starts at Grid[1,1], MovesUsed = 0

// PLAY (repeats)
WHILE the game is not finished
    // Ask for a move: left, right, up or down
    // Validate: the move must stay within the grid
    // Apply the move and count it
    // Test for X → "You Win"
    // Test for 10 moves → "You Lose"
ENDWHILE

📖 Detailed explanation

“At the start of the game” covers three set-up jobs — emptying every cell, hiding the X and positioning the player — all of which happen exactly once, before the first move.

“10 moves or less” and “without finding” are the two exits of the same loop; the order of the two tests decides the tenth move — the win must be tested first.

“All inputs and outputs must contain suitable messages” means the move prompt names the four directions and every rejection explains itself.

“You do not need to declare” tells you the array and variables already exist — spend the answer’s time on the logic, not on declarations.

⚠️ Common mistakes

Placing the X inside the game loop, so it moves every turn.
Letting an invalid move use up one of the 10 moves.
Testing the lose condition before the win condition, so a tenth move onto the X wrongly loses.
Forgetting that the player starts at Grid[1,1], not at a random cell.

💡 Exam hack / tip

Underline “random cell (not in Grid[1,1])”, “must be within the grid”, “10 moves or less” and “10 moves without finding”. Those four phrases map one-to-one onto the four code sections: RANDOM placement, bounds validation, the win test and the lose test.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · loop with two exitsR1–R5 · full requirement coverageAO3 · correct test 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 track the secret, the player and the clock.

Required data structures

🧠 Step-by-step thinking

Use the given name. The question supplies the 5 × 5 array Grid[] — rows 1 to 5, columns 1 to 5, holding one character per cell (“X” or empty).
Track the secret cell. SecretRow and SecretCol store where the X was hidden; the array could be searched instead, but storing the draw makes the “not Grid[1,1]” check a single comparison.
Track the player. PlayerRow and PlayerCol are the player’s position; they start at 1 and 1 and change only when a valid move is applied.
Count the moves. MovesUsed starts at 0 and grows by one per accepted move; the lose test compares it with 10.
Control the loop. MoveInput holds the requested direction, ValidMove records the bounds decision, and GameFinished ends the WHILE loop when either exit fires.

Given: Grid[,] 5 × 5Position: Secret and Player pairsControl: ValidMove, GameFinished

❓ Guiding questions – think before revealing

Why store SecretRow and SecretCol when the X is already in Grid[]?
Why a ValidMove flag rather than updating the position inside each direction test?
What data type is each cell?

Reveal suggested reasoning

Why store SecretRow and SecretCol when the X is already in Grid[]? The win test reads Grid[PlayerRow, PlayerCol] directly, but the set-up must guarantee “not Grid[1,1]” — keeping the drawn row and column in variables makes that redraw check a single condition.

Why a ValidMove flag rather than updating the position inside each direction test? Updating inside the four tests would move the player before you know whether the requested direction was legal at all. The flag separates deciding from applying, which keeps the counting correct.

What data type is each cell? CHAR (or string): “X” for the secret cell and “” for an emptied one — the win test compares the current cell with “X”.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given and assumed already declared:
// Grid[1:5, 1:5] — one character per cell, "X" or empty

// Working variables chosen for the game:
// SecretRow, SecretCol — where the X was hidden
// PlayerRow, PlayerCol — the player's position (start: 1, 1)
// MovesUsed           — accepted moves so far (start: 0)
// MoveInput           — the direction typed this turn
// ValidMove           — TRUE only when the move stays within the grid
// GameFinished        — ends the WHILE loop when the game is decided

📖 Detailed explanation

Two position pairs, two jobs. SecretRow, SecretCol never change after set-up; PlayerRow, PlayerCol change on every accepted move.

MovesUsed is the game’s clock. The question limits the player to 10 moves, so the counter — not the player’s position — decides when the game is lost.

Flags keep the loop honest. ValidMove prevents rejected moves from counting, and GameFinished gives the WHILE loop its single, clear exit condition.

⚠️ Common mistakes

Renaming the given array — the mark scheme expects Grid[].
Using 0-based indexes, so row 1 becomes row 0 and every bounds test shifts.
Storing the player’s position as a single number instead of a row and a column.
Leaving out a flag for valid moves, so rejected moves silently move the player.

💡 Exam hack / tip

Name variables after the question’s own nouns: SecretRow, PlayerRow, MovesUsed. An examiner can then match every variable back to a sentence in the question.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate variablesR1–R3 · set-up data trackedAO3 · 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.

Set up the grid, the X and the player

The three start-of-game bullets happen once, in this order.

R1 · R2

🧠 Step-by-step thinking

Empty every cell first. A nested pair of FOR loops writes “” into all 25 cells — the question says the program empties all the other cells.
Choose the secret cell at random. INT(RANDOM() * 5) + 1 gives a whole number from 1 to 5 for the row, and again for the column.
Guarantee it is not Grid[1,1]. A REPEAT … UNTIL loop redraws the pair until SecretRow <> 1 OR SecretCol <> 1 — only Grid[1,1] fails both parts.
Write the X and place the player. Grid[SecretRow, SecretCol] ← "X", then PlayerRow ← 1, PlayerCol ← 1 and MovesUsed ← 0.
Keep the order. Emptying before placing means the X is never wiped; placing the player last means the starting cell is already empty.

Nested FOR: 25 cellsINT(RANDOM() * 5) + 1REPEAT … UNTIL not [1,1]

❓ Guiding questions – think before revealing

Why INT(RANDOM() * 5) + 1 and not INT(RANDOM() * 5)?
Why OR in UNTIL SecretRow <> 1 OR SecretCol <> 1?
Does the order of the three set-up jobs matter?

Reveal suggested reasoning

Why INT(RANDOM() * 5) + 1 and not INT(RANDOM() * 5)? RANDOM() gives 0.0 to just under 1.0, so INT(RANDOM() * 5) gives only 0 to 4. Adding 1 shifts the range to the 1-based rows and columns the array actually uses.

Why OR in UNTIL SecretRow <> 1 OR SecretCol <> 1? The only forbidden cell is row 1 and column 1 together. The loop must continue while either coordinate differs from 1, and stops only when both are 1. Writing AND here would keep redrawing until the pair is exactly (1, 1) — almost never.

Does the order of the three set-up jobs matter? Yes: emptying first means the X is never overwritten, and placing the player last means Grid[1,1] is guaranteed empty when the game begins.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Empty all 25 cells of the grid
FOR RowCounter ← 1 TO 5
    FOR ColCounter ← 1 TO 5
        Grid[RowCounter, ColCounter] ← ""
    NEXT ColCounter
NEXT RowCounter

// Draw a random cell until it is not Grid[1, 1]
REPEAT
    SecretRow ← INT(RANDOM() * 5) + 1
    SecretCol ← INT(RANDOM() * 5) + 1
UNTIL SecretRow <> 1 OR SecretCol <> 1
Grid[SecretRow, SecretCol] ← "X"

// Player starts at the top left with 10 moves
PlayerRow ← 1
PlayerCol ← 1
MovesUsed ← 0

📖 Detailed explanation

“Empties all the other cells” is a whole-array job: every one of the 25 cells must be written, even the ones the player never visits.

The random expression is a fixed idiom. INT(RANDOM() * n) + 1 is the Cambridge way to draw a whole number from 1 to n; it appears in every random-placement question.

REPEAT … UNTIL fits redraw loops. The pair must be drawn at least once before it can be tested, which is exactly the REPEAT pattern.

⚠️ Common mistakes

Using INT(RANDOM() * 5) and drawing the range 0 to 4.
Using AND in the UNTIL condition, which keeps redrawing until the pair is exactly (1, 1).
Emptying the cells after placing the X, wiping the secret away.
Starting the player at a random cell instead of the top left.

💡 Exam hack / tip

Memorise the pair as one unit: INT(RANDOM() * 5) + 1 for the value, REPEAT … UNTIL for the restriction. Almost every Cambridge random-placement requirement is solved by exactly these two lines.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · random placementR1 · R2 · set-up completeAO3 · correct 1-based range

The set-up phase supplies the random-generation and initialisation evidence for AO2, and the correct 1-based range is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Loop until the game is won or lost

One iteration per attempted move, with two ways out.

R3 · R4 · R5

🧠 Step-by-step thinking

Control the loop with a flag. WHILE GameFinished = FALSE keeps the game running until either the win or the lose branch sets the flag.
Ask for a direction every turn. The prompt names all four directions — a suitable message — and INPUT MoveInput reads the player’s choice.
Count accepted moves only. MovesUsed grows inside the valid branch; Stage 5’s validation decides whether the move is applied at all.
Set the flag inside the loop. Both the win branch and the lose branch set GameFinished ← TRUE; nothing else ends the game.
Report between moves. Telling the player their new position and move count keeps every output suitably messaged and makes tracing easy.

WHILE + GameFinished flagOne turn per iterationTwo exits, one flag

❓ Guiding questions – think before revealing

Why WHILE rather than FOR MovesUsed ← 1 TO 10?
What happens to the loop when the game ends?
Why prompt inside the loop?

Reveal suggested reasoning

Why WHILE rather than FOR MovesUsed ← 1 TO 10? A FOR loop always runs its full ten passes unless the language offers a mid-loop exit. The flag lets the loop end on the very move the X is found — exactly the behaviour “10 moves or less” describes.

What happens to the loop when the game ends? The ending message is output and GameFinished becomes TRUE, so the WHILE condition fails and the program continues after ENDWHILE with nothing left to do.

Why prompt inside the loop? Each turn needs a fresh direction. Reading the move once before the loop would repeat the same direction for ever — and the prompt is an output, so it must appear every turn to carry a suitable message.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

GameFinished ← FALSE
WHILE GameFinished = FALSE
    OUTPUT "Enter your move: left, right, up or down"
    INPUT MoveInput
    // Stage 5 validates the move and applies it
    // Stage 6 tests for the X and for 10 moves used
ENDWHILE

📖 Detailed explanation

The loop body is one turn. Prompt, input, validate, apply, count, test — the full turn repeats until an exit fires.

Two exits, one flag. The question’s two display conditions map onto two places that set GameFinished; the loop condition itself stays simple.

Every turn produces output. Between moves the player is told their position and how many moves are used, satisfying the suitable-messages requirement.

⚠️ Common mistakes

Looping a fixed ten times and still asking for moves after the X is found.
Forgetting to set the flag, so the game never ends.
Reading the move outside the loop, so the same direction repeats for ever.
Putting the win and lose tests outside the loop, where the current cell is no longer known.

💡 Exam hack / tip

Say the exit conditions aloud — found the X or ten moves played — and give each one a line that sets the same flag. Two exits, one flag, no confusion.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · conditional iterationR3 · move loopAO3 · clean exit logic

The game loop is the clearest AO2 evidence of conditional iteration, and the flag-controlled exits are AO3 logic evidence. These are alignment notes, not separately allocated marks.

Validate every move against the edge of the grid

Left, right, up and down each need their own direction-and-bound test.

🧠 Step-by-step thinking

Test the direction and the edge together. IF MoveInput = "left" AND PlayerCol > 1 — the move is only possible if the player is not already in the first column.
Repeat for the other three directions. Right needs PlayerCol < 5, up needs PlayerRow > 1, down needs PlayerRow < 5.
Let the matching test apply the move. The branch that recognises the direction also changes PlayerRow or PlayerCol by exactly one and raises the ValidMove flag.
Reject everything else with a message. If no test fired, the requested move would leave the grid: output a message, change nothing, count nothing.
Keep moves to one cell. Each branch adds or subtracts exactly 1 — diagonal or two-cell moves are not in the question.

Direction AND boundRows 1–5, columns 1–5Rejected moves uncounted

❓ Guiding questions – think before revealing

Why must each test combine the direction and the bound?
Why is a rejected move not counted?
Which comparisons keep the move inside rows 1 to 5?

Reveal suggested reasoning

Why must each test combine the direction and the bound? Testing only the direction would let the player walk off the grid; testing only the bound would apply an unknown direction. The pair — direction and room to move — is what “the move must be within the grid” demands.

Why is a rejected move not counted? The question gives the player 10 moves; a move that was never made cannot use one up. The counter only grows when ValidMove is TRUE.

Which comparisons keep the move inside rows 1 to 5? For up: PlayerRow > 1. For down: PlayerRow < 5. The same 1-to-5 window applies to columns for left and right.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

ValidMove ← FALSE
IF MoveInput = "left" AND PlayerCol > 1 THEN
    ValidMove ← TRUE
    PlayerCol ← PlayerCol - 1
ENDIF
IF MoveInput = "right" AND PlayerCol < 5 THEN
    ValidMove ← TRUE
    PlayerCol ← PlayerCol + 1
ENDIF
// ... and the same pattern for "up" and "down"
IF ValidMove = FALSE THEN
    OUTPUT "That move is not within the grid. Please try again."
ENDIF

📖 Detailed explanation

Four directions, four windows. Columns 1 to 5 bound left and right; rows 1 to 5 bound up and down. Each test is the conjunction of the requested direction and the space to move.

Rejection changes nothing. Neither the position nor MovesUsed may change on a rejected move — only the message is output.

The flag carries the decision forward. Stage 6’s counting and win test run only when ValidMove is TRUE, which keeps validation and outcome separate.

⚠️ Common mistakes

Using < 1 and > 5 instead of the 1-to-5 window, so edge cells behave in reverse.
Counting a rejected move towards the 10.
Accepting diagonal moves such as “up-left”, which the question does not allow.
Applying the move before validating it, so the player can end up at row 0 or column 6.

💡 Exam hack / tip

Write the four tests as a 2 × 2 table — rows or columns against minus or plus — and fill in > 1 or < 5 for each. The table is the validation; the code just copies it.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · validation with ANDR3 · within-the-grid ruleAO3 · correct boundary comparisons

The four direction tests supply the validation evidence for AO2, and the correct boundary comparisons are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Test for the X, then for the tenth move

The order of the two outcome tests decides the tenth move.

R4 · R5

🧠 Step-by-step thinking

Count the accepted move first. MovesUsed ← MovesUsed + 1 runs as soon as the move is applied, so both outcome tests see the up-to-date count.
Test the X with the fresh position. IF Grid[PlayerRow, PlayerCol] = "X" — the player has just moved, so the current cell is the one to test.
Output “You Win” and stop. Reaching the X in 10 moves or fewer ends the game immediately.
Only then test the tenth move. IF MovesUsed = 10 sits in the ELSE branch, so it can only run when the cell was empty — ten moves without the X means “You Lose”.
Order matters on move ten. If the tenth move lands on the X, the win test runs first and the player wins — exactly what “10 moves or less” promises.

Win test: cell = "X"Lose test: MovesUsed = 10X before clock

❓ Guiding questions – think before revealing

Why must the win test come before the lose test?
Why is the lose test nested in ELSE rather than a separate IF?
What does the player see between moves?

Reveal suggested reasoning

Why must the win test come before the lose test? On the tenth move both conditions could be true — the tenth move may land on the X. Testing the X first makes that move a win, matching “has played 10 moves or less”. The reverse order would wrongly display “You Lose”.

Why is the lose test nested in ELSE rather than a separate IF? The lose branch must run only when the cell was not the X. Nesting it in the ELSE guarantees the two messages can never appear for the same move.

What does the player see between moves? A message giving the new position and the number of moves used — the output of the neither-win-nor-lose branch.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

IF ValidMove = TRUE THEN
    MovesUsed ← MovesUsed + 1
    IF Grid[PlayerRow, PlayerCol] = "X" THEN
        OUTPUT "You Win"
        GameFinished ← TRUE
    ELSE
        IF MovesUsed = 10 THEN
            OUTPUT "You Lose"
            GameFinished ← TRUE
        ELSE
            OUTPUT "You are in row ", PlayerRow, " column ", PlayerCol
        ENDIF
    ENDIF
ENDIF

📖 Detailed explanation

The win test reads the array. The player’s new cell either holds the X or was emptied at set-up, so a single comparison decides the game.

The lose test reads the counter. Ten accepted moves with no X is the only losing position; the flag ends the loop so no further moves are requested.

Both branches display the quoted messages. “You Win” and “You Lose” are output verbatim, as the question’s quotation marks require.

⚠️ Common mistakes

Testing MovesUsed = 10 before testing the cell, so the tenth move can never win.
Comparing the cell the player came from instead of the freshly entered cell.
Continuing to ask for moves after the game has been won.
Writing “You win” with a small w — the displayed messages should match the question.

💡 Exam hack / tip

Remember the sentence: the X is tested first, the clock second. It settles the tenth-move case and it is the single most-checked line in this question’s mark scheme.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · nested selectionR4 · R5 · both messagesAO3 · decisive test order

The nested outcome tests supply the selection evidence for AO2, and the win-before-lose order is AO3 logic evidence. These are alignment notes, not separately allocated marks.

End the game and check the whole answer

After ENDWHILE the only job left is completeness.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Close the loop correctly. ENDWHILE follows the whole turn; nothing game-related may sit outside it.
Check every start-of-game bullet. Emptied grid, random X that is never Grid[1,1], player at the top left, 10 moves — four ticks from the first three bullets.
Check every during-game bullet. Four one-cell directions, bounds validation, “You Win” within 10 moves or fewer, “You Lose” after 10 moves without the X.
Check the message rule. The move prompt, the rejection message, the between-move updates and both endings all carry suitable text.
Re-read the assumption line. This question says the arrays and variables are already declared — no DECLARE block is needed, so spend the remaining effort on comments.

Loop closureSix bullets, six answersMessages everywhere

❓ Guiding questions – think before revealing

Which sentence of the question is easiest to drop?
How can you prove the tenth move is handled?
What should follow ENDWHILE?

Reveal suggested reasoning

Which sentence of the question is easiest to drop? “All inputs and outputs must contain suitable messages.” It is the last line and the easiest to forget — the prompt, the rejection and the between-move updates all count as outputs.

How can you prove the tenth move is handled? Trace it: on the tenth accepted move MovesUsed becomes 10; if the cell holds the X the win test fires first; otherwise the lose test displays “You Lose”. Both cases end the loop.

What should follow ENDWHILE? Nothing. The win and lose branches are the last statements the program runs, which is a quick visual check that no processing was left stranded outside the loop.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// After ENDWHILE the game is over — no further processing is needed.
// Final check-list against the question:
// 1. X placed at random, never Grid[1,1]     (start bullet 1)
// 2. Player begins top left with 10 moves    (start bullets 2 and 3)
// 3. One-cell moves, rejected at the edge    (during-game bullet 1)
// 4. "You Win" within 10 moves or fewer      (during-game bullet 2)
// 5. "You Lose" after 10 moves without X     (during-game bullet 3)
// 6. Suitable messages on every input and output

📖 Detailed explanation

Completeness is a mark band. The top AO2 band needs the full range of techniques the scenario requires — random placement, iteration, validation, selection and messaging.

The trace is the fastest check. Walk one move through the code — input, validation, application, counting, tests — and every stage of the program is exercised.

Accuracy hides in small places. The + 1 in the random expression, the 1-to-5 windows and the test order are each single-character errors that lose whole requirements.

⚠️ Common mistakes

Leaving the X’s placement inside the loop during a hasty rewrite.
Dropping the rejection message because the move “simply does nothing”.
Adding extra processing after ENDWHILE that re-tests the cell.
Declaring the array and variables when the question says it is unnecessary — a waste of exam time.

💡 Exam hack / tip

Final 30 seconds: point at each bullet in the question and point at the line of code that answers it. Six bullets, six answers — if any finger hovers, that is where the marks are missing.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · complete technique rangeR4 · R5 · game ends correctlyAO3 · whole-answer accuracy

The closing check confirms every requirement is answered, which is the evidence the top AO2 and AO3 bands demand. 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 set-up phase, the play loop and both endings.	Establishes logical order and comments plan.
2 · Data	Required data structures	Grid[,], secret and player position pairs, move counter, flags.	Meaningful identifiers throughout.
3 · Setup	R1, R2	Empties all 25 cells; random X never at Grid[1,1]; player placed with 10 moves.	Correct INT(RANDOM()*5)+1 range.
4 · Moves	R3, R4, R5	WHILE loop with a flag; one turn per iteration; prompt each turn.	Prompt and input inside the loop.
5 · Bounds	R3	Four direction tests keep every move within the 5 × 5 grid.	Correct 1-to-5 comparisons; rejected moves uncounted.
6 · Win/Lose	R4, R5	X tested before the tenth-move test; both messages displayed.	Test order handles the tenth-move win.
7 · Summary	R1–R5	Loop closes at the right point; whole answer checked against all six bullets.	Suitable messages verified everywhere.

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

Read this carefully: this follows the structure and techniques of the specimen mark scheme. The 5 × 5 array Grid[] and all variables are already declared, as the question allows. The program runs a one-off set-up phase — empty the grid, hide the X by redrawing until it is not Grid[1,1], place the player — then a single WHILE loop plays the game: each turn validates the requested direction against the edge of the grid, applies and counts accepted moves, and tests the X before the tenth-move counter.

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

// Start of game — Grid[] and all variables are already declared; empty the grid, hide the X, place the player
FOR RowCounter ← 1 TO 5
    FOR ColCounter ← 1 TO 5
        Grid[RowCounter, ColCounter] ← ""    // empty every one of the 25 cells
    NEXT ColCounter
NEXT RowCounter
// Draw a random cell until it is not the start cell Grid[1,1]
REPEAT
    SecretRow ← INT(RANDOM() * 5) + 1        // whole number in the range 1 to 5
    SecretCol ← INT(RANDOM() * 5) + 1
UNTIL SecretRow <> 1 OR SecretCol <> 1       // exit only when the pair is not (1, 1)
Grid[SecretRow, SecretCol] ← "X"
PlayerRow ← 1                                // the player starts at the top left
PlayerCol ← 1
MovesUsed ← 0                                // none of the 10 moves used yet
GameFinished ← FALSE
// ---- During the game: one iteration per attempted move ----
WHILE GameFinished = FALSE
    OUTPUT "Enter your move: left, right, up or down"
    INPUT MoveInput
    // Validate the move: it must stay within rows and columns 1 to 5
    ValidMove ← FALSE
    IF MoveInput = "left" AND PlayerCol > 1 THEN
        ValidMove ← TRUE
        PlayerCol ← PlayerCol - 1
    ENDIF
    IF MoveInput = "right" AND PlayerCol < 5 THEN
        ValidMove ← TRUE
        PlayerCol ← PlayerCol + 1
    ENDIF
    IF MoveInput = "up" AND PlayerRow > 1 THEN
        ValidMove ← TRUE
        PlayerRow ← PlayerRow - 1
    ENDIF
    IF MoveInput = "down" AND PlayerRow < 5 THEN
        ValidMove ← TRUE
        PlayerRow ← PlayerRow + 1
    ENDIF
    // Apply and count only accepted moves, then test the outcomes
    IF ValidMove = TRUE
    THEN
        MovesUsed ← MovesUsed + 1
        IF Grid[PlayerRow, PlayerCol] = "X"
        THEN
            OUTPUT "You Win"                 // found in 10 moves or less
            GameFinished ← TRUE
        ELSE
            IF MovesUsed = 10
            THEN
                OUTPUT "You Lose"            // 10 moves played, X not found
                GameFinished ← TRUE
            ELSE
                OUTPUT "You are in row ", PlayerRow, " column ", PlayerCol, " Moves used: ", MovesUsed
            ENDIF
        ENDIF
    ELSE
        // A rejected move is not counted and the position does not change
        OUTPUT "That move is not within the grid. Please try again."
    ENDIF
ENDWHILE

Why this is a complete response

It covers the five mark-scheme requirements: the X is placed at random and every other cell emptied (R1), the player starts at the top left with 10 moves counted (R2), each move is validated to stay within the grid and rejected moves are not counted (R3), “You Win” is displayed when the X is reached in 10 moves or fewer (R4), and “You Lose” is displayed after 10 moves without finding the X (R5).

What to check before submitting

Check the INT(RANDOM() * 5) + 1 ranges, the UNTIL condition that rules out Grid[1,1], the four direction-and-bound tests, that rejected moves neither move the player nor count, the X-before-clock test order, 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 grid game play out.

Step through a complete sample game. Watch the grid being emptied, the secret X placed at random, the rejected and accepted moves changing the player’s position, and the win test ending the game two moves early.

Last tab · Trace player

Sample input → expected results

One sample game on the real 5 × 5 grid. The random draw has hidden the X in Grid[4,4] — shown in the table only so you can follow the walk; the real program never displays it — and the player finds it in exactly 8 of the 10 allowed moves: right, right, down, up, right, down, down, down. The walk deliberately includes a rejected move (up from the top row, which is not within the grid and does not use up one of the 10 moves) and a wasted move (move 4 steps back up to row 1), so the boundary handling is visible. These are illustrative values, not data supplied by the examination question.

The game grid Grid[,] · 5 rows × 5 columns · secret X visible

Grid row	Column 1	Column 2	Column 3	Column 4	Column 5

The first index selects the row, the second the column: Grid[4, 4] is row 4, column 4. The secret cell is shown here so you can follow the walk — the real game never displays it.

Reveal the final grid and game summary

Expected final grid After the winning walk

Grid row	Cell 1	Cell 2	Cell 3	Cell 4	Cell 5	Times entered	Last move in row

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Live game counters

Ready

Tip: use Next step slowly and watch PlayerRow, PlayerCol and MovesUsed. The move counter only grows on accepted moves — the rejected up move leaves it at zero, and Moves left counts down from 10.

Trace colours: blue row = the player’s current row; amber cell = the player’s current cell; green cells = cells already visited on the walk.

Worked detail: the rejected up move fails because 1 − 1 = 0 lies outside rows 1 to 5, so neither the position nor the move counter changes. Move 4 steps back up to row 1, so the cell in row 1, column 3 shows the last move that landed on it — move 4 — and row 1’s Times entered counts the start plus four landings. Because the win test runs before the tenth-move test, reaching Grid[4,4] on move 8 displays You Win with 2 moves to spare.

A ten-move hunt for the secret cell in a 5 × 5 grid.

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

Set up the grid, the X and the player

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Loop until the game is won or lost

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Validate every move against the edge of the grid

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Test for the X, then for the tenth move

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

End the game and check the whole answer

🧠 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 grid game play out.

Sample input → expected results

The game grid Grid[,] · 5 rows × 5 columns · secret X visible

Expected final grid After the winning walk

Execution trace

Initialisation

Live variable values

Live game counters