How to Generate Random Numbers (Methods & Use Cases)

Random numbers power everything from board games and lottery drawings to encryption protocols and Monte Carlo simulations. Whether you need a quick dice roll or a statistically sound sample for research, understanding how randomness works helps you pick the right method and avoid common pitfalls.

This guide explains the core concepts behind random number generation, compares true randomness to pseudorandomness, walks through probability distributions, and covers real-world use cases. For instant results, try our Random Number Generator.

True Randomness vs. Pseudorandomness

The distinction between these two types matters more than most people realize.

True Random Numbers

True randomness comes from physical phenomena that are inherently unpredictable: radioactive decay, atmospheric noise, thermal fluctuations in a resistor, or the exact timing of keystrokes. Organizations like random.org use atmospheric noise to generate numbers that can’t be predicted or reproduced.

True random number generators (TRNGs) are slower because they depend on measuring a physical process. They also can’t produce the same sequence twice, which is a strength for security but a limitation for scientific experiments that require reproducibility.

Pseudorandom Numbers (PRNGs)

A pseudorandom number generator uses a mathematical algorithm to produce a sequence of numbers that appears random but is entirely determined by an initial value called the seed. Given the same seed, a PRNG produces the identical sequence every time.

Common PRNG algorithms include:

• Linear Congruential Generator (LCG): Fast but has short periods and predictable patterns. Formula: X(n+1) = (a * X(n) + c) mod m.
• Mersenne Twister: The default in many programming languages. Period of 2^19937 - 1, which is astronomically long. Good for simulations, not for cryptography.
• Xorshift: Extremely fast with reasonable statistical properties. Popular in game engines.

Cryptographically Secure PRNGs (CSPRNGs)

For passwords, encryption keys, and authentication tokens, you need a CSPRNG. These algorithms (like ChaCha20 or AES-CTR) are designed so that even if an attacker sees millions of outputs, they can’t predict the next number. Operating systems provide CSPRNGs through interfaces like /dev/urandom on Linux or CryptGenRandom on Windows. In JavaScript, crypto.getRandomValues() taps into the browser’s CSPRNG.

Rule of thumb: Use a standard PRNG for games, simulations, and statistics. Use a CSPRNG for anything security-related.

Probability Distributions

Not all random number generation is about picking a number between 1 and 100. The distribution controls how likely each outcome is.

Uniform Distribution

Every value in the range has an equal probability. Rolling a fair die is uniform: each face has a 1/6 chance. When you ask for “a random number between 1 and 50,” you almost always mean a uniform distribution.

Normal (Gaussian) Distribution

Values cluster around a mean, forming the classic bell curve. About 68% of values fall within one standard deviation of the mean, 95% within two, and 99.7% within three. Human height, test scores, and measurement errors follow this pattern.

To generate normally distributed numbers from uniform ones, the Box-Muller transform is commonly used:

$Z = \sqrt{-2 \ln(U_1)} \times \cos(2\pi U_2)$

where U1 and U2 are independent uniform random numbers between 0 and 1.

Exponential Distribution

Models the time between events in a Poisson process: how long until the next customer arrives, the next earthquake hits, or the next server request comes in. The probability density drops off exponentially — short waits are common, long waits are rare.

Other Distributions

• Binomial: Number of successes in n independent yes/no trials (coin flips, defective products in a batch).
• Poisson: Number of events in a fixed interval (emails per hour, car accidents per month).
• Log-normal: Product of many independent positive random variables (stock prices, city populations).

Practical Use Cases

Games and Entertainment

Dice rolls, card shuffles, loot drops, procedural terrain generation, and enemy spawn patterns all rely on random numbers. Game developers typically use fast PRNGs like Xorshift and seed them based on the system clock so each playthrough feels different.

Statistical Sampling

Researchers use random number generators to select unbiased samples from larger populations. If you have a mailing list of 50,000 customers and need to survey 500, you assign each customer a random number and pick the 500 lowest (or highest) values. This produces a simple random sample where every customer has an equal chance of selection.

Stratified sampling divides the population into groups (strata) first, then randomly samples within each group. This ensures representation across categories like age brackets or geographic regions.

Monte Carlo Simulations

Named after the casino, Monte Carlo methods use repeated random sampling to estimate numerical results. Applications include pricing financial derivatives, modeling particle physics, estimating pi, and evaluating engineering risk. The accuracy improves with more iterations — run 10,000 simulations and you get a far better estimate than running 100.

Example: To estimate pi, randomly generate points inside a unit square. Count how many fall inside the quarter-circle (where x^2 + y^2 <= 1). The ratio of points inside the circle to total points, multiplied by 4, approximates pi.

Cryptography and Security

Password generation, session tokens, encryption keys, nonces, and salts all demand unpredictable random values. A weak random number generator in a security context is a vulnerability, not a minor inconvenience. The 2008 Debian OpenSSL bug, caused by accidentally crippling the random number generator, left thousands of SSL certificates breakable.

Randomized Algorithms

Quicksort with a random pivot, randomized primality testing (Miller-Rabin), and hash table collision resolution all use randomness to achieve better average-case performance. These algorithms don’t need true randomness — a decent PRNG is sufficient.

How to Generate a Random Integer in a Range

The most common task is generating a random integer between a minimum and maximum value (inclusive). The general formula is:

$\text{randomInt} = \lfloor \text{random()} \times (\text{max} - \text{min} + 1) \rfloor + \text{min}$

Example: Generate a random integer between 5 and 20.

• random() produces a value like 0.7382.
• Multiply: 0.7382 x (20 - 5 + 1) = 0.7382 x 16 = 11.81.
• Floor: 11.
• Add min: 11 + 5 = 16.

Our Random Number Generator handles this calculation instantly and lets you generate multiple values at once.

Common Mistakes

Modulo bias: Using rand() % n to get a number between 0 and n-1 introduces subtle bias when the PRNG’s range isn’t evenly divisible by n. The correct approach is rejection sampling: discard values that fall outside an evenly divisible range and re-roll.

Reusing seeds: If you seed a PRNG with the same value every time your program starts, you get the same “random” sequence. This is useful for testing but disastrous in production.

Confusing uniform with normal: Drawing salary data from a uniform distribution between $30,000 and $200,000 produces unrealistic models. Real salaries follow a skewed distribution where most values cluster at the lower end.

Frequently Asked Questions

Are computer-generated random numbers truly random?

No. Standard computer algorithms produce pseudorandom numbers that are deterministic sequences mimicking randomness. For most purposes — games, simulations, sampling — pseudorandom numbers are perfectly adequate. True randomness requires a physical source like atmospheric noise or quantum measurement.

What does “seed” mean in random number generation?

A seed is the starting value fed into a pseudorandom algorithm. The same seed always produces the same sequence of numbers. This is useful for reproducibility: scientists can share a seed so that others can replicate their simulation results exactly. For unpredictable output, programs typically seed the generator with the current system time in milliseconds or data from the operating system’s entropy pool.

How do I generate a random number with a specific probability distribution?

Start with a uniform random number between 0 and 1, then apply a transformation. For a normal distribution, use the Box-Muller transform. For an exponential distribution, use the inverse transform: X = -ln(U) / lambda, where U is uniform and lambda is the rate parameter. Most programming languages and statistics libraries have built-in functions for common distributions.

Can someone predict my random numbers?

If you use a standard PRNG and an attacker discovers the seed or observes enough output, they can predict future values. Mersenne Twister, for example, can be fully recovered after observing 624 consecutive 32-bit outputs. This is why security applications require cryptographically secure generators where prediction is computationally infeasible.

How many random numbers do I need for a Monte Carlo simulation to be accurate?

There is no single answer — it depends on the problem’s dimensionality and the precision you need. A rough guideline: doubling accuracy requires quadrupling the sample size because error decreases proportionally to 1 / sqrt(n). For basic estimates, 10,000 iterations often suffice. For high-precision financial models, millions of iterations may be necessary.