🚢 Topic 11 Programming scenarios · 11.4

Ship — full end-to-end 15-mark solutions

The scenario becomes shippable. Read (Lab A) → Build (Lab B) → Ship: assemble your patterns into a complete Cambridge-marker-ready pseudocode solution. Six scenarios × four modes × the exam-grade 5-axis mark scheme.

Prereq: Lab A · Read (scenario analysis) + Lab B · Build (pattern blocks) are strongly recommended before starting Lab C. If you haven't done them, head there first — Scenario Bench will feel much harder without the patterns.

📚 Book Notes

🎓 Learn

🎮 Activities

✎ Practice

📋 Exam

🔄 Review

🏆 Mastery

§1 · Topic overview

Lab C · Ship — the destination

Everything Labs A and B built for arrives here. Paper 2 Question 11 is 15 marks — roughly 20% of the whole paper. Get it right and you can afford to lose marks elsewhere. Get it wrong and every other topic has to overperform.

Cambridge marks Q11 against five axes. Every scenario is scored the same way — same rubric, same expectations, whether you're totalling sports league points or menu-driving a video library. Learn the axes once, use them forever.

🎯 The five mark-scheme axes

1 · Data structures — used correctly, with the given names

2 · Techniques — ≥2 of selection, iteration, counting, totalling, I/O

3 · Requirements coverage — every bullet in the scenario addressed

4 · Messages — appropriate prompts on all inputs and outputs

5 · Comments — explain the purpose of each logical block

§2 · Learning objectives

By the end of Lab C you can:

Complete a full 15-mark Paper 2 Q11 scenario in Cambridge Pseudocode.
Correctly use the given data structures — not renamed, not restructured.
Cover every requirement in the bullet list.
Wire 3-5 Lab B patterns into a single working solution.
Include validation on every input (loop, not IF).
Include appropriate messages on every I/O.
Include comments on every logical block.
Output ALL matches when multiple exist, not just one.
Recognise exam-time-pressure trade-offs (requirements first, polish last).
Self-assess against the five axes before submitting.

§3 · Key terminology

Term	Definition
Mark scheme axis	One of the five things Cambridge examiners check
Full solution	A complete pseudocode program that meets every requirement in a scenario
Requirement coverage	The percentage of scenario bullets your solution addresses
Technique diversity	How many of {selection, iteration, counting, totalling, I/O} your solution uses
Method 1 (Analytical)	Read → IPO table → code
Method 2 (Practical)	Walk through requirements with sample data → note the steps → turn steps into code

§4 · Core theory — the two methods

§4.1 · Method 1 (Analytical) — IPO-first

Best for scenarios with clear inputs, processes, and outputs (most 15-mark questions). Build the IPO table first, then translate to pseudocode row-by-row.

§4.2 · Method 2 (Practical) — walk-through

Best when the scenario is menu-driven or state-machine-like. Walk through with sample data (e.g. "user picks 1, so ..."), note each step, then turn steps into code.

§4.3 · The 60-minute exam plan

5min · read scenario twice + IPO table

40min · write the pseudocode

10min · add comments + I/O messages

5min · review against the 5 axes

§4.4 · Axis priority when time runs short

Data structures > requirements coverage > techniques > messages > comments. Missing any single axis is recoverable; missing two is fatal. If you're behind on time, the panic order is: fix a missing data structure first, then bag one more requirement — comments and messages can be sprinkled in the last 5 minutes.

§4.5 · The second-pass output habit

Every "output the X" requirement needs a second read: one or many? If the scenario says "output the names of the competitors who achieved the highest score", a single-name output loses marks. Cambridge examiner report (2025 M/J P21 Q11) noted: "Only a few candidates correctly outputted the names of all the competitors who achieved the highest score."

§5 · Worked examples

WE1 · Sports league (2023 F/M P22 Q11) — Method 1

Cambridge scenario · TeamName[] 1D + TeamPoints[] 2D · four requirements.

Step 1 · IPO · Inputs already in TeamName[] and TeamPoints[]. Processes: total per team, count categories, find high/low, output names. Outputs: totals, counts, names.

Step 2 · Initialise counters · HomeWins ← 0, Drawn ← 0, etc. Examiner-cited trap: "not initialising counters to zero" (2023 F/M P22 Q11).

Step 3 · Nested loop over TeamPoints[t, m] · Total per team goes in the outer loop, counting per category goes in the inner IF chain.

Step 4 · Two-pass for high/low · Pass 1 finds Highest/Lowest values. Pass 2 outputs ALL TeamName[t] where TeamTotal[t] = Highest (and again for Lowest).

Step 5 · Comment every block, message every OUTPUT · Both are marks, not decoration.

WE2 · Screen time (2024 F/M P22 Q11) — the MIN-with-all-matches

Cambridge scenario · StudentName[] 1D + ScreenTime[] 2D · four requirements including "output the student with the lowest weekly minutes".

The trap · "The lowest weekly minutes" is ambiguous — could be one student, could be several. The double-pass MIN pattern handles both.

Pass 1 · Loop through StudentTotal[] to find the minimum value.

Pass 2 · Loop through again; output StudentName[s] for every s where StudentTotal[s] = Lowest. If there's exactly one, one name gets printed. If there are ties, all get printed — no code change needed.

Cambridge verbatim · "correctly used all the data structures given in the scenario in the way they were expected to be used as stated in their descriptions" — 2024 F/M P22 Q11 examiner report.

WE3 · Video library (2025 M/J P23 Q8) — Method 2 menu-driven

Cambridge scenario · Video[] 2D + Results[] · menu-driven with three options (Add / Search / End).

Method 2 wins here · A menu system is a state machine, not a linear IPO problem. Walk through with sample data: "user picks 1, so I input title + format and store". "user picks 2, so I search and output matches". Turn each walk-through into pseudocode.

Outer loop · WHILE Choice <> 3 DO ... ENDWHILE. Validate Choice inside.

Choice = 1 · Add · Input title + format, increment Count, store Video[Count, 1] = title, Video[Count, 2] = format.

Choice = 2 · Search · Loop through Video[], store up to 20 matches in Results[], print.

Cambridge verbatim · "followed the remaining additional guidance at the end of the scenario" — 2025 M/J P23 Q8 examiner report (referencing top-marks candidates).

§6 · Common misconceptions

🚨 Writing code before doing IPO / walk-through

Diving straight into pseudocode without analysing the scenario always loses requirements coverage. Read twice, plan (IPO or walk-through), then code.

✅ Fix · 5 minutes on planning saves 15 minutes on debugging.

🚨 Under-commenting to save time

Comments earn marks on the comments axis (up to 2/15). Cutting them to save time is a false economy — they take 60 seconds and are worth up to 2 marks.

✅ Fix · One comment per logical block. // initialise counters, // nested loop over 2D array, // output all top teams.

🚨 Over-engineering requirement 1 at cost of requirement 4

Spending 20 minutes perfecting the validation loop for requirement 1 while requirement 4 remains unattempted is a mark disaster. Requirements coverage is worth up to 5/15.

✅ Fix · Cover all requirements first at 70% quality, then polish. Perfection on 3 requirements loses to adequacy on 5.

§7 · Cambridge exam focus

Verbatim mark-scheme language — you'll see these exact phrases on every 2023-2025 Q11 mark scheme.

"Data structures required with names as given in the scenario"

"More than one technique seen applied to the scenario, check the list of techniques"

"All criteria stated for the scenario have been covered by the use of appropriate structure"

"Appropriate messages to accompany all inputs and outputs"

"Comments to explain the purpose or function of each part or sub-part of the solution"

§8 · Quick knowledge check

1 · How many marks is Paper 2 Q11 worth?

15 marks — roughly 20% of Paper 2. Every sitting from 2023 onwards has one.

2 · Name the five mark-scheme axes.

Data structures · Techniques · Requirements coverage · Messages · Comments.

3 · What are the two methods for tackling a scenario?

Method 1 (Analytical) — build IPO table then translate to code. Method 2 (Practical) — walk through with sample data, note steps, turn into code.

4 · When is Method 2 the better choice?

When the scenario is menu-driven or state-machine-like (e.g. the video library scenario). A linear IPO doesn't capture branching menus well.

5 · What's the priority order if time runs short?

Data structures > requirements coverage > techniques > messages > comments. Missing one axis is recoverable; missing two is fatal.

6 · What's the "output ALL matches" habit?

Every "output the X" requirement needs a second-pass loop: after finding the target value, loop again and output every entry that matches — one or many.

7 · How should you split your 60-minute Q11?

5 min read + IPO · 40 min code · 10 min comments + messages · 5 min review.

8 · Which of {selection, iteration, counting, totalling, I/O} count as "techniques"?

All five. Cambridge wants ≥2 for any mark on the techniques axis, ≥3 for full marks.

§9 · Ready for Scenario Bench?

🚢 You know the method and the mark scheme

Head to the Activities tab — Scenario Bench is the full exam simulator with six real Cambridge scenarios and the exam-grade 5-axis marker. Start with Walk-through mode for the menu-driven video library, then try Guided on any other scenario. Exam Mode (60-minute timer) unlocks once you've completed two of the earlier modes.

🎯 The 5 axes at a glance

3Data structures /3 — used with given names

3Techniques /3 — ≥2 of 5 families

5Requirements /5 — every bullet covered

2Messages /2 — prompts on all I/O

2Comments /2 — one per logical block

15Total = full marks

📖 Cambridge Pseudocode side-by-side

Same logic, different notation. Cambridge only marks the pseudocode.

Cambridge	Python
`INPUT Name`	`name = input()`
`OUTPUT "Hi ", Name`	`print("Hi", name)`
`Total ← 0`	`total = 0`
`FOR i ← 1 TO 10`	`for i in range(1, 11):`
`IF X = 5 THEN`	`if x == 5:`
`WHILE X <> 0 DO`	`while x != 0:`

🏆 Progress signals

0Scenarios completed

0Modes unlocked (of 4)

0Knowledge checks revealed

📖 Getting Started

Paper 2 Q11 is 15 marks — worth roughly 20% of the whole paper. Get it right and you can afford to lose marks elsewhere. Get it wrong and every other topic has to overperform.

📖 Context

Consider the 2025 M/J P23 Q8 scenario. A collector stores video details in Video[] (2D: title + format) and Results[] (up to 20 matches from a search). The program displays a menu with three options: Add, Search, End. This is a state machine — Method 2 (walk-through) beats Method 1 (IPO) here because the flow branches on menu choice, not on a linear input-process-output.

📖 Discussion

Q · You have 60 minutes for Q11. You've written full pseudocode covering 4 of 5 requirements, with no comments. Do you fix requirement 5, or add comments? Why?

Add comments first. Requirements coverage is /5 — one missing requirement is up to 1 mark lost. Comments are /2 — no comments is 2 marks lost. In marks-per-minute terms, sprinkling // initialise counter style comments across your existing 4 requirements will score more than a rushed and probably-wrong attempt at requirement 5. This is the axis-priority trade-off in action.

Contrast box 1 · Under-commented vs commented

❌ No comments

Total ← 0
FOR i ← 1 TO 10
   Total ← Total + Scores[i]
NEXT i
OUTPUT "Total: ", Total

Comments axis: 0/2. Cambridge examiner (2023 F/M P22 Q11): "omitting comments" cited as a common error.

✅ Commented

// initialise the running total
Total ← 0
// sum the 10 scores
FOR i ← 1 TO 10
   Total ← Total + Scores[i]
NEXT i
// output with prompt
OUTPUT "Total: ", Total

Comments axis: 2/2. Same code + 3 well-placed comments = 2 more marks.

Contrast box 2 · Method 1 vs Method 2

Method 1 · IPO-first (analytical)

Best for: linear input-processing-output scenarios.

Input  | Process       | Output
scores | sum all       | total
5-100  | average       | avg
       | count > 100   | count

Then translate each row to pseudocode. Works for ~70% of Q11 scenarios (sports league, temperatures, screen time, competitors).

Method 2 · Walk-through (practical)

Best for: menu-driven, state-machine, branching scenarios.

User picks 1 → input title + format → store
User picks 2 → input search → find + print
User picks 3 → exit loop

Turn each walked step into code. Works for the ~30% of Q11 scenarios that branch on user choice (video library, secret cell game).

🧪 Mark Scheme Simulator

Tap the axis each snippet fulfils. Trains axis-recognition before Scenario Bench's full marker fires.

📌 Six exam-safe habits

Habit	Pseudocode form	Mark-scheme axis
Initialise before accumulate	`Total ← 0` before `FOR`	Techniques (counting/totalling)
Loop-not-IF for validation	`WHILE cond DO INPUT ENDWHILE`	Requirements (validation)
Second pass for all matches	Two-loop MIN/MAX pattern	Requirements (output all)
Message every I/O	`OUTPUT "Enter score: "`	Messages axis
Comment every block	`// find lowest total`	Comments axis
Use given names	`TeamName[]` not `Teams`	Data structures axis

🚨 Six inline trap cards

Trap 1 · Single-match output when all matches required

Storing the first matching name in a variable then outputting one name. If two students tie for lowest weekly minutes, both should be output.

2025 M/J P21 Q11 examiner: "Only a few candidates correctly outputted the names of all the competitors who achieved the highest score."

✅ Two-pass pattern: pass 1 finds Lowest; pass 2 outputs every StudentName[s] where StudentTotal[s] = Lowest.

Trap 2 · Renaming the given data structures

The scenario says TeamPoints, you write Points. Zero marks on the data structures axis, regardless of how correct your logic is.

2024 F/M P22 Q11 examiner: "correctly used all the data structures given in the scenario in the way they were expected to be used as stated in their descriptions".

✅ Copy the identifier names from the scenario verbatim. Case matters.

Trap 3 · Not covering all requirements

Requirements coverage is /5 — the highest single-axis weight in the mark scheme. Skipping requirement 4 or 5 to polish requirement 1 is a mark disaster.

2024 F/M P22 Q11 examiner: "candidates whose responses closely matched the requirements stated in the scenario, ensuring that all points were fully covered, achieved the highest marks".

✅ Cover every requirement at 70% quality first, then polish. Adequacy on 5 beats perfection on 3.

Trap 4 · Under-commented — under-marked

Comments are worth /2. Skipping them costs the whole axis.

2023 F/M P22 Q11 examiner: "omitting comments" cited as common error.

✅ One // comment per logical block. Takes 60 seconds. Worth up to 2 marks.

Trap 5 · Missing input/output messages

INPUT Score with no preceding OUTPUT "Enter score: " — user sees a blank cursor and has no idea what to type. Same for outputs.

2024 F/M P22 Q11 mark scheme: "use of appropriate messages to accompany all inputs and outputs".

✅ Every INPUT is preceded by an OUTPUT prompt. Every OUTPUT includes a label string.

Trap 6 · Using IF for validation (single-shot bug)

IF Score < 0 THEN OUTPUT "bad" ENDIF lets the invalid value through — the program continues. A validation LOOP re-prompts until the value is valid.

2025 M/J P21 Q11 examiner: "Some candidates used an IF statement to validate the entry, but this only allows for one extra data entry."

✅ REPEAT INPUT Score UNTIL Score >= 0 AND Score <= 100.

🎯 Quick check

1 · What's the axis-priority order when time is tight?

Data structures > requirements > techniques > messages > comments.

2 · Why is IF-only validation a trap?

If the input is invalid, IF-only lets the program continue with a bad value. LOOP validation re-prompts until valid. Cited verbatim in 2025 M/J P21 Q11 as "only allows for one extra data entry".

3 · Which method suits a menu-driven scenario?

Method 2 (walk-through). Menus branch on user choice, not on linear I/O — walk through with sample data, note steps, code each branch.

4 · What does the "second pass" pattern give you?

It handles output-ALL-matches correctly. Pass 1 finds the target value (min or max); pass 2 outputs every entry that matches. If one entry matches, one name prints; if ten match, ten print — no code change.

🚢 Ready for Scenario Bench?

Head to Activities and pick a scenario. Six real Cambridge scenarios, four modes (Walk-through → Guided → Timed → Exam), the exam-grade 5-axis marker on every submit.

🚢 Scenario Bench — full-scenario simulator

Six real Cambridge scenarios · four modes · exam-grade 5-axis marker. Pick a mode, pick a scenario, write the pseudocode, hit Mark.

0Scenarios completed

0Modes tried (of 4)

–Last score (/15)

1 · Choose a mode

Pick a mode to begin. Walk-through and Guided are open; Timed and Exam Mode unlock after you complete Walk-through + one other.

2 · Choose a scenario

3 · The scenario

Pick a scenario above to see the stem.

4 · Write your pseudocode

⚡ Sprint drill · 60 seconds

Rapid recall of the 5 axes, key traps, and scenario shapes. Answer as many as you can before the timer hits 0.

60seconds left

0score

0streak

0best

Press Start to begin.

🎯 The 5 axes

Data structures /3 — required identifiers appear with given names.

Techniques /3 — ≥2 of {selection, iteration, counting, totalling, I/O}.

Requirements /5 — scenario-specific predicates.

Messages /2 — OUTPUT/INPUT with prompt strings.

Comments /2 — // occurrences.

Total /15 = full Q11 marks.

🏁 Verdict thresholds

Perfect · 14-15

Strong · 11-13

Partial · 7-10

Weak · 0-6

Malformed · parse error

⏱ Mode reference

1 · Walk-through — Method 2 exemplar. Video library scenario. Step through with reveal-on-tap sample data.

2 · Guided — Any scenario. Reference "shape" available on tap. Marker fires on demand.

3 · Timed — Any scenario. 20-minute timer. Marker only on submit.

4 · Exam Mode 🔒 — Any scenario. 60-minute timer. Full Q11 simulation, no hints. Unlocks after completing Walk-through + one other.

✎ Practice — 18 adaptive MCQs

Difficulty tags · adaptive weighting · Exam Mode toggle for recall + self-mark.

Loading first question...

0Attempted

0Correct

0%Accuracy

💪 Weak skills

Answer some questions and the areas you keep missing will show up here — the adaptive weighting will resurface them.

📊 Skill coverage

Practice covers the 5 mark-scheme axes and cross-axis exam-time triage: data structures ID · techniques counting · requirements recognition · messages/comments recognition · exam-time triage.

📋 Exam — 12 real Paper 2 items

Every item cited to a real Cambridge Paper 2 or textbook §. Tap Reveal mark scheme to see the Cambridge-style checklist for the item.

📚 Sources

Cambridge Paper 2 (2023-2025) — 6 items

Textbook §11.2 · 11.4 — 2 items

Textbook end-of-chapter — 2 items

Synthetic exam-style — 2 items

🔄 Review — examiner-cited traps

Ten traps distilled from 2023-2025 Cambridge examiner reports. Each carries the verbatim examiner quote plus the fix.

🧠 Memory triggers

🏆 Mastery — 12-item revision checklist

Tick off each capability as you own it. Long-hold any item to force it done (override).

🎓 Module Mastered · you're ready for Paper 2 Q11.

Progress

0of 12 items ticked

0overrides