15-mark question lab · start here

From a grid of match points to a full league table.

Build the solution in a sensible order: decode the five requirements, plan the totals array and the four counters, zero everything at the right loop level, total each team’s points, count the four result types, output every team’s line, then crown the top and bottom teams. Learn the reasoning before revealing the complete program.

2D array accessNested loopsTotallingCounting four result typesFinding max and min15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the given arrays TeamName[] and TeamPoints[], the variables LeagueSize and MatchNo, the 3–2–1–0 points system and the five requirements hidden in the bullet list.

02 · Construct

Build the program in order: zero the totals array, then nested loops that total each team’s points and use CASE OF to count away wins, home wins, drawn matches and lost matches, outputting every team’s six lines.

03 · Complete

Track the highest and lowest totals with strict tests that store the champion indices, then output the top and bottom team names through TeamName[].

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 3–2–1–0 points system, the parallel arrays and the two champion outputs all affect the structure of your solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 11

The one-dimensional (1D) array TeamName[] contains the names of teams in a sports league.

The two-dimensional (2D) array TeamPoints[] contains the points awarded for each match.

The position of each team’s data in the two arrays is the same. For example, the team stored at index 10 in TeamName[] and TeamPoints[] is the same.

The variable LeagueSize contains the number of teams in the league. The variable MatchNo contains the number of matches played. All teams have played the same number of matches.

The arrays and variables have already been set up and the data stored.

Each match can be played at home or away. Points are recorded for the match results of each team with the following values:

3 – away win
2 – home win
1 – drawn match
0 – lost match.

Write a program that meets the following requirements:

calculates the total points for all matches played for each team
counts the total number of away wins, home wins, drawn matches and lost matches for each team
outputs for each team:
- name
- total points
- total number of away wins, home wins, drawn matches and lost matches
finds and outputs the name of the team with the highest total points
finds and outputs the name of the team with the lowest total points.

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 arrays TeamName[] and TeamPoints[] or the variables LeagueSize and MatchNo

Before you move on

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

Mark-scheme map

Calculate the total points for all matches played by each team — nested iteration over teams and matches with totalling.

Accumulate into a parallel totals array so every team’s total survives for the output line and the champion comparisons.

Count the total number of away wins, home wins, drawn matches and lost matches for each team — nested iteration and counting.

Output, with the team’s name, each team’s total points and four counts with suitable messages — output.

Find and output the names of the teams with the highest and the lowest total points — selection and output.

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 two given arrays and two variables. TeamName[] is a 1D array of names; TeamPoints[] is a 2D array whose row is the team and whose column is the match; LeagueSize and MatchNo size the two loops.
Decode the points code. Each cell of TeamPoints[] holds exactly one of four values: 3 for an away win, 2 for a home win, 1 for a drawn match and 0 for a lost match — the value both adds to the total and selects the counter to increment.
Notice the parallel positions. The question stresses that index 10 in TeamName[] and row 10 of TeamPoints[] are the same team — one loop counter reaches both arrays.
Separate per-team work from once-only work. Totalling, the four counts and the six output lines happen once per team inside a loop; zeroing the totals array and the Top Team and Bottom Team lines happen once.
Build the order. zero the totals array → team loop (zero four counters → match loop (total + count) → output six lines → highest/lowest check) → output the top and bottom names.

Given: TeamName[] and TeamPoints[]Sizes: LeagueSize and MatchNoFour result types: 3, 2, 1, 0Once-only: two champion lines

❓ Guiding questions – think before revealing

Why does the question tell you the two arrays share positions?
Where does the counting happen?
Which outputs belong inside the team loop, and which outside?

Reveal suggested reasoning

Why does the question tell you the two arrays share positions? Because one loop counter — the team index — addresses both arrays. TeamName[TeamCounter] gives the name and TeamPoints[TeamCounter, MatchCounter] gives that team’s match result, with no searching needed.

Where does the counting happen? Inside the match loop. Each points value belongs to exactly one of four categories, so a CASE OF on TeamPoints[TeamCounter, MatchCounter] routes the match to the away-win, home-win, draw or loss counter.

Which outputs belong inside the team loop, and which outside? The six per-team lines — name, total points and the four counts — print inside the loop, once per team. The Top Team and Bottom Team lines print once after the loop, using the indices stored while it ran.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Once: zero TotalPoints[] for every team

FOR TeamCounter ← 1 TO LeagueSize        // per team:
    // zero the four result counters
    FOR MatchCounter ← 1 TO MatchNo      // per match:
        // add TeamPoints[TeamCounter, MatchCounter] to the team total
        // CASE OF the same value: 3 away, 2 home, 1 draw, 0 loss
    NEXT MatchCounter

    // output name, total points and the four counts
    // compare the total with the highest and lowest so far
NEXT TeamCounter

// Once: output the names of the top and bottom teams

📖 Detailed explanation

The points value does two jobs. It is added to the team’s total and it selects the counter to increment — one array read, two updates, both inside the same inner loop.

The four values are exhaustive. Every cell is 3, 2, 1 or 0, so the CASE OF needs no OTHERWISE branch; each match lands in exactly one counter.

The champions are found during the same pass. After a team’s output lines, compare its total with the best and worst so far — no second pass over the grid is needed.

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” mean the algorithm starts straight away with the given names.

⚠️ Common mistakes

Counting only wins and forgetting that drawn matches (1) and lost matches (0) must be counted too.
Printing the per-team lines after the loop has finished, so only the last team’s results appear.
Using one counter for wins and losses instead of four separate counters.
Finding the top team’s total without storing its index, then having no way to output its name.

💡 Exam hack / tip

Underline 3, 2, 1, 0 the moment you read them: those four values are both the points system and the CASE OF labels. Then underline highest and lowest — two champions, two stored indices, two final output lines.

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. TeamName[], TeamPoints[], LeagueSize and MatchNo must appear as given — the mark scheme lists them as the data structures required with names as given in the scenario.
Store the totals in an array. The published answer uses TotalPoints[], parallel to TeamName[], because every team’s total is needed twice: once for the output line and once for the champion comparisons.
Add the two loop counters. TeamCounter runs from 1 to LeagueSize and also indexes TeamName[]; MatchCounter runs from 1 to MatchNo and indexes the columns of TeamPoints[].
Add four result counters. AwayWinNo, HomeWinNo, DrawNo and LostNo hold one team’s counts at a time — they are reset for each team, so simple variables are enough.
Add the champion variables. HighestResult and LowestResult track the best and worst totals; TopTeam and BottomTeam store the indices needed to print the names at the end.

Given: TeamName[] and TeamPoints[]Parallel: TotalPoints[]Counters: four result typesChampions: TopTeam, BottomTeam

❓ Guiding questions – think before revealing

Why store the totals in an array instead of one variable?
Why are TopTeam and BottomTeam indices and not names?
Do the four counters need to be arrays?

Reveal suggested reasoning

Why store the totals in an array instead of one variable? A single Total variable is overwritten by each new team, so the champion comparisons would test the last team against itself. TotalPoints[TeamCounter] keeps every team’s total available for both the output line and the champion tests.

Why are TopTeam and BottomTeam indices and not names? The comparisons happen while the loop is running; storing the index keeps the link to both arrays, and TeamName[TopTeam] produces the name only when it is needed for the final output.

Do the four counters need to be arrays? No. They are zeroed for each team, filled by the match loop and printed before the next team begins, so their values are never needed later — four simple variables are enough.

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:
//   TeamName[]     1D, team names, index = team
//   TeamPoints[,]  2D, points per match, row = team, column = match
//   LeagueSize     number of teams in the league
//   MatchNo        matches played by every team

// Working values the program uses:
TeamCounter            // current team, runs 1 to LeagueSize
MatchCounter           // current match, runs 1 to MatchNo
TotalPoints[]          // each team's total, parallel to TeamName[]
AwayWinNo              // this team's away wins     (points value 3)
HomeWinNo              // this team's home wins     (points value 2)
DrawNo                 // this team's drawn matches (points value 1)
LostNo                 // this team's lost matches  (points value 0)
HighestResult          // best total seen so far
LowestResult           // worst total seen so far
TopTeam                // index of the team with the highest total
BottomTeam             // index of the team with the lowest total

📖 Detailed explanation

Parallel arrays are the heart of the question. One index — the team’s position — reaches the name in TeamName[] and the results in TeamPoints[], exactly as the question’s index-10 example describes.

TotalPoints[] is a design decision worth marks. AO2 credit comes from data structures that store all the data required; an array of totals keeps every team’s result for the champion comparisons.

The counters live for one team at a time. They are zeroed at the top of the team loop, filled by the match loop and printed immediately — arrays here would add risk without benefit.

Meaningful identifiers earn AO3 credit. AwayWinNo, DrawNo and TopTeam say what they hold, and every name maps back to the question’s wording.

⚠️ Common mistakes

Renaming TeamName[] or TeamPoints[], which the mark scheme treats as not using the supplied data structures.
Using a single Total variable, so the champion tests compare the last team’s value with itself.
Storing the champion’s name but not its index, then printing TeamName[TopTeam] with a string inside the brackets.
Inventing a 2D array for the four counts when four simple variables reset per team are enough.

💡 Exam hack / tip

Point at each name and ask “which phrase in the question does this store?” TeamPoints answers “points awarded for each match”, LeagueSize answers “the number of teams” and TopTeam answers “the team with the highest total points”.

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 totals and counters

Zero everything that accumulates — at exactly the right loop level.

R1 · R2

🧠 Step-by-step thinking

Zero the totals array first. The published answer runs a separate loop FOR TeamCounter ← 1 TO LeagueSize setting TotalPoints[TeamCounter] ← 0, because the main loop adds to that slot without assigning it first.
Zero the four counters per team. AwayWinNo, HomeWinNo, DrawNo and LostNo are reset at the top of the team loop — inside it, not before it — so each team starts its counts from zero.
Seed the champions from the first team. IF TeamCounter = 1 sets both HighestResult and LowestResult from the first team’s finished total, so the trackers start from real data instead of an invented limit.
Two different reset rhythms. TotalPoints[] is zeroed once for the whole league; the four counters are zeroed once per team. Mixing the two rhythms is the classic slip.

Zeroed once: TotalPoints[]Zeroed per team: four countersSeeded: HighestResult, LowestResult

❓ Guiding questions – think before revealing

Why does TotalPoints[] need its own zeroing loop?
Why are the four counters zeroed inside the team loop rather than before it?
Why seed the champions with IF TeamCounter = 1?

Reveal suggested reasoning

Why does TotalPoints[] need its own zeroing loop? The team loop performs TotalPoints[TeamCounter] ← TotalPoints[TeamCounter] + …, which reads the slot before writing it. The zeroing pass guarantees every team’s total genuinely starts from 0.

Why are the four counters zeroed inside the team loop rather than before it? Each team’s counts must start at 0. If the counters were zeroed only once, every team would inherit the previous team’s away wins, home wins, draws and losses.

Why seed the champions with IF TeamCounter = 1? The first team’s total is the only real starting value available. Seeding from it keeps the logic correct whatever the totals turn out to be, and the strict tests that follow keep the first occurrence of any tie.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Once, before the main loop: zero the totals array
FOR TeamCounter ← 1 TO LeagueSize
    TotalPoints[TeamCounter] ← 0
NEXT TeamCounter

FOR TeamCounter ← 1 TO LeagueSize
    // once per team: zero the four result counters
    AwayWinNo ← 0
    HomeWinNo ← 0
    DrawNo ← 0
    LostNo ← 0

    // match loop goes here ...

    // after this team's output lines: seed the champions
    IF TeamCounter = 1
      THEN
        HighestResult ← TotalPoints[TeamCounter]
        LowestResult ← TotalPoints[TeamCounter]
    ENDIF
NEXT TeamCounter

📖 Detailed explanation

Two rhythms, two places. The totals array is zeroed once for the league; the counters are zeroed once per team. Each reset lives at the level of the loop it serves.

The seed uses real data. HighestResult and LowestResult start from the first team’s total, so no invented limit such as 0 or 999 is needed.

Resetting is what makes reuse safe. The same four variables count every team’s results because they are returned to zero before each team’s match loop begins.

⚠️ Common mistakes

Zeroing the four counters only once, before the team loop, so every team inherits the previous team’s counts.
Forgetting the zeroing pass for TotalPoints[] entirely.
Seeding LowestResult with 0, which no team can beat when the bottom team really has 0 points.
Resetting the champion variables inside the loop, so the highest and lowest only reflect the last team.

💡 Exam hack / tip

Say it as a rule: zero what accumulates, at the level of the loop that accumulates it. League-wide totals are zeroed once; per-team counters are zeroed per team; champions are seeded once from the first team.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR1 · R2 · totals and counters start at zeroAO3 · resets at the right loop level

Initialisation supports AO2 because the accumulators genuinely start from a known state, and AO3 because the resets sit at the right loop level. These are alignment notes, not separately allocated marks.

Total each team’s points

A match loop inside a team loop reads every cell of the grid.

🧠 Step-by-step thinking

Nest the loops team-outside, match-inside. FOR TeamCounter ← 1 TO LeagueSize wraps FOR MatchCounter ← 1 TO MatchNo, so the program reads row 1 match by match, then row 2, and so on — the natural reading order of the grid.
Read each cell once. TeamPoints[TeamCounter, MatchCounter] is the current team’s current match — two indexes, one value, and both come from the loop counters.
Add into the team’s own slot. TotalPoints[TeamCounter] ← TotalPoints[TeamCounter] + TeamPoints[TeamCounter, MatchCounter] — the running total lives in the row that matches the team.
The loops run LeagueSize × MatchNo times. All teams have played the same number of matches, so one pair of loops covers the whole grid — 5 × 4 = 20 visits in the sample league.
One pass is enough. The totalling happens in the same inner loop as the counting, so the grid is read exactly once.

Iteration: FOR inside FORAccess: TeamPoints[t, m]Totalling into TotalPoints[]

❓ Guiding questions – think before revealing

Why is the team loop the outer one?
Why does the totals array use TeamCounter as its index?
How many times does the inner loop body run in total?

Reveal suggested reasoning

Why is the team loop the outer one? The outputs and the counters are per team: the program must finish one team’s matches before printing that team’s line and comparing its total. Swapping the loops would total columns of mixed teams instead.

Why does the totals array use TeamCounter as its index? Because the totals are parallel to the teams. TotalPoints[3] must always mean the third team’s total — the same row 3 that names the team in TeamName[].

How many times does the inner loop body run in total? LeagueSize × MatchNo times — once for every cell of the grid. Each visit adds one value to a team’s total and increments exactly one counter.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR TeamCounter ← 1 TO LeagueSize
    AwayWinNo ← 0
    HomeWinNo ← 0
    DrawNo ← 0
    LostNo ← 0

    FOR MatchCounter ← 1 TO MatchNo
        // add this match's points to the team's running total
        TotalPoints[TeamCounter] ← TotalPoints[TeamCounter] +
            TeamPoints[TeamCounter, MatchCounter]

        // count the result type here (Stage 05)

    NEXT MatchCounter
NEXT TeamCounter

📖 Detailed explanation

Nested iteration is the R1 technique. The mark scheme names “nested iteration, totalling” — the match loop inside the team loop plus the running addition is exactly that.

The two indexes have different meanings. The first selects the team (the row); the second selects the match (the column). Writing them the wrong way round reads another team’s result.

The total grows across the inner loop. Each match adds its value to the same slot TotalPoints[TeamCounter], which was zeroed for the whole league in Stage 03.

The loop finishes with a complete row. After NEXT MatchCounter, TotalPoints[TeamCounter] holds that team’s points for all matches played — ready for the output lines and the champion tests.

⚠️ Common mistakes

Swapping the indexes — TeamPoints[MatchCounter, TeamCounter] reads the wrong team’s match.
Totalling into a single variable, so only the last team’s total survives.
Looping MatchCounter to LeagueSize instead of MatchNo — the two sizes are different numbers.
Resetting TotalPoints[TeamCounter] to 0 inside the match loop, so the total only ever holds the last match’s value.

💡 Exam hack / tip

Read the cell address aloud as “this team, this match”: TeamPoints[TeamCounter, MatchCounter]. If your sentence sounds like “this match, this team”, your indexes are the wrong way round.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · nested iteration and totallingR1 · total points per teamAO3 · correct two-index accessAO3 · comments explain purpose

The nested loops and the running total are the R1 evidence for AO2, and the two-index array access is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Count the four result types

CASE OF on the points value routes each match to one of four counters.

🧠 Step-by-step thinking

One value, four categories. A cell of 3 is an away win, 2 a home win, 1 a drawn match and 0 a lost match — the value itself tells you which counter to increment.
CASE OF fits perfectly. TeamPoints[TeamCounter, MatchCounter] takes exactly four values, so CASE OF with labels 3, 2, 1 and 0 covers every match with no OTHERWISE branch.
The count happens beside the total. Inside the same inner loop, straight after the addition — one pass over the grid does both jobs.
Four separate counters. The question asks for the total number of away wins, home wins, drawn matches and lost matches — four numbers in the output, so four counters.
The counters were reset for this team. They were zeroed at the top of the team loop (Stage 03), so by NEXT MatchCounter they hold exactly this team’s four counts.

Selection: CASE OFCounting: + 1 per matchLabels: 3, 2, 1, 0

❓ Guiding questions – think before revealing

Why CASE OF rather than a chain of IFs?
Why does the CASE test the array cell directly?
What do the four counters hold after the inner loop finishes?

Reveal suggested reasoning

Why CASE OF rather than a chain of IFs? One value is tested against four constant alternatives — exactly what CASE OF expresses. Four IF statements also work, but the case structure shows the examiner a cleaner selection and mirrors the published answer.

Why does the CASE test the array cell directly? The published answer writes CASE OF TeamPoints[TeamCounter, MatchCounter] — the same expression it just added to the total. The reader can see at a glance that both jobs use the same value.

What do the four counters hold after the inner loop finishes? This team’s away wins, home wins, draws and losses — a team whose matches score 2, 3, 1 and 0 finishes with 1, 1, 1, 1. Together with the total they are the five numbers the output needs.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR MatchCounter ← 1 TO MatchNo
    TotalPoints[TeamCounter] ← TotalPoints[TeamCounter] +
        TeamPoints[TeamCounter, MatchCounter]

    // count this match's result type
    CASE OF TeamPoints[TeamCounter, MatchCounter]
      3 : AwayWinNo ← AwayWinNo + 1
      2 : HomeWinNo ← HomeWinNo + 1
      1 : DrawNo ← DrawNo + 1
      0 : LostNo ← LostNo + 1
    ENDCASE
NEXT MatchCounter

📖 Detailed explanation

Counting is the R2 technique. The mark scheme names “nested iteration, counting, output” — incrementing exactly one of four counters per match is the counting it looks for.

Every match lands in exactly one branch. The four labels cover all possible values, so no match is missed and none is counted twice.

The order of the labels does not matter. 3, 2, 1, 0 reads naturally from the question, but CASE OF tests every label — only the matching one runs.

The counters pair with the total. A team’s total points and its four counts come from the same cells: matches of 2, 3, 1 and 0 give 2 + 3 + 1 + 0 = 6 points and one of every result type.

⚠️ Common mistakes

Writing conditions such as = 3 or >= 2 inside the case — CASE OF labels are plain values.
Incrementing one shared counter for wins and draws, losing the four-way split the question demands.
Putting the counters’ reset inside the match loop, so no count ever passes 1.
Treating a 0 cell as “no match” — a lost match is data and must be counted.

💡 Exam hack / tip

Write the four labels straight from the question’s bullet list — 3 away, 2 home, 1 draw, 0 loss — and increment one counter per label. The points table and the counter names are the same list twice.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selection and countingR2 · four result counts per teamAO3 · correct case labels

The CASE OF counting is the R2 evidence for AO2, and the exact labels 3, 2, 1 and 0 are AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Output each team’s line

Six output lines per team, printed before the loop moves on.

🧠 Step-by-step thinking

Print inside the team loop. The lines must appear for every team, so they sit after NEXT MatchCounter and before the champion checks and NEXT TeamCounter.
Six lines, six facts. Name, total points, away wins, home wins, draws and losses — the question’s output bullet expanded, with the four counts on lines of their own.
The name comes through the array. TeamName[TeamCounter] prints the team’s name — the parallel-position rule from the question’s first paragraph in action.
Suitable messages are required. The closing line “All inputs and outputs must contain suitable messages” means every line says what it is printing, not just a bare number.

Output: six lines per teamName: TeamName[TeamCounter]Messages: every line labelled

❓ Guiding questions – think before revealing

Why must the OUTPUT statements sit inside the team loop?
Why print TeamName[TeamCounter] instead of a stored copy of the name?
What does “suitable messages” mean for this program?

Reveal suggested reasoning

Why must the OUTPUT statements sit inside the team loop? Each team’s counters are overwritten by the next team. Printing immediately — while the values are still this team’s — is what makes reuse of the four variables safe.

Why print TeamName[TeamCounter] instead of a stored copy of the name? The array already holds every name at the team’s index. Reading it through the index needs no extra variable and shows the examiner the parallel arrays are being used as given.

What does “suitable messages” mean for this program? Every output line carries words that name its value — “Total points 6”, not just “6”. The question’s closing lines ask for it explicitly, and the published answer’s messages do exactly this.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// this team's results, printed before the next team begins
OUTPUT "Team ", TeamName[TeamCounter]
OUTPUT "Total points ", TotalPoints[TeamCounter]
OUTPUT "Away wins ", AwayWinNo
OUTPUT "Home wins ", HomeWinNo
OUTPUT "Draws ", DrawNo
OUTPUT "Losses ", LostNo

📖 Detailed explanation

Output is half of R2. The mark scheme’s R2 is “counts and outputs, with the team’s name” — the counting happens in Stage 05 and this stage delivers the output with the name.

The timing is the trap. Move these lines outside the loop and only the last team is printed, with every other team’s results lost for good.

The published answer prints six lines. “Team”, “Total points”, “Away wins”, “Home wins”, “Draws” and “Losses” — each message names its value, satisfying the suitable-messages closing line.

⚠️ Common mistakes

Printing only the name and the total points, forgetting the four counts the question lists.
Printing outside the team loop, so only the last team’s results appear.
Outputting bare numbers with no message text.
Printing TeamCounter instead of TeamName[TeamCounter], so the league table shows row numbers instead of names.

💡 Exam hack / tip

Match your OUTPUT lines to the question’s output bullet: name, total points, four counts. If you can tick all three sub-bullets with your output block, R2’s output half is safe.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · output with suitable messagesR2 · name, total and four counts per teamAO3 · outputs inside the loop

The per-team outputs complete the R2 evidence for AO2, and their position inside the loop is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Find the top and bottom teams

Seed from the first team, then strict tests keep the first occurrence.

🧠 Step-by-step thinking

Seed both trackers from team 1. IF TeamCounter = 1 sets HighestResult and LowestResult from the first team’s finished total — real data, not an invented limit.
Test strictly greater for the top. IF TotalPoints[TeamCounter] > HighestResult updates the champion and stores TopTeam ← TeamCounter only when a team strictly beats the best so far.
Test strictly less for the bottom. IF TotalPoints[TeamCounter] < LowestResult does the same for the worst, storing BottomTeam ← TeamCounter.
Store the index, not the name. The champions are remembered as positions, so the final lines can print TeamName[TopTeam] and TeamName[BottomTeam].
Two final lines, once each. After NEXT TeamCounter, output the top and bottom team names — the last requirement and the end of the program.

Selection: > and < testsStored: TopTeam and BottomTeamOutput: two final lines

❓ Guiding questions – think before revealing

Why seed from the first team instead of 0?
What happens if two teams tie for highest?
Why compare after the output lines rather than inside the match loop?

Reveal suggested reasoning

Why seed from the first team instead of 0? For the highest, 0 happens to work because points are never negative — but for the lowest, 0 is a trap: a bottom team with exactly 0 points would fail 0 < 0 and never be recorded. Seeding from a real total avoids both risks.

What happens if two teams tie for highest? The test is strictly >, so a later team that merely equals the champion changes nothing — the first team to reach that total keeps the title.

Why compare after the output lines rather than inside the match loop? A team’s total is complete only after all its matches. The published answer checks the champions after the team’s six output lines, using the finished TotalPoints[TeamCounter].

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// after this team's output lines
IF TeamCounter = 1
  THEN
    HighestResult ← TotalPoints[TeamCounter]
    LowestResult ← TotalPoints[TeamCounter]
ENDIF

IF TotalPoints[TeamCounter] > HighestResult
  THEN
    HighestResult ← TotalPoints[TeamCounter]
    TopTeam ← TeamCounter
ENDIF

IF TotalPoints[TeamCounter] < LowestResult
  THEN
    LowestResult ← TotalPoints[TeamCounter]
    BottomTeam ← TeamCounter
ENDIF

NEXT TeamCounter

// once, after the loop
OUTPUT "Top Team ", TeamName[TopTeam]
OUTPUT "Bottom Team ", TeamName[BottomTeam]

📖 Detailed explanation

Selection and output are the R3 techniques. The mark scheme names “output, selection” — the two strict tests supply the selection and the two final lines supply the output.

The seed team sets both trackers at once. Team 1’s total is both the highest and the lowest known at that moment; every later team gets two chances to take a title.

Strict tests keep the first occurrence. A tie never displaces the earlier champion — a team equal to the leader does not take the title from it.

The names arrive at the very end. TeamName[TopTeam] and TeamName[BottomTeam] turn the stored indices into the names the question asks to output.

⚠️ Common mistakes

Seeding LowestResult with 0, so a bottom team with exactly 0 points is never recorded.
Using >= or <=, so a later tied team steals a title from the earlier one.
Storing the champion’s total but not its index, then having no way to print its name.
Putting the Top Team and Bottom Team outputs inside the loop, so they print once per team.

💡 Exam hack / tip

Write the two tests as a pair and read them aloud: greater than the best, less than the worst. Then store the index with the total — a champion you cannot name cannot be output.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selection and outputR3 · highest and lowest team namesAO3 · strict tests and stored indices

The champion search is the R3 evidence for AO2, and the strict tests with stored indices 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 the four result types.	Establishes logical order and comments the plan.
2 · Data	Required data structures	Uses TeamName[] and TeamPoints[] as given, with a totals array and four result counters.	Meaningful identifiers throughout.
3 · Initialise	R1, R2	TotalPoints[] zeroed for the league; the four counters zeroed per team; champions seeded from team 1.	Resets sit at the right loop level.
4 · Points	R1	Nested iteration and totalling of every team’s matches.	Accurate two-index array access.
5 · Results	R2	CASE OF counting of away wins, home wins, draws and losses.	Correct labels 3, 2, 1 and 0.
6 · Output	R2	Six output lines per team with the team’s name.	Outputs inside the team loop with suitable messages.
7 · Champions	R3	Finds the teams with the highest and lowest totals and outputs their names.	Strict tests, stored indices and two final lines.

Consolidated Cambridge pseudocode

Complete solution

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

15-mark exemplar style

Read this carefully: this mirrors the official published mark scheme answer for 0478/22 February/March 2023 Question 11. The arrays TeamName[] and TeamPoints[] and the variables LeagueSize and MatchNo are supplied by the question and are used exactly as given. The published answer keeps each team’s total in the parallel array TotalPoints[], counts the four result types with CASE OF on the points value, and finds the highest and lowest totals in the same pass through the teams, storing their indices for the final two output lines.

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

// meaningful identifier names and appropriate data structures to store the data required
DECLARE TeamCounter : INTEGER
DECLARE MatchCounter : INTEGER

FOR TeamCounter ← 1 TO LeagueSize    // zero totals for each club's results
    TotalPoints[TeamCounter] ← 0
NEXT TeamCounter

FOR TeamCounter ← 1 TO LeagueSize
    AwayWinNo ← 0    // zero totals for each club's result details
    HomeWinNo ← 0
    DrawNo ← 0
    LostNo ← 0
    FOR MatchCounter ← 1 TO MatchNo
        TotalPoints[TeamCounter] ← TotalPoints[TeamCounter] + TeamPoints[TeamCounter, MatchCounter]
        CASE OF TeamPoints[TeamCounter, MatchCounter]
          3 : AwayWinNo ← AwayWinNo + 1
          2 : HomeWinNo ← HomeWinNo + 1
          1 : DrawNo ← DrawNo + 1
          0 : LostNo ← LostNo + 1
        ENDCASE
    NEXT MatchCounter

    OUTPUT "Team ", TeamName[TeamCounter]    // Output details of a team's results
    OUTPUT "Total points ", TotalPoints[TeamCounter]
    OUTPUT "Away wins ", AwayWinNo
    OUTPUT "Home wins ", HomeWinNo
    OUTPUT "Draws ", DrawNo
    OUTPUT "Losses ", LostNo

    // Check for highest and lowest results
    IF TeamCounter = 1
      THEN
        HighestResult ← TotalPoints[TeamCounter]
        LowestResult ← TotalPoints[TeamCounter]
    ENDIF

    IF TotalPoints[TeamCounter] > HighestResult
      THEN
        HighestResult ← TotalPoints[TeamCounter]
        TopTeam ← TeamCounter
    ENDIF
    IF TotalPoints[TeamCounter] < LowestResult
      THEN
        LowestResult ← TotalPoints[TeamCounter]
        BottomTeam ← TeamCounter
    ENDIF

NEXT TeamCounter

// output names of the teams with the highest and lowest number of points
OUTPUT "Top Team ", TeamName[TopTeam]
OUTPUT "Bottom Team ", TeamName[BottomTeam]

Why this is a complete response

It covers the three mark-scheme requirements. R1: the nested loops visit every match of every team and total the points into TotalPoints[TeamCounter]. R2: CASE OF on TeamPoints[TeamCounter, MatchCounter] counts the away wins, home wins, drawn matches and lost matches for each team, and the six output lines print each team’s name, total points and four counts with suitable messages. R3: the highest and lowest totals are tracked with strict tests that store TopTeam and BottomTeam, and the final two lines output their names through TeamName[].

What to check before submitting

Check the two-index accesses TeamPoints[TeamCounter, MatchCounter], the CASE OF labels 3, 2, 1 and 0, the position of the counters’ reset inside the team loop, the seed IF TeamCounter = 1, the strict > and < tests, 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 the sample league. Watch the totals array being zeroed, each team’s four counters reset, every match add its points and feed the CASE OF, six output lines appear per team, and the two champions change hands.

Last tab · Trace player

Sample input → expected results

The sample league shrinks the data to LeagueSize = 5 teams and MatchNo = 4 matches per team. The grid deliberately includes one team — Alton — whose four matches hit all four result values (2 home win, 3 away win, 1 drawn match, 0 lost match), a clear highest total (Barrow, 11 points), a clear lowest total (Cranford, 2 points), and drawn matches worth 1 point. The walkthrough follows the published mark scheme answer’s execution order exactly, from the zeroing loop to the Top Team and Bottom Team lines. This is the authentic 0478/22 February/March 2023 Question 11. These are illustrative values, not data supplied by the examination question.

Input arrays TeamName[] and TeamPoints[,]

Team	Match 1	Match 2	Match 3	Match 4

The row number is the team’s position in both arrays — team 1 is stored in TeamName[1] and row 1 of TeamPoints[].

Reveal expected team results and league summary

Expected team results After all calculations

Team	Total points	Away wins	Home wins	Draws	Losses

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Result counters

Ready

Tip: use Next step slowly and watch TeamCounter and MatchCounter. The match counter returns to 1 for each new team while the away-win and home-win counters reset to 0; HighestResult and LowestResult never reset — they are seeded once from team 1.

Trace colours: blue row = current team; amber cell = current match; green cells = matches already processed.

Boundary example: Alton’s four matches score 2, 3, 1 and 0 — one of each result type — so CASE OF TeamPoints[1, 3] matches label 1 and DrawNo becomes 1. The champion tests are strict: Dunmoor’s 7 > Barrow’s 11 is FALSE, so Barrow keeps the top spot, and a team merely equal to the champion would not take it either.

From a grid of match points to a full league table.

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 totals and counters

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Total each team’s points

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Count the four result types

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Output each team’s line

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Find the top and bottom teams

🧠 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 TeamName[] and TeamPoints[,]

Expected team results After all calculations

Execution trace

Initialisation

Live variable values

Result counters