15-mark question lab · start here

From a 2D contacts array to a menu-driven phone book.

Build the solution in a sensible order: decode the requirements, plan the array and its working variables, start the menu loop, validate the choice, add the batch within the five-and-100 caps, bubble-sort by contact name, then display and delete the whole array. Learn the reasoning before revealing the complete program.

2D array of stringsMenu-driven programValidation loopsBubble sortCaps: 5 and 10015 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the given 2D array Contacts[] — names as last name, first name in column 1, telephone numbers in column 2 — the variable CurrentSize, the 100-contact capacity and the requirements hidden in the bullet list.

02 · Construct

Build the menu loop with a validated choice, then the add branch: ask how many new contacts, enforce the 1-to-5 and 100-contact caps, store each name and number in the next free rows, update CurrentSize and bubble-sort by contact name.

03 · Complete

Output the whole of the array with a labelling header when the user chooses display, and delete the contents of every cell when the user chooses delete.

How Cambridge awards the marks: the mark scheme gives AO2 a maximum of 9 marks and AO3 a maximum of 6 marks. It lists requirements R1–R5, but does not assign a separate fixed mark total to each R requirement. The stage-to-mark links in this guide show alignment, not invented stage marks.

Source question

Read the whole question first

Do not begin coding after the first paragraph. The two-column array, the two caps of five and 100, the conditional sort and the delete-all branch all affect the structure of your solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/23 · Question 11

A two-dimensional (2D) array Contacts[] is used to store names and telephone numbers. All the data is stored as strings. The array must have the capacity to store 100 contacts in the form of:

column 1 – contact names as: last name, first name
- for example: Smith, John
column 2 – telephone numbers.

The variable CurrentSize shows how many contacts are in the array.

Write a program that meets the following requirements:

display a menu of choices:
- enter new contact details
- display all the contact details
- delete all the contact details
validate the menu input
allow up to a maximum of five new contacts to be added to the array at any one time
do not allow more than 100 contacts in total
after new contacts have been added, sort the array by contact name, as long as there are at least two contacts in the array
output the whole of the array
delete the contents of the array.

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; you may assume that this has already been done.

All inputs and outputs must contain suitable messages.

You do not need to initialise the data in the array Contacts[] and the variable CurrentSize

Before you move on

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

Mark-scheme map

Output the menu of choices and input the user’s choice with prompts — output and input with messages.

Validate the menu input with a range check on 1 to 3, re-asking with suitable messages until a legal choice is entered.

Input the number of new entries within its limits — at least 1 and at most 5 at any one time, and never more than 100 contacts in total — updating CurrentSize.

Input the new contact data into the array and bubble-sort it by contact name whenever at least two contacts are stored.

Output the whole contents of the array with labelling and delete the contents of every cell.

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

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3

🧠 Step-by-step thinking

Spot the given data structure. Contacts[] is a 2D array of strings with capacity for 100 contacts: column 1 holds names in the form last name, first name and column 2 holds telephone numbers; CurrentSize shows how many contacts are in the array.
Notice this is a menu-driven program. The first bullet asks for a menu of three choices — enter new, display all, delete all — so the program needs a loop that redisplays the menu and branches on the choice; the published answer wraps everything in WHILE Cont DO.
Collect the two caps. At most five new contacts may be added at any one time, and the array may never hold more than 100 contacts in total — two separate range checks on the number of new contacts.
Spot the conditional sort. After new contacts have been added, the array is sorted by contact name — but only as long as there are at least two contacts in the array, so the sort sits inside an IF CurrentSize >= 2 guard.
Build the order. initialise → loop (display menu → input and validate choice → choice 1: ask how many, check both caps, store each contact, update CurrentSize, sort if two or more → choice 2: output the whole array → choice 3: delete the contents).

Given: Contacts[,] and CurrentSizeMenu: three choicesCaps: five at a time, 100 in totalConditional: sort if at least two

❓ Guiding questions – think before revealing

Why does the question say the sort happens only when there are at least two contacts?
How many different validations does the question demand?
Why does the program need a loop around the whole menu?

Reveal suggested reasoning

Why does the question say the sort happens only when there are at least two contacts? Sorting one contact — or none — is meaningless: a single row is already in order. The guard IF CurrentSize >= 2 prevents the sort from running on an array where it could do nothing.

How many different validations does the question demand? Three. The menu choice must be 1, 2 or 3; the batch size must be between 1 and 5; and the stored size plus the batch must never pass 100. Each needs its own check with its own message.

Why does the program need a loop around the whole menu? The question asks it to display a menu of choices and act on them. Without an outer loop the program would serve one choice and stop; the delete option only makes sense if the user can return to the menu and add contacts again.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Program runs until stopped
WHILE Cont DO
    // display the three-choice menu
    // INPUT Choice, validate 1 to 3

    IF Choice = 1
      THEN
        // ask how many (1 to 5, and not past 100)
        // store each name and number in the next free rows
        // update CurrentSize
        // IF CurrentSize >= 2 THEN bubble sort by name
    ENDIF

    IF Choice = 2
      THEN
        // output the whole of the array
    ENDIF

    IF Choice = 3
      THEN
        // delete the contents of the array
    ENDIF
ENDWHILE

📖 Detailed explanation

The menu turns one program into three. Each choice selects a different block of work: add (validation, storing and sorting), display (a loop over every stored row) and delete (nested loops over every cell of the whole array).

“Output the whole of the array” means the stored contacts. Only rows 1 to CurrentSize hold data — the published answer loops FOR Count ← 1 TO CurrentSize, not to 100.

“Delete the contents” clears every cell. The published answer uses nested loops over all 100 rows and both columns, setting each cell to the empty string — array initialisation.

The closing lines shape the answer. “You do not need to declare any arrays, variables or constants” and “you do not need to initialise the data” let the algorithm start straight away with Contacts[] and CurrentSize as given.

⚠️ Common mistakes

Writing three separate programs instead of one menu loop that branches on the choice.
Sorting after every menu choice instead of after new contacts have been added.
Looping the display to 100 instead of to CurrentSize, printing empty rows.
Forgetting the “at least two contacts” guard and sorting even when the array holds one contact.

💡 Exam hack / tip

Underline five, 100 and at least two the moment you read them: two caps on the batch, one condition on the sort. Then underline the three menu verbs — enter, display, delete — your three branches.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R3 · full requirement coverageAO3 · logical orderAO3 · comments explain purpose

This planning stage supports AO2 by identifying the full range of techniques required. It supports AO3 by establishing a logical sequence. These are alignment notes, not separately allocated marks.

Plan the data and identifiers

Choose variables and arrays that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given names exactly. Contacts[] and CurrentSize must appear as given — the mark scheme lists them as the data structures required with names as given in the scenario.
Store both columns of a contact together. A contact is one row of the 2D array: Contacts[Count, 1] is the name as last name, first name and Contacts[Count, 2] is the telephone number — every sort swap must move both columns.
Take the published answer’s variables. The mark scheme names Cont (keep the menu running), Choice (menu selection), NewContacts (size of this batch), Count and Count2 (loop counters) and Flag (sort-pass flag).
Add the swap pair. Temp1 and Temp2 hold one contact’s name and number during a swap — two columns, two temporaries.
CurrentSize is the key to every loop. It gives the first free row for storing (CurrentSize + 1), the number of rows to display and sort, and the value the 100-contact cap is checked against.

Given: Contacts[,] CurrentSizeBatch: NewContacts, 1 to 5Sort: Flag, Temp1, Temp2Menu: Choice, Cont

❓ Guiding questions – think before revealing

Why does a swap need two temporaries when the sort compares names only?
Why is CurrentSize so central?
What is Flag for?

Reveal suggested reasoning

Why does a swap need two temporaries when the sort compares names only? The comparison uses column 1, but a contact is both columns. Swapping Contacts[Count, 1] without also swapping Contacts[Count, 2] would pair every moved name with the wrong telephone number.

Why is CurrentSize so central? It is the boundary between used and unused rows. Storing writes to rows CurrentSize + 1 onwards, the sort and the display stop at CurrentSize, and the 100-contact cap is checked against it.

What is Flag for? It reports whether a pass of the bubble sort swapped anything. Every pass starts with Flag ← FALSE; any swap sets it TRUE, and the sort repeats UNTIL NOT Flag — the first swap-free pass proves the array is sorted.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question — already set up and stored:
//   Contacts[,]   2D array of strings, 100 rows × 2 columns
//                 column 1: "last name, first name"
//                 column 2: telephone number
//   CurrentSize   how many contacts are in the array

// Working values the program uses:
Cont            // BOOLEAN — keep the menu loop running
Choice          // menu selection, 1 to 3
NewContacts     // how many contacts to add this batch, 1 to 5
Count           // loop counter — rows of the array
Count2          // loop counter — columns of the array
Flag            // BOOLEAN — TRUE if a sort pass swapped
Temp1           // a contact's name during a swap
Temp2           // the same contact's number during a swap

📖 Detailed explanation

The 2D array stores exactly what the scenario describes. One row per contact, name in column 1 in the required last name, first name form, number in column 2 — the data structure AO2 looks for.

Meaningful identifiers earn AO3 credit. NewContacts, Flag and CurrentSize say what they hold; the mark scheme itself uses these names.

Two counters serve two different loops. Count walks rows everywhere; Count2 walks the two columns in the delete branch — reusing one variable for nested loops would break them.

The name format is part of the data. “Last name, first name” is what makes the sort meaningful: comparing column 1 as a string sorts by last name first, which is exactly what the question asks.

⚠️ Common mistakes

Renaming Contacts[] or CurrentSize, which the mark scheme treats as not using the supplied data structures.
Sorting by column 2, which orders contacts by telephone number instead of name.
Swapping the name column but not the number column during the sort.
Using one counter for the nested delete loops, so the inner loop overwrites the outer.

💡 Exam hack / tip

Point at each name and ask “which phrase in the question does this store?” CurrentSize answers “how many contacts are in the array”, NewContacts answers “maximum of five new contacts … at any one time” and Flag answers “has this sort pass swapped?”

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR1 · R2 · given names reusedAO3 · meaningful identifiers

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

Initialise the size and start the menu loop

CurrentSize tracks the stored contacts while Cont keeps the menu alive.

R1 · R2

🧠 Step-by-step thinking

Start from the given state. The question says you need not initialise Contacts[] and CurrentSize — the data is already stored. The published answer still opens with CurrentSize ← 0 to show a program that starts empty; either starting point is acceptable.
Set the continuation flag. Cont ← TRUE before WHILE Cont DO — the menu loop repeats until something sets it FALSE, which is what makes the program menu-driven.
Everything else is initialised per menu pass. Choice is re-input every pass; NewContacts belongs to the add branch; Flag ← FALSE starts every sort pass.
The add branch trusts CurrentSize. The first free row is always CurrentSize + 1 — no other pointer is needed because the size is updated after every batch.

Given: stored contacts and sizeOnce: Cont ← TRUEEvery pass: Choice re-input

❓ Guiding questions – think before revealing

Why does the published answer set CurrentSize ← 0 if the question says the data is already stored?
Why a WHILE loop rather than REPEAT for the menu?
What happens to Choice and NewContacts between passes?

Reveal suggested reasoning

Why does the published answer set CurrentSize ← 0 if the question says the data is already stored? It demonstrates a program that begins with an empty phone book. The question’s closing line frees you from initialising the data, so starting with contacts already present — as the visualisation does — is equally valid; what matters is that every loop uses CurrentSize consistently.

Why a WHILE loop rather than REPEAT for the menu? The published answer chooses WHILE Cont DO with Cont ← TRUE set beforehand. A REPEAT … UNTIL around the menu works equally well — the examiner accepts either structure.

What happens to Choice and NewContacts between passes? They keep their old values until re-input. That is harmless: every pass re-reads Choice before branching, and NewContacts is read only inside the add branch after being input.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// the number of contacts in the array
CurrentSize ← 0    // question: data already stored —
                   // either starting point is acceptable

// to allow program to continue indefinitely
Cont ← TRUE
WHILE Cont DO
    // display menu (Stage 04)
    // INPUT Choice and validate (Stage 04)

    // IF Choice = 1 → add and sort (Stages 05 and 06)
    // IF Choice = 2 → display all (Stage 07)
    // IF Choice = 3 → delete all (Stage 07)
ENDWHILE

📖 Detailed explanation

The flag gives the program its shape. WHILE Cont DO wraps all three branches; every menu pass redisplays the menu, reads a choice and runs exactly one branch.

Initialisation here is minimal. Unlike totalling questions, nothing accumulates across the whole program — the array and its size carry the state, and each branch resets what it needs.

The published answer’s comments matter. Lines such as “to allow program to continue indefinitely” are the AO3 evidence of a fully commented program in a logical order.

⚠️ Common mistakes

Forgetting Cont ← TRUE, so WHILE Cont DO never runs.
Resetting CurrentSize inside the menu loop, wiping the record of stored contacts on every pass.
Displaying the menu after reading the choice instead of before.
Initialising Flag outside the sort, which makes the first pass meaningless.

💡 Exam hack / tip

Say it as a rule: the menu loop owns everything; each branch owns its own variables. Only Cont is initialised once — everything else is reborn inside the pass that uses it.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR1 · menu loop structureAO3 · logical order

Initialisation supports AO2 because the program starts from a known state, and AO3 because the menu loop establishes a logical order. These are alignment notes, not separately allocated marks.

Display the menu and validate the choice

Two WHILE loops re-ask until the choice is legal — and refuse 1 when the array is full.

🧠 Step-by-step thinking

Output the menu before any input. Four OUTPUT lines — the prompt plus the three numbered options — then INPUT Choice. Every line carries a message, as the closing line of the question requires.
Guard the full-array case first. The published answer rejects choice 1 when the array is full: WHILE Choice = 1 AND CurrentSize = 100 DO outputs “Your contacts are full, please enter 2 or 3” and re-asks.
Range-check the choice itself. WHILE Choice < 1 OR Choice > 3 DO outputs “Incorrect entry” and re-asks — a range check with messages, exactly the R1 technique.
Two loops, two messages. Each invalid case explains itself: one message for a full array, another for an out-of-range number. A single generic message loses the specificity the examiner looks for.
WHILE works because the check follows the input. The choice is input once, then tested; an invalid value sends the loop back for another INPUT — a post-condition validation pattern.

Output: four menu linesValidation: two WHILE loopsSpecial case: array fullRange: 1 to 3

❓ Guiding questions – think before revealing

Why is the full-array test a separate loop before the range check?
Why is the condition Choice < 1 OR Choice > 3?
What does “validate the menu input” earn?

Reveal suggested reasoning

Why is the full-array test a separate loop before the range check? Choice 1 is in range but impossible when 100 contacts are already stored — a range check alone would let it through to the add branch. Testing it first re-asks before any storing can begin.

Why is the condition Choice < 1 OR Choice > 3? A compound condition with OR describes the invalid region directly: anything below 1 or above 3. It reads as “keep asking while the choice is invalid”, which is exactly what a validation loop does.

What does “validate the menu input” earn? R1 credit: the mark scheme describes R1 as “output menu and input choice, with validation (range check, output with messages, input with prompts)” — the menu lines plus the two validation loops deliver all of it.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// display menu
OUTPUT "Please choose one of the following: "
OUTPUT "Press 1 to enter new contacts "
OUTPUT "Press 2 to display your contacts "
OUTPUT "Press 3 to delete all contacts "
INPUT Choice

// validate choice as 1, 2 or 3
WHILE Choice = 1 AND CurrentSize = 100 DO
    OUTPUT "Your contacts are full, please enter 2 or 3"
    INPUT Choice
ENDWHILE

WHILE Choice < 1 OR Choice > 3 DO
    OUTPUT "Incorrect entry – please enter 1, 2, or 3"
    INPUT Choice
ENDWHILE

📖 Detailed explanation

Menu plus validation is the whole of R1. Output of the menu with prompts, input of the choice and a range check that re-asks with messages — the published answer’s two loops demonstrate every part.

The full-array test is part of the 100-contact cap. Refusing choice 1 at CurrentSize = 100 is a second line of defence: the program prevents any addition to a full array before the batch size is even asked.

Every input and output carries words. The question’s closing line demands suitable messages; the menu lines, the two error messages and every later prompt all comply.

The loop order never lets an illegal choice through. A choice of 4 fails the range test and is re-asked; a choice of 1 with a full array fails the first test and is re-asked — only a legal, possible choice reaches the branches.

⚠️ Common mistakes

Using IF instead of WHILE, so one invalid entry still reaches the branches.
Validating with Choice > 3 only, letting 0 and negative values through.
Printing bare option numbers with no message text.
Forgetting the full-array case, so choice 1 on a 100-contact array overflows it.

💡 Exam hack / tip

Write the two loop headers as a pair and read them aloud: refuse 1 when the array is full; refuse anything outside 1 to 3. Two invalid cases, two WHILE loops, two messages.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · validation with range checkR1 · menu, input and messagesAO3 · correct loop conditions

The menu and its validation are the R1 evidence for AO2, and the two loop conditions are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Add up to five new contacts

Ask how many, respect both caps, store each row and update CurrentSize.

🧠 Step-by-step thinking

Ask for the batch size with a stated range. OUTPUT “How many contacts (1 to 5 only)?” then INPUT NewContacts — the prompt itself teaches the limit.
Validate the batch against 1 to 5. WHILE NewContacts < 1 OR NewContacts > 5 DO re-asks — the “maximum of five … at any one time” requirement.
Then validate it against the 100 cap. WHILE CurrentSize + NewContacts > 100 explains the space left — 100 - CurrentSize — and re-asks; this is the “do not allow more than 100 contacts in total” requirement.
Store into the next free rows. FOR Count ← CurrentSize + 1 TO CurrentSize + NewContacts writes each name into column 1 and each number into column 2 — the loop bounds derive entirely from the two size variables.
Update the size once, after the loop. CurrentSize ← CurrentSize + NewContacts — the mark scheme’s totalling step. Updating inside the loop would also work, but the published answer totals once, after the batch.

Range: 1 to 5 per batchCap: size + batch <= 100Store: rows CurrentSize + 1 …Totalling: CurrentSize update

❓ Guiding questions – think before revealing

Why does the second loop re-test CurrentSize + NewContacts after every re-answer?
Why do the loop bounds use CurrentSize and not a fixed row number?
Why is updating CurrentSize described as totalling?

Reveal suggested reasoning

Why does the second loop re-test CurrentSize + NewContacts after every re-answer? Because NewContacts changes inside the loop when the user re-answers. The test must combine the fresh batch size with the stored size — a stale total could let 101 contacts in.

Why do the loop bounds use CurrentSize and not a fixed row number? The first free row depends on what is already stored. With CurrentSize = 3, a batch of 5 fills rows 4 to 8; after a delete-all, the same batch fills rows 1 to 5. Deriving the bounds from CurrentSize makes the program work in every state.

Why is updating CurrentSize described as totalling? The mark scheme lists “range check, totalling, iteration and bubble sort” among the techniques. The update CurrentSize ← CurrentSize + NewContacts keeps a running total of contacts — the same accumulate pattern as summing points.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

IF Choice = 1
  THEN
    OUTPUT "How many contacts (1 to 5 only)?"
    INPUT NewContacts

    // validates new contacts input
    WHILE NewContacts < 1 OR NewContacts > 5 DO
        OUTPUT "You may only enter between 1 and 5 contacts. Please try again"
        INPUT NewContacts
    ENDWHILE

    // checks the maximum size is not exceeded
    WHILE CurrentSize + NewContacts > 100 DO
        OUTPUT "Not enough space in your contacts"
        OUTPUT "The maximum number you may input is ", 100 - CurrentSize
        INPUT NewContacts
    ENDWHILE

    FOR Count ← CurrentSize + 1 TO CurrentSize + NewContacts
        OUTPUT "Enter the contact name as last name, first name"
        INPUT Contacts[Count, 1]
        OUTPUT "Enter the telephone number"
        INPUT Contacts[Count, 2]
    NEXT Count

    CurrentSize ← CurrentSize + NewContacts
ENDIF

📖 Detailed explanation

Two caps, two loops, two messages. The 1-to-5 loop guards the batch; the 100 loop guards the array. Each names the limit in its message, which is what “suitable messages” means.

The space-left message is a courtesy that earns credit. 100 - CurrentSize tells the user the largest legal batch — output with a label, exactly as the closing line asks.

The FOR bounds write to exactly the free rows. From CurrentSize + 1 to CurrentSize + NewContacts: no gaps, no overwrites, no dependence on a fixed row number.

Each contact is two inputs. The name prompt even restates the required format — last name, first name — so the sort’s string comparison works on consistently formed names.

⚠️ Common mistakes

Checking only the five cap and letting the total pass 100.
Storing from row 1, overwriting the contacts already in the array.
Updating CurrentSize inside the FOR loop, which moves the loop’s end while it is still running.
Asking for names and numbers with bare INPUTs and no prompt messages.

💡 Exam hack / tip

Say the two checks aloud as a sentence: at least 1 and at most 5 this time; at most 100 altogether. If your code cannot say both sentences, one cap is missing.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · range checks and iterationR2 · batch limits and storingAO3 · derived loop bounds

The batch validation and the storing loop are the R2 evidence for AO2, and the derived loop bounds are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Bubble-sort the array by contact name

A flag-driven REPEAT … UNTIL pass swaps out-of-order neighbours when at least two contacts exist.

🧠 Step-by-step thinking

Guard the sort with the two-contact test. IF CurrentSize >= 2 THEN — the question’s “as long as there are at least two contacts in the array”, written as a single condition.
Compare names, swap whole contacts. The test is Contacts[Count + 1, 1] < Contacts[Count, 1] — column 1 only — but the swap moves column 2 as well, through Temp1 and Temp2.
One pass = one sweep of neighbour pairs. FOR Count ← 1 TO CurrentSize - 1 compares rows 1–2, 2–3, …, swapping each out-of-order pair; the alphabetically last name bubbles to the end.
The flag decides when to stop. Each pass starts Flag ← FALSE; any swap sets it TRUE; UNTIL NOT Flag repeats until a whole pass swaps nothing — the array is then sorted.
The sort runs after every batch. Because it sits inside the add branch, the array is re-sorted each time new contacts are added — the question’s “after new contacts have been added”.

Guard: CurrentSize >= 2Compare: column 1 onlySwap: both columns via Temp1, Temp2Stop: UNTIL NOT Flag

❓ Guiding questions – think before revealing

Why compare with < rather than >?
Why does the inner loop stop at CurrentSize - 1?
Why not just sort every time, whatever the size?

Reveal suggested reasoning

Why compare with < rather than >? The question sorts by contact name in ascending order. Testing whether the next row’s name is less than this row’s name identifies a pair in the wrong order; swapping them moves smaller names towards the top.

Why does the inner loop stop at CurrentSize - 1? It compares row Count with row Count + 1, so the last comparison is rows CurrentSize − 1 and CurrentSize. Looping to CurrentSize would read row CurrentSize + 1 — an empty, unused row.

Why not just sort every time, whatever the size? With zero or one contact there is nothing to compare. The guard prevents a meaningless pass — and shows the examiner you read the “at least two” wording rather than assuming the sort is unconditional.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// bubble sort to sort array if it contains 2 or more contacts
IF CurrentSize >= 2
  THEN
    REPEAT
        Flag ← FALSE
        FOR Count ← 1 TO CurrentSize - 1
            IF Contacts[Count + 1, 1] < Contacts[Count, 1]
              THEN
                Flag ← TRUE
                Temp1 ← Contacts[Count, 1]
                Temp2 ← Contacts[Count, 2]
                Contacts[Count, 1] ← Contacts[Count + 1, 1]
                Contacts[Count, 2] ← Contacts[Count + 1, 2]
                Contacts[Count + 1, 1] ← Temp1
                Contacts[Count + 1, 2] ← Temp2
            ENDIF
        NEXT Count
    UNTIL NOT Flag
ENDIF

📖 Detailed explanation

Bubble sort is the named technique. The mark scheme lists “iteration and bubble sort” — the neighbour comparison, the three-step swap and the flag-driven repeat are exactly that.

Both columns travel together. Temp1 and Temp2 carry the name and the number, so after sorting, every telephone number still belongs to its contact.

The flag makes the sort self-terminating. No pass count is known in advance; the first pass with no swaps proves the order and ends the REPEAT.

String comparison follows the stored format. Names stored as last name, first name compare by last name first — “Abara, Ngozi” sorts before “Ali, Rahim” because the last names decide.

⚠️ Common mistakes

Swapping column 1 only, leaving numbers attached to the wrong names.
Looping the inner FOR to CurrentSize, comparing the last contact against an empty row.
Sorting unconditionally, without the CurrentSize >= 2 guard.
Setting Flag ← TRUE before the pass, so the sort never terminates.

💡 Exam hack / tip

Chant the swap as three moves: save this contact, pull the next one up, drop the saved one into the hole. Temp1 and Temp2 are the saving hands — one per column.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration and bubble sortR2 · sort by contact nameAO3 · correct comparison and swap

The guarded bubble sort completes the R2 evidence for AO2, and the comparison with its two-column swap is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Display the whole array, then delete its contents

One branch prints every stored row; the other empties all 100 × 2 cells.

🧠 Step-by-step thinking

Branch on the choice with separate IFs. The published answer uses one IF Choice = 2 block and one IF Choice = 3 block after the add branch — a CASE OF Choice works equally well.
Guard the display against an empty array. IF CurrentSize > 0 THEN — printing nothing at all is cleaner than a bare header over an empty phone book.
Output a header, then every stored row. OUTPUT “Name and Telephone Number”, then FOR Count ← 1 TO CurrentSize prints Contacts[Count, 1] and Contacts[Count, 2] on one line — the whole of the stored array, in sorted order after an add.
Delete means every cell of the whole array. Nested loops FOR Count ← 1 TO 100 and FOR Count2 ← 1 TO 2 set Contacts[Count, Count2] ← “” — array initialisation, the technique R3 names.
Two iterations, two different bounds. The display loop runs to CurrentSize (stored rows only); the delete loops run to 100 and 2 (the whole array). Mixing the bounds is the classic slip.

Display: rows 1 to CurrentSizeHeader: Name and Telephone NumberDelete: 100 × 2 cells clearedGuard: CurrentSize > 0

❓ Guiding questions – think before revealing

Why does the display loop stop at CurrentSize instead of 100?
Why does delete clear all 100 rows rather than just the used ones?
What should you add after the delete loops for a complete solution?

Reveal suggested reasoning

Why does the display loop stop at CurrentSize instead of 100? “Output the whole of the array” means the whole of the stored data — rows beyond CurrentSize hold empty strings or nothing at all. Looping to 100 would print empty rows after every contact.

Why does delete clear all 100 rows rather than just the used ones? The requirement says delete the contents of the array — the whole structure, not just the used rows. The published answer’s nested loops cover the full capacity, so the array is empty whatever CurrentSize was; clearing rows 1 to CurrentSize is also accepted.

What should you add after the delete loops for a complete solution? CurrentSize ← 0, so later menu passes treat the array as empty, plus a message such as “All contacts deleted”. The published answer omits both — acceptable in the exam, but the reset is the more complete solution.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// display all contacts
IF Choice = 2
  THEN
    IF CurrentSize > 0
      THEN
        OUTPUT "Name and Telephone Number"
        FOR Count ← 1 TO CurrentSize
            OUTPUT Contacts[Count, 1], "   ", Contacts[Count, 2]
        NEXT Count
    ENDIF
ENDIF

// delete all contacts
IF Choice = 3
  THEN
    FOR Count ← 1 TO 100
        FOR Count2 ← 1 TO 2
            Contacts[Count, Count2] ← ""
        NEXT Count2
    NEXT Count
ENDIF

📖 Detailed explanation

Iteration with output is the R3 technique. The mark scheme names “iteration, output with labelling/messages, array initialisation” — the display loop, the header line and the clearing loops supply all three.

The displayed order is the sorted order. Because the sort runs inside the add branch, a display after any add shows the contacts ordered by name — the program’s two halves work together.

The delete branch initialises the array. Setting every cell to the empty string returns the whole structure to its starting state — the same technique as zeroing an array before totalling.

Deleting the contents is not deleting the array. The 100 × 2 structure survives; only its contents are erased, which is why the program can keep running and accepting new contacts.

⚠️ Common mistakes

Looping the display to 100 and printing rows of empty strings.
Displaying the rows before the header, or omitting the header entirely.
Clearing only the name column, leaving numbers behind in the “deleted” array.
Leaving CurrentSize unchanged after deleting, so the next display prints empty rows — reset it to 0 for a complete solution.

💡 Exam hack / tip

Match each branch to its bullet: output the whole of the array → loop to CurrentSize with a header; delete the contents → loop over every cell with “”. Different bounds, different jobs — never reuse one loop for the other.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration, output, array initialisationR3 · display and delete branchesAO3 · correct loop bounds

The display and delete branches are the R3 evidence for AO2, and their distinct loop bounds are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Cambridge assessment criteria

What does a high-level response look like?

The mark scheme assesses the answer across AO2 and AO3. Use these descriptors to check the whole program, not just one isolated code section.

9 AO2 + 6 AO3 = 15

AO2 · Apply knowledge and understandingMaximum 9 marks · programming techniques and data structures

Band	What the descriptor means
0	No creditable response.
1–3	At least one programming technique is used. Some data is stored, but not appropriately. Any use of iteration, selection, counting, totalling, input or output may be credited.
4–6	Some programming techniques are appropriate to the problem, with more than one technique applied. Some data structures are appropriate and store some of the required data.
7–9	The full range of techniques needed by the scenario is used appropriately. The chosen data structures are appropriate and store all the required data.

AO3 · Provide solutions to problemsMaximum 6 marks · comments, identifiers, logic and accuracy

Band	What the descriptor means
0	No creditable response.
1–2	Program seen without relevant comments. Some identifier names and some data-structure names are appropriate. The solution may be illogical or inaccurate in many places, but attempts at least one requirement.
3–4	Program seen with some relevant comments. The majority of identifiers and most data-structure names are meaningful. Parts may be illogical or inaccurate, but most requirements are met.
5–6	The program is fully commented. Suitable identifiers are meaningful throughout, and all data structures have meaningful names. The program is logical and accurate and meets all requirements; minor syntax errors are ignored.

How the seven stages contribute

These are links to the assessment criteria, not separate mark allocations.

R1–R5

Stage	Mark-scheme link	AO2 evidence	AO3 evidence
1 · Decode	R1–R3	Identifies the full set of required techniques, including both caps and the conditional sort.	Establishes logical order and comments the plan.
2 · Data	Required data structures	Uses Contacts[] and CurrentSize as given, with Cont, Choice, NewContacts, Count, Count2, Flag, Temp1 and Temp2.	Meaningful identifiers throughout.
3 · Initialise	R1, R2	Starts from the given data with Cont ← TRUE driving the menu loop.	Resets belong inside the pass that uses them.
4 · Menu	R1	Outputs the menu, inputs the choice and validates it with two WHILE loops.	Correct conditions, including the full-array case.
5 · Add	R2	Validates the batch against 1 to 5 and the 100 total, stores into the free rows and updates CurrentSize.	Derived loop bounds and suitable messages.
6 · Sort	R2	Bubble-sorts by contact name under the CurrentSize ≥ 2 guard, swapping both columns.	Correct comparison, swap and flag logic.
7 · Output	R3	Displays rows 1 to CurrentSize with a header and deletes every cell of the array.	Correct loop bounds for each branch.

Consolidated Cambridge pseudocode

Complete solution

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

15-mark exemplar style

Read this carefully: this mirrors the official published mark scheme answer for 0478/23 May/June 2023 Question 11. The 2D array Contacts[] and the variable CurrentSize are supplied by the question and are used exactly as given. The published answer keeps the whole program inside a WHILE Cont menu loop, validates the choice with two WHILE loops (including the full-array case), caps each batch at five and the total at 100, stores each name and number in the next free rows, updates CurrentSize, bubble-sorts by contact name with a flag when at least two contacts are stored, then displays or deletes the array contents on the other two choices.

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

// meaningful identifiers and appropriate data structures for
// all data required
DECLARE Contacts : ARRAY[1:100, 1:2] OF STRING
DECLARE CurrentSize : INTEGER
DECLARE Cont : BOOLEAN
DECLARE Choice : INTEGER
DECLARE NewContacts : INTEGER
DECLARE Count : INTEGER
DECLARE Count2 : INTEGER
DECLARE Flag : BOOLEAN
DECLARE Temp1 : STRING
DECLARE Temp2 : STRING

// the number of contacts in the array
CurrentSize ← 0

// to allow program to continue indefinitely
Cont ← TRUE
WHILE Cont DO
// display menu
    OUTPUT "Please choose one of the following: "
    OUTPUT "Press 1 to enter new contacts "
    OUTPUT "Press 2 to display your contacts "
    OUTPUT "Press 3 to delete all contacts "
    INPUT Choice
// validate choice as 1, 2 or 3
    WHILE Choice = 1 AND CurrentSize = 100 DO
        OUTPUT "Your contacts are full, please enter 2 or 3"
        INPUT Choice
    ENDWHILE
    WHILE Choice < 1 OR Choice > 3 DO
        OUTPUT "Incorrect entry – please enter 1, 2, or 3"
        INPUT Choice
    ENDWHILE

// enter new contacts
    IF Choice = 1
      THEN
        OUTPUT "How many contacts (1 to 5 only)?"
        INPUT NewContacts
// validates new contacts input
        WHILE NewContacts < 1 OR NewContacts > 5 DO
            OUTPUT "You may only enter between 1 and 5 contacts. Please try again"
            INPUT NewContacts
        ENDWHILE
// checks the maximum size is not exceeded
        WHILE CurrentSize + NewContacts > 100 DO
            OUTPUT "Not enough space in your contacts"
            OUTPUT "The maximum number you may input is ", 100 - CurrentSize
            INPUT NewContacts
        ENDWHILE
        FOR Count ← CurrentSize + 1 TO CurrentSize + NewContacts
            OUTPUT "Enter the contact name as last name, first name"
            INPUT Contacts[Count, 1]
            OUTPUT "Enter the telephone number"
            INPUT Contacts[Count, 2]
        NEXT Count
        CurrentSize ← CurrentSize + NewContacts
// bubble sort to sort array if it contains 2 or more contacts
        IF CurrentSize >= 2
          THEN
            REPEAT
                Flag ← FALSE
                FOR Count ← 1 TO CurrentSize - 1
                    IF Contacts[Count + 1, 1] < Contacts[Count, 1]
                      THEN
                        Flag ← TRUE
                        Temp1 ← Contacts[Count, 1]
                        Temp2 ← Contacts[Count, 2]
                        Contacts[Count, 1] ← Contacts[Count + 1, 1]
                        Contacts[Count, 2] ← Contacts[Count + 1, 2]
                        Contacts[Count + 1, 1] ← Temp1
                        Contacts[Count + 1, 2] ← Temp2
                    ENDIF
                NEXT Count
            UNTIL NOT Flag
        ENDIF
    ENDIF

// display all contacts
    IF Choice = 2
      THEN
        IF CurrentSize > 0
          THEN
            OUTPUT "Name and Telephone Number"
            FOR Count ← 1 TO CurrentSize
                OUTPUT Contacts[Count, 1], "   ", Contacts[Count, 2]
            NEXT Count
        ENDIF
    ENDIF

// delete all contacts
    IF Choice = 3
      THEN
        FOR Count ← 1 TO 100
            FOR Count2 ← 1 TO 2
                Contacts[Count, Count2] ← ""
            NEXT Count2
        NEXT Count
    ENDIF
ENDWHILE

Why this is a complete response

It covers the three mark-scheme requirements. R1: the menu is output with prompts, the choice is input and validated — a range check on 1 to 3 plus the full-array case — with messages on every input and output. R2: the batch size is validated to 1 to 5 and against the 100-contact total, each name and number is stored in the next free rows through FOR Count ← CurrentSize + 1 TO CurrentSize + NewContacts, CurrentSize is updated, and the flag-driven bubble sort orders the array by contact name whenever at least two contacts are stored. R3: choice 2 outputs the whole stored array under a labelling header, and choice 3 deletes the contents of every cell of the array.

What to check before submitting

Check the two menu-validation conditions, the 1-to-5 batch loop, the CurrentSize + NewContacts > 100 test, the derived bounds of the storing loop, the sort’s comparison of column 1 with its two-column swap through Temp1 and Temp2, the UNTIL NOT Flag termination, the display bound of CurrentSize, and the comments explaining the program.

Remember: the mark scheme awards AO2 a maximum of 9 marks and AO3 a maximum of 6 marks, giving 15 in total, judged by best fit across the whole response. R1, R2 and R3 are the technique requirements the examiners look for, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the program work.

Step through one complete session on a small phone book. Watch the menu appear, an invalid choice get rejected, the maximum batch of five contacts stored in rows 4 to 8, CurrentSize update, the bubble sort move new contacts before and after the originals, the sorted array print, and every cell get deleted.

Last tab · Trace player

Sample input → expected results

The sample session starts from three stored contacts (Ali, Rahim; Devi, Priya; Okafor, Ada) with CurrentSize = 3. The user first types 4 — an invalid menu choice the range check rejects — then chooses 1 and asks for five new contacts, the maximum allowed at any one time; 3 + 5 = 8 is within the 100-contact total, so both caps are checked and passed. The new names deliberately sort both before and after the originals: Abara, Ngozi becomes the first contact and Zhang, Wei the last, while Bello, Kofi, Costa, Maria and Naeem, Sara slot between existing rows, so the bubble sort visibly moves contacts. Choices 2 and 3 then display the sorted array and delete its contents. This is the authentic 0478/23 May/June 2023 Question 11. These are illustrative values, not data supplied by the examination question.

Input data the batch of new contacts for Contacts[]

New contact	Name (column 1)	Telephone (column 2)

Batch row i is stored in Contacts[CurrentSize + i, 1] and Contacts[CurrentSize + i, 2] — with CurrentSize = 3, batch row 1 fills array row 4.

Reveal expected contact positions and session summary

Expected contact results After the sort

New contact	Position after sort	Sorted between

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Session counters

Ready

Tip: use Next step slowly and watch CurrentSize, Count and Flag. CurrentSize jumps from 3 to 8 only after the whole batch is stored; during the sort, Flag turns TRUE on every pass that swaps, and the sort ends on the first pass where it stays FALSE.

Trace colours: blue row = current new contact; amber cell = the name or number being stored; teal cells = contacts already processed.

Boundary example: the user asks for NewContacts = 5 — the maximum allowed at any one time — and the batch check computes 3 + 5 = 8, which is not greater than 100, so the batch is accepted. Asking for 98 instead would give 3 + 98 = 101 > 100, and the program would re-ask, offering a maximum of 100 - 3 = 97.

From a 2D contacts array to a menu-driven phone book.

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 size and start the menu loop

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Display the menu and validate the choice

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Add up to five new contacts

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Bubble-sort the array by contact name

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Display the whole array, then delete its contents

🧠 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 data the batch of new contacts for Contacts[]

Expected contact results After the sort

Execution trace

Initialisation

Live variable values

Session counters