15-mark question lab · start here

From room measurements to a stored, priced wood quotation.

Build the solution in a sensible order: decode the requirements, plan the arrays, initialise the wood tables, input and validate the measurements, round the area up, choose the wood and find its price, then store and output the quotation. Learn the reasoning before revealing the complete program.

Input validationRange check 1.5–10.0Rounding upArray lookup2D array storage15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the given arrays Customers[] and Quotations[] with its five columns, the wood tables WoodType[] and Price[] you must initialise yourself, the inclusive 1.5–10.0 measurement range and the nine requirement bullets.

02 · Construct

Build the program in order: populate the wood arrays, then inside WHILE Cont — input and validate the name, length and width, round the area up to the next whole number, choose the wood, retrieve its price and calculate the cost.

03 · Complete

Store all five values in the columns of Quotations[], output each customer’s quotation — name, choice of wood and calculated price — with suitable messages, and continue to accept the next customer.

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 five columns of Quotations[], the inclusive 1.5–10.0 range and the two arrays you must initialise yourself all affect the structure of your solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 11

A wood flooring company stores the names of up to 100 customers in a one-dimensional (1D) array Customers[]. A two-dimensional (2D) array Quotations[] stores details of each customer’s quotation:

length of room (one decimal place)
width of room (one decimal place)
area of wood required (rounded up to next whole number)
choice of wood index (whole number)
price of wood required in dollars (two decimal places).

The floor measurements (room length and room width) are taken in metres. All floors are rectangles and room measurements must be between 1.5 and 10.0 inclusive.

The index of any customer’s data is the same in both arrays. For example, a customer named in index 4 of Customers[] corresponds to the data in index 4 of Quotations[]

The wood choices available are:

Index 1 — wood type Laminate — price per square metre $29.99
Index 2 — wood type Pine — price per square metre $39.99
Index 3 — wood type Oak — price per square metre $54.99.

The data are stored in two 1D arrays named WoodType[] and Price[]. The index of the wood type and price in their arrays share the same index number.

Write a program that meets the following requirements:

input a new customer’s name, room length and room width
check that each measurement is valid
output an error message and require the measurement to be re-entered until it is valid
calculate the area of the room by multiplying together the length of the room and the width of the room
input the choice of wood and find its price per square metre
calculate the price of the wood needed
store all data in the relevant array
output the customer’s quotation to include: the name of the customer, the choice of wood and the calculated price of the wood required
continue to accept the next customer.

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 will need to initialise WoodType[] and Price[]

All inputs and outputs must contain suitable messages.

Before you move on

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

Mark-scheme map

Input and store the customer’s name, room length and room width, with validation of the room dimensions — input with prompts, range check and iteration.

Output an error message and require each measurement to be re-entered until it is valid — the WHILE validation loop that repeats the input.

Initialise the wood arrays, calculate the room area and round it up to the next whole number, then select the wood, retrieve its price and calculate the price of the wood — array initialisation, rounding, data retrieval from array, calculation.

Round and store all data in the relevant array — the five columns of Quotations[] receive length, width, area, wood index and price.

Output the full details — name of customer, choice of wood and quotation price with appropriate messages — and continue for the next customer — output with messages, iteration of the whole program.

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 four arrays and their jobs. Customers[] holds up to 100 names; Quotations[] is 2D with five columns — length, width, area, wood index, price; WoodType[] and Price[] are the two 1D arrays the closing lines tell you to initialise yourself.
Decode the five column formats. Length and width are one decimal place; the area is rounded up to the next whole number; the wood index is a whole number; the price is two decimal places — each format says which rounding happens where.
Notice the validation rule. Measurements must be between 1.5 and 10.0 inclusive — an exact 1.5 or an exact 10.0 is valid, 1.4 and 10.1 are not, and an invalid entry must produce an error message and be re-entered until it is valid.
Separate once-only work from per-customer work. Populating WoodType[] and Price[] happens once; everything from the name input to the quotation output happens per customer inside a whole-program loop.
Build the order. initialise the wood arrays → WHILE Cont (input name → input and validate length → input and validate width → area rounded up → wood menu, choice and price → cost → store five columns → output quotation → next customer).

Given: Customers[] and Quotations[]Initialise: WoodType[] and Price[]Range: 1.5 to 10.0 inclusiveRounding: area up, price 2dp

❓ Guiding questions – think before revealing

Why does the question give a format for every column of Quotations[]?
What does “between 1.5 and 10.0 inclusive” mean for the condition?
Which parts run once, and which run per customer?

Reveal suggested reasoning

Why does the question give a format for every column of Quotations[]? Each format is an instruction. One decimal place means the inputs arrive as 1dp values; rounded up to next whole number means the area needs a round-up operation; two decimal places means the price is stored at 2dp — and because the area is whole before the multiplication, the product lands on 2dp exactly.

What does “between 1.5 and 10.0 inclusive” mean for the condition? Both ends count: 1.5 and 10.0 are valid. The published answer tests WHILE RoomLength < 1.5 OR RoomLength > 10.0 — a value is rejected only when it is strictly below 1.5 or strictly above 10.0.

Which parts run once, and which run per customer? The wood arrays are populated once, before any loop. Everything from the name to the quotation output is per customer, inside WHILE Cont — and the final bullet, “continue to accept the next customer”, is what makes the whole program a loop.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Once: populate the wood arrays
WoodType[1..3] ← ...   Price[1..3] ← ...
CurrentCustomer ← 1
Cont ← TRUE
WHILE Cont DO
    // input the name into Customers[CurrentCustomer]
    // input and validate the room length (1.5 to 10.0 inclusive)
    // input and validate the room width (1.5 to 10.0 inclusive)
    // area = length × width, rounded up to the next whole number
    // show the wood table, input the choice, find Price[WoodChoice]
    // WoodCost = RoomArea × Price[WoodChoice]
    // store all five values in Quotations[CurrentCustomer, 1..5]
    // output the quotation: name, wood, price
    // ready for the next customer
ENDWHILE

📖 Detailed explanation

The bullet list is the mark scheme in disguise. The nine requirement bullets map onto R1 (input and validate the measurements), R2 (area, wood selection, price, storage) and R3 (output the quotation and continue).

“Rounded up to next whole number” is a rounding instruction. The area column is not the raw product — the published answer calculates it and then applies a round-up before anything is stored.

“You will need to initialise WoodType[] and Price[]” is a gift. Those two arrays are the question’s wood table in array form: index 1 Laminate $29.99, index 2 Pine $39.99, index 3 Oak $54.99 — set up once, then used for the menu and the price lookup.

“Continue to accept the next customer” shapes the whole program. One quotation is one pass of a loop; the published answer wraps everything in WHILE Cont DO and moves CurrentCustomer on at the end of each pass.

⚠️ Common mistakes

Starting to code before listing the nine requirement bullets and the five column formats.
Treating 1.5 or 10.0 as invalid — “inclusive” means both boundaries are accepted.
Forgetting the error message and re-entry loop, which the third bullet demands explicitly.
Missing that WoodType[] and Price[] must be initialised — the closing lines say so.

💡 Exam hack / tip

Underline inclusive, rounded up to next whole number and continue to accept the next customer. Those three phrases carry the validation condition, the round-up and the whole-program loop.

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 names exactly. Customers[], Quotations[], WoodType[] and Price[] must appear as given — the mark scheme lists all four as the data structures required with names as given in the scenario.
Quotations[] has five fixed columns. Column 1 length, 2 width, 3 area, 4 wood index, 5 price — the published answer stores them in exactly that order, so one row holds every value a customer generates.
Add the room working variables. RoomLength, RoomWidth and RoomArea hold the current customer’s measurements and area while they are validated and rounded.
Add the wood working variables. WoodChoice holds the index the customer types; the price per square metre is retrieved straight from Price[WoodChoice]; WoodCost holds the calculated price.
Add the loop control values. CurrentCustomer is the row index — it starts at 1 and moves on after each quotation; Cont is the BOOLEAN that lets the program continue to accept the next customer.

Given: four named arrays2D: Quotations[] five columnsWorking: RoomArea, WoodCostControl: CurrentCustomer, Cont

❓ Guiding questions – think before revealing

Why does the price not need its own working variable before the lookup?
Why is CurrentCustomer a variable rather than a loop counter?
What type are the room measurements?

Reveal suggested reasoning

Why does the price not need its own working variable before the lookup? The published answer reads Price[WoodChoice] directly inside WoodCost ← RoomArea * Price[WoodChoice] — the array is the storage, so no intermediate variable is needed. Keeping the lookup inline shows the examiner the data retrieval from array that R2 names.

Why is CurrentCustomer a variable rather than a loop counter? It is both. It indexes Customers[] and Quotations[] during the pass, and the published answer increments it at the end of the pass — with a reset to 1 if it passes 100, because the company stores up to 100 customers.

What type are the room measurements? Real — one decimal place. RoomArea is also real after the multiplication, but the round-up makes it a whole number of square metres before it is stored, which is why the stored price always lands on exactly two decimal places.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question — set up and named as in the scenario:
//   Customers[]   1D, up to 100 customer names
//   Quotations[]  2D, five columns per customer:
//       1 length (1dp)      2 width (1dp)
//       3 area (rounded up) 4 wood index
//       5 price (2dp)
//   WoodType[]    1D, three wood names — you initialise it
//   Price[]       1D, three prices — you initialise it

// Working values the program uses:
CurrentCustomer   // row index, starts at 1
Cont              // BOOLEAN, keeps the program running
RoomLength        // this customer's length (1dp)
RoomWidth         // this customer's width (1dp)
RoomArea          // raw area, then rounded up
WoodChoice        // 1, 2 or 3 — the customer's choice
WoodCost          // RoomArea * Price[WoodChoice] (2dp)

📖 Detailed explanation

Parallel positions link the arrays. The question’s index-4 example means one index — the customer’s position — reaches the name in Customers[] and all five values in row 4 of Quotations[].

The five columns are a design decision worth marks. AO2 credit comes from data structures that store all the data required — the 2D Quotations[] keeps every customer’s quotation together in one row.

The wood arrays do two jobs. WoodType[] and Price[] print the menu and look up the price — one pair of arrays serving both the display and the calculation.

Meaningful identifiers earn AO3 credit. RoomLength, RoomArea, WoodChoice and WoodCost say what they hold, and every name maps back to the question’s wording.

⚠️ Common mistakes

Renaming the given arrays, which the mark scheme treats as not using the supplied data structures.
Storing the values in the wrong columns, or in fresh variables instead of Quotations[].
Using INTEGER for the room measurements — they are real numbers with one decimal place.
Forgetting Cont or CurrentCustomer, so the program processes one customer and stops.

💡 Exam hack / tip

Point at each name and ask “which phrase in the question does this store?” RoomLength answers “room length”, WoodChoice answers “choice of wood index”, and WoodCost answers “price of wood required in dollars”.

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 wood arrays and the loop

Populate WoodType[] and Price[] once, then set up the whole-program loop.

R2 · R3

🧠 Step-by-step thinking

Populate the wood arrays once. The published answer assigns WoodType[1] ← “Laminate”, WoodType[2] ← “Pine”, WoodType[3] ← “Oak” and Price[1] ← 29.99, Price[2] ← 39.99, Price[3] ← 54.99 — and notes that input and loops are also acceptable.
Start the row index at 1. CurrentCustomer ← 1 initialises the starting customer in the sales arrays, so the first name typed lands in Customers[1] and row 1 of Quotations[].
Start the loop control. Cont ← TRUE allows the program to continue to the next customer — the last requirement bullet in action from the very first line.
Everything else is overwritten per customer. RoomLength, RoomWidth, RoomArea, WoodChoice and WoodCost are reassigned on every pass, so they need no initial values here.

Once: WoodType[] and Price[]Row: CurrentCustomer ← 1Loop: Cont ← TRUE

❓ Guiding questions – think before revealing

Why populate the wood arrays by assignment rather than INPUT?
Why does the initialisation happen outside the loop?
What would happen if CurrentCustomer started at 0?

Reveal suggested reasoning

Why populate the wood arrays by assignment rather than INPUT? The values are fixed — three woods and three prices — so direct assignment is simplest. The published answer explicitly allows input and loops as an alternative; either way the initialisation happens once, before any customer is processed.

Why does the initialisation happen outside the loop? WoodType[] and Price[] never change from customer to customer. Assigning them inside the loop would repeat identical work and make the reader think the table is per-customer data.

What would happen if CurrentCustomer started at 0? The first name would be stored in Customers[0], breaking the question’s shared-index rule — the index of a customer’s data is the same in both arrays, and the published answer starts at 1.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// initial population of WoodType[] and Price[] arrays
WoodType[1] ← "Laminate"
WoodType[2] ← "Pine"
WoodType[3] ← "Oak"
Price[1] ← 29.99
Price[2] ← 39.99
Price[3] ← 54.99

// initialises starting customer in sales arrays
CurrentCustomer ← 1
// to allow program to continue to next customer
Cont ← TRUE
WHILE Cont DO
    // one quotation is produced per pass
ENDWHILE

📖 Detailed explanation

Array initialisation is named in R2. The mark scheme’s R2 begins “Initialise wood arrays” — this stage is that requirement, delivered before anything else runs.

The wood arrays mirror the question’s table. Index 1 Laminate $29.99, index 2 Pine $39.99, index 3 Oak $54.99 — the same index shared by WoodType[] and Price[], exactly as the question describes.

Two control values start the loop. CurrentCustomer fixes where the first quotation is stored; Cont keeps the whole program running — together they deliver “continue to accept the next customer”.

⚠️ Common mistakes

Populating the wood arrays inside the loop, redoing identical work on every pass.
Swapping the wood indices so Pine gets Oak’s price — check each pair against the question’s table.
Starting CurrentCustomer at 0, which breaks the shared-index rule between Customers[] and Quotations[].
Forgetting Cont entirely, so the program has no whole-program iteration.

💡 Exam hack / tip

Say it as a rule: what never changes is initialised once, outside the loop — the wood table, the row index and the loop control; everything that changes per customer waits for the loop.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · array initialisationR2 · wood arrays initialisedAO3 · setup before the loop

Initialisation supports AO2 because the wood arrays store all the data required from the start, and AO3 because the setup sits in a logical place before the loop. These are alignment notes, not separately allocated marks.

Input and validate the measurements

Prompt for the name, length and width; reject out-of-range values until they are valid.

🧠 Step-by-step thinking

Input the name straight into the array. INPUT Customers[CurrentCustomer] stores the name exactly where the quotation will be stored — no extra variable, and the prompt carries a suitable message.
Prompt, then input, then validate. Each measurement gets OUTPUT “What is the length of your room? ”, INPUT RoomLength, then the WHILE check — suitable messages on the way in, as the closing line demands.
The condition is a range check. WHILE RoomLength < 1.5 OR RoomLength > 10.0 — reject only strictly-below-1.5 or strictly-above-10.0, so 1.5 and 10.0 pass and 1.4 and 10.1 fail.
The loop repeats the input. Inside the WHILE: OUTPUT the error message, INPUT again — the body repeats until the condition is FALSE, which is exactly “require the measurement to be re-entered until it is valid”.
Length and width get identical treatment. Two separate WHILE loops with the same condition — the published answer validates each measurement independently, one at a time.

Input: name, length, widthRange: < 1.5 OR > 10.0Repeat: error + re-enter

❓ Guiding questions – think before revealing

Why WHILE rather than IF for the validation?
Why is the condition written with OR rather than AND?
What exactly must the error message do?

Reveal suggested reasoning

Why WHILE rather than IF for the validation? An IF checks once; a wrong value would pass through. The question demands re-entry until valid — only a loop repeats the input, and the mark scheme names “range check and iteration” in R1.

Why is the condition written with OR rather than AND? A number cannot be below 1.5 and above 10.0 at the same time, so AND would never be TRUE and nothing would ever be rejected. OR is TRUE whenever the value is out of range on either side.

What exactly must the error message do? Tell the user the valid range and ask again — the published answer prints “The measurement must be in the range 1.5 to 10.0 inclusive, please try again”. Any clear message with a re-input earns the credit.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

OUTPUT "Input the customer’s name "
INPUT Customers[CurrentCustomer]

OUTPUT "What is the length of your room? "
INPUT RoomLength
WHILE RoomLength < 1.5 OR RoomLength > 10.0
    OUTPUT "The measurement must be in the range 1.5 to 10.0 inclusive, please try again "
    INPUT RoomLength
ENDWHILE

OUTPUT "What is the width of your room? "
INPUT RoomWidth
WHILE RoomWidth < 1.5 OR RoomWidth > 10.0
    OUTPUT "The measurement must be in the range 1.5 to 10.0 inclusive, please try again "
    INPUT RoomWidth
ENDWHILE

📖 Detailed explanation

Input with prompts, range check and iteration is R1. The mark scheme names all three techniques in one requirement — the prompts, the 1.5–10.0 check and the WHILE re-entry loop deliver them together.

The boundaries are inclusive. 1.5 and 10.0 are the question’s own limits, so the strict inequalities keep both valid — the two boundary customers in the visualisation rely on this.

The name needs no validation. Only the room dimensions carry a stated range, so the name is input directly — validating it would be invented work.

Each measurement is validated immediately. The length is fully valid before the width is asked for, so at most one measurement is ever in question at a time.

⚠️ Common mistakes

Using IF instead of WHILE, so an invalid value is never re-entered.
Writing AND instead of OR, so no value is ever rejected.
Excluding the boundaries with <= 1.5 or >= 10.0, which wrongly rejects 1.5 and 10.0.
Printing the error message without asking for the value again.

💡 Exam hack / tip

Read the condition aloud as a question: is it under one-and-a-half or over ten? If yes, reject and re-ask; if no, the measurement is valid. The word inclusive in the question is what keeps the equal signs out of the test.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · input with validationR1 · range check and repeated inputAO3 · inclusive boundariesAO3 · comments explain purpose

The validation loops are the R1 evidence for AO2, and the exact inclusive boundaries are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Calculate the area and round it up

Multiply the two measurements, then round up to the next whole number.

🧠 Step-by-step thinking

Multiply the two 1dp measurements. RoomArea ← ROUND(RoomLength, 1) * ROUND(RoomWidth, 1) — the published answer re-rounds each input to one decimal place before multiplying, so the product carries no more than two decimal places.
Round up, never down. RoomArea ← ROUND(RoomArea + 0.5, 0) — adding 0.5 before rounding to zero decimal places lifts any fractional part to the next whole number.
Whole areas move up too. An exact whole number of square metres becomes the next whole number: 25.0 + 0.5 = 25.5, which rounds to 26 — matching the question’s phrase “rounded up to next whole number”.
The round-up happens before the wood is chosen. The area is complete before the menu is shown, so the room’s size in whole square metres is known when the customer picks a wood.

Calculation: length × widthRound-up: + 0.5 then ROUNDStorage: area is whole

❓ Guiding questions – think before revealing

Why add 0.5 before rounding?
Why re-round the inputs to one decimal place first?
What does 3.7 × 2.4 equal, and what is stored?

Reveal suggested reasoning

Why add 0.5 before rounding? ROUND alone would round to the nearest whole number — 8.2 would become 8. Adding 0.5 first pushes every non-integer over the halfway point, so the result is always the next whole number up: ROUND(8.2 + 0.5, 0) = ROUND(8.7, 0) = 9.

Why re-round the inputs to one decimal place first? The question states the measurements are one decimal place, so the inputs should already be 1dp — the ROUND(…, 1) wrappers guarantee the product is at most two decimal places no matter what was typed.

What does 3.7 × 2.4 equal, and what is stored? The product is 8.88 — two decimal places. The round-up stores 9: the customer is quoted for nine square metres of wood, never 8.88 and never 8.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// both measurements are one decimal place
RoomArea ← ROUND(RoomLength, 1) * ROUND(RoomWidth, 1)
// round up to the next whole number
RoomArea ← ROUND(RoomArea + 0.5, 0)

// e.g. 3.7 × 2.4 = 8.88   →  ROUND(9.38, 0)   = 9
//      10.0 × 2.5 = 25.0  →  ROUND(25.5, 0)  = 26

📖 Detailed explanation

Rounding is named in R2. The mark scheme’s R2 lists “rounding” among its techniques — the round-up of the area is where it happens.

A 1dp × 1dp product has at most 2dp. Two one-decimal-place inputs multiply to at most two decimal places — 3.7 × 2.4 = 8.88 — which is why the raw area never needs more than two decimal places.

The stored area is always a whole number. After the round-up, RoomArea is an integer number of square metres — and that is what makes the stored price land on exactly two decimal places in the next stage.

The area is stored, not just used. Column 3 of Quotations[] receives the rounded-up area, so the quotation keeps every intermediate result.

⚠️ Common mistakes

Rounding to the nearest whole number instead of up — 8.2 would wrongly become 8.
Forgetting the round-up entirely and storing the raw product, e.g. 8.88.
Truncating with INT() instead of rounding up.
Applying a round-up to the price as well — the price needs no rounding once the area is whole.

💡 Exam hack / tip

Write the round-up as a pair of lines and test it on three values: 8.88 → 9, 8.2 → 9 and 25.0 → 26. If all three move up, your technique matches the published answer.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · rounding techniqueR2 · area rounded upAO3 · accurate round-up cases

The round-up is R2 evidence for AO2, and its behaviour on whole-number areas is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Choose the wood and find its price

Show the menu, input a valid index, and retrieve Price[WoodChoice].

🧠 Step-by-step thinking

Show the menu with a loop. FOR Count ← 1 TO 3 prints each index, wood name and price — WoodType[] and Price[] doing their second job.
Input the index, not the name. The customer types 1, 2 or 3; WoodChoice holds the index — the same index used for the lookup and stored in column 4.
Validate the choice too. The published answer wraps the input in WHILE WoodChoice < 1 OR WoodChoice > 3 — the same range-check pattern as the measurements, with 3 as the limit.
Retrieve the price through the shared index. Price[WoodChoice] is the data retrieval from array that R2 names — no searching, no IF chain, one array access.

Menu: FOR Count ← 1 TO 3Input: index 1–3, validatedLookup: Price[WoodChoice]

❓ Guiding questions – think before revealing

Why print the menu from the arrays rather than fixed text?
What does “find its price per square metre” mean in code?
Why validate the wood choice when the question only demands measurement validation?

Reveal suggested reasoning

Why print the menu from the arrays rather than fixed text? The wood table lives in WoodType[] and Price[] — printing from the arrays keeps one source of truth and shows the examiner both arrays in use, which supports the data-structures credit.

What does “find its price per square metre” mean in code? One array access: Price[WoodChoice]. The index is shared, so the choice and the price are linked by position — the same parallel rule that joins Customers[] and Quotations[].

Why validate the wood choice when the question only demands measurement validation? The published answer adds it — a robust program checks every value the user types. It costs two lines and mirrors the measurement pattern; the mark scheme’s R1 technique list makes it natural.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

OUTPUT "the wood choices available are:"
OUTPUT "Number    Wood Type   Price($)"
FOR Count ← 1 TO 3
    OUTPUT Count, " ", WoodType[Count], "     ", Price[Count]
NEXT Count

OUTPUT "Input a number from 1 to 3 "
INPUT WoodChoice
WHILE WoodChoice < 1 OR WoodChoice > 3
    OUTPUT "Your input is out of range, please try again "
    INPUT WoodChoice
ENDWHILE

// the price per square metre, retrieved from the array
// WoodChoice = 1  →  Price[1] = 29.99

📖 Detailed explanation

Data retrieval from array is named in R2. Price[WoodChoice] is the lookup the mark scheme lists — the wood’s price per square metre found through the shared index.

The menu satisfies “suitable messages”. Every input is preceded by an output that tells the user what to type — the closing line of the question demands it.

The validation mirrors the measurements. Same WHILE pattern, different limits — 1 to 3 instead of 1.5 to 10.0 — one technique applied twice.

The choice is stored as an index. Column 4 of Quotations[] receives WoodChoice itself, because the question says “choice of wood index (whole number)”.

⚠️ Common mistakes

Storing the wood’s name instead of its index in column 4 — the question says “choice of wood index (whole number)”.
Looking the price up with an IF chain instead of Price[WoodChoice].
Forgetting to re-ask after an out-of-range wood choice.
Printing the menu once outside the loop, so later customers never see the choices.

💡 Exam hack / tip

The wood table is three arrays in one: index, WoodType[index], Price[index]. Whatever the customer types becomes the index for both — one number, two lookups, and column 4 stores that same number.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · data retrieval from arrayR2 · wood selected and pricedAO3 · shared-index lookup

The menu and lookup are R2 evidence for AO2, and the shared-index access is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Store the quotation and output it

Five columns into Quotations[], three output lines, then the next customer.

R2 · R3

🧠 Step-by-step thinking

Store all five values. Columns 1–5 receive RoomLength, RoomWidth, RoomArea, WoodChoice and WoodCost — “store all data in the relevant array” means every value the program produced.
The price is stored, not just printed. Column 5 holds WoodCost, and the output line reads Quotations[CurrentCustomer, 5] — the published answer prints from the array, proving the storage happened.
Three output lines with messages. Customer name, the chosen wood, the total price — each with a message naming its value, exactly the question’s output bullet.
Move on, and cap at 100. CurrentCustomer ← CurrentCustomer + 1, with a reset to 1 if it passes 100 — “up to 100 customers” honoured, and WHILE Cont returns to the top.

Storage: columns 1–5Output: name, wood, priceNext: + 1, cap at 100

❓ Guiding questions – think before revealing

Why print Quotations[CurrentCustomer, 5] instead of WoodCost?
Why does the program reset CurrentCustomer to 1 after 100?
When does the program stop?

Reveal suggested reasoning

Why print Quotations[CurrentCustomer, 5] instead of WoodCost? Both work, but printing from the array shows the storage requirement is genuinely met — the examiner sees the value travel into Quotations[] and back out. The published answer prints from the array.

Why does the program reset CurrentCustomer to 1 after 100? Customers[] stores up to 100 customers; once a 101st row is needed, the published answer wraps back to row 1, overwriting the oldest quotation. The question says “up to 100 customers”, and this keeps every store in range.

When does the program stop? In the published answer Cont is never set to FALSE — the program continues to accept the next customer, as the final bullet requires. A real system would ask whether to continue and set Cont accordingly.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// to store the relevant data in Quotations[]
Quotations[CurrentCustomer, 1] ← RoomLength
Quotations[CurrentCustomer, 2] ← RoomWidth
Quotations[CurrentCustomer, 3] ← RoomArea
Quotations[CurrentCustomer, 4] ← WoodChoice
Quotations[CurrentCustomer, 5] ← WoodCost

// final output of quotation
OUTPUT "Customer name: ", Customers[CurrentCustomer]
OUTPUT "The wood you have chosen is: ", WoodType[WoodChoice]
OUTPUT "Your total price is: ", Quotations[CurrentCustomer, 5]

// ready for next customer
CurrentCustomer ← CurrentCustomer + 1
IF CurrentCustomer > 100
  THEN
    CurrentCustomer ← 1
ENDIF

📖 Detailed explanation

Storage of results is in R2. “Round and store all data to relevant array” — the five assignments are that requirement, delivered after the cost is calculated.

Output with messages is R3. “Output full details: name of customer, choice of wood and quotation price with appropriate messages” — three lines, each carrying its own message.

Iteration of the whole program is R3 too. “Program continues for next customer” — the WHILE Cont loop and the CurrentCustomer increment are what the mark scheme means.

The price needs no further rounding. RoomArea is whole and the price per square metre has two decimal places, so their product lands on exactly two decimal places — the published answer stores WoodCost as calculated.

⚠️ Common mistakes

Printing the quotation before storing the data, then storing nothing.
Outputting a bare number with no message text.
Forgetting to increment CurrentCustomer, so every customer overwrites row 1.
Letting CurrentCustomer run past 100 and out of the array.

💡 Exam hack / tip

Match your OUTPUT lines to the question’s output bullet: name, choice of wood, calculated price. Then check the five columns in order — length, width, area, index, price — the same order as the question’s first bullet list.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · storage of resultsR2 · R3 · store, output, continueAO3 · prints from the arrays

The storage and quotation output complete the R2 and R3 evidence for AO2, and printing from the arrays is AO3 accuracy 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 validation loops and the round-up.	Establishes logical order and comments the plan.
2 · Data	Required data structures	Uses Customers[], Quotations[], WoodType[] and Price[] as given, with working variables for the room and the quotation.	Meaningful identifiers throughout.
3 · Initialise	R2, R3	WoodType[] and Price[] populated with the three woods; CurrentCustomer and Cont set for the whole-program loop.	Setup sits once, outside the loop.
4 · Measure	R1	Inputs the name, length and width with prompts, a 1.5–10.0 inclusive range check and repeated input.	The boundary conditions are accurate at 1.5 and 10.0.
5 · Area	R2	Calculates the area and rounds it up to the next whole number.	The round-up is accurate, including whole-number areas.
6 · Wood	R2	Shows the wood table, inputs and validates the choice and retrieves the price per square metre.	Price[WoodChoice] uses the shared index.
7 · Quote	R2, R3	Stores all five values in Quotations[] and outputs the quotation with messages.	Correct columns, and the program continues for the next customer.

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/22 October/November 2023 Question 11. The arrays Customers[] and Quotations[] are supplied by the question and are used exactly as given. The published answer populates WoodType[] and Price[] by direct assignment, validates both room measurements with WHILE loops that output an error message and repeat the input, rounds the area up with ROUND(RoomArea + 0.5, 0), retrieves the wood’s price through Price[WoodChoice], stores all five values in Quotations[], prints the quotation from the arrays, and wraps everything in WHILE Cont DO so the program continues to accept the next customer, resetting CurrentCustomer to 1 once it passes 100.

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

// declarations not required in the answer
// initial population of WoodType[] and Price[] arrays
// input and loops are also acceptable
WoodType[1] ← "Laminate"
WoodType[2] ← "Pine"
WoodType[3] ← "Oak"
Price[1] ← 29.99
Price[2] ← 39.99
Price[3] ← 54.99
// initialises starting customer in sales arrays
CurrentCustomer ← 1
// to allow program to continue to next customer
Cont ← TRUE
WHILE Cont DO
    // input customer name
    OUTPUT "Input the customer’s name "
    INPUT Customers[CurrentCustomer]
    // input of room dimensions with validation
    OUTPUT "What is the length of your room? "
    INPUT RoomLength
    // validate RoomLength
    WHILE RoomLength < 1.5 OR RoomLength > 10.0
        OUTPUT "The measurement must be in the range 1.5 to 10.0 inclusive, please try again "
        INPUT RoomLength
    ENDWHILE
    OUTPUT "What is the width of your room? "
    INPUT RoomWidth
    // validate RoomWidth
    WHILE RoomWidth < 1.5 OR RoomWidth > 10.0
        OUTPUT "The measurement must be in the range 1.5 to 10.0 inclusive, please try again "
        INPUT RoomWidth
    ENDWHILE
    RoomArea ← ROUND(RoomLength, 1) * ROUND(RoomWidth, 1)
    RoomArea ← ROUND(RoomArea + 0.5, 0)
    // show the wood available and prices
    OUTPUT "the wood choices available are:"
    OUTPUT "Number    Wood Type   Price($)"
    FOR Count ← 1 TO 3
        OUTPUT Count, " ", WoodType[Count], "     ", Price[Count]
    NEXT Count
    // input wood choice
    OUTPUT "Input a number from 1 to 3 "
    INPUT WoodChoice
    // validate wood choice
    WHILE WoodChoice < 1 OR WoodChoice > 3
        OUTPUT "Your input is out of range, please try again "
        INPUT WoodChoice
    ENDWHILE
    // to calculate the total cost of the wood
    WoodCost ← RoomArea * Price[WoodChoice]
    // to store the relevant data in Quotations[]
    Quotations[CurrentCustomer, 1] ← RoomLength
    Quotations[CurrentCustomer, 2] ← RoomWidth
    Quotations[CurrentCustomer, 3] ← RoomArea
    Quotations[CurrentCustomer, 4] ← WoodChoice
    Quotations[CurrentCustomer, 5] ← WoodCost
    // final output of quotation
    OUTPUT "Customer name: ", Customers[CurrentCustomer]
    OUTPUT "The wood you have chosen is: ", WoodType[WoodChoice]
    OUTPUT "Your total price is: ", Quotations[CurrentCustomer, 5]
    // ready for next customer
    CurrentCustomer ← CurrentCustomer + 1
    // resets CurrentCustomer to beginning of array when array limit reached
    IF CurrentCustomer > 100
        THEN
            CurrentCustomer ← 1
    ENDIF
ENDWHILE

Why this is a complete response

It covers the three mark-scheme requirements. R1: the name, length and width are input with prompts, each measurement passes a 1.5 to 10.0 inclusive range check inside a WHILE loop that outputs an error message and repeats the input until it is valid. R2: WoodType[] and Price[] are initialised, the area is calculated and rounded up to the next whole number, the wood’s price per square metre is retrieved through Price[WoodChoice], the price of the wood is calculated, and all five values are stored in the relevant columns of Quotations[]. R3: the quotation is output with the customer’s name, the choice of wood and the calculated price, all with suitable messages, and WHILE Cont continues to accept the next customer.

What to check before submitting

Check the validation conditions RoomLength < 1.5 OR RoomLength > 10.0 and RoomWidth < 1.5 OR RoomWidth > 10.0, the round-up ROUND(RoomArea + 0.5, 0), the wood lookup Price[WoodChoice], the five columns of Quotations[], the quotation output with messages, 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 four sample quotations. Watch the wood arrays being initialised, each customer’s name stored, both measurements validated with retries, the area rounded up to the next whole number, the wood’s price looked up through Price[], all five values stored in Quotations[], and the quotation printed from the arrays.

Last tab · Trace player

Sample input → expected results

The sample run serves four customers, following the published mark scheme answer’s execution order exactly. Amara’s length of 1.5 is the exact lower boundary, accepted first time. Bruno’s first attempts — 10.1 for the length and 1.4 for the width — are both rejected with the mark scheme’s error message and re-entered as 10.0 (the exact upper boundary) and 2.5, so he is the retry customer. Cleo’s raw area 3.7 × 2.4 = 8.88 needs the round up to 9, and her price 9 × $29.99 = $269.91 shows the two-decimal-place storage; Bruno’s raw area 10.0 × 2.5 = 25.0 is a whole number, which the published technique ROUND(area + 0.5, 0) moves up to 26 — the next whole number. This is the authentic 0478/22 October/November 2023 Question 11. These are illustrative values, not data supplied by the examination question.

Input arrays Customers[] and Quotations[] (filled as each customer is served)

Customer	Length (m)	Width (m)	Wood choice

The row number is the customer’s position in both arrays — customer 1 is stored in Customers[1] and row 1 of Quotations[]. Each row shows the values accepted after validation, with the wood shown as index · type.

Reveal expected quotation results and summary

Expected quotation results After all four customers

Customer	Wood type	Area (m²)	Price ($)

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Quotation counters

Ready

Tip: use Next step slowly and watch CurrentCustomer and RoomArea. The amber cell follows the detail being entered — length, then width, then wood — and the validation WHILE loops never let 10.1 or 1.4 through. The area is rounded up before the wood is chosen, so every price lands on two decimal places.

Trace colours: blue row = current customer; amber cell = current detail; green cells = details already processed.

Round-up example: Cleo’s room is 3.7 × 2.4 = 8.88 square metres, so ROUND(8.88 + 0.5, 0) = ROUND(9.38, 0) = 9 — and 9 × $29.99 stores $269.91 at exactly two decimal places, because a whole-number area times a two-decimal-place price never needs further rounding. Bruno’s raw area is a whole 25.0, and the published technique still moves up: ROUND(25.0 + 0.5, 0) = 26.

From room measurements to a stored, priced wood quotation.

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 wood arrays and the loop

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input and validate the measurements

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Calculate the area and round it up

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Choose the wood and find its price

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Store the quotation and output it

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

What does a high-level response look like?

How the seven stages contribute

Final self-check

Complete solution

Why this is a complete response

What to check before submitting

Visualisation: watch the program work.

Sample input → expected results

Input arrays Customers[] and Quotations[] (filled as each customer is served)

Expected quotation results After all four customers

Execution trace

Initialisation

Live variable values

Quotation counters