15-mark question lab · start here

From 100 000 random integers to a fairness report.

Build the solution in a sensible order: understand the two arrays, declare everything the question demands, generate and store the random integers, count each frequency, adapt the given ascending sort to descending, calculate every chance to four decimal places and output the sorted results with suitable messages. Learn the reasoning before revealing the complete program.

1D + 2D arraysRandom generationFrequency countingAdapting a given sortRounding to 4 dp15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the 1D RandomNumber[] of 100 000 generated integers, the 2D CountedNumber[] of integer-plus-frequency rows, and the given ascending snippet that must be adapted to descending.

02 · Construct

Generate and store 100 000 integers in the range 1 to 10, count each frequency into column 2, and adapt the bubble sort so the highest frequency finishes in row 1.

03 · Complete

Calculate chance = frequency / 100000 rounded to four decimal places, and output each integer with its chance, in stored order, with suitable messages and full declarations.

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 direction of the sort, the exact divisor 100 000 and the demand for declarations all affect the structure of your solution.

Question 8 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 8

A program is required to test the fairness of the random number generator.

The one-dimensional (1D) array RandomNumber[] is used to store 100 000 random integers. The two-dimensional (2D) array CountedNumber[] is used to store the integers 1 to 10, inclusive, and the frequency of each integer (the number of times each integer was generated).

Write a program that meets the following requirements:

Generate 100 000 random integers between 1 and 10, inclusive.
Store each integer in the appropriate array.
Calculate the frequency of each of the integers 1 to 10 and store these values in the appropriate array.
Sort the contents of the counted number array in descending order of frequency.
Calculate the chance of generating each of the integers 1 to 10, rounded to four decimal places.
Use the formula: chance = frequency / 100000
Output each of the integers 1 to 10 in the order they are stored in the counted number array, along with the chance of generating them.

The following is an example of an algorithm that sorts a 2D array in an ascending order:

F ← TRUE
WHILE F DO
    F ← FALSE
    FOR I ← 1 TO 9
        IF A[I, 2] > A[I + 1, 2]
           THEN
              T1 ← A[I, 1]
              T2 ← A[I, 2]
              A[I, 1] ← A[I + 1, 1]
              A[I, 2] ← A[I + 1, 2]
              A[I + 1, 1] ← T1
              A[I + 1, 2] ← T2
              F ← TRUE
        ENDIF
    NEXT I
ENDWHILE

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

All arrays, variables or constants used must be declared for this algorithm.

All inputs and outputs must contain suitable messages.

Before you move on

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

Mark-scheme map

Generate 100 000 random integers between 1 and 10, inclusive, and store each one in RandomNumber[].

Calculate the frequency of each integer 1 to 10 and store it in column 2 of CountedNumber[], beside the integer in column 1.

Sort CountedNumber[] into descending order of frequency by adapting the given ascending snippet — flip the comparison.

Calculate chance = frequency / 100000 for each integer, rounded to four decimal places.

Output each integer with its chance, with suitable messages, in the order the rows are stored after the sort.

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

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Spot what is different about this question. Nothing is typed in. The program generates its own data: 100 000 random integers stored in RandomNumber[], then processed into a report.
Split the bullets into four phases. Generate and store → count frequencies → sort descending → calculate chances and output. The output loop depends on the sort; the sort depends on the counts; the counts depend on the generation.
Read the array descriptions precisely. RandomNumber[] is 1D with 100 000 cells. CountedNumber[] is 2D with ten rows and two columns: the integer and the number of times it was generated.
Treat the given snippet as a starting point, not an answer. The paper supplies an ascending bubble sort on column 2. The question asks for descending order of frequency, so the comparison must be flipped from > to <.
Note the three closing lines. Comments are required; every array, variable and constant must be declared; every output needs a suitable message. This question therefore needs a declaration block, unlike questions that say data is already set up.

Generation loop: 100 000 integersCounting into a 2D arrayDescending bubble sortRounding: four decimal places

❓ Guiding questions – think before revealing

Which array does each bullet mean by “the appropriate array”?
What exactly is sorted, and into what order?
How do the closing lines change your answer?

Reveal suggested reasoning

Which array does each bullet mean by “the appropriate array”? The generated integers are stored in RandomNumber[]; the frequencies are stored in column 2 of CountedNumber[], beside the integer they belong to in column 1.

What exactly is sorted, and into what order? CountedNumber[] — “the counted number array” — is sorted into descending order of frequency, on column 2. RandomNumber[] is never sorted. The given snippet sorts ascending, so its comparison must be adapted.

How do the closing lines change your answer? This question demands declarations for every array, variable and constant, so a DECLARE/CONSTANT block is part of the answer. Comments must explain the code and every OUTPUT must carry a message.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// 1. Declare every array, variable and constant
// 2. Generate 100 000 integers 1–10 and store them
FOR Counter ← 1 TO TotalNumbers
    // RandomNumber[Counter] ← INT(RANDOM() * 10) + 1
NEXT Counter
// 3. Give CountedNumber[] its ten rows: integer + zero frequency
// 4. Count each generated integer into its own row
// 5. Sort CountedNumber[] descending by frequency (adapt the snippet)
// 6. For each row: chance ← frequency / 100000, rounded to 4 dp,
//    then output the integer with its chance, in stored order

📖 Detailed explanation

“Test the fairness” is the scenario’s purpose: if the generator is fair, every integer 1 to 10 should end with a chance close to 0.1. The program measures that by counting.

“The appropriate array” points each value to its home — generated integers to RandomNumber[], frequencies to column 2 of CountedNumber[].

“In the order they are stored” tells you the final output loop must walk the sorted rows of CountedNumber[], not the integers 1 to 10 in numeric order.

“Descending order of frequency” decides the comparison direction: a swap fires when the left frequency is less than the right.

⚠️ Common mistakes

Copying the given ascending snippet without flipping the comparison, which reports the least likely integer first.
Looking for data to input — there is none; the first loop generates the data.
Writing chance as frequency / 10 (the count of possible integers) instead of frequency / 100000.
Ignoring the closing lines: no declarations, no comments, or bare OUTPUT statements without messages.

💡 Exam hack / tip

Underline “100 000”, “descending”, “four decimal places” and “must be declared”. Those four phrases decide the loop bound, the comparison direction, the rounding and the declaration block.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · multi-phase algorithm designR1–R5 · all six bullets coveredAO3 · adapting a given algorithmAO3 · declarations and messages

This planning stage supports AO2 by identifying the full range of techniques required, and AO3 by recognising what adapting the supplied algorithm means. These are alignment notes, not separately allocated marks.

Plan the data and identifiers

Declare exactly what the algorithm needs — this question demands it.

Required data structures

🧠 Step-by-step thinking

Keep the given names. RandomNumber[] and CountedNumber[] are named by the question — use them exactly as printed.
Size the arrays from the wording. RandomNumber[1:100000] holds one cell per generated integer; CountedNumber[1:10, 1:2] holds one row per integer 1 to 10, with column 1 for the integer and column 2 for its frequency.
Declare the working variables. Counter and I walk the loops; F (BOOLEAN) records whether a pass swapped anything; T1 and T2 protect both columns during a swap; Chance (REAL) holds each probability.
Use constants for the two magic numbers. TotalNumbers = 100000 and HighestInteger = 10 keep the loop bounds and the chance divisor self-documenting and consistent.
Declare everything — the question says so. “All arrays, variables or constants used must be declared” makes the declaration block examinable content, not an optional extra.

Given: RandomNumber[] and CountedNumber[]1D: 100 000 cells2D: ten rows × two columns

❓ Guiding questions – think before revealing

Why does CountedNumber[] need two columns?
Why is F a BOOLEAN?
Could the frequencies live in a 1D array instead?

Reveal suggested reasoning

Why does CountedNumber[] need two columns? Each row must keep the integer and its frequency together so the sort can move both as one unit. Sorting only the frequencies would detach every integer from its own count.

Why is F a BOOLEAN? It answers one question per pass — did any swap happen? — so TRUE/FALSE is its natural type. It is set FALSE at the start of each pass and becomes TRUE the moment a swap fires.

Could the frequencies live in a 1D array instead? Not here: the question fixes CountedNumber[] as the 2D store of integer-plus-frequency, and the given snippet swaps two columns per row, which only makes sense in a 2D array.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

DECLARE RandomNumber : ARRAY[1:100000] OF INTEGER
DECLARE CountedNumber : ARRAY[1:10, 1:2] OF INTEGER
DECLARE Counter : INTEGER   // generation, counting and output loops
DECLARE I : INTEGER         // adjacent-pair position inside the sort
DECLARE F : BOOLEAN         // swap flag for the bubble sort
DECLARE T1 : INTEGER        // temporary for column 1 during a swap
DECLARE T2 : INTEGER        // temporary for column 2 during a swap
DECLARE Chance : REAL       // chance of generating an integer

CONSTANT TotalNumbers = 100000
CONSTANT HighestInteger = 10

📖 Detailed explanation

Column 1 is the label, column 2 is the count. Row k of CountedNumber always answers “how often was integer k generated?” — and because column 1 travels with column 2 in every swap, the pairing survives the sort.

The sort moves rows, not columns. T1 and T2 exist so both cells of a row travel together — exactly the job the given snippet gives them.

One constant keeps 100 000 honest. It is easy to type 10 000 or 1 000 000 by mistake; a named constant used in the loop bound and the divisor keeps every occurrence consistent.

⚠️ Common mistakes

Declaring RandomNumber with 10 cells (the integer range) instead of 100 000 cells (the number of generations).
Planning to swap only column 2 in the sort, which would leave every frequency beside the wrong integer.
Declaring Chance as INTEGER, which would truncate a chance such as 0.1250 to 0.
Renaming the given arrays or inventing a third array the question never mentions.

💡 Exam hack / tip

Count your declarations against the identifiers in your final program. Every name — arrays, loop counters, flag, temporaries, chance, constants — must appear in a DECLARE or CONSTANT line, because this question says so.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresDeclarations demanded by the questionAO3 · meaningful identifiers

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

Generate and store 100 000 random integers

One loop, one idiom: INT(RANDOM() * 10) + 1.

🧠 Step-by-step thinking

Loop 100 000 times. FOR Counter ← 1 TO TotalNumbers — one iteration draws one integer and stores it in one position.
Build the range 1 to 10. RANDOM() returns a value from 0 up to (but not including) 1, so INT(RANDOM() * 10) gives 0 to 9, and + 1 shifts it to 1 to 10, inclusive.
Store into the 1D array. RandomNumber[Counter] ← INT(RANDOM() * HighestInteger) + 1 — the loop counter is the position.
Keep the range inclusive. “Between 1 and 10, inclusive” forbids both 0 and 11; the multiplication by 10 and the + 1 together guarantee the range.
Keep counting out of this loop. The bullets ask you to store every integer; a separate counting loop (Stage 4) reads them back and is far easier to check.

INT(RANDOM() * 10) + 1100 000 iterationsCounter is the position

❓ Guiding questions – think before revealing

Why INT(RANDOM() * 10) + 1 rather than INT(RANDOM() * 10)?
Why store the integers at all, if only frequencies are output?
How big is the workload?

Reveal suggested reasoning

Why INT(RANDOM() * 10) + 1 rather than INT(RANDOM() * 10)? Multiplying by 10 gives ten values, 0 to 9. The question wants 1 to 10 inclusive, so 1 is added after truncating. Without the + 1 the integer 10 could never be generated and a phantom 0 would be counted.

Why store the integers at all, if only frequencies are output? “Store each integer in the appropriate array” is a requirement in its own right, and the counting pass reads the values back from RandomNumber[].

How big is the workload? 100 000 iterations — trivial for a computer, impossible by hand, which is exactly why the question asks for a program.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Generate and store 100 000 random integers, 1 to 10 inclusive
FOR Counter ← 1 TO TotalNumbers
    RandomNumber[Counter] ← INT(RANDOM() * HighestInteger) + 1
NEXT Counter

📖 Detailed explanation

RANDOM() sits between 0 and 1. Multiplying by 10 stretches it to 0 to just under 10; INT truncates downwards, so the ten possible results are 0, 1, …, 9.

The + 1 is the inclusive boundary. Shifting after truncation maps 0 → 1 and 9 → 10, giving exactly the ten integers the question names.

One counter does both jobs. Counter walks the array positions and counts the iterations; no second variable is needed.

⚠️ Common mistakes

Using ROUND instead of INT, which biases the extremes: a raw value near 0.95 would round up to 10 and then step to 11.
Multiplying by 11 “to make room for the + 1”, producing 1 to 11.
Generating only 10 integers (one per possible value) instead of 100 000.
Drawing the value but forgetting to store it, leaving the counting loop nothing to read.

💡 Exam hack / tip

Sanity-check the range at both ends: RANDOM() just below 1 gives INT(9.99…) + 1 = 10, and near 0 gives INT(0) + 1 = 1. If either end fails, the expression is wrong.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · random generation idiomR1 · 100 000 integers storedAO3 · inclusive range boundaries

The generation loop is the clearest AO2 evidence for R1, and the end-point check is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Count each frequency into CountedNumber[]

Prepare ten rows, then let every integer find its own row.

🧠 Step-by-step thinking

Prepare column 2 before counting. CountedNumber[Counter, 1] ← Counter and CountedNumber[Counter, 2] ← 0 for Counter = 1 to 10 — every integer present, every frequency zero.
Read the integers back. A second loop walks RandomNumber[] from position 1 to TotalNumbers.
Let the integer find its own row. CountedNumber[RandomNumber[Counter], 2] ← CountedNumber[RandomNumber[Counter], 2] + 1 — the generated value is itself the row index.
Never touch column 1 here. Column 1 keeps the integer identity; only the frequency in column 2 grows.
Check the total. After the loop, the ten frequencies must add up to exactly 100 000 — a one-line sanity check that catches most counting bugs.

Initialise: integers + zerosDirect indexing: value = rowTotals, not averages

❓ Guiding questions – think before revealing

Why initialise the frequencies to 0 first?
What does CountedNumber[RandomNumber[Counter], 2] mean?
Is a nested-loop search also acceptable?

Reveal suggested reasoning

Why initialise the frequencies to 0 first? An integer that is never generated must end with frequency 0. Without initialisation its cell holds an undefined value, and adding 1 to it is meaningless.

What does CountedNumber[RandomNumber[Counter], 2] mean? First read the stored integer v, then use v as the row index: add 1 to the frequency stored beside integer v.

Is a nested-loop search also acceptable? Yes — IF CountedNumber[Counter, 1] = RandomNumber[Inner] inside two loops — but it is ten times slower. Direct indexing earns the same marks and is neater.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Give every integer a row and a zero frequency
FOR Counter ← 1 TO HighestInteger
    CountedNumber[Counter, 1] ← Counter
    CountedNumber[Counter, 2] ← 0
NEXT Counter

// Count each generated integer into its own row
FOR Counter ← 1 TO TotalNumbers
    CountedNumber[RandomNumber[Counter], 2] ←
        CountedNumber[RandomNumber[Counter], 2] + 1
NEXT Counter

📖 Detailed explanation

Counting is selection in disguise. The IF-based search asks “which row does this value belong to?”; direct indexing answers the same question by arithmetic — the row number equals the value.

Frequencies are totals, not averages. Column 2 accumulates occurrences with + 1; division happens only later, once, when the chance is calculated.

The sum check is a free safety net. Ten frequencies totalling 100 000 proves every generated integer was counted exactly once.

⚠️ Common mistakes

Incrementing column 1, destroying the integer identity the final output still needs.
Starting the frequencies at 1, which adds a phantom occurrence to every integer.
Counting Counter (the position) instead of RandomNumber[Counter] (the value), so each integer’s row is never really found.
Resetting the frequencies inside the counting loop, wiping earlier counts.

💡 Exam hack / tip

Trace one iteration aloud: RandomNumber[7] = 3, so CountedNumber[3, 2] grows by 1. If your sentence does not name a value and a row, the indexing is wrong.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · counting with arraysR2 · frequencies into CountedNumber[]AO3 · correct 2D indexing

This stage supplies the counting evidence for R2, and the two-index access is the AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Adapt the given sort to descending frequency

The snippet is scaffolding — flip the comparison, keep the swap.

🧠 Step-by-step thinking

Start from the given snippet. It is a flagged bubble sort on column 2 of a 2D array: WHILE F repeats passes; FOR I ← 1 TO 9 compares the nine adjacent pairs of ten rows; T1/T2 swap both columns; F ← TRUE records the swap.
Adapt it to descending. Ascending swaps when the left value is greater (>). Descending must swap when the left frequency is less: IF CountedNumber[I, 2] < CountedNumber[I + 1, 2].
Keep the swap intact. Both columns move through T1 and T2, so each integer stays glued to its own frequency.
Let the flag end the sort. Each pass sets F ← FALSE first; if a whole pass makes no swap, F stays FALSE and ENDWHILE exits — the array is sorted.
Expect several passes. Each pass moves out-of-order rows one step; passes repeat until a clean pass proves the descending order.

Flip: > becomes <Swap both columns via T1, T2Flag: F ends the WHILE

❓ Guiding questions – think before revealing

Why < and not <=?
Why does the FOR loop stop at 9, not 10?
What has actually changed from the given snippet?

Reveal suggested reasoning

Why < and not <=? Two integers with equal frequencies keep the order they are already in. Using <= would swap equals pointlessly, churning the array without improving the order.

Why does the FOR loop stop at 9, not 10? Each comparison looks at rows I and I + 1; with ten rows the last valid pair starts at row 9. FOR I ← 1 TO 10 would compare row 10 with a non-existent row 11.

What has actually changed from the given snippet? Only the comparison — > becomes < — and the array name A becomes CountedNumber. The flag, the pass loop, the temporaries and F ← TRUE are inherited unchanged.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Bubble sort CountedNumber[] DESCENDING by frequency (column 2).
// Adapted from the given ascending snippet: > flipped to <.
F ← TRUE
WHILE F DO
    F ← FALSE
    FOR I ← 1 TO 9
        IF CountedNumber[I, 2] < CountedNumber[I + 1, 2]
        THEN
            T1 ← CountedNumber[I, 1]
            T2 ← CountedNumber[I, 2]
            CountedNumber[I, 1] ← CountedNumber[I + 1, 1]
            CountedNumber[I, 2] ← CountedNumber[I + 1, 2]
            CountedNumber[I + 1, 1] ← T1
            CountedNumber[I + 1, 2] ← T2
            F ← TRUE
        ENDIF
    NEXT I
ENDWHILE

📖 Detailed explanation

The snippet is scaffolding, not the answer. Cambridge supplies it so every candidate has a starting point; the marks come from adapting the direction and wiring in the right array.

Descending means biggest first. After the sort, row 1 holds the most frequent integer — the first line of the fairness report.

The flag is the termination guarantee. Without F ← TRUE inside the swap branch, F would stay FALSE after one pass and the sort would stop after a single sweep.

⚠️ Common mistakes

Leaving the snippet’s > in place, sorting ascending and reporting the rarest integer first.
Comparing column 1 (the integers 1 to 10) instead of column 2, which merely re-sorts the rows into numeric order.
Swapping only the frequencies, so every chance ends up attached to the wrong integer.
Writing FOR I ← 1 TO 10 and reading a non-existent row 11, or dropping F ← TRUE so the sort ends after one pass.

💡 Exam hack / tip

Say the direction out loud: descending = swap when the left is smaller = <. One character separates ascending from descending — it is the single most checked adaptation in this question.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · standard algorithm adaptedR3 · descending by frequencyAO3 · whole-row swaps with flag

The sort is the AO2 evidence for a standard algorithm adapted to the scenario, and the flag-terminated loop with intact row swaps is the AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Calculate each chance and output the sorted report

chance = frequency / 100000, rounded to four decimal places.

R4 · R5

🧠 Step-by-step thinking

Apply the given formula. Chance ← CountedNumber[Counter, 2] / TotalNumbers — frequency divided by the number of generations.
Round to four decimal places. ROUND(Chance, 4) gives the four decimal places the question demands.
Walk the sorted rows. FOR Counter ← 1 TO HighestInteger now visits the rows in descending-frequency order — “the order they are stored”.
Output the pair with a message. OUTPUT "Integer ", CountedNumber[Counter, 1], " has chance ", ROUND(Chance, 4) — message, integer, chance.
Divisor sanity check. The divisor is 100 000 (the generations), not 10 (the possible integers) — a fair generator puts every chance near 0.1.

Formula: frequency / 100000ROUND(Chance, 4)Stored order = sorted order

❓ Guiding questions – think before revealing

Why does the output loop give the sorted order automatically?
Why divide by 100 000?
Where does the rounding happen?

Reveal suggested reasoning

Why does the output loop give the sorted order automatically? After the sort, row 1 holds the highest frequency. Looping rows 1 to 10 of CountedNumber[] outputs the integers in the order they are stored — exactly what the last bullet asks for.

Why divide by 100 000? Chance is a probability: favourable outcomes over total outcomes. The total number of generations is 100 000, so a fair generator gives every integer a chance near 0.1.

Where does the rounding happen? In the chance line, with ROUND(Chance, 4). Rounding the frequency first, or dividing by the wrong number, produces values the mark scheme cannot match.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Calculate each chance and output in stored (sorted) order
FOR Counter ← 1 TO HighestInteger
    Chance ← CountedNumber[Counter, 2] / TotalNumbers
    OUTPUT "Integer ", CountedNumber[Counter, 1],
        " has chance ", ROUND(Chance, 4)
NEXT Counter

📖 Detailed explanation

One loop does the maths and the output. A row’s chance is needed only for that row’s output line, so calculating and printing live together inside the same loop.

A fair generator lands near 0.1000. With 100 000 draws, every integer’s chance should be close to 0.1; a chance far from 0.1 is the evidence of unfairness the scenario is hunting for.

ROUND(Chance, 4) matches the wording. “Rounded to four decimal places” maps directly onto the second argument of ROUND.

⚠️ Common mistakes

Dividing by 10 instead of 100 000, giving probabilities up to ten times too large.
Rounding to two decimal places out of habit — this question says four.
Re-computing each integer’s frequency in numeric order 1 to 10 after the sort, ignoring the stored (sorted) order.
Printing the frequency instead of the chance, or forgetting the message around the values.

💡 Exam hack / tip

Attach the units: a frequency is “times out of 100 000”, a chance is “a probability to 4 dp”. If a line of your answer mixes the two, recheck the divisor and the ROUND.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · formula application and roundingR4 · R5 · sorted output with messagesAO3 · correct divisor

The chance calculation and the sorted outputs are the R4 and R5 evidence, and the divisor check is the AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Assemble the program and audit the closing lines

Declarations, comments, messages — then check the order of everything.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Assemble in bullet order. Declarations → generation → initialisation → counting → sort → chance and output. Each phase consumes the previous one’s output.
Re-read the closing lines against your answer. Comments present? Every identifier declared? Every OUTPUT worded with a message? Three ticks.
Check the six bullets one by one. Generate ✓ store ✓ frequency ✓ sort descending ✓ chance to 4 dp ✓ output in stored order ✓.
Test the extremes mentally. An integer generated every time → chance 1.0000; never generated → 0.0000. Both must be expressible in your program.
Match the question’s vocabulary. RandomNumber[], CountedNumber[], chance = frequency / 100000 — the examiner should see the question’s own words in your code.

Pipeline orderClosing-line auditNames straight from the paper

❓ Guiding questions – think before revealing

What single detail proves the output order is right?
How do the closing lines earn their marks?
What does “fair” look like in the output?

Reveal suggested reasoning

What single detail proves the output order is right? The output loop must index CountedNumber[Counter, …] directly after the sort. Re-deriving frequencies for integers 1 to 10 would output numeric order, not stored order.

How do the closing lines earn their marks? Declarations: a DECLARE/CONSTANT for every identifier. Comments: one per phase explaining purpose. Messages: every OUTPUT begins with a string the user can read.

What does “fair” look like in the output? Ten chances all near 0.1000, in descending order — the most frequent integer first, the least frequent last, which is precisely the report the sorted array produces.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Complete program order
// 1. DECLARE every array, variable and constant
// 2. Generate + store: FOR Counter ← 1 TO TotalNumbers
// 3. Initialise CountedNumber[] rows (integer + 0)
// 4. Count frequencies into column 2
// 5. Bubble sort descending (adapted snippet, flag-terminated)
// 6. FOR Counter ← 1 TO HighestInteger: chance + OUTPUT
// Audit: comments ✓ declarations ✓ messages ✓

📖 Detailed explanation

The phases form a pipeline. Generation feeds counting; counting feeds the sort; the sort feeds the output. Nothing can be reordered without breaking a dependency.

The given snippet anchored the hardest phase. Recognising the standard algorithm the question supplied — and what adapting it means — is exactly the skill this paper is testing.

The closing lines are worth real marks. On questions that demand declarations, omitting them is a structural loss, not a style quibble.

⚠️ Common mistakes

Reordering the phases — for example sorting before counting, or calculating chances before the sort.
Dropping the comments when assembling the final answer under time pressure.
Leaving a stray identifier (a second counter, an unused temporary) undeclared.
Outputting during the sort instead of after it, printing half-finished rows.

💡 Exam hack / tip

Final 30 seconds: run a ruler down the six bullets, then down the three closing lines. Nine ticks — submit with confidence.

Reveal the Cambridge mark-scheme and rubric connection

R1–R5 · every bullet satisfiedAO2 · pipeline structureAO3 · closing lines satisfied

The final assembly supports AO2 through the dependency-correct pipeline and AO3 through the closing-line audit. These are alignment notes, not separately allocated marks.

Cambridge assessment criteria

What does a high-level response look like?

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

9 AO2 + 6 AO3 = 15

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

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

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

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

How the seven stages contribute

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

R1–R5

Stage	Mark-scheme link	AO2 evidence	AO3 evidence
1 · Decode	R1–R5	Identifies the generate–count–sort–chance pipeline and the required declarations.	Establishes a logical order and plans the comments.
2 · Data	Given structures + declarations	RandomNumber[1:100000]; CountedNumber[1:10, 1:2]; flag, temporaries, Chance, two constants.	Meaningful identifiers; every name declared.
3 · Generate	R1	100 000 integers 1–10 generated and stored with INT(RANDOM() * 10) + 1.	Inclusive range proven at both ends.
4 · Count	R2	Column 2 of every row initialised to 0; each generated integer increments its own row.	Correct 2D indexing; column 1 preserved.
5 · Sort	R3	Given ascending snippet adapted to descending on column 2.	Strict < comparison; whole-row swap; flag ends the loop.
6 · Chance	R4 · R5	chance = frequency / 100000 rounded to four decimal places; output with messages.	ROUND(x, 4); divisor 100000; stored order.
7 · Summary	R1–R5	Assembles the pipeline and audits comments, declarations and messages.	All six bullets and three closing lines satisfied.

Consolidated Cambridge pseudocode

Complete solution

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

15-mark exemplar style

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

// ----- Declarations: this question demands every one of them -----
DECLARE RandomNumber : ARRAY[1:100000] OF INTEGER
DECLARE CountedNumber : ARRAY[1:10, 1:2] OF INTEGER
DECLARE Counter : INTEGER     // walks the generation, counting and output loops
DECLARE I : INTEGER           // adjacent-pair position inside the sort
DECLARE F : BOOLEAN           // swap flag: did this pass swap anything?
DECLARE T1 : INTEGER          // temporary for column 1 during a swap
DECLARE T2 : INTEGER          // temporary for column 2 during a swap
DECLARE Chance : REAL         // chance of generating an integer

CONSTANT TotalNumbers = 100000   // how many integers are generated
CONSTANT HighestInteger = 10     // integers run from 1 to 10, inclusive

// Generate 100 000 random integers between 1 and 10 and store them
FOR Counter ← 1 TO TotalNumbers
    RandomNumber[Counter] ← INT(RANDOM() * HighestInteger) + 1
NEXT Counter

// Prepare CountedNumber[]: column 1 = the integer, column 2 = its frequency
FOR Counter ← 1 TO HighestInteger
    CountedNumber[Counter, 1] ← Counter
    CountedNumber[Counter, 2] ← 0
NEXT Counter

// Count each generated integer into its own row of CountedNumber[]
FOR Counter ← 1 TO TotalNumbers
    // the stored value is itself the row index in CountedNumber[]
    CountedNumber[RandomNumber[Counter], 2] ←
        CountedNumber[RandomNumber[Counter], 2] + 1
NEXT Counter

// Sort CountedNumber[] into DESCENDING order of frequency.
// Adapted from the given ascending snippet: > flipped to <, and the
// array A replaced by CountedNumber. F ends the loop once a whole
// pass makes no swap.
F ← TRUE
WHILE F DO
    F ← FALSE
    FOR I ← 1 TO 9
        IF CountedNumber[I, 2] < CountedNumber[I + 1, 2]
        THEN
            T1 ← CountedNumber[I, 1]
            T2 ← CountedNumber[I, 2]
            CountedNumber[I, 1] ← CountedNumber[I + 1, 1]
            CountedNumber[I, 2] ← CountedNumber[I + 1, 2]
            CountedNumber[I + 1, 1] ← T1
            CountedNumber[I + 1, 2] ← T2
            F ← TRUE
        ENDIF
    NEXT I
ENDWHILE

// Calculate the chance of each integer and output them in the order
// they are stored — highest frequency first — with suitable messages
FOR Counter ← 1 TO HighestInteger
    Chance ← CountedNumber[Counter, 2] / TotalNumbers
    OUTPUT "Integer ", CountedNumber[Counter, 1],
        " has chance ", ROUND(Chance, 4)
NEXT Counter

Why this is a complete response

It covers the mark-scheme requirements: 100 000 random integers between 1 and 10 generated and stored in RandomNumber[] (R1), the frequency of each integer counted into CountedNumber[] column 2 (R2), the counted number array sorted into descending order of frequency by adapting the given snippet (R3), chance = frequency / 100000 rounded to four decimal places (R4), and each integer output with its chance in stored order with suitable messages (R5) — plus the comments and declarations the three closing lines demand.

What to check before submitting

Check that every identifier appears in a DECLARE or CONSTANT line, that the range is 1 to 10 inclusive at both ends, that the sort comparison is < (descending) and swaps both columns, that the divisor is 100000, that ROUND uses four decimal places, and that the output loop walks the sorted rows.

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

Interactive execution trace

Visualisation: watch the fairness report build.

Step through a sample run. Watch RandomNumber[] fill with generated integers, the frequencies grow, the adapted bubble sort reorder the ten rows, and each chance print to four decimal places.

Last tab · Trace player

Sample input → expected results

The real program generates 100 000 random integers and divides every frequency by 100 000. This demonstration generates a sample of 40 integers (shown four to a row), so each chance here is frequency / 40. The sample deliberately includes integer 8, which is never generated (chance 0.0000), integer 4, generated only once (1 / 40 = 0.0250), and a tie — integers 5 and 10 are each generated 4 times, so both show 0.1000 and the strict < comparison keeps them in their stored order. These are illustrative values, not data supplied by the examination question.

Sample run RandomNumber[] — the 40 generated integers

Positions	1	2	3	4

Row and column give the array position: row 3, column 2 is RandomNumber[10]. The real program fills 100 000 positions; this sample stops at 40.

Reveal the sorted CountedNumber[] with chances

Expected results CountedNumber[] after the descending sort

Row	Integer	Frequency	Chance (4 dp)

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Run counters

Ready

Tip: use Next step slowly and watch Counter fill and then re-read the sample data, Frequency grow during counting, and the swap flag F during the sort. The frequencies total never changes after counting — swaps only reorder rows.

Trace colours: blue row = current row of the sample data; amber cell = the position just written or read; green cells = positions already processed.

Worked examples: integer 7 is generated 8 of the 40 times, so chance = 8 / 40 = 0.2, printed as 0.2000 to four decimal places. Integer 8 is never generated, so its chance is 0.0000. In the real run a frequency such as 10 072 gives 10 072 / 100 000 = 0.10072, which ROUND trims to 0.1007.

From 100 000 random integers to a fairness report.

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

Generate and store 100 000 random integers

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Count each frequency into CountedNumber[]

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Adapt the given sort to descending frequency

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Calculate each chance and output the sorted report

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Assemble the program and audit the closing lines

🧠 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 fairness report build.

Sample input → expected results

Sample run RandomNumber[] — the 40 generated integers

Expected results CountedNumber[] after the descending sort

Execution trace

Initialisation

Live variable values

Run counters