15-mark question lab · start here

From a cinema seat map to a booked ticket.

Build the solution in a sensible order: understand the seat data, count what is still available, total the money already collected, find the row with the most free seats, validate the customer's request and book the seat. Learn the reasoning before revealing the complete program.

2D arraysNested iterationMaximum trackingValidation and booking15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the two 2D arrays, their shared row-and-seat indexes, and the values already supplied.

02 · Construct

Use nested loops to count the available seats in each row and total the money from booked seats.

03 · Complete

Track the row with the most available seats, validate the requested seat, book it and output every required result.

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 two arrays, the validation ranges and the booking rules all affect the structure of your solution.

Question 14 · 15 marks

Cambridge IGCSE Computer Science · 0478/02 · Question 14

A cinema has seats arranged in rows. The two-dimensional (2D) array SeatTaken[] contains, for every seat, the value TRUE if the seat has already been booked and FALSE if the seat is still available. The first index gives the row number and the second index gives the seat number within the row. For example, SeatTaken[3, 7] refers to seat 7 in row 3.

The two-dimensional (2D) array SeatPrice[] contains the price of every seat. The two arrays use the same row and seat indexes, so SeatPrice[3, 7] is the price of seat 7 in row 3.

The variable RowNo contains the number of rows. The variable SeatsInRow contains the number of seats in each row. Every row has the same number of seats.

The arrays and variables have already been set up and the data stored.

Write a program that meets the following requirements:

counts and outputs the number of seats still available in each row
calculates and outputs the total number of seats still available in the whole cinema
calculates and outputs the total amount of money already collected from all the booked seats
finds and outputs the number of the row with the most seats still available
asks the user to input the row number and the seat number of the seat they want to book; both inputs must be validated as within the correct range
if the requested seat is still available, books the seat, outputs the price of the seat and outputs the new total number of seats available in the whole cinema; if the requested seat is already booked, outputs a suitable message.

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

You do not need to initialise the data in the arrays.

Before you move on

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

Mark-scheme map

Count the seats still available in each row using iteration and counting.

Total the available seats for the whole cinema and the money collected from booked seats.

Find the row with the most available seats using maximum tracking.

Input and validate the requested row and seat numbers.

Book the seat when it is available and output the price and the updated total, or a suitable message when it is taken.

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

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Identify the repeated unit. Every seat of every row must be examined, so an outer loop must repeat from row 1 to RowNo and an inner loop from seat 1 to SeatsInRow.
Identify the two accumulations. Counting available seats and totalling the money from booked seats can both happen during the same visit to each seat.
Identify the comparison process. “The row with the most” signals a maximum search over the completed row totals.
Identify the interactive part. One booking request is made, and both inputs must be validated before they are used.
Build the order: initialise → count and total per row → whole-cinema totals → best row → input and validate → book → updated output.

Outer loop: rowsInner loop: seatsSelection: taken or freeValidation: input ranges

❓ Guiding questions – think before revealing

Which phrases tell you how many loops are needed?
Which totals are per row, and which are for the whole cinema?
What must happen when the requested seat is already booked?

Reveal suggested reasoning

Which phrases tell you how many loops are needed? “In each row” signals the outer loop over rows; every seat in the row is examined by the inner loop.

Which totals are per row, and which are for the whole cinema? The available-seat count is produced for each row. The total available seats and the money collected are whole-cinema figures.

What must happen when the requested seat is already booked? The program must not book it; it outputs a suitable message and changes nothing.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Visit every seat in the cinema
FOR RowCounter ← 1 TO RowNo
    FOR SeatCounter ← 1 TO SeatsInRow
        // Count available seats; total money from booked seats
    NEXT SeatCounter
    // Store and output this row's available count
NEXT RowCounter

// Output the whole-cinema totals and the best row
// Input and validate the requested row and seat
// Book the seat if it is available, then output the results

📖 Detailed explanation

“In each row” tells you the available-seat count is produced once per row, inside the row loop.

“Whole cinema” and “all the booked seats” tell you two totals accumulate across every row and are output once.

“The most seats still available” is a maximum: each row’s total is compared with the best so far.

“Must be validated” means each input is checked against its range and re-asked until it is valid.

The order matters: the best-row search needs the completed row counts, and the booking must use validated indexes.

⚠️ Common mistakes

Starting to write code before identifying the six required outcomes.
Mixing up the seat count with the money total.
Trying to find the best row before the row counts exist.
Using unvalidated inputs to book a seat.

💡 Exam hack / tip

Underline “in each row”, “whole cinema”, “the most” and “must be validated”. Those phrases reveal the counting loop, the cinema-level totals, the maximum search and the validation loops.

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

AO2 · Data structures

🧠 Step-by-step thinking

Use the given structures. SeatTaken stores one boolean value per seat; SeatPrice stores one price per seat.
Keep the same index order. SeatTaken[RowCounter, SeatCounter] and SeatPrice[RowCounter, SeatCounter] refer to the same seat: row first, seat second.
Store each row’s count. The 1D array AvailableInRow[] keeps one available count per row, ready for the maximum search.
Use whole-cinema totals. AvailableTotal and MoneyCollected accumulate across all rows.
Plan the booking identifiers. BestRow and BestRowAvailable track the maximum; RequestRow and RequestSeat store the customer’s validated request.

❓ Guiding questions – think before revealing

Why do both 2D arrays use the same indexes?
Which arrays and variables are already supplied?
Why store the available count in an array rather than a single variable?

Reveal suggested reasoning

Why do both 2D arrays use the same indexes? The question states they share the row-and-seat index order, so one pair of loop counters can read both arrays for the same seat.

Which arrays and variables are already supplied? SeatTaken, SeatPrice, RowNo and SeatsInRow are already set up and populated.

Why store the available count in an array rather than a single variable? Each row needs its own count. Keeping all six counts means the maximum search can compare rows without visiting every seat again.

Given by the question

2D array	`SeatTaken[,]`
2D array	`SeatPrice[,]`
Variables	`RowNo`, `SeatsInRow`

These are already set up and contain data. Do not initialise them again.

Additional identifiers

Array	`AvailableInRow[]`
Loop counters	`RowCounter`, `SeatCounter`
Cinema totals	`AvailableTotal`, `MoneyCollected`
Maximum	`BestRow`, `BestRowAvailable`
Request	`RequestRow`, `RequestSeat`

Reveal Cambridge pseudocode for Stage 2

CAMBRIDGE PSEUDOCODE · DECLARATIONSBased on the specimen mark-scheme style

DECLARE AvailableInRow : ARRAY[1:20] OF INTEGER
DECLARE RowCounter : INTEGER
DECLARE SeatCounter : INTEGER
DECLARE AvailableTotal : INTEGER
DECLARE MoneyCollected : INTEGER
DECLARE BestRow : INTEGER
DECLARE BestRowAvailable : INTEGER
DECLARE RequestRow : INTEGER
DECLARE RequestSeat : INTEGER

📖 Detailed explanation

Both 2D arrays share the same index order — row first, seat second — so SeatTaken[3, 7] and SeatPrice[3, 7] describe the same seat.

AvailableInRow stores one value per row. The maximum search then works on this small array instead of re-visiting all sixty seats.

The cinema-level totals live in single variables because they are never needed per row.

RequestRow and RequestSeat are named to show they hold the customer’s request after validation. Meaningful identifiers support the AO3 requirement.

⚠️ Common mistakes

Using a single index for SeatTaken or SeatPrice.
Swapping the row and seat index order between the two arrays.
Renaming identifiers that the scenario says must be used as provided.
Declaring or initialising the supplied arrays as though they were empty.

💡 Exam hack / tip

Write the reminder “row, seat” beside every 2D array access, and check that both arrays use the same order. One index pair must work for SeatTaken and SeatPrice together.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresAO2 · store all required dataR1–R5 · counters and totalsAO3 · meaningful identifiers

The AO2 7–9 descriptor requires appropriate data structures that store all data required by the scenario. The given 2D arrays are reused, and the row-count array supports both R1 and R3 without extra work.

Initialise the counters and totals

Give every accumulator a known starting value before it is used.

R1 · R2

🧠 Step-by-step thinking

Ask what is counted. No seats have been counted yet, so AvailableTotal must start at zero.
Ask what is totalled. No money has been added yet, so MoneyCollected must also start at zero.
Reset the row counter once per row. AvailableInRow[RowCounter] must return to zero at the start of each row, before that row’s seats are visited.
Do not reset the cinema totals for each row. They must keep accumulating until every row has been processed.
Do not initialise the question’s input arrays. The question explicitly says their data is already stored.

❓ Guiding questions – think before revealing

Which values must start at zero before counting begins?
Why is AvailableInRow reset for every row?
Should SeatTaken and SeatPrice be initialised?

Reveal suggested reasoning

Which values must start at zero before counting begins? AvailableTotal and MoneyCollected, once for the whole program.

Why is AvailableInRow reset for every row? Each row has its own available count stored in its own array element, so every element needs a known starting value before its seats are counted.

Should SeatTaken and SeatPrice be initialised? No. The question states that both arrays already contain the cinema’s data.

Reveal Cambridge pseudocode for Stage 3

CAMBRIDGE PSEUDOCODE · INITIALISATIONBefore the main processing loop

// Initialise the whole-cinema totals
AvailableTotal ← 0
MoneyCollected ← 0

FOR RowCounter ← 1 TO RowNo
    // Each row starts with no available seats counted
    AvailableInRow[RowCounter] ← 0
    // The inner seat loop follows in Stage 4
NEXT RowCounter

📖 Detailed explanation

Cinema totals: AvailableTotal and MoneyCollected are initialised once, before the outer loop, because they accumulate for the whole cinema.

Row counter: AvailableInRow[RowCounter] is re-initialised at the start of each row iteration. A per-row accumulator must reset per row.

Maximum: BestRow and BestRowAvailable are initialised after the counting loop, when the first row’s total is known. This is shown in Stage 5.

Given data: re-initialising SeatTaken or SeatPrice would destroy the cinema’s booking state and lose all the money data.

⚠️ Common mistakes

Resetting AvailableTotal inside the row loop, erasing earlier rows’ counts.
Forgetting to zero MoneyCollected.
Initialising AvailableInRow once only, so later rows inherit earlier rows’ counts.
Adding unnecessary code to initialise SeatTaken or SeatPrice, even though the question says they already contain data.

💡 Exam hack / tip

Use the rule “reset an accumulator immediately before the loop that updates it”. A per-row accumulator resets once per row; a whole-cinema accumulator resets once for the whole program.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · initialisationR1 · row countersR2 · cinema totalsAO3 · comments explain purpose

Initialising every accumulator before use is part of the logical, accurate program the AO3 5–6 descriptor expects. The exemplar zeroes the cinema totals first and resets each row counter at the start of its row.

Count available seats and total the money

Use an outer loop for rows and an inner loop for seats.

R1 · R2 · Counting and totalling

🧠 Step-by-step thinking

Select one row. The outer loop sets RowCounter to the current row and resets that row’s counter.
Visit every seat in that row. The inner loop changes SeatCounter from 1 to SeatsInRow.
Check the seat’s state. Read SeatTaken[RowCounter, SeatCounter].
Update the matching accumulator. FALSE means available, so increment the row count; TRUE means booked, so add the seat’s price to MoneyCollected.
Close the row. After the inner loop, add the row count to AvailableTotal and output the row’s result.

Worked example · Row 1

Seats 1 to 8 are booked at $6; seats 9 and 10 are free. The row count becomes 0 → 1 → 2, and the money total gains 8 × 6 = $48.

❓ Guiding questions – think before revealing

Which loop should change the row position?
Why do the two updates live in different branches?
When is AvailableTotal updated, and why?

Reveal suggested reasoning

Which loop should change the row position? The outer loop changes RowCounter from 1 to RowNo; the inner loop changes SeatCounter from 1 to SeatsInRow.

Why do the two updates live in different branches? A seat is either available or booked. Available seats feed the count; booked seats feed the money total. One seat can never update both.

When is AvailableTotal updated, and why? After the inner loop, once per row, using the completed row count. Updating it per seat would also work, but the row-by-row update keeps the link to R1 clear.

Reveal Cambridge pseudocode for Stage 4

CAMBRIDGE PSEUDOCODE · NESTED LOOPSCore R1 and R2 operations

FOR RowCounter ← 1 TO RowNo
    // Reset this row's counter
    AvailableInRow[RowCounter] ← 0
    FOR SeatCounter ← 1 TO SeatsInRow
        IF SeatTaken[RowCounter, SeatCounter] = FALSE
        THEN
            AvailableInRow[RowCounter] ←
                AvailableInRow[RowCounter] + 1
        ELSE
            MoneyCollected ← MoneyCollected +
                SeatPrice[RowCounter, SeatCounter]
        ENDIF
    NEXT SeatCounter
    // Add the completed row to the cinema total
    AvailableTotal ← AvailableTotal + AvailableInRow[RowCounter]
    OUTPUT "Row ", RowCounter, " available seats: ",
        AvailableInRow[RowCounter]
NEXT RowCounter

OUTPUT "Total available seats: ", AvailableTotal
OUTPUT "Money collected: ", MoneyCollected

📖 Detailed explanation

One visit per seat serves both totals: the IF/ELSE sends each seat to exactly one accumulator, so no seat is missed or double-counted.

The ELSE branch reads the price from SeatPrice using the same row-and-seat indexes as SeatTaken — no second lookup is needed.

AvailableTotal is updated after the inner loop, once per row, using the completed row count.

The per-row OUTPUT sits inside the outer loop, so it appears once for every row. The two cinema totals are output after the outer loop.

For the sample cinema, RowNo = 6 and SeatsInRow = 10, so 60 seats are visited in total.

⚠️ Common mistakes

Incrementing the seat count in the same branch that adds the price.
Adding the price of available seats to MoneyCollected.
Testing SeatTaken = TRUE in the branch that counts available seats.
Putting the per-row output outside the outer loop, so only the last row is reported.
Updating AvailableTotal inside the inner loop, before the row count is complete.

💡 Exam hack / tip

Say “one seat, one branch”: FALSE feeds the count, TRUE feeds the money. The ELSE is not an afterthought — it is where the revenue requirement (R2) is earned.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · nested iterationAO2 · counting and totallingR1 · available seats per rowR2 · money collectedAO3 · accurate branch logic

This stage addresses R1 and R2 directly: the counting loop earns the per-row availability, and the ELSE branch earns the revenue total. Both are explicit requirements in the mark scheme.

Find the row with the most available seats

Crown the first row as champion, then let every other row challenge it.

R3 · Maximum tracking

🧠 Step-by-step thinking

Crown the first row. Before comparing anything, row 1 is the champion: BestRow ← 1 and BestRowAvailable ← AvailableInRow[1].
Challenge the rest. Loop from row 2 to RowNo.
Replace on strictly greater. If AvailableInRow[RowCounter] > BestRowAvailable, update both champion variables.
Keep the first row on ties. Because the comparison uses >, a row that only equals the champion does not replace it.
Output the row number. After the loop, BestRow holds the answer.

Champion: row 1Loop: rows 2 to RowNoReplace only if >Ties keep the first row

❓ Guiding questions – think before revealing

Why does row 1 become the first champion?
What happens when two rows have the same count?
Why use > instead of >=?

Reveal suggested reasoning

Why does row 1 become the first champion? A maximum search needs a starting candidate. Row 1’s completed count is a real value, so the first comparison is always meaningful.

What happens when two rows have the same count? Nothing changes: the challenger’s count is not strictly greater, so the earlier row keeps the title.

Why use > instead of >=? With >, the first of several tied rows is reported. With >=, the last one would be. Either rule is acceptable if applied consistently, but > is the usual exemplar choice.

Reveal Cambridge pseudocode for Stage 5

CAMBRIDGE PSEUDOCODE · MAXIMUM TRACKINGAfter the counting loop

// Row 1 is the first candidate
BestRow ← 1
BestRowAvailable ← AvailableInRow[1]

FOR RowCounter ← 2 TO RowNo
    IF AvailableInRow[RowCounter] > BestRowAvailable
    THEN
        BestRow ← RowCounter
        BestRowAvailable ← AvailableInRow[RowCounter]
    ENDIF
NEXT RowCounter

OUTPUT "Row with most available seats: ", BestRow

📖 Detailed explanation

This is the champion pattern: store the best value and its position, then compare every remaining candidate with the running best.

Sample tie: rows 2 and 3 both finish with 6 available seats. Row 3 does not replace row 2, because 6 > 6 is FALSE. Row 6 then wins with 10.

Boundary behaviour: with >= instead, a tie would replace the champion and the last tied row would be reported. The answer must follow one consistent rule.

The two champion variables are an inseparable pair: updating BestRow without BestRowAvailable breaks every later comparison.

⚠️ Common mistakes

Comparing each row with AvailableInRow[1] instead of the running champion BestRowAvailable.
Forgetting to update BestRowAvailable together with BestRow.
Outputting BestRowAvailable when the question asks for the row number.
Initialising BestRowAvailable to zero before any counts exist, then comparing row 1 with itself anyway.

💡 Exam hack / tip

“Crown the first, challenge the rest”: initialise the champion from row 1, loop from row 2, and use strictly greater than so the first row keeps ties. Write the two champion updates as an inseparable pair.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · maximum trackingR3 · row with most availableAO3 · accurate comparison logicAO3 · tie behaviour explained

R3 asks for the row with the most available seats. The champion pattern is the appropriate technique, and explaining the tie behaviour demonstrates the accurate logic the AO3 5–6 descriptor rewards.

Input and validate the requested row and seat

Ask first, check after — re-ask until both values are within range.

R4 · Input validation

🧠 Step-by-step thinking

Ask for the row. OUTPUT a prompt that shows the valid range, then INPUT RequestRow.
Check the range. The value must be at least 1 and at most RowNo.
Repeat until valid. REPEAT-UNTIL automatically re-asks whenever the condition fails.
Repeat the same pattern for the seat. The valid range is 1 to SeatsInRow.
Use the validated values everywhere. The booking in Stage 7 can trust RequestRow and RequestSeat.

❓ Guiding questions – think before revealing

Why is REPEAT-UNTIL suitable here?
What exactly makes a row number valid?
Why use two separate validation loops?

Reveal suggested reasoning

Why is REPEAT-UNTIL suitable here? The user must type a value before it can be checked. REPEAT-UNTIL is a post-condition loop, so the body always runs at least once — exactly the “ask, then check” pattern.

What exactly makes a row number valid? It is at least 1 AND at most RowNo. Both checks must pass together.

Why use two separate validation loops? Each input has its own prompt and its own range. A single combined loop would re-ask both values even when only one is invalid.

Reveal Cambridge pseudocode for Stage 6

CAMBRIDGE PSEUDOCODE · VALIDATIONPost-condition input loops

// Input and validate the requested row
REPEAT
    OUTPUT "Enter row number (1 to ", RowNo, ")"
    INPUT RequestRow
UNTIL RequestRow >= 1 AND RequestRow <= RowNo

// Input and validate the requested seat
REPEAT
    OUTPUT "Enter seat number (1 to ", SeatsInRow, ")"
    INPUT RequestSeat
UNTIL RequestSeat >= 1 AND RequestSeat <= SeatsInRow

📖 Detailed explanation

Post-condition: REPEAT-UNTIL tests the condition after the body, so the prompt always appears at least once — the natural shape for input validation.

Compound condition: the two range checks are joined with AND. A value is valid only when it passes both; joining them with OR would accept almost every number.

Two loops: separating the row and seat prompts keeps each range check with its own input, so one valid value never has to be retyped.

Safe indexes: after validation, SeatTaken[RequestRow, RequestSeat] and SeatPrice[RequestRow, RequestSeat] are guaranteed to be inside both arrays.

⚠️ Common mistakes

Using WHILE with an uninitialised value, so the loop body may never run.
Checking only the upper bound, or only the lower bound, of the range.
Joining the two range checks with OR instead of AND.
Validating the seat with RowNo, or the row with SeatsInRow.

💡 Exam hack / tip

For input validation remember “ask first, check after”: REPEAT the prompt and input, UNTIL the value passes the whole range check. Copy the pattern for every input the question requires — never invent a different one halfway.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · validationR4 · validated row and seat inputsAO3 · post-condition loop logicAO3 · comments explain purpose

R4 explicitly requires both inputs to be validated as within range. A REPEAT-UNTIL loop with a compound AND condition is the appropriate technique and demonstrates the logical structure AO3 rewards.

Book the seat and output the final results

Check availability with the validated indexes, book or refuse, then report.

R5 · Selection and output

🧠 Step-by-step thinking

Check availability. SeatTaken[RequestRow, RequestSeat] = FALSE means the seat is still free.
Book in the TRUE branch. Write TRUE into the array, output the price, decrement AvailableTotal and output the new total.
Refuse politely in the ELSE. Output a suitable message and change nothing.
Update the total simply. Exactly one seat was booked, so AvailableTotal ← AvailableTotal − 1. Re-running the whole count is not needed.
Check every required output. Per-row counts, cinema totals, best row, booking result and updated total must all appear.

❓ Guiding questions – think before revealing

What exactly changes inside the array when a seat is booked?
Why does the updated total only appear in the TRUE branch?
Which required outputs come from earlier stages?

Reveal suggested reasoning

What exactly changes inside the array when a seat is booked? Only the single element SeatTaken[RequestRow, RequestSeat] changes from FALSE to TRUE. Everything else is untouched.

Why does the updated total only appear in the TRUE branch? The question links the new total to a successful booking. When the seat is already taken, nothing is booked, so no total is reported.

Which required outputs come from earlier stages? The per-row counts, the two cinema totals and the best row were output in Stages 4 and 5. This stage adds the booking result.

Reveal Cambridge pseudocode for Stage 7

CAMBRIDGE PSEUDOCODE · BOOKINGSelection with array update

IF SeatTaken[RequestRow, RequestSeat] = FALSE
THEN
    // Book the seat and update the cinema total
    SeatTaken[RequestRow, RequestSeat] ← TRUE
    OUTPUT "Seat booked. Price: ",
        SeatPrice[RequestRow, RequestSeat]
    AvailableTotal ← AvailableTotal - 1
    OUTPUT "Seats now available: ", AvailableTotal
ELSE
    OUTPUT "Sorry, that seat is already booked"
ENDIF

📖 Detailed explanation

State change: writing TRUE into SeatTaken is the booking. 2D arrays can be updated element by element, and the seat’s state changes for any later use.

Price lookup: the price is read from SeatPrice with the same validated index pair — no second input is needed.

Simple update: the decrement keeps AvailableTotal correct without repeating the counting loops. Recounting would also work, but it repeats work already done.

Placement: the booking IF sits after the validation loops and outside the counting loops. Everything above it has already been output.

Full order check: initialise → count and total per row → cinema outputs → best row → validate → book → booking outputs.

⚠️ Common mistakes

Setting SeatTaken to FALSE instead of TRUE when booking.
Outputting the price from SeatTaken instead of SeatPrice.
Updating AvailableTotal inside the ELSE branch, although no seat was booked.
Forgetting the final updated-total output after a successful booking.
Placing the booking IF inside the counting loops, so it runs once per seat.

💡 Exam hack / tip

Bookings change state: read with the validated indexes, write the new state back. Then ask “what must the user see?” — the price and the new total after a success, a clear refusal otherwise.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selectionAO2 · array updateR5 · booking, price and updated totalAO3 · complete outputs with suitable messages

This stage completes R5: the availability check, the array update, the price output and the updated cinema total. The ELSE branch provides the suitable message the question requires for a taken seat.

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 counting, totalling, maximum and validation techniques.	Establishes logical order and comments plan.
2 · Data	Required data structures	Reuses the given 2D arrays; adds the row-count array and totals.	Meaningful identifiers throughout.
3 · Initialise	R1, R2	Row counters and whole-cinema totals correctly initialised.	Clear comments and reliable starting state.
4 · Count	R1, R2	Nested iteration, counting available seats, totalling money.	Accurate branch logic and index use.
5 · Best row	R3	Maximum tracking across the completed row totals.	Correct champion update and tie handling.
6 · Validate	R4	REPEAT-UNTIL range validation of both inputs.	Post-condition loop logic explained.
7 · Book	R5	Availability check, array update, price and updated total.	Complete outputs with suitable messages.

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 14 · FULL PSEUDOCODECambridge 0478 style · 1-based indexing

// Meaningful identifiers and appropriate data structures are used
// to store the data required by the question
DECLARE AvailableInRow : ARRAY[1:20] OF INTEGER
DECLARE RowCounter : INTEGER
DECLARE SeatCounter : INTEGER
DECLARE AvailableTotal : INTEGER
DECLARE MoneyCollected : INTEGER
DECLARE BestRow : INTEGER
DECLARE BestRowAvailable : INTEGER
DECLARE RequestRow : INTEGER
DECLARE RequestSeat : INTEGER

// Initialise the whole-cinema totals
AvailableTotal ← 0
MoneyCollected ← 0

// Visit every row and every seat
FOR RowCounter ← 1 TO RowNo
    // Each row starts with no available seats counted
    AvailableInRow[RowCounter] ← 0
    FOR SeatCounter ← 1 TO SeatsInRow
        // Available seats are counted; booked seats pay money
        IF SeatTaken[RowCounter, SeatCounter] = FALSE
        THEN
            AvailableInRow[RowCounter] ← AvailableInRow[RowCounter] + 1
        ELSE
            MoneyCollected ← MoneyCollected +
                SeatPrice[RowCounter, SeatCounter]
        ENDIF
    NEXT SeatCounter
    // Add this row to the cinema total and output it
    AvailableTotal ← AvailableTotal + AvailableInRow[RowCounter]
    OUTPUT "Row ", RowCounter, " available seats: ",
        AvailableInRow[RowCounter]
NEXT RowCounter

// Output the whole-cinema results
OUTPUT "Total available seats: ", AvailableTotal
OUTPUT "Money collected: ", MoneyCollected

// Row 1 is the first candidate for the most available seats
BestRow ← 1
BestRowAvailable ← AvailableInRow[1]
FOR RowCounter ← 2 TO RowNo
    IF AvailableInRow[RowCounter] > BestRowAvailable
    THEN
        BestRow ← RowCounter
        BestRowAvailable ← AvailableInRow[RowCounter]
    ENDIF
NEXT RowCounter
OUTPUT "Row with most available seats: ", BestRow

// Input and validate the requested row
REPEAT
    OUTPUT "Enter row number (1 to ", RowNo, ")"
    INPUT RequestRow
UNTIL RequestRow >= 1 AND RequestRow <= RowNo

// Input and validate the requested seat
REPEAT
    OUTPUT "Enter seat number (1 to ", SeatsInRow, ")"
    INPUT RequestSeat
UNTIL RequestSeat >= 1 AND RequestSeat <= SeatsInRow

// Book the seat when it is available
IF SeatTaken[RequestRow, RequestSeat] = FALSE
THEN
    SeatTaken[RequestRow, RequestSeat] ← TRUE
    OUTPUT "Seat booked. Price: ", SeatPrice[RequestRow, RequestSeat]
    AvailableTotal ← AvailableTotal - 1
    OUTPUT "Seats now available: ", AvailableTotal
ELSE
    OUTPUT "Sorry, that seat is already booked"
ENDIF

Why this is a complete response

It covers the five mark-scheme requirements: per-row and cinema availability (R1), the money total (R2), the best row (R3), validated inputs (R4), and the booking with price, updated total and suitable message (R5).

What to check before submitting

Check the nested loop indexes, the IF/ELSE branch targets, the champion updates, the validation conditions, the array write when booking, 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 cinema. Watch the inner loop visit seats, the row counts grow, the money total climb, the champion row change, and one validated booking succeed.

Last tab · Trace player

Sample input → expected results

The sample cinema has 6 rows of 10 seats (RowNo = 6; SeatsInRow = 10). Seats in rows 1–2 cost $6, rows 3–4 cost $8 and rows 5–6 cost $10. The booked seats deliberately test a nearly full row, an empty row, a tie between rows 2 and 3, and a free seat in row 1 for the booking demo. These are illustrative values, not data supplied by the examination question.

Seat map SeatTaken[,] and SeatPrice[,]

Row	S1	S2	S3	S4	S5	S6	S7	S8	S9	S10

Each cell shows the seat price. ✓ marks an available seat; ✗ marks a booked seat.

Reveal expected row results and cinema totals

Expected row results After the counting loop

Row	Available	Money	Best

Available36

Collected$172

Best row6

Best count10

Execution trace

Step 1 of 1

Initialisation

Initialise the cinema totals

The program begins by setting the whole-cinema totals to zero.

AvailableTotal ← 0
MoneyCollected ← 0

Program output so far

(No output yet)

Live variable values

Row available counts

Row 1—

Row 2—

Row 3—

Row 4—

Row 5—

Row 6—

Ready

Tip: use Next step slowly and watch RowCounter, SeatCounter and the row counts. The seat counter returns to 1 for each new row.

Trace colours: blue row = current row; amber cell = current seat; green cells = seats already visited. Seat map: ✓ green = available, ✗ pink = booked.

Tie example: rows 2 and 3 both have 6 available seats. Because the champion comparison uses >, row 3 does not replace row 2; row 6 then wins with 10. The booking demo asks for row 9 first (invalid), then row 1 seat 9 — available, so it is booked at $6 and availability falls to 35.

From a cinema seat map to a booked ticket.

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

Given by the question

Additional identifiers

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Initialise the counters and totals

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Count available seats and total the money

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Find the row with the most available seats

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input and validate the requested row and seat

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Book the seat and output the final results

🧠 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

Seat map SeatTaken[,] and SeatPrice[,]

Expected row results After the counting loop

Execution trace

Initialise the cinema totals

Live variable values

Row available counts