Skip to main content

How To Think Like a Computer Scientist C++ Edition The Pretext Interactive Version

Section 10.7 Random numbers

Most computer programs do the same thing every time they are executed, so they are said to be deterministic. Usually, determinism is a good thing, since we expect the same calculation to yield the same result. For some applications, though, we would like the computer to be unpredictable. Games are an obvious example.
Making a program truly nondeterministic turns out to be not so easy, but there are ways to make it at least seem nondeterministic. One of them is to generate pseudorandom numbers and use them to determine the outcome of the program. Pseudorandom numbers are not truly random in the mathematical sense, but for our purposes, they will do.
C++ provides a function called random that generates pseudorandom numbers (pseudo- meaning "fake"). It is declared in the header file cstdlib, which contains a variety of “standard library” functions, hence the name.

Warning 10.7.1.

random is not a perfect random number generator, but it is good enough for the simple purposes we are using it for. If you are doing serious work that requires high-quality random numbers, like cryptography, you should use a different library.
The return value from random is an integer between 0 and RAND_MAX, where RAND_MAX is a large number (about 2 billion on my computer) also defined in the header file. Each time you call random you get a different randomly-generated number. To see a sample, run this loop:
Listing 10.7.1. Take a look at this active code, which generates 4 random numbers.
On my machine I got the following output:
1804289383
846930886
1681692777
1714636915
You will probably get something similar, but different, on yours.
Of course, we don’t always want to work with gigantic integers. More often we want to generate integers between 0 and some upper bound. A simple way to do that is with the modulus operator. For example:
int x = random();
int y = x % upperBound;
Since y is the remainder when x is divided by upperBound, the only possible values for y are between 0 and upperBound - 1, including both end points.

Note 10.7.2.

Keep in mind, though, that y will never be equal to upperBound.
Listing 10.7.2. This active code generates random numbers between 1 and 7.
It is also frequently useful to generate random floating-point values. A common way to do that is by dividing by RAND_MAX. For example:
int x = random();
double y = double(x) / RAND_MAX;

Note 10.7.3.

Notice that we cast x to a double before dividing by RAND_MAX. This is because RAND_MAX is an integer, and if we divided two integers, the result would also be an integer, and we would lose the fractional part.
This code sets y to a random value between 0.0 and 1.0, including both end points. As an exercise, you might want to think about how to generate a random floating-point value in a given range; for example, between 100.0 and 200.0.

Activity 10.7.1.

This active code generates random numbers between 0 and 1. Can you modify it to generate random numbers between 100.0 and 200.0? If you’re stuck you can reveal the hint below!
Hint.
The formula to generate random numbers between min and max is min + (max - min) * double(x) / RAND_MAX.

Checkpoint 10.7.1.

Checkpoint 10.7.2.

What header file do we need to declare in order to use the random function?
  • cstdlib
  • Correct!
  • random
  • Incorrect!
  • cmath
  • Incorrect!
  • iostream
  • Incorrect!

Checkpoint 10.7.3.

If we wanted to generate a random number between 0 and 12, and we have previously declared int int x = random();, what should be our next line of code?
  • int y = x / 12
  • This returns some random number between 0 and x / 12, which is out of range.
  • int y = x % 12
  • This returns a random number between 0 and 11.
  • int y = x / 13
  • This returns some random number between 0 and x / 13, which is out of range.
  • int y = x % 13
  • There are 13 numbers from 0 to 12 (the remainders of a division by 13).
You have attempted 1 of 6 activities on this page.