15-mark question lab · start here

Volumes returned by three functions, driven by a validated menu.

Build the solution in a sensible order: understand the three formulae, declare every variable and the constant Pi, write one function per shape with the input data as parameters, then drive them from a validated menu that loops until the user chooses stop and outputs each volume rounded to two decimal places. Learn the reasoning before revealing the complete program.

Functions with parametersValidated menu loopCASE selectionConstant Pi = 3.142Rounding to 2 dp15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the three formulae, the shared menu loop, and why each function must receive its input data as parameters.

02 · Construct

Write one function per shape, each returning its volume, and select between them with a validated menu choice.

03 · Complete

Declare every variable and the constant Pi = 3.142, round each output to two decimal places, and stop only on the stop option.

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 exact formulae, the validated menu, the function-per-shape rule and the two-decimal rounding all shape the structure of your solution.

Question 10 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 10

A program is required to allow students to calculate the volume of a number of standard three-dimensional shapes. It will use functions to allow other shapes to be added in the future.

Cuboid

volume = base × depth × height

Triangular prism

volume = ½ × base × depth × height

Sphere

volume = 4/3 × Pi × radius × radius × radius

Pi is a constant with value 3.142

Write a program that meets the following requirements:

Output a menu to ask the user for an input to indicate the shape for which a volume needs to be calculated, from the three shapes given or if they want to stop the program. The program must validate the input.
Input the data needed to calculate the volume of the chosen shape, based on the given formulae.
Create one function for each shape to calculate and return the volume using the given formulae. Each function uses the input data as parameters.
Output the volume in the main program, rounded to two decimal places.

The program continues until the user inputs the stop option from the menu.

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

All variables and constants used must be declared for this algorithm.

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

Output a validated menu offering the three shapes or the stop option, and keep looping until the stop option is chosen.

Input the data the chosen shape's formula needs — base, depth and height for the cuboid and prism, radius for the sphere.

Create one function per shape — Cuboid, TriangularPrism and Sphere — taking the input data as parameters and returning the volume.

Output each volume in the main program, rounded to two decimal places.

Declare every variable and the constant Pi = 3.142, comment the code, and give every input and output a suitable message.

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

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Spot the program shape. A menu repeats until the user chooses stop, so the main program is a REPEAT … UNTIL (or WHILE … ENDWHILE) loop wrapping the menu display, the validation and the shape selection.
Separate the calculations from the main program. “Create one function for each shape” means three self-contained functions — Cuboid, TriangularPrism and Sphere — each calculating and returning its volume.
Map the inputs to each formula. The cuboid and the triangular prism need base, depth and height; the sphere needs only the radius. The validated menu choice decides which inputs are requested.
Translate command words. “Validate” means re-asking until the choice is one of the four options; “return” means the function hands its value back to the caller; “rounded to two decimal places” means a ROUND operation in the main program; “must be declared” means a declarations section is required.
Build the order. declare variables and the constant Pi → repeat: show menu → input and validate choice → input the chosen shape's data → call its function → output the rounded volume → until the stop option.

Loop: repeat until stopSelection: validated choiceFunctions: one per shapeRounding: two decimal places

❓ Guiding questions – think before revealing

How many functions are needed, and what decides their parameters?
Why does the menu bullet mention validation?
Where does the rounding happen?

Reveal suggested reasoning

How many functions are needed, and what decides their parameters? Three — one per shape. “Each function uses the input data as parameters”, so Cuboid and TriangularPrism take Base, Depth and Height, while Sphere takes only Radius.

Why does the menu bullet mention validation? “The program must validate the input” — the menu choice must be re-asked until it is one of the three shapes or the stop option, and this happens before any shape data is requested.

Where does the rounding happen? In the main program. “Output the volume in the main program, rounded to two decimal places” — the functions return unrounded volumes, and the display applies ROUND(Volume, 2).

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Declarations — every variable and the constant
DECLARE MenuChoice : INTEGER
DECLARE Volume : REAL
CONSTANT Pi = 3.142

// Three functions, one per shape
FUNCTION Cuboid(Base, Depth, Height)
    // return base × depth × height
ENDFUNCTION

FUNCTION TriangularPrism(Base, Depth, Height)
    // return ½ × base × depth × height
ENDFUNCTION

FUNCTION Sphere(Radius)
    // return 4/3 × Pi × radius × radius × radius
ENDFUNCTION

// Main program: repeat until stop
REPEAT
    // output menu, input and validate choice
    // input the chosen shape's data
    // call the matching function
    // output ROUND(Volume, 2)
UNTIL MenuChoice = 4

📖 Detailed explanation

“It will use functions to allow other shapes to be added” explains why the volume calculations must live in functions: a fourth shape later would simply be another function plus one more menu option.

“From the three shapes given or if they want to stop” tells you the menu has exactly four options — three shapes plus stop — and nothing else may be accepted.

“Each function uses the input data as parameters” forbids reading the dimensions inside the functions with INPUT — the values must travel in through the parameter list.

“The program continues until the user inputs the stop option” fixes the loop exit: the stop option is the only way out.

⚠️ Common mistakes

Writing the volume calculations in the main program instead of inside three functions, losing the whole point of the question.
Using INPUT inside a function to fetch the dimensions, ignoring the parameter requirement.
Forgetting the stop option, or accepting menu choices outside 1 to 4.
Rounding inside the functions — the rounding belongs to the output in the main program.

💡 Exam hack / tip

Underline “one function for each shape”, “uses the input data as parameters”, “must validate the input” and “rounded to two decimal places”. Those four phrases decide the entire structure: three functions, parameters in, validation on the menu choice, ROUND in the main program.

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 declarations

This question demands a declaration for every variable and constant.

Required data structures

🧠 Step-by-step thinking

Use one variable for the menu. MenuChoice : INTEGER holds the user's validated selection — 1, 2, 3 or the stop option 4.
Declare the shape data. Base, Depth, Height and Radius are REAL, because dimensions can be decimal and the outputs carry two decimal places.
Declare the result. Volume : REAL receives whatever value the called function returns.
Declare the constant. CONSTANT Pi = 3.142 — the paper fixes the value, so it must not be typed as 3.14 and must not be read from the user.
Remember the parameters. The functions need no further declarations — their data arrives through the parameter lists (Base, Depth, Height) or (Radius).

MenuChoice : INTEGERDimensions and Volume : REALCONSTANT Pi = 3.142

❓ Guiding questions – think before revealing

Why are the dimensions REAL rather than INTEGER?
Does Pi need declaring?
Do the functions need their own declarations?

Reveal suggested reasoning

Why are the dimensions REAL rather than INTEGER? Dimensions such as a radius of 2.5 are perfectly possible, and the volumes are printed to two decimal places. REAL is the appropriate type for both the inputs and Volume.

Does Pi need declaring? Yes — “all variables and constants used must be declared”, and the paper states that Pi is a constant with value 3.142, so CONSTANT Pi = 3.142 belongs at the top of the answer.

Do the functions need their own declarations? No. Each function works only with its parameters and the global constant Pi. Inventing extra local variables would add risk and earn no credit.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Declarations required by the question
DECLARE MenuChoice : INTEGER
DECLARE Base   : REAL
DECLARE Depth  : REAL
DECLARE Height : REAL
DECLARE Radius : REAL
DECLARE Volume : REAL

// Pi is a constant with value 3.142
CONSTANT Pi = 3.142

// The functions' data arrives through parameters:
// Cuboid(Base : REAL, Depth : REAL, Height : REAL)
// TriangularPrism(Base : REAL, Depth : REAL, Height : REAL)
// Sphere(Radius : REAL)

📖 Detailed explanation

Declarations are a stated requirement here. Unlike some questions that let you assume declarations, this paper says “all variables and constants used must be declared” — the section earns its place at the very top.

One variable set serves all three shapes. Base, Depth, Height and Radius are reused by whichever branch runs; the shapes never need storing, only the current shape's inputs.

The constant lives outside the functions. Pi is declared once in the main program and used by Sphere, which is exactly what CONSTANT is for.

⚠️ Common mistakes

Omitting the declarations section entirely, directly losing the marks the question pins to it.
Declaring Pi as a variable and assigning 3.142 later, instead of declaring it as a constant.
Typing 3.142 inline inside the Sphere function and never declaring Pi at all.
Declaring Volume as INTEGER, which would discard the decimal places the question asks to be output.

💡 Exam hack / tip

Reread the closing lines before you write anything: “all variables and constants used must be declared”. List every name you plan to use — MenuChoice, Base, Depth, Height, Radius, Volume, Pi — and declare each one first.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR5 · declarations presentAO3 · meaningful identifiers

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

Build the validated menu loop

Show the menu, input the choice, re-ask until it is valid.

🧠 Step-by-step thinking

Output the four options. Three shapes plus stop, each numbered, so the user can indicate a choice with one value.
Validate before acting. A loop re-asks until MenuChoice is 1 to 4; only then does the selection decide which shape's data to input.
Choose the loop exit carefully. The whole menu repeats until the user inputs the stop option, so the outer loop's UNTIL test is MenuChoice = 4.
Keep validation separate from selection. First make the choice valid; the selection then never has to defend itself against impossible values.
Give every message words. The menu itself, the prompt and the rejection message are all outputs — “all inputs and outputs must contain suitable messages”.

Outer loop: REPEAT … UNTILValidation: 1 to 4 onlyExit: stop option = 4

❓ Guiding questions – think before revealing

Why validate before the selection?
What happens if the user types 7?
Why is the UNTIL test MenuChoice = 4?

Reveal suggested reasoning

Why validate before the selection? The selection should only ever see a choice from 1 to 4. Validating first means the CASE statement needs no defensive branch for impossible values.

What happens if the user types 7? MenuChoice < 1 OR MenuChoice > 4 is TRUE, so the rejection message is output and the choice is re-asked. Nothing else runs until a valid number arrives.

Why is the UNTIL test MenuChoice = 4? The stop option is the only exit the question allows: “the program continues until the user inputs the stop option from the menu”.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

REPEAT
    OUTPUT "1  Cuboid"
    OUTPUT "2  Triangular prism"
    OUTPUT "3  Sphere"
    OUTPUT "4  Stop"
    OUTPUT "Enter your choice: "
    INPUT MenuChoice
    // Validate: re-ask until the choice is 1 to 4
    WHILE MenuChoice < 1 OR MenuChoice > 4
        OUTPUT "Invalid choice - please enter 1, 2, 3 or 4"
        INPUT MenuChoice
    ENDWHILE
    // ... selection happens here ...
UNTIL MenuChoice = 4

📖 Detailed explanation

Two loops, two jobs. The outer REPEAT … UNTIL drives the whole program; the inner WHILE only repairs an invalid menu choice. Keeping them apart makes both easy to verify.

The validation test has two halves. A choice is valid only when it is >= 1 and <= 4, so the re-ask condition is the OR of the two failures — miss one half and values escape.

Validation runs before any shape data. This ordering guarantees the program never asks for a radius when the user actually typed 9.

⚠️ Common mistakes

Testing only MenuChoice > 4 and letting 0 or a negative value through.
Putting the validation after the selection, so an invalid value still triggers a branch.
Forgetting to re-input MenuChoice inside the validation loop, creating an endless rejection.
Ending the outer loop on anything other than the stop option, such as exiting after one volume.

💡 Exam hack / tip

Say the two loop sentences aloud: the inner loop asks “is the choice valid?”, the outer loop asks “did they choose stop?” If your code cannot answer both questions, the menu is not finished.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration and validationR1 · validated menu loopAO3 · correct boundary test

The menu loop supplies the iteration and validation evidence for AO2, and the correct 1-to-4 boundary supports AO3 accuracy. These are alignment notes, not separately allocated marks.

Function Cuboid and its menu option

Input base, depth and height; call the function; round the return value.

R2 · R3 · R4

🧠 Step-by-step thinking

Write the function with a parameter list. FUNCTION Cuboid(Base : REAL, Depth : REAL, Height : REAL) RETURNS REAL — the three inputs arrive as parameters, not from INPUT.
Return the formula, unrounded. RETURN Base * Depth * Height — the function's job is the mathematics, not the formatting.
Option 1 in the selection. The main program prompts for base, depth and height, then assigns Volume ← Cuboid(Base, Depth, Height).
Output belongs to the main program. OUTPUT “Volume = ”, ROUND(Volume, 2) prints 60.00 for a 3 × 4 × 5 cuboid.
Mirror the question's words. The parameter names Base, Depth and Height match the formula exactly, so the examiner can check them line by line.

FUNCTION … RETURNS REALParameters: Base, Depth, HeightROUND in main program

❓ Guiding questions – think before revealing

Why pass Base, Depth and Height as parameters?
What does RETURNS REAL promise?
Why not round inside the function?

Reveal suggested reasoning

Why pass Base, Depth and Height as parameters? “Each function uses the input data as parameters.” The values are input in the main program and travel into the function through its parameter list.

What does RETURNS REAL promise? That the function hands back a real number — RETURN Base * Depth * Height — which the main program stores in Volume before outputting it.

Why not round inside the function? The question pins the rounding to the output in the main program. Returning the raw volume keeps the function reusable and leaves ROUND(Volume, 2) where the question puts it.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FUNCTION Cuboid(Base : REAL, Depth : REAL, Height : REAL) RETURNS REAL
    // Volume of a cuboid = base × depth × height
    RETURN Base * Depth * Height
ENDFUNCTION

// Menu option 1 in the main program:
OUTPUT "Enter the base: "
INPUT Base
OUTPUT "Enter the depth: "
INPUT Depth
OUTPUT "Enter the height: "
INPUT Height
Volume ← Cuboid(Base, Depth, Height)
OUTPUT "Volume = ", ROUND(Volume, 2)

📖 Detailed explanation

The function is deliberately tiny. One comment, one RETURN — nothing else. A function that only calculates is easy to check against the given formula and easy to reuse.

The call site reads like the question. Input the data, call the function with that data, output the rounded result — the same rhythm every branch of the menu will follow.

The arguments and parameters share names on purpose. Cuboid(Base, Depth, Height) passes the main program's variables into parameters that happen to share their names — the values are copied either way.

⚠️ Common mistakes

Writing INPUT Base inside the function, which breaks the parameters requirement.
Omitting RETURNS REAL, or writing RETURN with no value after it.
Rounding inside the function with RETURN ROUND(Base * Depth * Height, 2), moving the rounding away from the main program.
Forgetting the prompts on the three inputs, ignoring the “suitable messages” requirement.

💡 Exam hack / tip

Treat the formula line as a checklist: base × depth × height means three parameters, three inputs, one RETURN. If the function and the formula disagree by a single word, fix the function.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · function with parametersR2 · R3 · R4 · input, call, rounded outputAO3 · formula matches the question

This stage is the clearest AO2 evidence of parameter passing and returned values, with the exact formula supporting AO3 accuracy. These are alignment notes, not separately allocated marks.

Function TriangularPrism

Same parameters as the cuboid, but the formula takes one half of the product.

R2 · R3 · R4

🧠 Step-by-step thinking

Reuse the same parameter list. TriangularPrism(Base : REAL, Depth : REAL, Height : REAL) RETURNS REAL — identical inputs to the cuboid, different mathematics.
Apply the half. RETURN 0.5 * Base * Depth * Height — the formula is ½ × base × depth × height, so multiply by 0.5 or divide the product by 2.
Option 2 in the selection. The main program prompts for the same three dimensions and calls Volume ← TriangularPrism(Base, Depth, Height).
Same rounding, same output line. The shared output statement in the main program prints ROUND(Volume, 2) whichever function ran.
Check the arithmetic. A 6 × 5 × 4 prism gives 0.5 × 6 × 5 × 4 = 60 — the same volume as a 3 × 4 × 5 cuboid, a useful self-test when revising.

Half factor: 0.5 × …Same three parametersShared ROUND output

❓ Guiding questions – think before revealing

Why is ½ written as 0.5 in code?
Could the prism just call Cuboid and halve it?
What does the main program do differently for option 2?

Reveal suggested reasoning

Why is ½ written as 0.5 in code? Pseudocode arithmetic needs a number, not a fraction layout: 0.5 * Base * Depth * Height and (Base * Depth * Height) / 2 are both accepted — pick one and stay consistent.

Could the prism just call Cuboid and halve it? The volumes are related, but the question says create one function for each shape using the given formulae — keep the two functions separate and literal.

What does the main program do differently for option 2? Only the call: Volume ← TriangularPrism(Base, Depth, Height). The prompts, the assignment pattern and the output line are identical to option 1.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FUNCTION TriangularPrism(Base : REAL, Depth : REAL, Height : REAL) RETURNS REAL
    // Volume of a triangular prism = ½ × base × depth × height
    RETURN 0.5 * Base * Depth * Height
ENDFUNCTION

// Menu option 2 in the main program:
OUTPUT "Enter the base: "
INPUT Base
OUTPUT "Enter the depth: "
INPUT Depth
OUTPUT "Enter the height: "
INPUT Height
Volume ← TriangularPrism(Base, Depth, Height)
OUTPUT "Volume = ", ROUND(Volume, 2)

📖 Detailed explanation

The ½ must reach the final value. Multiplying by 0.5 anywhere in the product gives the same answer, but keeping the factor visible in RETURN 0.5 * Base * Depth * Height mirrors the printed formula.

Three parameters again. The prism's formula names base, depth and height just as the cuboid's does — the function signature repeats even though the mathematics differs.

The output line is shared. Because every branch stores its result in Volume, one rounded output in the main program serves the cuboid, the prism and the sphere alike.

⚠️ Common mistakes

Forgetting the 0.5 and returning a full cuboid volume for the prism.
Dropping one of the three parameters because the prism “feels” simpler than the cuboid.
Writing 1/2 * Base and relying on integer division, which can evaluate to 0.
Duplicating the rounded output inside every branch and then again after the selection, printing volumes twice.

💡 Exam hack / tip

Compare the two functions side by side: identical signatures, one differing factor. Spotting that pattern in revision is what makes the sphere — with its single parameter and constant Pi — feel like the only genuinely new case.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · second function, same patternR2 · R3 · correct ½ formulaAO3 · accurate expression

The prism function reinforces the parameter-passing pattern for AO2 while the ½ factor tests AO3 accuracy. These are alignment notes, not separately allocated marks.

Function Sphere and the constant Pi

One parameter, Pi = 3.142, and a volume that genuinely needs rounding.

R2 · R3 · R4

🧠 Step-by-step thinking

One parameter only. FUNCTION Sphere(Radius : REAL) RETURNS REAL — the sphere's formula needs nothing else.
Use the declared constant. RETURN (4.0 / 3.0) * Pi * Radius * Radius * Radius — Pi comes from the declared constant, not from 3.142 typed inline.
Multiply radius three times. The paper writes radius × radius × radius; that literal repetition in pseudocode is safest — no power operator is needed.
A real rounding case. A radius of 3 gives 4/3 × 3.142 × 27 = 113.112, and ROUND(113.112, 2) prints 113.11 — rounding that actually changes the final digits.
Option 3 in the selection. Input only the radius, call Sphere(Radius), then output through the shared ROUND line.

Single parameter: RadiusConstant Pi usedROUND(113.112, 2) → 113.11

❓ Guiding questions – think before revealing

Why bracket (4.0 / 3.0)?
Why use the constant instead of typing 3.142?
Why write Radius * Radius * Radius three times?

Reveal suggested reasoning

Why bracket (4.0 / 3.0)? The division must happen before the multiplication. Left-to-right evaluation would still work here, but the brackets make the fraction explicit and remove all doubt for the reader.

Why use the constant instead of typing 3.142? The paper declares “Pi is a constant with value 3.142”. Using Pi proves the declaration is real and means one edit if the precision ever changed.

Why write Radius * Radius * Radius three times? It matches the formula exactly as printed. Writing Radius3 risks being read as an identifier, and a power notation is not part of the pseudocode guide.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FUNCTION Sphere(Radius : REAL) RETURNS REAL
    // Volume of a sphere = 4/3 × Pi × radius × radius × radius
    RETURN (4.0 / 3.0) * Pi * Radius * Radius * Radius
ENDFUNCTION

// Menu option 3 in the main program:
OUTPUT "Enter the radius: "
INPUT Radius
Volume ← Sphere(Radius)
OUTPUT "Volume = ", ROUND(Volume, 2)

// Self-test: radius 3 → 4/3 × 3.142 × 27 = 113.112
// so the main program prints ROUND(113.112, 2) = 113.11

📖 Detailed explanation

The sphere is the declaration test. This is the one function that cannot be written without CONSTANT Pi = 3.142, which is why the paper fixes the value in the question.

Only one input is requested. Branch 3 prompts for the radius alone — asking for base, depth or height here would reveal a copy-pasted branch rather than a read formula.

The rounding finally matters. 60 needed no rounding at all, but 113.112 does: ROUND(113.112, 2) = 113.11, so the two-decimal requirement is visible in the output.

⚠️ Common mistakes

Using 3.14 or the calculator's fuller value of Pi instead of the constant 3.142 the question fixes.
Multiplying by 4/3 as 4 DIV 3, which evaluates to 1 and destroys the answer.
Cubing with Radius ^ 3 or Radius3 — notation the pseudocode guide does not provide.
Asking for all three cuboid dimensions in the sphere branch because the branches were copied.

💡 Exam hack / tip

Underline the words “Pi is a constant with value 3.142” in the question. That single sentence must surface twice in your answer: once as CONSTANT Pi = 3.142 and once inside the Sphere function's RETURN.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · constant plus single-parameter functionR2 · R3 · radius-only input, correct formulaAO3 · accurate 4/3 × Pi × radius³

The Sphere function combines constant use, parameter passing and a demanding expression — strong AO2 and AO3 evidence. These are alignment notes, not separately allocated marks.

Stop option, shared output and future shapes

Close the loop on stop and check the answer against every bullet.

R1 · R4 · R5

🧠 Step-by-step thinking

End only on stop. When the user chooses option 4, the UNTIL test is TRUE and the program finishes — no shape data is requested for option 4.
One shared output line. Because every branch stores its result in Volume, a single OUTPUT “Volume = ”, ROUND(Volume, 2) after the selection serves all three shapes.
Guard the output for stop. The output must not run when the user chose stop — there is no new volume then, so an IF wraps the output for choices 1 to 3.
Check the declarations. MenuChoice, Base, Depth, Height, Radius, Volume and the constant Pi — every name used has been declared at the top.
Imagine the fourth shape. Adding a cone later means one new function and one more menu option — exactly the flexibility the question's introduction promises.

Exit: UNTIL MenuChoice = 4Shared guarded outputDeclarations complete

❓ Guiding questions – think before revealing

Why must the output be guarded?
How does the answer show it can grow?
Which bullet is easiest to drop accidentally?

Reveal suggested reasoning

Why must the output be guarded? When the user chooses stop there is no new calculation — printing Volume would repeat the previous run's answer. The IF keeps the output tied to a real choice of 1 to 3.

How does the answer show it can grow? A new shape needs only a new function and one more option in the menu and selection — the loop, the validation and the output line stay untouched.

Which bullet is easiest to drop accidentally? The declarations line. The functions and loop earn the technique marks, but “all variables and constants used must be declared” is a stated requirement — check the top of the answer first.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// After the selection (options 1 to 3):
IF MenuChoice >= 1 AND MenuChoice <= 3
THEN
    OUTPUT "Volume = ", ROUND(Volume, 2)
ENDIF

// Option 4: no data requested, no output,
// because the CASE has no branch for 4
UNTIL MenuChoice = 4
// Program stops here

📖 Detailed explanation

The stop option changes nothing except the loop. Option 4 passes validation, finds no CASE branch, skips the guarded output and makes the UNTIL test TRUE — the cleanest possible exit.

The rounded output sits in the main program. That placement is worth re-reading: the question deliberately says in the main program, so the ROUND must not migrate into the functions.

Final check walks the bullets. Menu and validation (R1), shape data inputs (R2), three parameterised functions (R3), rounded output (R4), declarations, comments and messages (R5) — tick them in the margin.

⚠️ Common mistakes

Printing the volume for the stop option, repeating the previous run's answer.
Leaving the UNTIL test as MenuChoice <> 0 or another value no option produces, so the program never stops.
Declaring variables that are never used, or using a variable that was never declared.
Forgetting comments entirely — the question requires comments explaining how the code works.

💡 Exam hack / tip

End-of-question checklist: declared everything, validated the choice, one function per shape, ROUND in the main program, stop ends the loop. Five ticks in the margin cover every bullet on the paper.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · complete loop and outputsR1 · R4 · stop option and rounded outputsAO3 · logical loop closure

The summary stage delivers the loop exit and the guarded output, and its checklist role 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–R5	Identifies menu loop, validation, three functions, parameter passing and rounding.	Establishes logical order and comments plan.
2 · Data	Required data structures	MenuChoice, dimension and volume variables typed appropriately; constant Pi declared.	Declarations present with meaningful identifiers.
3 · Menu	R1	Menu output, validated input and repeat-until-stop loop.	Correct 1-to-4 boundary test and suitable messages.
4 · Cuboid	R2, R3, R4	Inputs base, depth, height; calls Cuboid with them as parameters; rounded output.	Formula matches base × depth × height exactly.
5 · Prism	R2, R3, R4	Reuses the parameter pattern for the ½ × base × depth × height formula.	Accurate 0.5 factor inside the function.
6 · Sphere	R2, R3, R4	Radius-only input; Sphere uses the constant Pi and returns the volume.	Correct 4/3 × Pi × radius × radius × radius expression.
7 · Summary	R1, R4, R5	Stop option ends the loop; shared guarded output; declarations complete.	Suitable messages throughout and comments explaining the code.

Consolidated Cambridge pseudocode

Complete solution

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

15-mark exemplar style

QUESTION 10 · FULL PSEUDOCODECambridge 0478 style · functions with parameters

// Declarations — all variables and constants used must be declared
DECLARE MenuChoice : INTEGER
DECLARE Base : REAL
DECLARE Depth : REAL
DECLARE Height : REAL
DECLARE Radius : REAL
DECLARE Volume : REAL
CONSTANT Pi = 3.142
// Cuboid: volume = base × depth × height
FUNCTION Cuboid(Base : REAL, Depth : REAL, Height : REAL) RETURNS REAL
    RETURN Base * Depth * Height
ENDFUNCTION
// Triangular prism: volume = ½ × base × depth × height
FUNCTION TriangularPrism(Base : REAL, Depth : REAL, Height : REAL) RETURNS REAL
    RETURN 0.5 * Base * Depth * Height
ENDFUNCTION
// Sphere: volume = 4/3 × Pi × radius × radius × radius
FUNCTION Sphere(Radius : REAL) RETURNS REAL
    RETURN (4.0 / 3.0) * Pi * Radius * Radius * Radius
ENDFUNCTION
// Main program: loops until the stop option is chosen
REPEAT
    OUTPUT "1  Cuboid"
    OUTPUT "2  Triangular prism"
    OUTPUT "3  Sphere"
    OUTPUT "4  Stop"
    OUTPUT "Enter your choice: "
    INPUT MenuChoice
    // Validate the menu choice: re-ask until it is 1 to 4
    WHILE MenuChoice < 1 OR MenuChoice > 4
        OUTPUT "Invalid choice - please enter 1, 2, 3 or 4"
        INPUT MenuChoice
    ENDWHILE
    // Input the chosen shape's data and call its function
    CASE MenuChoice OF
        1 : OUTPUT "Enter the base: "
            INPUT Base
            OUTPUT "Enter the depth: "
            INPUT Depth
            OUTPUT "Enter the height: "
            INPUT Height
            Volume ← Cuboid(Base, Depth, Height)
        2 : OUTPUT "Enter the base: "
            INPUT Base
            OUTPUT "Enter the depth: "
            INPUT Depth
            OUTPUT "Enter the height: "
            INPUT Height
            Volume ← TriangularPrism(Base, Depth, Height)
        3 : OUTPUT "Enter the radius: "
            INPUT Radius
            Volume ← Sphere(Radius)
    ENDCASE
    // Output the volume in the main program, rounded to two decimal places
    IF MenuChoice >= 1 AND MenuChoice <= 3 THEN
        OUTPUT "Volume = ", ROUND(Volume, 2)
    ENDIF
UNTIL MenuChoice = 4

Why this is a complete response

It covers the five mark-scheme requirements: a validated menu with a stop option and a loop that continues until stop is chosen (R1), inputs matched to the chosen shape's formula (R2), one function per shape taking the input data as parameters and returning the volume (R3), output of the volume in the main program rounded to two decimal places (R4), and declarations for every variable and constant with comments and suitable messages (R5).

What to check before submitting

Check the declarations section, the parameter lists against the question's formulae, the validation condition on the menu choice, the UNTIL MenuChoice = 4 exit, the ROUND(Volume, 2) output positioned in the main program, and the comments explaining how the code works.

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: run the program, one choice at a time.

Step through three menu runs — a cuboid, a triangular prism and a sphere. Watch the menu re-ask after an invalid choice, the dimensions travel into each function as parameters, the volumes come back, and the main program round each one to two decimal places.

Last tab · Trace player

Sample input → expected results

Three sample runs drive the menu (1 = Cuboid, 2 = Triangular prism, 3 = Sphere, 4 = Stop) with the constant Pi = 3.142: a 3 × 4 × 5 cuboid, a 6 × 5 × 4 prism and a sphere of radius 3. The sample deliberately includes: a first menu choice of 7, which the validation rejects before the cuboid run begins; the prism's ½ factor cancelling its larger base so the prism prints exactly the same 60.00 as the cuboid; and the sphere's 4/3 × 3.142 × 27 = 113.112, whose ROUND(x, 2) output genuinely changes the final digits to 113.11. These are illustrative values, not data supplied by the examination question.

Sample runs menu choice and the data for each shape

Run	Menu choice	Base	Depth	Height	Radius

A dash means the dimension is not needed by that shape's formula — the sphere asks for the radius only.

Reveal expected volumes and run summary

Expected results After each function returns

Run	Function called	Inputs used	Volume (2 dp)

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Run counters

Ready

Tip: use Next step slowly and watch MenuChoice, FunctionCall and Volume. The dimension boxes are refilled for each new run, but the two run counters never reset.

Trace colours: blue row = current menu run; amber cell = the value just input; green cells = inputs already taken.

Worked examples: the first choice typed is 7, and MenuChoice < 1 OR MenuChoice > 4 is TRUE, so the message appears and the choice is re-asked. The cuboid returns 3 × 4 × 5 = 60 and the prism returns 0.5 × 6 × 5 × 4 = 60, so both display ROUND(60, 2) = 60.00. The sphere returns (4/3) × 3.142 × 3 × 3 × 3 = 113.112, and the main program outputs ROUND(113.112, 2) = 113.11.

Volumes returned by three functions, driven by a validated menu.

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 declarations

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Build the validated menu loop

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Function Cuboid and its menu option

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Function TriangularPrism

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Function Sphere and the constant Pi

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Stop option, shared output and future shapes

🧠 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: run the program, one choice at a time.

Sample input → expected results

Sample runs menu choice and the data for each shape

Expected results After each function returns

Execution trace

Initialisation

Live variable values

Run counters