15-mark question lab · start here

From a sports-club register to a menu-driven membership program.

Build the solution in a sensible order: decode the menu requirements, plan the arrays and counters, initialise your own variables, drive the program from a validated menu, gate each new code through the LENGTH and uniqueness checks, store it in the first free slot, and finish with the list output and stop. Learn the reasoning before revealing the complete program.

Menu-driven loopLENGTH validationUniqueness searchFirst-free-slot storageParallel arrays15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the 1D and 2D arrays, their shared member index, the NewID input variable and the three choices the menu must offer.

02 · Construct

Wrap the program in a validated menu loop and gate every new code through the LENGTH = 6 test and the uniqueness search before storing it in the first available space.

03 · Complete

Input the first and last names into the matching location of Name[], output the full member list with suitable messages, and stop only when the menu offers it.

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 shared member index, the six-character gate and the first-available-space rule all affect the structure of your solution.

Question 10 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 10

A sports club uses a six-character alphanumeric membership code to identify each member of the club. The one-dimensional (1D) array MemberID[] is used to store the unique membership codes for club members. The two-dimensional (2D) array Name[] is used to store the names of the club members. The first and last name of each member will be stored in separate array elements.

The system can store details for a maximum of 1000 members. The position of any member’s data is the same in both arrays. For example, the data in index 2 of MemberID[] belongs to the member in index 2 of Name[].

The variable NewID is used to input a new membership code.

Write a program that meets the following requirements:

Provide a menu that offers the choices: inputting a new member, outputting a list of membership codes and first and last names, or stopping.
Input and validate a response to the menu.
When inputting a new member, input a new membership code and check that it contains six characters:
- If the new code is six characters, check it against all the previously stored membership codes to make sure it is unique.
- If the code is not unique, a new code must be entered and checked.
- If the code is unique, it is stored in the first available space in the appropriate array and the new member is required to enter their first name and last name, which are also stored in the corresponding location of the appropriate array.
When outputting a list of membership codes and names, output for each member: their membership code, first name and last name.
The program will continue until the stop option on the menu is selected.

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

You do not need to declare any arrays, variables or constants; assume this has already been done.

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

You do need to initialise any variables or constants used if appropriate.

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

Provide a three-option menu — input a new member, output the list, or stop — and input and validate the response.

Input a new membership code and check that it contains six characters before anything else happens to it.

Check a six-character code against all the previously stored codes; a code that is not unique must be re-entered and checked again.

Store the unique code in the first available space and input the first and last names into the corresponding location of Name[].

Output each member’s code, first name and last name, and repeat the menu until the stop option is selected.

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 outermost structure first. The program “will continue until the stop option” is chosen, so a REPEAT … UNTIL menu loop wraps everything and ends only when MenuChoice = 3.
Map the menu to three branches. Choice 1 adds a member, choice 2 outputs the list and choice 3 stops. The response must be “input and validated”, so an out-of-range choice is re-asked before any branch runs.
Find the nested validation inside choice 1. A new code faces two checks in order: LENGTH = 6 first, then a uniqueness search — the paper only says “if the new code is six characters”, check it against the stored codes.
Note the shared index. MemberID[i] and Name[i, …] belong to the same member, so the code and both names are written using one NextSlot value.
Build the order. initialise variables → display menu → validate choice → branch (add: length → uniqueness → store code → store names) or (list: loop and print) → until stop.

Menu-driven REPEAT loopNested checks: length, then uniquenessFirst-free-slot storageShared index for three writes

❓ Guiding questions – think before revealing

Which phrases tell you the program is menu-driven?
In what order are the two code checks applied?
What does “the first available space” mean?

Reveal suggested reasoning

Which phrases tell you the program is menu-driven? “Provide a menu that offers the choices” and “will continue until the stop option on the menu is selected” — the whole program sits inside one loop that ends on stop.

In what order are the two code checks applied? The length check comes first: only “if the new code is six characters” is it compared with the stored codes. A five-character duplicate should be rejected for its length, not searched for.

What does “the first available space” mean? The next unused position in both arrays. If NumMembers members are already stored contiguously from position 1, that space is position NumMembers + 1.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// One menu loop wraps the whole program
REPEAT
    // Display the three choices
    // Input and validate the response
    IF MenuChoice = 1 THEN
        // Input code: LENGTH = 6, then uniqueness,
        // then store code + names in the first free slot
    ENDIF
    IF MenuChoice = 2 THEN
        // Output code, first name and last name
        // for every stored member
    ENDIF
UNTIL MenuChoice = 3

📖 Detailed explanation

“Continue until the stop option” is a post-condition: the menu must be shown at least once, so REPEAT … UNTIL MenuChoice = 3 fits the program flow naturally.

“Input and validate a response” means an out-of-range choice is rejected and re-asked — a small WHILE loop around the input does the job.

“If the new code is six characters…” chains the checks: the uniqueness search is nested inside the length branch, not run beside it.

“The corresponding location” reminds you that one member occupies one position in both arrays, so the code and both names are written with the same slot number.

⚠️ Common mistakes

Checking uniqueness before the length check, ignoring the order stated in the bullet.
Ending the program after one action instead of looping back to the menu.
Stopping the program on an invalid choice rather than re-asking.
Storing the code in one position and the names in another, breaking the shared-index rule.

💡 Exam hack / tip

Underline “until the stop option”, “validate”, “six characters”, “unique” and “first available space”. Those five phrases are the whole question: one menu loop, a validated response, a chained LENGTH and uniqueness check, and a first-free-slot write.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · menu-driven program designR1–R5 · full requirement coverageAO3 · checks applied in the right 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 that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given names. MemberID[], Name[] and NewID are supplied by the question — the new code must be input into NewID.
Respect the array shapes. MemberID[] is 1D with room for 1000 codes; Name[,] is 2D with the first name in one element and the last name in the other, for example Name[3, 1] and Name[3, 2].
Count the stored members. NumMembers records how many members are already stored, so the first available space is NumMembers + 1 and the list loop runs 1 TO NumMembers.
Add the validation variables. MenuChoice for the response, IDLength for LENGTH(NewID), IsUnique as a BOOLEAN flag and NextSlot for the write position.
Check for unnecessary data. No result arrays are needed — the list is printed straight back out of the two given arrays.

Given: MemberID[] Name[] NewIDFlag: IsUnique : BOOLEANCounter: NumMembersSlot: NextSlot

❓ Guiding questions – think before revealing

Why is a NumMembers counter worth one variable?
Why does IsUnique need to be a BOOLEAN flag?
Do you need an array for the list output?

Reveal suggested reasoning

Why is a NumMembers counter worth one variable? Every requirement leans on it: the uniqueness search bound (1 TO NumMembers), the first free slot (NumMembers + 1) and the list loop all use it, and it grows by one after each successful add.

Why does IsUnique need to be a BOOLEAN flag? The scan compares NewID against every stored code. A flag remembers the verdict so the WHILE loop can stop at the first match and the UNTIL condition can test the outcome afterwards.

Do you need an array for the list output? No — the list is a read-back of MemberID[] and Name[], so a loop that outputs as it goes is enough.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question:
// MemberID[]   (1D, up to 1000 membership codes)
// Name[,]      (2D: first name, last name in separate elements)
// NewID        (input for a new membership code)

// Chosen by you:
// MenuChoice  : the validated menu response
// IDLength    : LENGTH(NewID)
// IsUnique    : BOOLEAN result of the stored-code search
// NextSlot    : first available position (NumMembers + 1)
// Index       : loop counter for the scan and the list
// NumMembers  : how many members are stored

📖 Detailed explanation

NewID is not optional. The question names the variable that receives the new code; inputting into a different identifier risks losing the mark for using the supplied data structure.

The 2D array is addressed with two indexes. Name[NextSlot, 1] is the first-name element and Name[NextSlot, 2] the last-name element of the same member position.

Meaningful identifiers earn AO3 credit. IDLength, IsUnique and NextSlot each map to one phrase of the question, which makes the code self-explanatory.

⚠️ Common mistakes

Renaming the given arrays or inputting the code into a variable other than NewID.
Keeping the first and last names together in one element — the paper demands separate elements.
Forgetting IsUnique, then trying to report a duplicate from inside the loop with no record of the outcome.
Using 1000 as the bound of the uniqueness search instead of the number of stored members.

💡 Exam hack / tip

Borrow the question’s own words for identifiers: NewID, IDLength, IsUnique, NextSlot. An examiner should map every variable back to a phrase in the paper without guessing.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR2–R4 · 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 variables

The arrays arrive populated; your own variables must start from known values.

R3 · R4

🧠 Step-by-step thinking

Follow the instruction literally. The paper says you do not need to initialise the data in the arrays — but you do need to initialise any variables or constants used, if appropriate.
Give MenuChoice a starting value. MenuChoice ← 0 guarantees the variable is defined before the first INPUT and cannot be mistaken for a valid choice.
Set NumMembers from the register. NumMembers ← 4 in this run: four members are already stored, so the first free slot will be position 5.
Leave the flags for their loops. IsUnique and IDLength are re-computed on every validation pass, so they are assigned at the top of each attempt, not once at the start.
Say what you are not doing. A one-line comment — “arrays are already populated” — tells the examiner the omission is deliberate.

Once: MenuChoice, NumMembersEvery attempt: IDLength, IsUniqueNever: the array data

❓ Guiding questions – think before revealing

Why does MenuChoice start at 0?
Why is NumMembers initialised to 4 and not 0?
Why are IsUnique and IDLength not initialised here?

Reveal suggested reasoning

Why does MenuChoice start at 0? It is outside the valid range 1–3, so it can never accidentally trigger a branch before the first input, and the WHILE validation loop always has a defined value to test.

Why is NumMembers initialised to 4 and not 0? The register is not empty: the question says the array data is already stored. NumMembers must mirror the real number of stored members (four in this sample) or both the uniqueness search and the first-free-slot calculation would be wrong.

Why are IsUnique and IDLength not initialised here? They are assigned inside the validation loop on every attempt, so any starting value would be overwritten before it was ever read.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Initialise the variables used by the program
// (MemberID[] and Name[] are already populated)
MenuChoice ← 0
NumMembers ← 4   // four members are stored before the run starts

// Assigned inside the loops, on every attempt:
// IDLength ← LENGTH(NewID)
// IsUnique ← TRUE before each search
// NextSlot ← NumMembers + 1 when the code is accepted

📖 Detailed explanation

“If appropriate” is doing work in the question. It frees you from seeding every variable blindly, and expects you to reason about which variables need a deliberate starting value.

Initialisation documents the model. NumMembers ← 4 states the starting size of the register, which is exactly the fact every later calculation depends on.

Flags belong to their loops. IsUnique ← TRUE sits immediately before the stored-code search so a rejected earlier attempt cannot poison a later one.

⚠️ Common mistakes

Initialising the arrays with nulls or zeros — the question says the data is already stored.
Starting NumMembers at 0, which would overwrite stored members from position 1.
Seeding IsUnique once before the menu loop and never resetting it, so a second attempt inherits a stale FALSE.
Omitting initialisation entirely, leaving the UNTIL condition reading an undefined variable.

💡 Exam hack / tip

Write the sentence into your answer: “arrays already populated; my own variables initialised”. It takes five seconds and shows the examiner you read the final instructions.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR3 · R4 · counters true to the registerAO3 · deliberate omissions commented

Initialisation supports AO2 because the variables can genuinely store the required data, and AO3 because the program starts from a reliable, commented state. These are alignment notes, not separately allocated marks.

Drive the program from a validated menu

One REPEAT loop wraps the whole program and only the stop option ends it.

🧠 Step-by-step thinking

Display the three choices with messages. Three OUTPUT lines offer inputting a new member, outputting the list, or stopping — exactly the choices the bullet demands.
Input the response into MenuChoice. One INPUT MenuChoice gathers the response, then a validation loop re-asks while it is outside 1–3.
Branch on the validated value. IF MenuChoice = 1 runs the add-member work; IF MenuChoice = 2 runs the list; choice 3 matches nothing and falls through to UNTIL.
End only on stop. UNTIL MenuChoice = 3 is the single exit — after every action, control returns to the menu.
Keep the branches mutually exclusive. Two separate IFs (or a CASE statement) both work; what matters is that exactly one branch runs per pass.

REPEAT … UNTIL MenuChoice = 3WHILE out-of-range: re-askTwo branches, one exit

❓ Guiding questions – think before revealing

Why REPEAT … UNTIL rather than WHILE?
What does “validate a response” require here?
Where does the program go after adding a member?

Reveal suggested reasoning

Why REPEAT … UNTIL rather than WHILE? The menu must be displayed at least once before the stop test means anything, so a post-condition loop matches the flow; a pre-condition WHILE would need a seeded dummy choice.

What does “validate a response” require here? Any value that is not 1, 2 or 3 is rejected with a message and re-entered — the response must be one of the offered choices before any branch runs.

Where does the program go after adding a member? Back to the top of the REPEAT loop: the menu is displayed again. Only MenuChoice = 3 leaves the loop.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Menu loop — the program runs until stop is selected
REPEAT
    OUTPUT "1 - Input a new member"
    OUTPUT "2 - Output the list of members"
    OUTPUT "3 - Stop"
    INPUT MenuChoice
    WHILE MenuChoice < 1 OR MenuChoice > 3
        OUTPUT "Invalid choice - please enter 1, 2 or 3"
        INPUT MenuChoice
    ENDWHILE
    IF MenuChoice = 1 THEN
        // ... add-member work (Stage 5 and Stage 6)
    ENDIF
    IF MenuChoice = 2 THEN
        // ... list work (Stage 7)
    ENDIF
UNTIL MenuChoice = 3

📖 Detailed explanation

The menu is the program’s spine. Every bullet except the code validation hangs off this loop: branches for choices 1 and 2, and an exit for choice 3.

Validation is a loop, not an IF. A single IF could reject one bad entry but could not re-ask; the WHILE keeps prompting until the response is one of the three offered choices.

Suitable messages are a stated requirement. “All inputs and outputs must contain suitable messages” — every prompt and rejection line tells the operator exactly what happened.

⚠️ Common mistakes

Testing UNTIL MenuChoice = 1 or forgetting the stop condition, creating a program that never ends.
Validating with IF instead of a loop, so one invalid entry crashes through to a branch.
Omitting the messages on the menu lines, losing the “suitable messages” requirement.
Nesting the choice-2 branch inside the choice-1 branch, making the list unreachable.

💡 Exam hack / tip

Say the loop contract out loud: show the menu, take a choice, reject anything outside 1–3, run one branch, come back. If your code does anything else, the loop is wrong.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration and validationR1 · menu with three choicesAO3 · single, correct exit condition

The menu loop is the clearest AO2 evidence of iteration and selection, and the single exit condition is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Input a code and check its length

LENGTH(NewID) = 6 is the gate that every other check waits behind.

🧠 Step-by-step thinking

Prompt and input into NewID. The question supplies NewID for exactly this: INPUT NewID with a message asking for the six-character code.
Measure, do not assume. IDLength ← LENGTH(NewID) counts the characters actually typed — the check is against the input, not a hope.
Gate the uniqueness search. Only “if the new code is six characters” is it compared with the stored codes, so the search sits inside the length branch.
Re-enter on any failure. A code that is too short or too long is rejected with a message and the whole input repeats — the REPEAT … UNTIL wraps both checks.
Exit with one compound condition. UNTIL IDLength = 6 AND IsUnique = TRUE leaves the loop only when both checks have passed on the same code.

LENGTH(NewID) = 6Search nested in the length branchOne loop, both checks

❓ Guiding questions – think before revealing

Why is LENGTH the first test?
Why wrap length and uniqueness in one loop?
What does LENGTH(NewID) return for “A1B2C9”?

Reveal suggested reasoning

Why is LENGTH the first test? The bullet is explicit: “check that it contains six characters”, and only a six-character code proceeds to the uniqueness comparison. The order is worth marks.

Why wrap length and uniqueness in one loop? “If the code is not unique, a new code must be entered and checked” — the re-entered code must pass the length check again too, and one loop guarantees the code that finally exits has passed both.

What does LENGTH(NewID) return for “A1B2C9”? Six — LENGTH counts characters including digits, so an alphanumeric code measures exactly like any other six-character string.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Inside the menu's choice-1 branch
REPEAT
    OUTPUT "Enter your six-character membership code: "
    INPUT NewID
    IDLength ← LENGTH(NewID)
    IF IDLength = 6 THEN
        // ... uniqueness search belongs here (Stage 6)
    ELSE
        OUTPUT "Code must contain exactly six characters"
    ENDIF
UNTIL IDLength = 6 AND IsUnique = TRUE

📖 Detailed explanation

LENGTH is the pseudocode length function. Cambridge expects LENGTH(NewID) to return the number of characters in the string — store it in IDLength so the UNTIL condition stays readable.

The compound UNTIL is the loop’s whole logic. IDLength = 6 AND IsUnique = TRUE fails if either check fails, so every rejected code — short or duplicated — is re-entered and re-checked.

Rejection messages double as validation evidence. Each ELSE branch explains the failure, which satisfies the “suitable messages” requirement and shows the examiner the check ran.

⚠️ Common mistakes

Checking uniqueness first, ignoring the paper’s stated order of the two checks.
Measuring LENGTH(NewID) once and never re-measuring after a re-entry.
Accepting a code whose length is “at least” six — the requirement is exactly six.
Forgetting the rejection message, so the operator faces a silent prompt.

💡 Exam hack / tip

Draw two gates: gate 1 LENGTH, gate 2 uniqueness. A code may only leave the loop through both gates, and the UNTIL line is the door frame.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · string handling with LENGTHR2 · six-character checkAO3 · compound exit condition

The length gate supports AO2 through string handling, and the compound exit condition is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Check uniqueness and store the new member

Search the stored codes with a flag, then write to the first free slot.

R2 · R3 · R4

🧠 Step-by-step thinking

Reset the flag before every scan. IsUnique ← TRUE then Index ← 1 start each attempt fairly — a stale FALSE from a rejected code must never survive.
Scan with a short-circuit WHILE. WHILE Index <= NumMembers AND IsUnique = TRUE stops at the first match; a matching code sets IsUnique ← FALSE, otherwise Index advances.
Re-enter a rejected code. “A new code must be entered and checked” — the outer REPEAT from Stage 5 re-runs the length check and this scan on the replacement code.
Write to the first available space. NextSlot ← NumMembers + 1, then MemberID[NextSlot] ← NewID stores the accepted code.
Complete the member in the same position. Input the first and last names into Name[NextSlot, 1] and Name[NextSlot, 2], then NumMembers grows by one.

Flag: IsUniqueShort-circuit WHILE scanNextSlot ← NumMembers + 1Three writes, one position

❓ Guiding questions – think before revealing

Why AND IsUnique = TRUE in the WHILE condition?
Why is the first available space NumMembers + 1?
Why must the names be written in the same pass?

Reveal suggested reasoning

Why AND IsUnique = TRUE in the WHILE condition? The moment a duplicate is found there is no reason to keep comparing — the flag ends the scan early and the UNTIL condition then forces a re-entry.

Why is the first available space NumMembers + 1? Members are stored contiguously from position 1, so positions 1 to NumMembers are taken and NumMembers + 1 is the first free one; storing there, then incrementing, keeps the register packed.

Why must the names be written in the same pass? The bullet says the names are stored “in the corresponding location” — the same index as the code. Writing all three values while NextSlot is known keeps the two arrays aligned.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Six-character code in hand — check the stored codes
IsUnique ← TRUE
Index ← 1
WHILE Index <= NumMembers AND IsUnique = TRUE
    IF MemberID[Index] = NewID THEN
        IsUnique ← FALSE       // duplicate found
    ELSE
        Index ← Index + 1      // try the next stored code
    ENDIF
ENDWHILE
// If IsUnique is still TRUE the code is accepted:
NextSlot ← NumMembers + 1
MemberID[NextSlot] ← NewID
OUTPUT "Enter your first name: "
INPUT Name[NextSlot, 1]
OUTPUT "Enter your last name: "
INPUT Name[NextSlot, 2]
NumMembers ← NumMembers + 1

📖 Detailed explanation

The flag pattern survives any re-entry. Because IsUnique is reset at the top of every attempt, a code rejected as a duplicate cannot contaminate the next scan.

Early exit is efficient and correct. With up to 1000 members, stopping at the first match avoids hundreds of pointless comparisons and cannot miss a duplicate — one match is enough to reject.

One slot number, three writes. MemberID[NextSlot], Name[NextSlot, 1] and Name[NextSlot, 2] share the index, which is exactly the shared-position rule from the question’s second paragraph.

⚠️ Common mistakes

Forgetting to reset IsUnique ← TRUE before the scan, so a second attempt exits immediately.
Scanning FOR Index ← 1 TO 1000, comparing the new code against empty slots.
Storing the code but inputting the names into Name[Index, …], where Index has already run past the slot.
Failing to increment NumMembers, so the next member overwrites this one.

💡 Exam hack / tip

Test your scan with the sample logic: a duplicate must stop the loop, a clean scan must reach NumMembers + 1. If either fails, the flag or the bound is wrong.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · linear search with a flagR3 · R4 · uniqueness and first-free-slotAO3 · parallel-array discipline

The flag-driven search and the shared-index writes are the AO2 evidence for R3 and R4, and the early-exit logic is AO3 evidence. These are alignment notes, not separately allocated marks.

List the members and stop cleanly

Print code, first name and last name for every member, then return to the menu.

R1 · R5

🧠 Step-by-step thinking

Loop over the stored members. FOR Index ← 1 TO NumMembers visits exactly the occupied positions — never the empty tail of the 1000-element array.
Output three fields with messages. Each pass prints MemberID[Index], Name[Index, 1] and Name[Index, 2] — code, first name, last name, each labelled.
Return to the menu after listing. The list branch ends, control falls back to REPEAT, and the operator chooses again — the program “continues until the stop option”.
Stop ends the loop, not the tidiness. UNTIL MenuChoice = 3 is the only exit; a closing message such as “Program stopped” confirms a deliberate end.
Re-read the bullets before finishing. Menu with three choices, validated response, length check, uniqueness check, first-free-slot storage, list output, stop — tick each one against your code.

FOR Index ← 1 TO NumMembersThree labelled outputs per memberUNTIL MenuChoice = 3

❓ Guiding questions – think before revealing

Why 1 TO NumMembers and not 1 TO 1000?
How do the three outputs reach one member?
What proves the program really continues until stop?

Reveal suggested reasoning

Why 1 TO NumMembers and not 1 TO 1000? Only the first NumMembers positions hold members; looping to 1000 would print a thousand rows of empty slots and expose whatever initial values the arrays hold.

How do the three outputs reach one member? The shared index: MemberID[Index], Name[Index, 1] and Name[Index, 2] are all looked up with the same Index, so each printed row belongs to one member.

What proves the program really continues until stop? The UNTIL MenuChoice = 3 condition — after a list or an add, the menu reappears, and only choice 3 ends the run.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Choice 2: output every stored member
FOR Index ← 1 TO NumMembers
    OUTPUT "Membership code ", MemberID[Index]
    OUTPUT "First name ", Name[Index, 1]
    OUTPUT "Last name ", Name[Index, 2]
NEXT Index

// Choice 3 falls through both IFs ...
// ... and the UNTIL condition ends the program
UNTIL MenuChoice = 3
OUTPUT "Program stopped"

📖 Detailed explanation

The list is a read-back, not a new structure. Nothing is stored during the list output — the two given arrays already hold everything the bullet asks you to print.

Labels make the output suitable. “Membership code”, “First name”, “Last name” turn three raw values into the “suitable messages” the question demands.

The stop branch is the absence of work. Choice 3 matches neither IF, so the pass reaches UNTIL MenuChoice = 3, which is finally TRUE and ends the loop.

⚠️ Common mistakes

Printing the member’s position number instead of the stored membership code.
Outputting the names without the code, or merging first and last into one element.
Ending the program after the first list output instead of looping back to the menu.
Leaving a stray OUTPUT inside the loop so the menu prints once per member.

💡 Exam hack / tip

Finish with the paper’s own checklist: menu, validation, length, uniqueness, first free slot, names, list, stop. Eight ticks — one per bullet — and the question is fully covered.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration over stored recordsR1 · R5 · list output and clean stopAO3 · labelled, suitable messages

The list loop and the stop condition deliver the remaining R1 and R5 outputs, and the labelled messages are AO3 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 the menu loop, the two chained code checks and the shared member index.	Establishes logical order and a commenting plan.
2 · Data	Required data structures	Given MemberID[], Name[] and NewID plus MenuChoice, IDLength, IsUnique, NextSlot and NumMembers.	Meaningful identifiers throughout.
3 · Initialise	R3, R4	Own variables initialised; the array data deliberately untouched.	NumMembers reflects the stored register.
4 · Menu loop	R1	Three-choice menu, validated response, single exit on stop.	WHILE re-ask for out-of-range choices.
5 · Add member	R2	LENGTH(NewID) = 6 gates the branch; re-entry on failure.	Compound UNTIL keeps both checks honest.
6 · Uniqueness	R2, R3, R4	Flag-driven scan of the stored codes; first free slot; names in the same position.	Short-circuit WHILE and shared-index writes.
7 · Summary	R1, R5	List of code, first and last names for every member; stop ends the program.	Loop bound 1 TO NumMembers and labelled messages.

Consolidated Cambridge pseudocode

Complete solution

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

15-mark exemplar style

QUESTION 10 · FULL PSEUDOCODECambridge 0478 style · 1-based indexing

// MemberID[] stores the unique six-character codes (up to 1000 members);
// Name[Index, 1] holds a member's first name and Name[Index, 2] the last name.
// NumMembers records the members already stored, so the first available
// space in both arrays is position NumMembers + 1. Declarations are assumed.
MenuChoice ← 0          // initialise the variables the program uses
NumMembers ← 4          // four members are stored before the program starts

// Menu loop: the program runs until the stop option is selected
REPEAT
    OUTPUT "1 - Input a new member"
    OUTPUT "2 - Output the list of members"
    OUTPUT "3 - Stop"
    INPUT MenuChoice
    WHILE MenuChoice < 1 OR MenuChoice > 3
        OUTPUT "Invalid choice - please enter 1, 2 or 3"
        INPUT MenuChoice
    ENDWHILE
    IF MenuChoice = 1 THEN   // choice 1: input a new member
        // Repeat until the code is six characters AND not already stored
        REPEAT
            OUTPUT "Enter your six-character membership code: "
            INPUT NewID
            IDLength ← LENGTH(NewID)
            IF IDLength = 6 THEN   // only a six-character code is compared
                IsUnique ← TRUE
                Index ← 1
                // Compare against all the previously stored codes
                WHILE Index <= NumMembers AND IsUnique = TRUE
                    IF MemberID[Index] = NewID THEN
                        IsUnique ← FALSE   // duplicate found
                    ELSE
                        Index ← Index + 1
                    ENDIF
                ENDWHILE
                IF IsUnique = FALSE THEN
                    OUTPUT "Code already stored - enter a different code"
                ENDIF
            ELSE
                OUTPUT "Code must contain exactly six characters"
            ENDIF
        UNTIL IDLength = 6 AND IsUnique = TRUE
        // Store the unique code in the first available space
        NextSlot ← NumMembers + 1
        MemberID[NextSlot] ← NewID
        // Input the names into the corresponding location of Name[]
        OUTPUT "Enter your first name: "
        INPUT Name[NextSlot, 1]
        OUTPUT "Enter your last name: "
        INPUT Name[NextSlot, 2]
        NumMembers ← NumMembers + 1
    ENDIF
    IF MenuChoice = 2 THEN   // choice 2: output the list of members
        FOR Index ← 1 TO NumMembers
            OUTPUT "Membership code ", MemberID[Index]
            OUTPUT "First name ", Name[Index, 1]
            OUTPUT "Last name ", Name[Index, 2]
        NEXT Index
    ENDIF
UNTIL MenuChoice = 3   // choice 3: stop
OUTPUT "Program stopped"

Why this is a complete response

It covers the five mark-scheme requirements: a menu with three choices and a validated response (R1), the LENGTH check that a new code contains six characters (R2), the uniqueness check against all the previously stored codes with the re-entry of a duplicate (R3), storage of the unique code in the first available space with the first and last names in the corresponding location of Name[] (R4), and the list of code, first name and last name for every member, repeated until stop is selected (R5).

What to check before submitting

Check that the uniqueness search only runs for six-character codes, that IsUnique is reset before every scan, that a re-entered code is checked again, that the code and both names share NextSlot, that NumMembers is incremented, and that the comments explain the program.

Remember: The AO2 and AO3 marks are awarded by judging the whole response. The individual R1–R5 labels are the technique requirements, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the program work.

Step through a sample run. Watch the menu validate each choice, the LENGTH test gate the uniqueness scan, the duplicate code get rejected, the new member land in the first free slot, and the list option print every member.

Last tab · Trace player

Sample input → expected results

The sample starts with four members already stored (NumMembers = 4) and then adds one new member: the first code typed, GD0771, is a duplicate of the code at index 2, so it is rejected and the operator re-enters XR5628, which is six characters and unique; the list option then prints all five members and stop ends the run. Only 5 of the maximum 1000 array positions are used. These are illustrative values, not data supplied by the examination question.

Input arrays MemberID[] and Name[,]

Member	MemberID[]	Name[,1] first	Name[,2] last

The row number is the shared array position used by MemberID[] and Name[].

Reveal expected member list and run summary

Expected member list After the add and the list choice

Position	Membership code	First name	Last name

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, IDLength, IsUnique and NextSlot. NumMembers only ever grows, and the codes-rejected counter moves only when a duplicate fails the scan.

Trace colours: blue row = the member or menu step currently processed; amber cell = the array element being compared or written; green cells = array elements already processed.

The first code typed, GD0771, equals the code at index 2, so IsUnique flips to FALSE after two comparisons and the scan stops early — one match is enough to reject. The re-entered XR5628 survives all four comparisons, and NextSlot ← NumMembers + 1 stores it at position 5 with both names written to Name[5, 1] and Name[5, 2].

From a sports-club register to a menu-driven membership program.

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 variables

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Drive the program from a validated menu

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input a code and check its length

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Check uniqueness and store the new member

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

List the members and stop cleanly

🧠 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 MemberID[] and Name[,]

Expected member list After the add and the list choice

Execution trace

Initialisation

Live variable values

Run counters