Why Programs Need Randomness

Some programs must do something different each time they run. A dice game should not roll the same number every turn. A simulation of traffic or weather needs variety to be realistic. A quiz app that samples a question should not always pick the first one. For all of these, a program uses a random value: a value the computer chooses that the programmer cannot predict in advance.

In AP pseudocode you generate one with RANDOM(a, b). In Python the closest match is random.randint(a, b). Both return a random integer, and both include a and b as possible results.

import random
roll = random.randint(1, 6)
print(roll)

roll <- RANDOM(1, 6)
DISPLAY(roll)

Each time this runs, roll may be a different integer from 1 to 6. Run it three times and you might see 4, then 1, then 6. That unpredictability is the whole point. You cannot know the exact value ahead of time, but you do know the set of values it could be, and that is what the exam tests.

n <- RANDOM(3, 9)
DISPLAY(n)

Counting the Possible Values

Because both endpoints are included, the number of possible results of RANDOM(a, b) is b - a + 1, not b - a. The + 1 is there because you are counting the fenceposts, not the gaps between them. From 2 to 8 the values are 2, 3, 4, 5, 6, 7, 8, which is seven numbers, and 8 - 2 + 1 equals 7.

lo = 2
hi = 8
count = hi - lo + 1
print(count)

lo <- 2
hi <- 8
count <- hi - lo + 1
DISPLAY(count)

Forgetting the + 1 is the single most common random-value mistake on the exam. If a question asks how many outcomes are possible, or asks you to make exactly a certain number of outcomes, reach for b - a + 1 every time.

# meant to roll a die
roll = 6
print(roll)

Random, but Repeatable: Seeding

By design, random values change from run to run, which makes them hard to test. To get the same sequence every time, a program can seed the generator with random.seed(k) before drawing values. A seed does not remove the randomness; it just fixes which random sequence you get, so the same seed always produces the same results.

import random
random.seed(7)
print(random.randint(1, 6))
print(random.randint(1, 6))

DISPLAY(RANDOM(1, 6))
DISPLAY(RANDOM(1, 6))

With random.seed(7) set first, those two calls always print the same two numbers, in the same order, on every machine. That is why every practice problem below sets a seed: it makes the "random" output predictable so you can check your work. On the real exam and on the Create Task, you normally do not seed, because you want genuine variety.

Using a Random Value in a Decision

A random value becomes useful when the program acts on it. Generate the value, then feed it into a conditional to branch, or into a counter inside a loop to build a simulation. A coin flip is the classic example: draw 0 or 1, then decide.

import random
flip = random.randint(0, 1)
if flip == 1:
    print("heads")
else:
    print("tails")

flip <- RANDOM(0, 1)
IF (flip = 1)
{
    DISPLAY("heads")
}
ELSE
{
    DISPLAY("tails")
}

Here RANDOM(0, 1) returns one of two equally likely results. The IF turns that number into a word. This same pattern, generate a random value then branch on it, is how you would build a dice game, a random enemy spawn, or a sampled survey response in your own project.

import random
random.seed(7)
print(random.randint(1, 6))

Key Vocabulary