Why is "Treating the range as exclusive — writing `RANDOM_INT(1, 5)` for a six-sided dice, or `RANDOM_INT(0, 6)`." a common mistake in Random number generation in a programming language?

Why it happens: Some real programming languages do exclude the upper bound (Python's `range` and `random.randrange` both stop one short), so students transfer that behaviour to AQA pseudo-code. How to avoid it: In AQA pseudo-code `RANDOM_INT(a, b)` **includes both endpoints**. A dice is `RANDOM_INT(1, 6)`. Check by listing the possible values, or by counting with `b − a + 1` — six values means the range is right. Source: The range is where the mark is awarded in 'write the call' questions, so an off-by-one here loses it outright.

Why is "Using `RANDOM_INT(0, LEN(a))` to pick an array index instead of `RANDOM_INT(0, LEN(a) - 1)`." a common mistake in Random number generation in a programming language?

Why it happens: `LEN(a)` feels like the natural upper limit, and the resulting bug only triggers when that specific index happens to be generated — so the program appears to work most of the time. How to avoid it: An n-element array has indices **0 to n−1**, so the largest valid index is one less than the length. Remember this bug is **intermittent**: with a 5-element array it crashes roughly one run in six, which means it can survive extensive testing before failing in use. Source: This is the same off-by-one as array traversal in 3.2.6 and appears in error-identification questions.

Why is "Calling the random generator twice when a single value was needed in two places." a common mistake in Random number generation in a programming language?

Why it happens: The call reads like a value rather than an action, so writing it again feels equivalent to referring to the same number — the fact that each call produces something new is not visible in the code. How to avoid it: **Generate once, store in a variable, use the variable.** Ask yourself whether the program needs **one value used twice** or **two genuinely independent values** — two dice legitimately need two calls, but a single roll that is both tested and reported needs one. Source: This produces a logic error with no error message, and is a standard fault in random-number debugging questions.

Why is "Placing the generation of a game's target inside the guessing loop instead of before it." a common mistake in Random number generation in a programming language?

Why it happens: The call sits naturally alongside the other statements that belong to each turn, and the consequence is only visible if you trace two iterations and notice the target has changed. How to avoid it: Ask **how often this value should change**. A secret number must stay fixed for the whole game, so it is generated **once, before** the loop. A value that should differ each turn — an enemy's attack strength, say — belongs inside. Trace two iterations to check. Source: Placement errors of this kind make a game unwinnable and are a recurring fault in error-identification questions.

Why is "Assuming that picking several random items will automatically produce different ones." a common mistake in Random number generation in a programming language?

Why it happens: Intuitively a random selection 'ought' to spread out, and with a large range duplicates are rare enough that casual testing does not reveal them. How to avoid it: Each call is **independent** and has no memory of previous ones, so repeats are always possible. To prevent them you must either **track which items have been used** with a Boolean array and re-pick, or **remove** each chosen item from the list once selected. Source: Lottery-number and quiz-question scenarios are set specifically to test whether this has been understood.

Why is "Spending revision time learning how pseudo-random number generators work internally." a common mistake in Random number generation in a programming language?

Why it happens: The word 'pseudo-random' invites curiosity, and wider reading or A-level material covers seeds and generating algorithms in detail. How to avoid it: The specification states plainly that **an understanding of how pseudo-random numbers are generated is not required**. Every available mark is for **using** the generator correctly — the right range, the right placement relative to a loop, and storing the value when it must be reused. Revise those instead. Source: AQA 8525 specification 3.2.9 additional information: 'An understanding of how pseudo-random numbers are generated is not required.'

AQA GCSE Computer Science (8525)

Random number generation in a programming language

0% Complete

Detailed Study Notes

Detailed notes on Programming for AQA GCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Random Number Generation — AQA GCSE Computer Science 8525 (3.2.9)

The smallest subtopic in the whole specification, with one requirement — be able to use random number generation within your programs — and one very clear exclusion: an understanding of how pseudo-random numbers are generated is not required. So you will never be asked how the generator works internally. What you will be asked is to use it correctly inside an algorithm, and that means getting the range right, which is where every mark in this subtopic is won or lost.

At a glance

The requirement is simply to use random number generation inside programs.
How pseudo-random numbers are generated internally is NOT required — an explicit specification exclusion.
RANDOM_INT(a, b) returns a whole number between a and b, inclusive of both ends.
Inclusive means RANDOM_INT(1, 6) can return 1, 2, 3, 4, 5 or 6 — a fair dice roll.
To pick a random element of an array, use RANDOM_INT(0, LEN(a) - 1) — array indices start at 0.
A random number must be stored in a variable if you want to use the same value more than once.
Calling the generator twice gives two different values, which is a very common bug.
Random values make a program non-deterministic, which makes testing harder.
Typical uses: dice, card shuffling, game enemies, lottery numbers, random questions from a bank.

What you’ll learn

Mapped to the AQA GCSE 8525 syllabus (2027-2029).

Be able to use random number generation within your computer programs.
Know that an understanding of how pseudo-random numbers are generated is not required.

Generating a random number

One operation, one thing to get right: the range, which is inclusive at both ends.

Random number generation produces an unpredictable value within a stated range, so that a program behaves differently each time it runs.

In AQA pseudo-code:

RANDOM_INT(1, 6)

This returns a whole number between 1 and 6, including both 1 and 6.

Inclusive means inclusive

This is the single fact that carries the marks:

Call	Possible values	How many
`RANDOM_INT(1, 6)`	1, 2, 3, 4, 5, 6	6
`RANDOM_INT(0, 9)`	0, 1, 2, …, 9	10
`RANDOM_INT(1, 10)`	1, 2, 3, …, 10	10
`RANDOM_INT(5, 5)`	5	1

Both endpoints can be produced. A dice roll is RANDOM_INT(1, 6), not RANDOM_INT(1, 5) and not RANDOM_INT(0, 6).

Counting the possible values: b − a + 1. For RANDOM_INT(1, 6): 6 − 1 + 1 = 6. The + 1 exists precisely because both ends are included, and forgetting it is the classic off-by-one here.

Storing the result

diceRoll ← RANDOM_INT(1, 6)
OUTPUT 'You rolled ', diceRoll

You must store it in a variable if you want to use the same value twice. This is the most common bug in the subtopic:

# WRONG — generates TWO different numbers
IF RANDOM_INT(1, 6) = 6 THEN
    OUTPUT 'You rolled a ', RANDOM_INT(1, 6)
ENDIF

# RIGHT — one number, used twice
roll ← RANDOM_INT(1, 6)
IF roll = 6 THEN
    OUTPUT 'You rolled a ', roll
ENDIF

In the wrong version, the program could test a 6, then print a 2 — because each call to the generator produces a fresh value.

AQA tip. When a question gives you a range in words, translate it carefully. "A number from 1 to 100" is RANDOM_INT(1, 100). "A number between 1 and 100" almost always means the same thing at GCSE, but if a question ever needs the endpoints excluded it will say so explicitly.

RANDOM_INT(a, b) returns a whole number from a to b, INCLUDING both ends.
A fair dice is RANDOM_INT(1, 6) — six possible values.
Number of possible values = b − a + 1.
Store the result in a variable if you need to use it more than once.
Each call to the generator produces a fresh, different value.

See the full worked example for random number generation in a programming language →

Getting the range right — especially with arrays

The range must match what you are choosing from. Arrays start at 0.

Most exam marks here are for choosing the correct arguments.

Common ranges

Requirement	Correct call	Why
Roll a six-sided dice	`RANDOM_INT(1, 6)`	Faces are numbered 1 to 6
Toss a coin	`RANDOM_INT(0, 1)`	Two outcomes: 0 = heads, 1 = tails
A single random digit	`RANDOM_INT(0, 9)`	Digits run 0 to 9
Pick a card value	`RANDOM_INT(1, 13)`	Ace to King
Lottery number	`RANDOM_INT(1, 49)`	Balls numbered 1 to 49
A random percentage	`RANDOM_INT(0, 100)`	0% to 100% inclusive

Choosing a random element from an array

This is the most examined application, and the range depends on the index base:

names ← ['Amina', 'Ben', 'Chi', 'Dara', 'Eze']    # 5 elements, indices 0-4

index  ← RANDOM_INT(0, LEN(names) - 1)
chosen ← names[index]

Why LEN(names) - 1? The array has 5 elements at indices 0 to 4. LEN(names) is 5, but index 5 does not exist — using it would cause an out-of-range error. The − 1 is exactly the same off-by-one as array traversal in 3.2.6.

Because the fault only triggers when the generator happens to return 5, this bug can survive many test runs before appearing.

Why this bug is nasty. RANDOM_INT(0, LEN(names)) crashes only when it happens to return 5 — roughly one run in six. A program can be tested repeatedly and appear to work perfectly, then fail unpredictably in use. That is a genuinely instructive point about testing (3.2.11).

AQA tip. If a question indexes an array from 1 rather than 0, the call becomes RANDOM_INT(1, LEN(a)). Always check the index base before writing the range.

The range must match exactly what you are choosing from.
Random array index (0-based): RANDOM_INT(0, LEN(a) - 1).
RANDOM_INT(0, LEN(a)) can produce an invalid index and crash the program.
The bug appears only sometimes, which makes it hard to detect by testing.
If the array is indexed from 1, use RANDOM_INT(1, LEN(a)).

See the full worked example for random number generation in a programming language →

Using random numbers inside a program

Games, simulations and quizzes — combined with loops, selection and arrays.

Random numbers rarely appear alone; they are combined with the other constructs.

A guessing game — random plus indefinite iteration

target   ← RANDOM_INT(1, 100)
attempts ← 0

REPEAT
    OUTPUT 'Guess a number between 1 and 100'
    guess    ← STRING_TO_INT(USERINPUT)
    attempts ← attempts + 1

    IF guess < target THEN
        OUTPUT 'Too low'
    ELSE IF guess > target THEN
        OUTPUT 'Too high'
    ENDIF
UNTIL guess = target

OUTPUT 'Correct! You took ', attempts, ' attempts'

Note the target is generated ONCE, before the loop. Putting RANDOM_INT inside the loop would pick a new target on every guess and the game could never be won — a classic exam fault.

Rolling two dice — two separate calls

dice1 ← RANDOM_INT(1, 6)
dice2 ← RANDOM_INT(1, 6)
total ← dice1 + dice2

OUTPUT 'You rolled ', dice1, ' and ', dice2, ' — total ', total

Here two calls are correct, because you genuinely want two independent dice. Compare that with the earlier bug, where one value was needed twice. The question is always: do I want one value or two?

A random question from a bank

questions ← ['What is 2+2?', 'Capital of France?', 'Largest planet?']

FOR i ← 1 TO 3
    index ← RANDOM_INT(0, LEN(questions) - 1)
    OUTPUT questions[index]
    answer ← USERINPUT
ENDFOR

⚠️ This can repeat questions, because nothing stops the same index being chosen twice. Recognising that limitation — and suggesting that chosen questions be removed from the list or marked as used — is a strong AO3 observation.

Simulating probability

# A 30% chance of an event happening
IF RANDOM_INT(1, 100) ≤ 30 THEN
    OUTPUT 'Event happened'
ENDIF

RANDOM_INT(1, 100) gives 100 equally likely values, and exactly 30 of them (1 to 30) satisfy ≤ 30 — giving a 30% probability. Note the ≤: using < would give only 29 values and a 29% chance.

AQA tip. Generate a random value once, in the right place, and store it. Most faults in this subtopic are about where the call is placed rather than the call itself.

Generate a game's target ONCE before the loop, never inside it.
Two dice need two calls; one value used twice needs one call stored in a variable.
Picking randomly from a list can repeat unless chosen items are removed or marked.
RANDOM_INT(1, 100) ≤ 30 simulates a 30% probability — note the ≤.
Most errors are about WHERE the call is placed, not the call itself.

See the full worked example for random number generation in a programming language →

Why random programs are harder to test

Non-deterministic output means the same input can give different results.

A program using random numbers is non-deterministic: running it twice with the same input can produce different output. That has real consequences, and it is the most likely angle for a higher-tariff question.

The three problems

1. Results cannot be predicted, so expected output is hard to state. Normal testing compares actual output against expected output. With randomness, there is no single expected value — only a range of acceptable ones.

2. Bugs appear intermittently. The RANDOM_INT(0, LEN(a)) fault crashes roughly one run in six. A tester could run the program ten times and never see it.

3. Faults are hard to reproduce. If a program crashes once, you may not be able to make it happen again — and a bug you cannot reproduce is very hard to fix.

How testers cope

Approach	What it means
Test the range, not the value	Run many times and check every result falls between the limits
Test the boundaries	Confirm the lowest and highest values (e.g. 1 and 6) can both actually occur
Run many trials	Roll a dice 6000 times and check each face appears roughly 1000 times
Replace the generator temporarily	Substitute a fixed value while testing the rest of the logic

The most practical technique is the last one: temporarily replace RANDOM_INT(1, 6) with a fixed 3, test that everything else works, then put the random call back. That makes the program deterministic while you debug the parts that are not about randomness.

Linking to test data (3.2.11)

For a program using RANDOM_INT(1, 6):

Normal test data: 2, 3, 4, 5 — typical values it should handle.
Boundary test data: 1 and 6 — confirm both extremes really occur.
Erroneous: 0 and 7 — these should never be produced; if they ever appear, the range is wrong.

AQA tip. If asked why a random program is difficult to test, give the reason and a coping strategy. "You cannot predict the output, so instead you test that every value falls within the expected range and run it many times to check the boundaries occur" is a complete answer.

Random programs are non-deterministic — same input, different output.
Expected output cannot be stated as a single value, only as a range.
Bugs may appear only occasionally and be hard to reproduce.
Test by checking the range, running many trials, and confirming boundaries occur.
Temporarily replacing the generator with a fixed value makes debugging deterministic.

See the full worked example for random number generation in a programming language →

Quick recap

The requirement is simply to use random number generation within programs.
How pseudo-random numbers are generated internally is explicitly NOT required.
RANDOM_INT(a, b) returns a whole number from a to b, including both endpoints.
The number of possible values is b − a + 1.
A dice roll is RANDOM_INT(1, 6); a coin toss is RANDOM_INT(0, 1).
A random array index (0-based) is RANDOM_INT(0, LEN(a) - 1).
Store the result in a variable if the same value is needed more than once.
Generate a game's target once, before the loop — not inside it.
Random programs are non-deterministic, so test the range and run many trials.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

RANDOM_INT(a, b) includes BOTH endpoints.
A fair dice is RANDOM_INT(1, 6) — six possible values.
Number of possible values = b − a + 1.
A random array index (indexed from 0) is RANDOM_INT(0, LEN(a) - 1).
Store a random value in a variable if you need it twice — each call gives a NEW value.
Generate a game's target ONCE, before the loop.
Understanding how pseudo-random numbers are generated is NOT required.

How it’s examined

3.2.9 is assessed on Paper 1 and is never a large question in its own right — it appears as one or two marks inside a larger algorithm, typically a game or simulation. Three shapes recur. (1) State the correct call, 1–2 marks: write the expression that rolls a dice or picks a random element from an array (AO2) — the mark is for the range, including LEN(a) - 1 when indexing an array. (2) Find the fault, 2–4 marks: identify why a program generates a new value when it should reuse one, why the target is regenerated inside the loop, or why an array index goes out of range (AO3). (3) Testing, 3–6 marks: explain why a program using random numbers is harder to test, and how you would test it anyway (AO3) — this is where the higher marks sit. The specification's exclusion is worth banking: 'an understanding of how pseudo-random numbers are generated is not required', so you will never be asked about seeds or algorithms internally. Every mark is about using the generator correctly, and the errors that cost most are the inclusive-range off-by-one and placing the call in the wrong position relative to a loop.

Sources: AQA GCSE Computer Science 8525 specification (v1.3, 16 June 2025) — 3.2.9 Random number generation in a programming language; AQA GCSE Computer Science 8525 standard pseudo-code reference document; AQA GCSE Computer Science Paper 1 past papers, mark schemes and examiner reports. Last reviewed 2026-07-28.

Take this whole topic with you

Step-by-step worked examples — Random number generation in a programming language

Step-by-step solutions to past-paper-style questions on random number generation in a programming language, written exactly the way a tutor would explain them at the board.

Question type:

1Write calls with the correct inclusive range (4 marks)
Getting startedIdentify & classify• Paper 1 style — 4 marks (AO2)• random, range, inclusive
Question
RANDOM_INT(a, b) returns a whole number from a to b inclusive.

Write the call that generates:

(a) a roll of a six-sided dice (b) a coin toss, where 0 is heads and 1 is tails (c) a single random digit (d) State how many different values RANDOM_INT(1, 6) can produce. (4 marks)
Step-by-step solution
1. Step 1
  (a) A dice has faces numbered 1 to 6, and both ends must be possible, so RANDOM_INT(1, 6).
2. Step 2
  (b) Two outcomes, given as 0 and 1, so RANDOM_INT(0, 1).
3. Step 3
  (c) Digits run from 0 to 9, so RANDOM_INT(0, 9).
4. Step 4
  (d) Count using b − a + 1: 6 − 1 + 1 = 6. The + 1 is there because both endpoints are included.
  $6 - 1 + 1 = 6$
Answer
(a) RANDOM_INT(1, 6) (1) (b) RANDOM_INT(0, 1) (1) (c) RANDOM_INT(0, 9) (1) (d) 6 different values — 1, 2, 3, 4, 5 and 6. The count is b − a + 1 = 6 − 1 + 1 = 6, and the + 1 exists because both endpoints are included (1). (4)
Examiner tip
Everything here turns on the range being inclusive at both ends. Writing RANDOM_INT(1, 5) for a dice loses the 6, and RANDOM_INT(0, 6) adds an impossible 0 — either would make the dice unfair. Part (d) tests the off-by-one directly: five is the tempting wrong answer.
2Store a random value so it can be reused (3 marks)
Getting startedIdentify & classify• Paper 1 style — 3 marks (AO3)• random, variable, debugging
Question
A student writes the code below to report a winning dice roll, but the number reported is sometimes different from the number that triggered the message. Explain why, and write a corrected version. (3 marks)

IF RANDOM_INT(1, 6) = 6 THEN OUTPUT 'You rolled a ', RANDOM_INT(1, 6) ENDIF
Step-by-step solution
1. Step 1
  Identify. RANDOM_INT is called twice — once in the condition and once in the output.
2. Step 2
  Explain. Each call generates a completely new value, so the number tested by the IF is not the number printed. The condition might see a 6 while the output prints a 2.
3. Step 3
  Fix. Call the generator once, store the result in a variable, then use that variable in both places.
Answer
RANDOM_INT is called twice, and each call produces a new, independent value (1). The number tested by the IF condition is therefore not the same number that is printed — the condition could detect a 6 while the output displays a completely different value such as 2 (1).

Corrected version:

roll ← RANDOM_INT(1, 6) IF roll = 6 THEN OUTPUT 'You rolled a ', roll ENDIF

(1)
Examiner tip
This is the most common random-number bug and produces a logic error — the program runs without any error message and simply reports the wrong number. The rule is simple: if you need the same random value more than once, generate it once and store it in a variable.
3Pick a random element from an array (3 marks)
Getting startedMulti-step problem• Paper 1 style — 3 marks (AO2)• random, array, index
Question
The array names holds 5 names at indices 0 to 4.

(a) Write the code that selects and outputs one name at random. (b) Explain why RANDOM_INT(0, LEN(names)) would be incorrect. (3 marks)
Step-by-step solution
1. Step 1
  (a) Match the range to the valid indices. The array is indexed 0 to 4, so the call must be RANDOM_INT(0, LEN(names) - 1).
2. Step 2
  Store the index, then use it to access the array element.
3. Step 3
  (b) LEN(names) is 5, but index 5 does not exist in an array indexed 0 to 4. Choosing it would cause an out-of-range error and crash the program.
Answer
(a)

index ← RANDOM_INT(0, LEN(names) - 1) chosen ← names[index] OUTPUT chosen

(1 for the correct range, 1 for using it to access the array.)

(b) LEN(names) returns 5, but the array's valid indices are only 0 to 4 — index 5 does not exist. If the generator happened to return 5, accessing names[5] would cause an out-of-range error and the program would crash (1).
Examiner tip
The - 1 is the same off-by-one as array traversal in 3.2.6, and for the same reason: an n-element array has indices 0 to n−1. What makes this bug particularly dangerous is that it only triggers when the generator happens to return the invalid index — roughly one run in six here — so the program can pass many tests before failing in use.
4Write a number guessing game (5 marks)
Building confidenceMulti-step problem• Paper 1 style — 5 marks (AO3)• random, loop, game, write-algorithm
Question
Write an algorithm using pseudo-code for a guessing game. The program should pick a random whole number between 1 and 100, then keep asking the user to guess until they are correct, telling them each time whether their guess was too high or too low. Finally it should report how many attempts they took. (5 marks)
Step-by-step solution
1. Step 1
  Generate the target ONCE, before the loop. If the call were inside the loop, a new target would be chosen on every guess and the game could never be won.
2. Step 2
  Initialise the attempt counter to 0 before the loop.
3. Step 3
  Choose the loop. The number of guesses is unknown, and a guess must be made before it can be checked — so condition at the end (REPEAT…UNTIL).
4. Step 4
  Inside the loop: prompt, read and convert the guess, increment the counter, then use nested selection to report too low or too high.
5. Step 5
  Report after the loop, once the guess has matched the target.
Answer
target ← RANDOM_INT(1, 100) attempts ← 0 REPEAT OUTPUT 'Guess a number between 1 and 100' guess ← STRING_TO_INT(USERINPUT) attempts ← attempts + 1 IF guess < target THEN OUTPUT 'Too low' ELSE IF guess > target THEN OUTPUT 'Too high' ENDIF UNTIL guess = target OUTPUT 'Correct! You took ', attempts, ' attempts'

Marks: RANDOM_INT(1, 100) with the correct inclusive range, generated before the loop (1); attempts initialised to 0 (1); REPEAT…UNTIL loop with the input inside it (1); correct too-low / too-high selection (1); counter incremented and the final message output after the loop (1). (5)
Examiner tip
The placement of RANDOM_INT is the mark that separates a working game from a broken one: inside the loop, a fresh target would be chosen on every guess and the UNTIL guess = target condition could only ever be satisfied by coincidence. Note also that the too-low and too-high tests need no ELSE for the equal case, because the loop exits as soon as they match.
5Decide how many calls are needed (4 marks)
Building confidenceWord problem• Paper 1 style — 4 marks (AO2/AO3)• random, multiple-calls, dice
Question
A board game rolls two six-sided dice and outputs both values and their total.

(a) Write the algorithm. (b) Explain why this requires two calls to RANDOM_INT, whereas the program in an earlier question needed only one. (4 marks)
Step-by-step solution
1. Step 1
  (a) Two dice are independent, so each needs its own call, and each result is stored in its own variable.
2. Step 2
  Calculate the total by adding the two stored values.
3. Step 3
  (b) The distinguishing question is: do I want one value or two? Two dice genuinely produce two independent results, so two calls are correct.
4. Step 4
  By contrast, when a single roll must be both tested and reported, that is one value used twice — so one call, stored in a variable.
Answer
(a)

dice1 ← RANDOM_INT(1, 6) dice2 ← RANDOM_INT(1, 6) total ← dice1 + dice2 OUTPUT 'You rolled ', dice1, ' and ', dice2, ' — total ', total

(1 for two separate calls with the correct range, 1 for storing each in its own variable, 1 for the correct total and output.)

(b) Two calls are correct here because the two dice are independent — each should produce its own result, and they may well differ (1). In the earlier program only one roll took place, and that single value needed to be used twice (once in the condition and once in the output), so it had to be generated once and stored in a variable. The deciding question is always whether the program needs one value used more than once, or several genuinely different values.
Examiner tip
This pairs deliberately with the earlier 'store the value' example to test whether the rule has been understood rather than memorised. Multiple calls are not a bug in themselves — they are exactly right when independent values are wanted. The fault is only calling twice when one value was needed twice.
6Simulate a stated probability (4 marks)
Building confidenceMulti-step problem• Paper 1 style — 4 marks (AO2/AO3)• random, probability, condition
Question
In a game, an enemy appears with a 25% probability each turn.

(a) Write the selection statement that simulates this. (b) Explain how it produces a 25% chance. (c) State what would happen if < were used instead of ≤. (4 marks)
Step-by-step solution
1. Step 1
  (a) Generate a number from 1 to 100, then act if it falls in the first quarter: IF RANDOM_INT(1, 100) ≤ 25 THEN.
2. Step 2
  (b) RANDOM_INT(1, 100) produces 100 equally likely values. Exactly 25 of them (1 to 25) satisfy ≤ 25.
3. Step 3
  So the probability is 25 out of 100 = 25%.
  $\frac{25}{100} = 25\%$
4. Step 4
  (c) With <, only the values 1 to 24 would qualify — 24 values out of 100, giving a 24% chance rather than 25%.
Answer
(a)

IF RANDOM_INT(1, 100) ≤ 25 THEN OUTPUT 'An enemy appears!' ENDIF

(1)

(b) RANDOM_INT(1, 100) produces 100 equally likely values (1). Exactly 25 of those — the numbers 1 to 25 — satisfy the condition ≤ 25, so the branch is taken 25 times out of every 100 on average, which is a probability of 25% (1).

(c) Using < would exclude the value 25 itself, leaving only the numbers 1 to 24 — 24 values out of 100 — so the enemy would appear with a 24% probability rather than the required 25% (1).
Examiner tip
Part (c) shows that the boundary operator choice from 3.2.4 has a directly measurable consequence here: one character changes the probability by a full percentage point. A neat alternative worth knowing is RANDOM_INT(1, 4) = 1, which gives exactly one chance in four, and avoids the boundary issue entirely.
7Select random items without repeats (6 marks)
StretchMulti-step problem• Paper 1 style — 6 marks (AO3)• random, array, no-repeats, validation
Question
A quiz picks 3 questions at random from an array of 10. A student writes the code below, but the same question sometimes appears more than once.

FOR i ← 1 TO 3 index ← RANDOM_INT(0, 9) OUTPUT questions[index] ENDFOR

(a) Explain why questions repeat. (b) Describe one way to prevent repeats. (c) Write an improved algorithm. (6 marks)
Step-by-step solution
1. Step 1
  (a) Each iteration generates an index independently, with nothing recording which indices have already been used — so the same index can be chosen again.
2. Step 2
  (b) Method 1 — track what has been used. Keep a parallel Boolean array marking each question as used, and keep re-picking until an unused index is found.
3. Step 3
  Method 2 — remove the chosen question from the list once used, so it cannot be selected again. (Either method is creditworthy.)
4. Step 4
  (c) Use the tracking method: a used array initialised to all False, and an inner REPEAT…UNTIL that keeps picking until an unused index appears.
5. Step 5
  Mark the index as used immediately after selecting it, so it cannot be chosen on a later pass.
6. Step 6
  Note the structure: a definite outer loop (3 questions, known) containing an indefinite inner loop (unknown number of re-picks).
Answer
(a) Each iteration calls RANDOM_INT(0, 9) independently, and the algorithm keeps no record of which indices have already been used — so nothing prevents the same index being generated two or three times (1).

(b) One solution is to maintain a parallel Boolean array marking which questions have been used, and to keep generating a new index until an unused one is found (1). An equally valid alternative is to remove each chosen question from the array once it has been asked, so it can no longer be selected (1).

(c)

used : ARRAY[0:9] OF Boolean FOR i ← 0 TO 9 used[i] ← False ENDFOR FOR q ← 1 TO 3 REPEAT index ← RANDOM_INT(0, 9) UNTIL used[index] = False OUTPUT questions[index] used[index] ← True ENDFOR

Marks: used array initialised to all False (1); inner indefinite loop that re-picks until an unused index is found (1); index marked as used after selection so it cannot recur (1). (6)
Examiner tip
This is the classic 'random without replacement' problem and rewards recognising that the outer loop is definite (3 questions, known) while the inner re-picking loop must be indefinite (unknown number of attempts). A strong extra observation is that this approach becomes inefficient if nearly all items have been used — with 9 of 10 taken, the inner loop may re-pick many times — which is why removing items from the list scales better.
8Explain how to test a program using random numbers (6 marks)
StretchWord problem• Paper 1 style — 6 marks (AO3)• testing, random, non-deterministic
Question
A program simulates rolling a dice using RANDOM_INT(1, 6). Explain why this program is harder to test than one without random numbers, and describe how it could be tested effectively. (6 marks)
Step-by-step solution
1. Step 1
  Why it is harder — unpredictable output. Normal testing compares actual output against a single expected value, but here the output legitimately differs on every run.
2. Step 2
  Why it is harder — intermittent bugs. A fault triggered by only one value (such as an out-of-range index) may not appear for many runs.
3. Step 3
  Why it is harder — hard to reproduce. A crash that happens once may not happen again, and a bug you cannot reproduce is very hard to fix.
4. Step 4
  How to test — check the range. Run the program many times and confirm every result lies between 1 and 6.
5. Step 5
  How to test — check the boundaries and distribution. Confirm that 1 and 6 both actually occur, and over many trials that each face appears roughly equally often.
6. Step 6
  How to test — remove the randomness temporarily. Replace the call with a fixed value so the rest of the logic can be tested deterministically.
Answer
Why it is harder to test. A program using random numbers is non-deterministic — running it twice with the same input can produce different output — so there is no single expected result to compare the actual output against, which is how testing normally works (1). Faults may also appear only intermittently: a bug triggered by one particular value might not show up for many runs, so the program can pass repeated testing and still fail in use (1). And because the values cannot be predicted, a fault that does occur may be very difficult to reproduce, making it hard to diagnose and fix (1).

How it could be tested effectively. Rather than testing for a specific value, test that every result falls within the expected range of 1 to 6, running the program many times to gain confidence (1). Check the boundary values specifically — confirm that both 1 and 6 can actually be produced, since an incorrect range such as RANDOM_INT(1, 5) would never reveal itself otherwise — and check that no value outside the range, such as 0 or 7, ever appears (1). Over a large number of trials the distribution can also be checked: rolling 6000 times should produce roughly 1000 of each face. Finally, the randomness can be temporarily removed by replacing RANDOM_INT(1, 6) with a fixed value such as 3, making the program deterministic so that the rest of its logic can be tested reliably before the random call is restored (1). (6)
Examiner tip
The strongest single technique, and the one that most clearly demonstrates AO3 judgement, is temporarily replacing the generator with a fixed value — it isolates the randomness from the logic being tested. Note how this question links directly to 3.2.11: the range 1–6 has normal test data (2–5), boundary data (1 and 6) and erroneous data (0 and 7, which should never occur).
9Find and fix the random number errors (6 marks)
StretchIdentify & classify• Paper 1 style — 6 marks (AO3)• debugging, random, identify-error, loop
Question
The algorithm below should pick a random secret number between 1 and 10 and give the user three attempts to guess it. It has three faults. Identify each, explain its effect, and write a corrected version. (6 marks)

1 attempts ← 0 2 REPEAT 3 secret ← RANDOM_INT(1, 10) 4 OUTPUT 'Guess the number' 5 guess ← STRING_TO_INT(USERINPUT) 6 attempts ← attempts + 1 7 UNTIL guess = secret 8 OUTPUT 'Correct!'
Step-by-step solution
1. Step 1
  Fault 1 — line 3 is inside the loop. A new secret number is chosen before every guess, so the user is effectively guessing a different number each time.
2. Step 2
  Its effect. The user can only win by coincidence, and the game becomes unfair and essentially unwinnable by skill.
3. Step 3
  Fault 2 — the three-attempt limit is never enforced. attempts is counted but never tested, so the loop continues indefinitely until the user guesses correctly.
4. Step 4
  Fix 2. Add the attempt limit to the loop condition with a compound condition: UNTIL guess = secret OR attempts = 3.
5. Step 5
  Fault 3 — 'Correct!' is output unconditionally. After the loop ends, the message is printed even when the user has run out of attempts without guessing correctly.
6. Step 6
  Fix 3. Use selection after the loop to report success or failure appropriately.
Answer
Fault 1 — line 3 is inside the loop (1). A new secret number is generated before every single guess, so the user is guessing against a different target each time and can only win by pure coincidence. The generation must happen once, before the loop (1).

Fault 2 — the three-attempt limit is never enforced (1). attempts is incremented but never tested, so the loop continues until the user guesses correctly, however many tries that takes. The limit must be part of the loop condition (1).

Fault 3 — 'Correct!' is output unconditionally (1). Once the fix for Fault 2 is applied, the loop can end because the attempts ran out rather than because the guess was right, so the message would wrongly congratulate a user who failed. A selection statement is needed after the loop (1).

Corrected version:

secret ← RANDOM_INT(1, 10) attempts ← 0 REPEAT OUTPUT 'Guess the number' guess ← STRING_TO_INT(USERINPUT) attempts ← attempts + 1 UNTIL guess = secret OR attempts = 3 IF guess = secret THEN OUTPUT 'Correct!' ELSE OUTPUT 'Out of attempts — the number was ', secret ENDIF
Examiner tip
The three faults are connected, which is what makes this a stretch question: fixing the attempt limit creates the need for Fault 3's fix, because the loop can now end in two different ways. Recognising that a compound exit condition requires you to determine which condition ended the loop is exactly the kind of reasoning top-band answers show.

Model Answers — Random number generation in a programming language

High-scoring sample answers for random number generation in a programming language on the AQA GCSE 8525 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
Paper 1 style — AO21 mark
Write the statement that stores the result of rolling a fair six-sided dice in the variable roll. (1 mark)
Model answer
roll ← RANDOM_INT(1, 6) (1)
Why this scores
Both endpoints must be included, since a dice can show either 1 or 6. RANDOM_INT(1, 5) and RANDOM_INT(0, 6) are the two wrong versions, each making the dice unfair in a different way.
Question 2
Paper 1 style — AO11 mark
State what the specification says is not required regarding random number generation. (1 mark)
Model answer
An understanding of how pseudo-random numbers are generated is not required (1).
Why this scores
This is an explicit exclusion in the specification's additional information column. You will never be asked about seeds, algorithms or the internal workings of the generator — every mark in this subtopic is for using random number generation correctly within a program.
Question 3
Paper 1 style — AO22 marks
State how many different values RANDOM_INT(3, 12) can produce, and show your working. (2 marks)
Model answer
The range is inclusive of both endpoints, so the count is b − a + 1 = 12 − 3 + 1 (1) = 10 values — the numbers 3, 4, 5, 6, 7, 8, 9, 10, 11 and 12 (1).
Why this scores
The tempting wrong answer is 9, obtained by simple subtraction. The + 1 is essential because both 3 and 12 are themselves possible outcomes — listing the values is a quick way to confirm the count if you are unsure.
Question 4
Paper 1 style — AO23 marks
An array prizes holds 8 prizes at indices 0 to 7. Write the code that selects one at random, and explain why the upper limit of the range is not 8. (3 marks)
Model answer
index ← RANDOM_INT(0, LEN(prizes) - 1) OUTPUT prizes[index]

(1 for the correct range, 1 for using the index to access the array.)

The upper limit is 7, not 8, because the array is indexed from 0 — so 8 elements occupy indices 0 to 7 and index 8 does not exist (1). Using RANDOM_INT(0, 8) would sometimes generate the index 8, causing an out-of-range error that crashes the program.
Why this scores
Writing LEN(prizes) - 1 rather than the literal 7 is better practice, because the code continues to work if the number of prizes changes. Note the danger of this bug: it only triggers when the generator happens to return 8, so the program may pass many tests before failing.
Question 5
Paper 1 style — AO33 marks
A game generates a secret number and lets the user guess repeatedly until they are correct. Explain where the RANDOM_INT call must be placed and why. (3 marks)
Model answer
The call must be placed before the loop begins, so the secret number is generated once (1). If it were placed inside the loop, a new secret number would be generated before every guess (1), which means the user would be guessing against a different target each time and could only ever win by coincidence — making the game unfair and effectively unwinnable (1).
Why this scores
This is a placement question rather than a syntax question, and it is where most random-number marks are actually lost. The general principle is worth carrying: a random value that must stay fixed for the duration of a process is generated once, before that process starts.
Question 6
Paper 1 style — AO2/AO33 marks
Write a selection statement that simulates an event happening with a 10% probability, and explain how it works. (3 marks)
Model answer
IF RANDOM_INT(1, 100) ≤ 10 THEN OUTPUT 'The event happened' ENDIF

(1)

RANDOM_INT(1, 100) produces 100 equally likely values (1). Exactly 10 of them — the numbers 1 to 10 — satisfy the condition ≤ 10, so on average the branch is taken 10 times out of every 100, giving a probability of 10% (1).

An equally valid alternative is IF RANDOM_INT(1, 10) = 1 THEN, which gives exactly one chance in ten.
Why this scores
Note the ≤ rather than <: using < would exclude the value 10 and give a 9% probability instead. The alternative RANDOM_INT(1, 10) = 1 sidesteps the boundary question entirely and is worth knowing as a cleaner solution when the probability is a simple fraction.
Question 7
Paper 1 style — AO38 marks
Write an algorithm using pseudo-code that generates 6 different lottery numbers between 1 and 49, storing them in an array called numbers. No number may appear twice. (8 marks)
Model answer
count ← 0 WHILE count < 6 candidate ← RANDOM_INT(1, 49) isDuplicate ← False FOR i ← 0 TO count - 1 IF numbers[i] = candidate THEN isDuplicate ← True ENDIF ENDFOR IF isDuplicate = False THEN numbers[count] ← candidate count ← count + 1 ENDIF ENDWHILE FOR i ← 0 TO 5 OUTPUT numbers[i] ENDFOR

Marks: count initialised to 0 (1); indefinite outer loop continuing until 6 numbers have been stored (1); RANDOM_INT(1, 49) with the correct inclusive range (1); isDuplicate flag reset to False for each candidate (1); inner loop comparing the candidate against every number stored so far (1); duplicate correctly detected and flagged (1); candidate stored and count incremented only when it is not a duplicate (1); all six numbers output after the loop (1). (8)
Why this scores
Two design points carry the hardest marks. The outer loop must be indefinite — you cannot know how many candidates will be rejected as duplicates, so a FOR loop counting to 6 would not work. And count must be incremented only inside the not-a-duplicate branch; incrementing it unconditionally would leave gaps in the array. Note the inner loop runs to count - 1, checking only the numbers already stored.
Question 8
Paper 1 style — AO36 marks
A student says: 'You cannot test a program that uses random numbers, because you never know what it will output.' Discuss this statement. (6 marks)
Model answer
There is truth in the statement. A program using random numbers is non-deterministic, so the same input can produce different output on different runs, and there is no single expected result to compare against in the way conventional testing requires (1). Faults may also appear only intermittently — a bug triggered by one particular value might not surface for many runs — so a program can pass repeated testing and still fail in use, and any fault that does occur may be very hard to reproduce (1).

However, the statement is wrong to conclude that testing is impossible. Instead of testing for a specific value, you test that the output always falls within the expected range — for a dice, that every result is between 1 and 6 (1). You test the boundaries specifically, confirming both 1 and 6 can actually occur, since a faulty range such as RANDOM_INT(1, 5) would otherwise pass unnoticed, and confirming that values outside the range never appear (1).

Over many trials the distribution can also be checked — 6000 rolls should give roughly 1000 of each face — which would expose a generator biased towards particular values (1).

Most usefully, the randomness can be temporarily removed during development by replacing the random call with a fixed value, making the program fully deterministic so that all the surrounding logic can be tested conventionally before the random call is restored (1). (6)
Why this scores
A 'discuss' question requires you to engage with both sides: concede what is genuinely true about the difficulty, then refute the conclusion. The strongest technique to name is temporarily replacing the generator with a fixed value, because it separates the randomness from the logic under test. Weak answers simply agree with the statement and stop.
Question 9
Paper 1 style — AO36 marks
Explain how random number generation could be used to shuffle an array of 52 playing cards into a random order, and state one advantage of shuffling in place over building a new array. (6 marks)
Model answer
The method. Work through the array one position at a time. For each position i, generate a random index somewhere in the remaining unshuffled part of the array (1), then swap the card at position i with the card at that random index (1). Because a swap is used rather than a copy, no card can ever be lost or duplicated — every card simply ends up somewhere different (1).

FOR i ← 0 TO 50 j ← RANDOM_INT(i, 51) temp ← cards[i] cards[i] ← cards[j] cards[j] ← temp ENDFOR

(1 for correct use of RANDOM_INT with a valid range, 1 for a correct three-line swap using a temporary variable.)

Advantage of shuffling in place. It uses far less memory, because the cards are rearranged within the existing array rather than requiring a second array of 52 elements to be created and held simultaneously (1). It also avoids the risk, present in a naive 'pick a random card and copy it across' approach, of selecting the same card twice — since swapping guarantees every card appears exactly once.
Why this scores
You are not required to know this algorithm by name, but the reasoning is highly creditworthy: swapping guarantees no duplicates and no losses, which is precisely the problem that defeats a naive random-selection approach. The three-line swap with a temporary variable links back to 3.1.4, and the memory argument links to the in-place discussion of bubble sort versus merge sort.

Key Formulae — Random number generation in a programming language

The formulae you need to memorise for random number generation in a programming language on the AQA GCSE 8525 paper, with every variable defined in plain English and a note on when to use it.

Number of values a random range can produce
$\text{count} = b - a + 1$
$a$
The lowest value the generator can return
$b$
The highest value the generator can return
When to use
When asked how many different values a call can produce, or when checking a range covers exactly the outcomes required. The + 1 exists because both endpoints are included.
Example
RANDOM_INT(1, 6) gives 6 − 1 + 1 = 6 possible values.
Random index for a zero-indexed array
$\text{index} = \text{RANDOM\_INT}(0, \text{LEN}(a) - 1)$
$a$
The array being selected from
$LEN(a)$
The number of elements it holds
When to use
Selecting a random element from an array indexed from 0. Omitting the − 1 allows an index equal to the length, which does not exist and causes an out-of-range error.
Example
A 5-element array has indices 0 to 4, so use RANDOM_INT(0, 4).

Key Definitions and Keywords — Random number generation in a programming language

Definitions to memorise and the exact keywords mark schemes credit for random number generation in a programming language answers — sharpened from recent examiner reports for the 2026 AQA GCSE 8525 sitting.

Random number generation
Examiner keyword
Producing an unpredictable value within a stated range, so that a program behaves differently each time it runs. The specification requires students to use it, but not to understand how it works internally.
Example
roll ← RANDOM_INT(1, 6)
Related: Pseudo random, Range
RANDOM_INT(a, b)
Examiner keyword
The AQA pseudo-code operation returning a random whole number from a to b, inclusive of both endpoints.
Example
RANDOM_INT(1, 6) can return 1, 2, 3, 4, 5 or 6.
Related: Inclusive range, Random number generation
Inclusive range
Examiner keyword
A range in which both the lower and upper limits are themselves possible outcomes. The number of values produced is b − a + 1.
Example
RANDOM_INT(1, 6) produces 6 − 1 + 1 = 6 different values.
Related: RANDOM_INT(a, b)
Pseudo-random
Examiner keyword
Describes numbers produced by a deterministic formula that merely appear random. Understanding how they are generated is explicitly not required by the specification.
Related: Random number generation, Non deterministic
Non-deterministic
Examiner keyword
Describes a program whose output can differ between runs even with the same input. Random number generation makes a program non-deterministic, which complicates testing.
Related: Testing, Pseudo random
Random index
Examiner keyword
A randomly generated position used to select an element of an array. For a zero-indexed array it must be RANDOM_INT(0, LEN(a) - 1) to stay within range.
Related: Out of range error, Array
Intermittent bug
Examiner keyword
A fault that appears only sometimes, because it depends on a particular random value being generated. Hard to detect by testing and hard to reproduce.
Example
RANDOM_INT(0, LEN(a)) crashes only when it happens to return the invalid index.
Related: Non deterministic, Testing
Selection without repeats
Choosing several random items with no duplicates, achieved by tracking which have been used and re-picking, or by removing each chosen item from the list.
Example
Picking 6 different lottery numbers, or 3 different quiz questions.
Related: Random index, Boolean flag
Simulating probability
Examiner keyword
Using a random number and a comparison to make an event occur with a stated likelihood.
Example
IF RANDOM_INT(1, 100) ≤ 25 THEN gives a 25% chance.
Related: RANDOM_INT(a, b), Relational operator
Replacing the generator for testing
Examiner keyword
Temporarily substituting a fixed value for a random call so the program becomes deterministic and the surrounding logic can be tested conventionally.
Related: Testing, Non deterministic
Off-by-one error (random ranges)
Examiner keyword
A range that is one value too wide or too narrow, most often caused by forgetting that RANDOM_INT includes both endpoints, or by mismatching a 1-based range to a 0-based array index.
Related: Inclusive range, Random index
Storing the result
Examiner keyword
Assigning a random call to a variable so the same value can be used more than once. Calling the generator again produces a different value, which is a common source of bugs.
Related: Random number generation, Intermittent bug

Common Mistakes and Misconceptions — Random number generation in a programming language

The traps other students keep falling into on random number generation in a programming language questions — taken from recent AQA GCSE 8525 examiner reports and mark schemes — and how to avoid them.

✕Treating the range as exclusive — writing RANDOM_INT(1, 5) for a six-sided dice, or RANDOM_INT(0, 6).
The range is where the mark is awarded in 'write the call' questions, so an off-by-one here loses it outright.
Why it happens
Some real programming languages do exclude the upper bound (Python's range and random.randrange both stop one short), so students transfer that behaviour to AQA pseudo-code.
How to avoid it
In AQA pseudo-code RANDOM_INT(a, b) includes both endpoints. A dice is RANDOM_INT(1, 6). Check by listing the possible values, or by counting with b − a + 1 — six values means the range is right.
✕Using RANDOM_INT(0, LEN(a)) to pick an array index instead of RANDOM_INT(0, LEN(a) - 1).
This is the same off-by-one as array traversal in 3.2.6 and appears in error-identification questions.
Why it happens
LEN(a) feels like the natural upper limit, and the resulting bug only triggers when that specific index happens to be generated — so the program appears to work most of the time.
How to avoid it
An n-element array has indices 0 to n−1, so the largest valid index is one less than the length. Remember this bug is intermittent: with a 5-element array it crashes roughly one run in six, which means it can survive extensive testing before failing in use.
✕Calling the random generator twice when a single value was needed in two places.
This produces a logic error with no error message, and is a standard fault in random-number debugging questions.
Why it happens
The call reads like a value rather than an action, so writing it again feels equivalent to referring to the same number — the fact that each call produces something new is not visible in the code.
How to avoid it
Generate once, store in a variable, use the variable. Ask yourself whether the program needs one value used twice or two genuinely independent values — two dice legitimately need two calls, but a single roll that is both tested and reported needs one.
✕Placing the generation of a game's target inside the guessing loop instead of before it.
Placement errors of this kind make a game unwinnable and are a recurring fault in error-identification questions.
Why it happens
The call sits naturally alongside the other statements that belong to each turn, and the consequence is only visible if you trace two iterations and notice the target has changed.
How to avoid it
Ask how often this value should change. A secret number must stay fixed for the whole game, so it is generated once, before the loop. A value that should differ each turn — an enemy's attack strength, say — belongs inside. Trace two iterations to check.
✕Assuming that picking several random items will automatically produce different ones.
Lottery-number and quiz-question scenarios are set specifically to test whether this has been understood.
Why it happens
Intuitively a random selection 'ought' to spread out, and with a large range duplicates are rare enough that casual testing does not reveal them.
How to avoid it
Each call is independent and has no memory of previous ones, so repeats are always possible. To prevent them you must either track which items have been used with a Boolean array and re-pick, or remove each chosen item from the list once selected.
✕Spending revision time learning how pseudo-random number generators work internally.
AQA 8525 specification 3.2.9 additional information: 'An understanding of how pseudo-random numbers are generated is not required.'
Why it happens
The word 'pseudo-random' invites curiosity, and wider reading or A-level material covers seeds and generating algorithms in detail.
How to avoid it
The specification states plainly that an understanding of how pseudo-random numbers are generated is not required. Every available mark is for using the generator correctly — the right range, the right placement relative to a loop, and storing the value when it must be reused. Revise those instead.

Random Number Generation — AQA GCSE Computer Science 8525 (3.2.9)

Call

Possible values

How many

RANDOM_INT(1, 6)

1, 2, 3, 4, 5, 6

RANDOM_INT(0, 9)

0, 1, 2, …, 9

RANDOM_INT(1, 10)

1, 2, 3, …, 10

RANDOM_INT(5, 5)

# WRONG — generates TWO different numbers IF RANDOM_INT(1, 6) = 6 THEN OUTPUT 'You rolled a ', RANDOM_INT(1, 6) ENDIF # RIGHT — one number, used twice roll ← RANDOM_INT(1, 6) IF roll = 6 THEN OUTPUT 'You rolled a ', roll ENDIF

Requirement

Correct call

Why

Roll a six-sided dice

RANDOM_INT(1, 6)

Faces are numbered 1 to 6

Toss a coin

RANDOM_INT(0, 1)

Two outcomes: 0 = heads, 1 = tails

A single random digit

RANDOM_INT(0, 9)

Digits run 0 to 9

Pick a card value

RANDOM_INT(1, 13)

Ace to King

Lottery number

RANDOM_INT(1, 49)

Balls numbered 1 to 49

A random percentage

RANDOM_INT(0, 100)

0% to 100% inclusive

target ← RANDOM_INT(1, 100) attempts ← 0 REPEAT OUTPUT 'Guess a number between 1 and 100' guess ← STRING_TO_INT(USERINPUT) attempts ← attempts + 1 IF guess < target THEN OUTPUT 'Too low' ELSE IF guess > target THEN OUTPUT 'Too high' ENDIF UNTIL guess = target OUTPUT 'Correct! You took ', attempts, ' attempts'

Approach

What it means

Test the range, not the value

Run many times and check every result falls between the limits

Test the boundaries

Confirm the lowest and highest values (e.g. 1 and 6) can both actually occur

Run many trials

Roll a dice 6000 times and check each face appears roughly 1000 times

Replace the generator temporarily

Substitute a fixed value while testing the rest of the logic

used : ARRAY[0:9] OF Boolean FOR i ← 0 TO 9 used[i] ← False ENDFOR FOR q ← 1 TO 3 REPEAT index ← RANDOM_INT(0, 9) UNTIL used[index] = False OUTPUT questions[index] used[index] ← True ENDFOR

1 attempts ← 0 2 REPEAT 3 secret ← RANDOM_INT(1, 10) 4 OUTPUT 'Guess the number' 5 guess ← STRING_TO_INT(USERINPUT) 6 attempts ← attempts + 1 7 UNTIL guess = secret 8 OUTPUT 'Correct!'

secret ← RANDOM_INT(1, 10) attempts ← 0 REPEAT OUTPUT 'Guess the number' guess ← STRING_TO_INT(USERINPUT) attempts ← attempts + 1 UNTIL guess = secret OR attempts = 3 IF guess = secret THEN OUTPUT 'Correct!' ELSE OUTPUT 'Out of attempts — the number was ', secret ENDIF

count ← 0 WHILE count < 6 candidate ← RANDOM_INT(1, 49) isDuplicate ← False FOR i ← 0 TO count - 1 IF numbers[i] = candidate THEN isDuplicate ← True ENDIF ENDFOR IF isDuplicate = False THEN numbers[count] ← candidate count ← count + 1 ENDIF ENDWHILE FOR i ← 0 TO 5 OUTPUT numbers[i] ENDFOR

Random number generation in a programming language

Detailed Study Notes

At a glance

What you’ll learn

Generating a random number

Inclusive means inclusive

Storing the result

Getting the range right — especially with arrays

Common ranges

Choosing a random element from an array

Using random numbers inside a program

A guessing game — random plus indefinite iteration

Rolling two dice — two separate calls

A random question from a bank

Simulating probability

Why random programs are harder to test

The three problems

How testers cope

Linking to test data (3.2.11)

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Write calls with the correct inclusive range (4 marks)

2Store a random value so it can be reused (3 marks)

3Pick a random element from an array (3 marks)

4Write a number guessing game (5 marks)

5Decide how many calls are needed (4 marks)

6Simulate a stated probability (4 marks)

7Select random items without repeats (6 marks)

8Explain how to test a program using random numbers (6 marks)

9Find and fix the random number errors (6 marks)

Number of values a random range can produce

Random index for a zero-indexed array