15-mark question lab · start here

From a Boolean seat grid to bookings, refusals and a full house.

Build the solution in a sensible order: decode the five requirements, plan the counters and constants, count the booked seats with nested loops, input and validate the request, then allocate seats in order or report exactly why you cannot. Learn the reasoning before revealing the complete program.

2D Boolean arrayNested iteration and countingInput validationSelection and assignmentRow-major allocation15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the given 2D Boolean array Evening[], the FALSE and TRUE meanings, the four-seat booking limit and the five requirements hidden in the bullet list.

02 · Construct

Build the program in order: count the booked seats with nested loops and output the total, input and validate the number of seats required with a re-ask loop, then check availability before changing any seat.

03 · Complete

Allocate seats in row-major order — a request can cross a row boundary — output the row and seat number for every seat booked, and report the seats-left message or “House full” when the request cannot be met.

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 Boolean meanings, the four-seat limit and the rule that seats are allocated in order all shape the structure of your solution.

Question 10 · 15 marks

Cambridge IGCSE Computer Science · 0478/21 · Question 10

Drama students put on a performance of a play for one evening. Seats in a small theatre can be booked for this performance.

The theatre has 10 rows of 20 seats. The status of the seat bookings for the evening is held in the two-dimensional (2D) Boolean array Evening[].

Each element contains FALSE if the seat is available and TRUE if the seat is booked.

Up to and including four seats can be booked at one time. Seats are allocated in order from those available. A row or seat number cannot be requested.

The array Evening[] has already been set up and some data stored.

Write a program that meets the following requirements:

counts and outputs the number of seats already booked for the evening
allows the user to input the number of seats required
validates the input
checks if enough seats are available:
- if they are available
  - changes the status of the seats
  - outputs the row number and seat number for each seat booked
- if they are not available:
  - outputs a message giving the number of seats left or ‘House full’ if the theatre is fully booked.

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.

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

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

Find the number of seats available for the performance and output it — searching the 10 × 20 Boolean array Evening[] with nested iteration, counting the TRUE cells into SeatCounter.

Allow the user to input the number of seats required — input with a suitable message; up to and including four seats can be booked at one time.

Validate the input — iteration and selection that re-ask while the value is below 1, above 4 or not a whole number.

Check if enough seats are available; if they are, change the status of the seats and output the row number and seat number for each seat booked — selection, assignment and output.

If they are not available, output a message giving the number of seats left or “House full” if the theatre is fully booked — selection and output with appropriate messages.

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

🧠 Step-by-step thinking

Spot the given array and its meaning. Evening[] is a 2D Boolean array of 10 rows and 20 seats; FALSE means the seat is available and TRUE means it is booked — the value is the seat’s status, and the program changes it.
Read the booking rules twice. Up to and including four seats can be booked at one time; seats are allocated in order from those available; a row or seat number cannot be requested — the customer never chooses where they sit.
Separate the once-only count from the per-request work. Counting the seats already booked happens once, before any request; the input, the validation, the availability checks and the booking happen around each request.
Notice the three-way ending. Enough seats → change the status and output the row and seat number for each seat booked; not enough → output the number of seats left; theatre fully booked → output “House full”.
Build the order. count pass over the whole grid → output the count → prompt and input → validation re-ask loop → house-full check → enough-seats check → book in order and output each seat, or output the refusal message.

Given: Evening[] 10 × 20FALSE free · TRUE bookedLimit: 1 to 4 seatsNo row or seat requests

❓ Guiding questions – think before revealing

Why does the question stress that a row or seat number cannot be requested?
What do FALSE and TRUE let you do that a number would not?
Where does the count pass belong in the program?

Reveal suggested reasoning

Why does the question stress that a row or seat number cannot be requested? Because allocation is the program’s job, not the customer’s. The program must search Evening[] in order and take the first available seats — the user inputs only how many seats, never where.

What do FALSE and TRUE let you do that a number would not? The Boolean is the seat’s status in one cell. Testing IF Evening[Row, Column] asks “is this seat booked?” directly, and booking a seat is a single assignment: Evening[Row, Column] ← TRUE.

Where does the count pass belong in the program? At the very start, before any input. The question’s first bullet asks for the number of seats already booked, and both availability checks later need that total.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Once: count every booked seat in the grid
FOR Row ← 1 TO 10
    FOR Column ← 1 TO 20
        // IF this seat is TRUE, add 1 to the booked counter
    NEXT Column
NEXT Row
// OUTPUT the number of seats already booked

// Per request:
//   prompt and INPUT the number of seats required
//   WHILE the input is invalid: re-ask
//   IF the theatre is full: OUTPUT "House full"
//   ELSE IF not enough seats: OUTPUT how many are left
//   ELSE book the seats in order, OUTPUT row and seat for each

📖 Detailed explanation

The Boolean array is both map and memory. Each cell records one seat’s status; reading it checks availability and writing TRUE books the seat — no second array is needed.

“Up to and including four” gives the validation bounds. The legal values are exactly 1, 2, 3 and 4, so the validation loop rejects anything below 1, above 4 or not a whole number.

“In order from those available” fixes the allocation rule. Seats are considered row by row, seat by seat, from the first FALSE cell onwards — a request can cross a row boundary.

The closing lines shape the answer. “You do not need to declare any arrays or variables” and “you do not need to initialise the data” mean the algorithm starts straight into the count pass with the given array.

⚠️ Common mistakes

Letting the user choose a row or seat number — the question forbids it; the program allocates.
Counting the available seats instead of the booked seats, or forgetting to output the count.
Booking seats before checking that enough are available.
Treating “House full” and “not enough seats” as the same case — the question lists two different messages.

💡 Exam hack / tip

Underline FALSE = available, TRUE = booked and up to and including four the moment you read them: they give you the test, the assignment and the validation bounds. Then list the three endings — booked, seats left, house full — so no branch goes missing.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R3 · 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 and arrays that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given array exactly. The mark scheme lists the 2D array Evening[1:10, 1:20] as a required data structure whose name must be used as given in the scenario — one Boolean per seat, 200 cells in all.
Use the published answer’s variable names. It declares Counter, SeatCounter, NumSeats, Row and Column — five integers that cover the count, the request and the allocation scan.
Add three constants. HouseFull = 200 (10 rows × 20 seats), MaxRow = 10 and MaxColumn = 20 keep every comparison and wrap-around meaningful.
SeatCounter drives every decision. It holds the number of seats already booked; HouseFull − SeatCounter is the number of seats left, which decides both the booking and the refusal message.
Row and Column serve twice. They run the counting loops, then run again in the allocation scan — one pair of names, two passes over the grid.

Given: Evening[1:10, 1:20]Variables: five integersConstants: HouseFull, MaxRow, MaxColumnSeatCounter drives the checks

❓ Guiding questions – think before revealing

Why is SeatCounter enough for both availability checks?
Why declare Row and Column instead of reusing Counter for the scan?
Do you need an array to remember which seats were booked?

Reveal suggested reasoning

Why is SeatCounter enough for both availability checks? Once the count pass finishes, SeatCounter is the number of booked seats. The theatre is full when SeatCounter = HouseFull, and the seats left are HouseFull − SeatCounter — no second count is needed.

Why declare Row and Column instead of reusing Counter for the scan? The allocation scan walks the grid cell by cell until it finds a FALSE seat, while Counter counts how many seats this request has booked so far. Two jobs, two variables — the published answer uses all five names.

Do you need an array to remember which seats were booked? No. Evening[] already stores the change — each booking is Evening[Row, Column] ← TRUE — and the row and seat numbers are output the moment they are booked.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question — already set up and stored:
//   Evening[1:10, 1:20]   2D Boolean array
//        FALSE = seat available, TRUE = seat booked

// Working values the program uses:
SeatCounter      // number of seats already booked (the count pass total)
NumSeats         // number of seats the customer requires
Counter          // seats booked so far for this request
Row              // current row, 1 to MaxRow
Column           // current seat, 1 to MaxColumn

// Constants that keep the logic readable:
CONSTANT HouseFull = 200     // 10 rows of 20 seats
CONSTANT MaxRow = 10
CONSTANT MaxColumn = 20

📖 Detailed explanation

The given array stores everything permanent. AO2 credit comes from data structures that store all the data required — here one 2D Boolean array records the status of all 200 seats, and booking updates it in place.

Five variables, five jobs. SeatCounter totals the booked seats, NumSeats holds the request, Counter tracks the booking loop, and Row and Column address the grid.

Constants make the checks self-explaining. SeatCounter = HouseFull reads as English, and the theatre’s 200 seats never appear as a bare magic number.

Meaningful identifiers earn AO3 credit. The published answer’s names — SeatCounter, NumSeats, HouseFull — say what they hold, and every name maps back to the question’s wording.

⚠️ Common mistakes

Renaming Evening[], which the mark scheme treats as not using the supplied data structure.
Using one variable for the request and the booking loop counter, so the loop overwrites the request.
Hard-coding 200, 20 and 10 everywhere instead of named constants.
Adding a second array to copy the bookings — Evening[] already records every change.

💡 Exam hack / tip

Point at each name and ask “which phrase in the question does this store?” SeatCounter answers “the number of seats already booked”, NumSeats answers “the number of seats required” and HouseFull answers “the theatre is fully booked”.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR1 · R2 · 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 counter and constants

Zero SeatCounter before the count pass and fix the house limits.

🧠 Step-by-step thinking

Zero the counter first. The published answer writes SeatCounter ← 0 before the loops, because the count pass adds to it — SeatCounter ← SeatCounter + 1 reads the variable before writing it.
Constants are set once. HouseFull = 200, MaxRow = 10 and MaxColumn = 20 never change while the program runs — they size the checks and the wrap-around.
The grid needs no initialising. The question states Evening[] has already been set up and some data stored — the closing line “you do not need to initialise the data” means the count pass starts reading real values at once.
The published answer’s typo. It prints SeatCounter1 ← 0 beside the comment “initialise seat counter for performance 1” — a stray “1” from the comment; the intended statement is SeatCounter ← 0.

Zeroed once: SeatCounterFixed: three constantsUntouched: Evening[] data

❓ Guiding questions – think before revealing

Why must SeatCounter be zeroed before the loops?
Why does the program not fill Evening[] with values first?
Where do Row and Column get their first values?

Reveal suggested reasoning

Why must SeatCounter be zeroed before the loops? The count pass performs SeatCounter ← SeatCounter + 1 for every TRUE cell. Without the zero, the total would start from whatever the variable happened to hold — an unknown value.

Why does the program not fill Evening[] with values first? The question’s closing lines say the array has already been set up and you do not need to initialise the data. Any initialising loop would be wasted work and earns nothing.

Where do Row and Column get their first values? In the count pass — FOR Row ← 1 TO 10 and FOR Column ← 1 TO 20 assign them as the loops begin, so no separate initialisation is needed.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// constants fixed once for the whole program
CONSTANT HouseFull = 200     // 10 rows of 20 seats
CONSTANT MaxRow = 10
CONSTANT MaxColumn = 20

// the count pass needs a genuine zero start
SeatCounter ← 0

// Evening[] is given — no initialisation of the data is required
FOR Row ← 1 TO 10
    FOR Column ← 1 TO 20
        // count this seat if it is booked (Stage 04)
    NEXT Column
NEXT Row

📖 Detailed explanation

One zero, one place. SeatCounter is zeroed once, before the loops; nothing else accumulates, so nothing else needs resetting.

The given data is treated as read-only until booking. The count pass changes no cell — it only reads TRUE and FALSE on its way to the total.

The constants document the theatre’s shape. MaxRow = 10 and MaxColumn = 20 match the question’s second sentence, and HouseFull = 200 appears in both availability checks.

⚠️ Common mistakes

Forgetting SeatCounter ← 0, so the count starts from an unknown value.
Writing a loop that initialises Evening[] — the question says the data is already stored.
Zeroing SeatCounter inside the loops, so every row resets the count.
Redefining the constants between passes, which pseudocode constants do not allow.

💡 Exam hack / tip

Say it as a rule: zero what accumulates, before the loop that accumulates it; never touch data the question has already stored.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR1 · count starts from zeroAO3 · constants and clean start

Initialisation supports AO2 because the counter genuinely starts from a known state, and AO3 because the constants and the zero sit in the right place. These are alignment notes, not separately allocated marks.

Count the seats already booked

Nested loops read all 200 cells and total the TRUE ones.

🧠 Step-by-step thinking

Nest the loops row-outside, seat-inside. FOR Row ← 1 TO 10 wraps FOR Column ← 1 TO 20, so the program reads row 1 seat by seat, then row 2, and so on — 10 × 20 = 200 visits.
Test the Boolean directly. IF Evening[Row, Column] is TRUE exactly when the seat is booked — the published answer tests the cell with no comparison needed.
Add one per booked seat. SeatCounter ← SeatCounter + 1 runs only inside the THEN branch, so the counter totals the booked seats — the requirement’s “counts”.
Output the count with a message. The requirement says counts and outputs; the published example answer omits the line, so add OUTPUT "Seats already booked ", SeatCounter straight after NEXT Row.
Seats available follow for free. HouseFull − SeatCounter is the number of seats left — computed later from the same total, with no second pass.

Iteration: FOR inside FORTest: IF Evening[Row, Column]Counting: + 1 per TRUE

❓ Guiding questions – think before revealing

Why does the count pass visit all 200 cells instead of stopping early?
Why test IF Evening[Row, Column] instead of comparing with TRUE?
The published answer seems to miss the output — what do you do?

Reveal suggested reasoning

Why does the count pass visit all 200 cells instead of stopping early? Booked seats can sit anywhere in the grid, so every cell must be tested. The published answer scans the whole theatre before taking any request.

Why test IF Evening[Row, Column] instead of comparing with TRUE? The cell is already a Boolean, so testing it directly is the idiomatic form — and the mark scheme’s requirement names “searching, nested iteration, output”, which this loop supplies.

The published answer seems to miss the output — what do you do? Add it. The question’s first bullet demands “counts and outputs the number of seats already booked”, so OUTPUT "Seats already booked ", SeatCounter completes R1. Published example answers occasionally drop a line; the requirement text always wins.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

SeatCounter ← 0

FOR Row ← 1 TO 10
    FOR Column ← 1 TO 20
        IF Evening[Row, Column]
          THEN
            SeatCounter ← SeatCounter + 1
        ENDIF
    NEXT Column
NEXT Row

OUTPUT "Seats already booked ", SeatCounter

📖 Detailed explanation

Nested iteration is the R1 technique. The mark scheme names “searching, nested iteration, output” — the seat loop inside the row loop, the counting, and the OUTPUT line are exactly that.

The two indexes address one seat. The first selects the row, the second the seat; Evening[Row, Column] is that one seat’s status.

The count is a search in disguise. Searching the grid for TRUE cells and counting them is the same visit — each TRUE cell found is one more booked seat.

One total serves three later decisions. The full-house check, the seats-left message and the booking all read SeatCounter after this pass.

⚠️ Common mistakes

Swapping the indexes — Evening[Column, Row] reads the wrong seat once Row passes 10.
Mixing the loop bounds — rows run to 10 and seats to 20, not the other way round.
Incrementing SeatCounter for FALSE cells, counting available seats instead of booked ones.
Forgetting the OUTPUT line, so the count is calculated but never reported.

💡 Exam hack / tip

Read the cell address aloud as “this row, this seat”: Evening[Row, Column]. Then check your loop bounds against the question’s own numbers — 10 rows, 20 seats.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · searching and nested iterationR1 · count and output booked seatsAO3 · correct two-index access

The nested loops and the count are the R1 evidence for AO2, and the two-index Boolean access is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Input and validate the request

Ask for the number of seats, then re-ask until it is 1, 2, 3 or 4.

🧠 Step-by-step thinking

Prompt with a suitable message. The closing line “all inputs and outputs must contain suitable messages” shapes the prompt: OUTPUT "How many seats do you want to book? 1, 2, 3 or 4 " — the published answer’s own wording.
Validate three ways at once. Reject the value while NumSeats < 1 or NumSeats > 4 or NumSeats <> ROUND(NumSeats, 0) — below the minimum, above the maximum, or not a whole number.
Re-ask inside a loop. A WHILE … ENDWHILE prints the correction message and takes a fresh INPUT NumSeats each time round — validation by iteration and selection, exactly the R2 techniques.
The bounds come from the question. “Up to and including four seats can be booked at one time” makes 1 the minimum and 4 the maximum — “including” is why the test is > 4, not >= 4.
The published answer’s typo. It prints WHILE 1 < NumSeats, which would reject every valid request of 2, 3 or 4; the intended test is NumSeats < 1.

Input: NumSeatsValidation: range and typeLoop: WHILE re-askBounds: 1 to 4

❓ Guiding questions – think before revealing

Why WHILE rather than a single IF?
What does the ROUND test catch?
Why is 4 allowed but 5 not?

Reveal suggested reasoning

Why WHILE rather than a single IF? A single IF can reject one bad value but cannot cope with a user who types another. The WHILE loop repeats until the value is genuinely valid — iteration is named in the R2 requirement.

What does the ROUND test catch? Values such as 2.5 — a number of seats must be whole, and NumSeats <> ROUND(NumSeats, 0) is TRUE whenever it is not.

Why is 4 allowed but 5 not? “Up to and including four seats” — the maximum itself is legal, so the rejection test is strictly NumSeats > 4.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

OUTPUT "How many seats do you want to book? 1, 2, 3 or 4 "
INPUT NumSeats

WHILE NumSeats < 1 OR NumSeats > 4 OR NumSeats <> ROUND(NumSeats, 0)
    OUTPUT "Please enter 1, 2, 3 or 4 for the number of seats "
    INPUT NumSeats
ENDWHILE

📖 Detailed explanation

Input, iteration and selection are the R2 techniques. One INPUT, one WHILE and three conditions — the mark scheme’s requirement is met by exactly this shape.

The message teaches the user the rules. The re-ask prompt restates the legal values, which is what “suitable messages” means for a validation loop.

Both boundary values must pass. 1 and 4 are legal; 0 and 5 are the first illegal values on either side — the classic range-check boundaries.

Validation happens before any availability check. The program never tests the house with a nonsense request such as 0 or 99 — order matters for the logic marks.

⚠️ Common mistakes

Validating with IF once, so a second invalid input passes straight through.
Writing NumSeats >= 4 and rejecting a perfectly legal four-seat request.
Checking the range but not whole numbers, so 2.5 seats can be requested.
Prompting again with a bare INPUT and no message — the question demands suitable messages.

💡 Exam hack / tip

Write the bounds as words first — at least 1, at most 4, whole numbers only — then turn each into one condition of the WHILE. Three phrases, three tests, one loop.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · input, iteration and selectionR2 · validate 1 to 4 with re-askAO3 · correct boundary tests

The input and validation loop are the R2 evidence for AO2, and the exact boundary tests are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Check availability and book the seats

Enough seats: flip the first FALSE cells in order and name each one.

🧠 Step-by-step thinking

Check the house before the request. IF SeatCounter = HouseFull catches the fully booked theatre — the “House full” case — before any seat hunting begins.
Check the request against the seats left. IF SeatCounter + NumSeats > HouseFull means the request cannot fit; otherwise there is room and the booking goes ahead.
Scan in order from the first seat. Start at Row ← 1, Column ← 0 and move forward — when Column passes MaxColumn, wrap to seat 1 of the next row. The first FALSE cell found is the next seat allocated.
Book by assignment. Evening[Row, Column] ← TRUE changes the status of the seat — the requirement’s exact words — and one OUTPUT names its row and seat.
Repeat once per requested seat. FOR Counter ← 1 TO NumSeats books exactly the number of seats asked for, each in row-major order, so a request can cross a row boundary.

Selection: two checksScan: row-major orderAssignment: ← TRUEOutput: row and seat

❓ Guiding questions – think before revealing

Why check SeatCounter = HouseFull separately?
How does a three-seat request cross a row boundary?
What does “changes the status of the seats” mean in code?

Reveal suggested reasoning

Why check SeatCounter = HouseFull separately? The question distinguishes two refusals: “House full” when the theatre is fully booked, and the number of seats left when it is not. With 200 booked, SeatCounter + NumSeats > HouseFull is also TRUE — only the separate test decides which message prints.

How does a three-seat request cross a row boundary? The scan moves seat by seat. If row 1 has only seats 19 and 20 free, the first two bookings fill them, then Column passes 20, Row becomes 2 and the third seat is row 2 seat 1 — allocation simply continues in order.

What does “changes the status of the seats” mean in code? One assignment per seat: Evening[Row, Column] ← TRUE. Nothing is deleted or moved — the Boolean flips and the seat is booked.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// inside the ELSE of the house-full check
IF SeatCounter + NumSeats > HouseFull
  THEN
    OUTPUT "Only ", HouseFull - SeatCounter, " seats left"   // Stage 07
  ELSE
    Row ← 1
    Column ← 0
    FOR Counter ← 1 TO NumSeats
        REPEAT                    // find the next available seat
            Column ← Column + 1
            IF Column > MaxColumn
              THEN
                Column ← 1
                Row ← Row + 1     // wrap to the next row
            ENDIF
        UNTIL Evening[Row, Column] = FALSE
        Evening[Row, Column] ← TRUE
        OUTPUT "Row ", Row, " seat ", Column, " booked"
    NEXT Counter
ENDIF

📖 Detailed explanation

Selection, assignment and output are the R3 techniques. The two IFs supply the selection, ← TRUE the assignment, and the per-seat OUTPUT the output with appropriate messages.

Row-major order is what “in order from those available” means. Seats are considered row 1 seat 1, seat 2, … seat 20, row 2 seat 1, and so on; the first free seats in that order are the ones booked.

The scan skips booked seats without counting them. UNTIL Evening[Row, Column] = FALSE moves past every TRUE cell — pre-booked seats anywhere in the grid simply delay the scan.

Each seat is output the moment it is booked. “Outputs the row number and seat number for each seat booked” — one OUTPUT inside the loop, not one list after it.

⚠️ Common mistakes

Booking NumSeats seats from row 1 seat 1 regardless of what is already booked — overwriting TRUE cells.
Stopping the scan at the end of a row instead of wrapping to the next row.
Printing one combined line after the loop instead of a row-and-seat output for each seat booked.
Asking the user which row or seat they want — the question forbids requests.

💡 Exam hack / tip

Trace one booking by hand before coding: point at the grid and hop cell by cell saying “booked, booked, free” — the first “free” is your seat. That finger-walk is the REPEAT loop.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selection, assignment, outputR3 · book and name each seatAO3 · correct scan across rowsAO3 · comments explain purpose

The availability checks and the booking scan are the R3 evidence for AO2, and the correct wrap across rows is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Report the refusals

Not enough seats or a full house — two different messages.

🧠 Step-by-step thinking

Two refusals, two messages. The question’s last bullet splits the failure path: “outputs a message giving the number of seats left or ‘House full’ if the theatre is fully booked”.
House full means zero seats left. SeatCounter = HouseFull is the fully booked case — 200 of 200 — and prints "House full".
Seats left is a subtraction. When the theatre is not full but the request cannot fit, the message prints HouseFull − SeatCounter — the seats still available.
The published answer’s slips. It prints the same condition SeatCounter + NumSeats > 200 for both branches, and its seats-left message shows SeatCounter + NumSeats − 200; normalised, the house-full branch tests SeatCounter = HouseFull and the message prints HouseFull − SeatCounter.
The refusal path changes no seats. Nothing is booked when either refusal prints — Evening[] is untouched and the program ends.

Two refusals, two branchesMessage: seats leftMessage: House full

❓ Guiding questions – think before revealing

Why can the seats-left message not use SeatCounter alone?
When exactly is “House full” printed?
Could you merge both refusals into one message?

Reveal suggested reasoning

Why can the seats-left message not use SeatCounter alone? The customer asked for NumSeats but the theatre has HouseFull − SeatCounter free — the message must report the second number, not the request or the booked total.

When exactly is “House full” printed? Only when the theatre is fully booked — every one of the 200 seats is TRUE, so SeatCounter = HouseFull. A near-full house with one seat left prints the seats-left message instead.

Could you merge both refusals into one message? Not safely. “House full” and “Only 2 seats left” report different situations, and the question asks for both by name — two branches, two messages.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

IF SeatCounter = HouseFull
  THEN
    OUTPUT "House full"
  ELSE
    IF SeatCounter + NumSeats > HouseFull
      THEN
        OUTPUT "Only ", HouseFull - SeatCounter, " seats left"
      ELSE
        // book the seats in order (Stage 06)
    ENDIF
ENDIF

📖 Detailed explanation

The order of the checks matters. The full-house test comes first: with 200 booked, SeatCounter + NumSeats > HouseFull would also be TRUE, and the wrong message would print.

The subtraction is the available count. HouseFull − SeatCounter is the number of seats left — the exact figure the question’s message asks to give.

Appropriate messages close the program. Every path ends with words that name the situation — booked seats, seats left, or house full — as the closing line requires.

⚠️ Common mistakes

Printing “House full” whenever the request cannot fit — a theatre with 2 seats left is not full.
Reporting NumSeats or SeatCounter instead of the seats left.
Testing the not-enough-seats case first, so a full house prints the seats-left message with 0.
Booking some of the requested seats anyway — the requirement is all or nothing.

💡 Exam hack / tip

Write the two refusal messages side by side and read them aloud: zero left → “House full”; some left but not enough → “Only N seats left”. If both could print for the same state, your branches are in the wrong order.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selection and output with messagesR3 · seats left or House fullAO3 · correct check order

The refusal messages complete the R3 evidence for AO2, and the order of the two checks is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Cambridge assessment criteria

What does a high-level response look like?

The mark scheme assesses the answer across AO2 and AO3. Use these descriptors to check the whole program, not just one isolated code section.

9 AO2 + 6 AO3 = 15

AO2 · Apply knowledge and understandingMaximum 9 marks · programming techniques and data structures

Band	What the descriptor means
0	No creditable response.
1–3	At least one programming technique is used. Some data is stored, but not appropriately. Any use of iteration, selection, counting, totalling, input or output may be credited.
4–6	Some programming techniques are appropriate to the problem, with more than one technique applied. Some data structures are appropriate and store some of the required data.
7–9	The full range of techniques needed by the scenario is used appropriately. The chosen data structures are appropriate and store all the required data.

AO3 · Provide solutions to problemsMaximum 6 marks · comments, identifiers, logic and accuracy

Band	What the descriptor means
0	No creditable response.
1–2	Program seen without relevant comments. Some identifier names and some data-structure names are appropriate. The solution may be illogical or inaccurate in many places, but attempts at least one requirement.
3–4	Program seen with some relevant comments. The majority of identifiers and most data-structure names are meaningful. Parts may be illogical or inaccurate, but most requirements are met.
5–6	The program is fully commented. Suitable identifiers are meaningful throughout, and all data structures have meaningful names. The program is logical and accurate and meets all requirements; minor syntax errors are ignored.

How the seven stages contribute

These are links to the assessment criteria, not separate mark allocations.

R1–R5

Stage	Mark-scheme link	AO2 evidence	AO3 evidence
1 · Decode	R1–R3	Identifies the full set of required techniques, including the three-way ending.	Establishes logical order and comments the plan.
2 · Data	Required data structures	Uses Evening[] as given, with SeatCounter, NumSeats, Counter, Row, Column and the three constants.	Meaningful identifiers throughout.
3 · Initialise	R1	SeatCounter zeroed before the count; constants fixed once; the given data untouched.	Clean start with no wasted initialisation.
4 · Count	R1	Nested iteration searches all 200 cells, totals the booked seats and outputs the count.	Accurate two-index Boolean access.
5 · Validate	R2	Input with a suitable message; WHILE re-ask for below 1, above 4 or not whole.	Correct boundary tests, with 1 and 4 included.
6 · Allocate	R3	Checks availability, books seats in row-major order, changing status and outputting row and seat.	Scan wraps correctly across row boundaries.
7 · Report	R3	Prints the number of seats left or “House full” when the request cannot be met.	Full-house test before the seats-left test.

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 mirrors the official published mark scheme answer for 0478/21 October/November 2023 Question 10. The 2D Boolean array Evening[] is supplied by the question and is used exactly as given, and the published answer’s own identifiers — Counter, SeatCounter, NumSeats, Row and Column — and constants are kept. Its obvious slips are normalised: “SeatCounter1 ← 0” is read as SeatCounter ← 0, “WHILE 1 < NumSeats” as NumSeats < 1, the branch condition printed identically twice becomes the house-full test SeatCounter = HouseFull, the seats-left message prints HouseFull − SeatCounter, the missing count output is restored for R1’s “and output”, and the booking loop’s misprinted DIV/MOD indexes are rewritten as the row-major scan the question itself describes — “seats are allocated in order from those available”.

QUESTION 10 · PUBLISHED MARK SCHEME ANSWERCambridge 0478 style · 1-based indexing

// meaningful identifier names and appropriate data structures to store the data required
DECLARE Counter, SeatCounter, NumSeats, Row, Column : INTEGER

CONSTANT HouseFull = 200    // the theatre holds 10 rows of 20 seats
CONSTANT MaxRow = 10
CONSTANT MaxColumn = 20

SeatCounter ← 0    // initialise the seat counter for the performance

// count and output the seats already booked for the evening
FOR Row ← 1 TO 10
    FOR Column ← 1 TO 20
        IF Evening[Row, Column]
          THEN
            SeatCounter ← SeatCounter + 1
        ENDIF
    NEXT Column
NEXT Row
OUTPUT "Seats already booked ", SeatCounter

// validate input
OUTPUT "How many seats do you want to book? 1, 2, 3 or 4 "
INPUT NumSeats

WHILE NumSeats < 1 OR NumSeats > 4 OR NumSeats <> ROUND(NumSeats, 0)
    OUTPUT "Please enter 1, 2, 3 or 4 for the number of seats "
    INPUT NumSeats
ENDWHILE

IF SeatCounter = HouseFull    // check for house full
  THEN
    OUTPUT "House full"
  ELSE
    IF SeatCounter + NumSeats > HouseFull    // checks for not enough seats
      THEN
        OUTPUT "Only ", HouseFull - SeatCounter, " seats left"
      ELSE
        // book the required number of seats, allocated in order from those available
        Row ← 1
        Column ← 0
        FOR Counter ← 1 TO NumSeats
            REPEAT    // find the next available seat in row order
                Column ← Column + 1
                IF Column > MaxColumn
                  THEN
                    Column ← 1
                    Row ← Row + 1
                ENDIF
            UNTIL Evening[Row, Column] = FALSE
            Evening[Row, Column] ← TRUE    // change the status of this seat
            OUTPUT "Row ", Row, " seat ", Column, " booked"
        NEXT Counter
    ENDIF
ENDIF

Why this is a complete response

It covers the three mark-scheme requirements. R1: the nested loops search all 200 cells of Evening[], count the booked seats into SeatCounter and output the total with a suitable message. R2: the prompt, INPUT and WHILE re-ask loop validate the number of seats required — below 1, above 4 or not a whole number is refused and asked for again. R3: the two selection checks report “House full” or the number of seats left, and the booking loop allocates seats in row-major order, changes each status with Evening[Row, Column] ← TRUE and outputs the row and seat number for every seat booked.

What to check before submitting

Check the direct Boolean test Evening[Row, Column], the WHILE conditions NumSeats < 1, NumSeats > 4 and NumSeats <> ROUND(NumSeats, 0), the order of the two availability checks, the column wrap when Column passes MaxColumn, and the comments explaining the program.

Remember: the mark scheme awards AO2 a maximum of 9 marks and AO3 a maximum of 6 marks, giving 15 in total, judged by best fit across the whole response. R1, R2 and R3 are the technique requirements the examiners look for, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the program work.

Step through the sample evening. Watch the nested loops count the 196 booked seats, the validation loop refuse 5 and 0 before accepting 3, the allocation hop across the row 1 → row 2 boundary, the refused request print the seats-left message, the last seat fill the house exactly, and the final request meet “House full”.

Last tab · Trace player

Sample input → expected results

The sample theatre is the full 10 × 20 grid the question describes, holding 196 of 200 seats already booked: rows 3 to 10 are completely full, row 1 has only seats 19 and 20 free, and row 2 has only seats 1 and 2 free. The walkthrough follows the published mark scheme answer’s execution order and plays the evening forward through four customers, each running the program once: customer 1’s request fails validation twice (5 is above the limit, 0 is below it) before the valid 3 books seats across the row 1 → row 2 boundary; customer 2’s valid 3 meets the seats-left message with only 1 seat remaining; customer 3’s single seat fills the house exactly; customer 4’s request meets “House full”. This is the authentic 0478/21 October/November 2023 Question 10. These are illustrative values, not data supplied by the examination question.

Input array Evening[1:10, 1:20] · 1 = TRUE (booked), 0 = FALSE (available)

Row	Seat 1	Seat 2	Seat 3	Seat 4	Seat 5	Seat 6	Seat 7	Seat 8	Seat 9	Seat 10	Seat 11	Seat 12	Seat 13	Seat 14	Seat 15	Seat 16	Seat 17	Seat 18	Seat 19	Seat 20

The row label is the row index and each seat its column — row 1, seat 19 is Evening[1, 19]. The walkthrough begins with only those four 0 cells available.

Reveal expected evening results and house summary

Expected evening results After all four customers

Row	Booked before	Booked after	New seats booked	End of evening

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

House counters

Ready

Tip: use Next step slowly and watch SeatCounter climb during each count pass, then hold while Row and Column hop through the booking scan. The house counter Seats booked is the live grid — it moves as soon as a seat flips, while SeatCounter keeps its counted value until the program runs again.

Trace colours: blue row = current row being counted or booked; amber cell = the current seat; orange cells = seats already processed.

Boundary example: customer 1 asks for 3 seats when row 1 has only seats 19 and 20 free. The scan books Evening[1, 19] and Evening[1, 20], then Column passes MaxColumn, so Column ← 1 and Row ← 2 — the third seat is Evening[2, 1], across the row boundary. The refusal check is just as strict: 199 + 3 > 200 is TRUE, so the message prints HouseFull − SeatCounter = 1 seat left.

From a Boolean seat grid to bookings, refusals and a full house.

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 counter and constants

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Count the seats already booked

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input and validate the request

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Check availability and book the seats

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Report the refusals

🧠 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 Evening[1:10, 1:20] · 1 = TRUE (booked), 0 = FALSE (available)

Expected evening results After all four customers

Execution trace

Initialisation

Live variable values

House counters