Random Numbers in C: rand, srand, and Generating a Number in a Range

C's random numbers come from two functions in <stdlib.h>: rand(), which produces the next value, and srand(), which sets the starting point. They are not truly random - they are a pseudorandom sequence, computed deterministically from a seed - which is a limitation for cryptography and a feature for testing.

rand() and RAND_MAX

rand() returns an int somewhere between 0 and RAND_MAX, inclusive. RAND_MAX is a macro guaranteed to be at least 32767; on Linux and macOS it is 2147483647.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    printf("RAND_MAX = %d\n\n", RAND_MAX);

    for (int i = 0; i < 5; i++) {
        printf("rand() -> %d\n", rand());
    }
    return 0;
}

Run that twice. The numbers are identical both times - and that is not a bug.

Seeding with srand

With no call to srand, the sequence behaves as if you had called srand(1). Same seed, same sequence, every run. To get different numbers per run, seed with something that changes - conventionally the current time:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void) {
    srand((unsigned int) time(NULL));

    for (int i = 0; i < 5; i++) {
        printf("%d\n", rand());
    }
    return 0;
}

time(NULL) from <time.h> returns the seconds since the start of 1970, so each run gets a different seed. The cast to unsigned int silences a warning about narrowing time_t.

Three rules about seeding, all of which people get wrong:

Seed exactly once, at the start of main. Calling srand before every rand() is the classic anti-pattern - inside a loop that finishes in under a second, time(NULL) returns the same value each iteration, so you reseed with the same number and rand() returns the same first value every time. The output is a column of identical "random" numbers.

Do not reseed to "improve" randomness. The generator's quality comes from its internal state advancing; resetting that state throws the sequence away.

time(NULL) has one-second resolution. Two programs launched in the same second get the same sequence. That is fine for a game and wrong for anything where independence matters.

A Number in a Range

The standard idiom uses the remainder operator:

rand() % n            /* 0 to n-1 */
rand() % n + min      /* min to min+n-1 */

To get min through max inclusive, the count of possible values is max - min + 1:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int random_between(int min, int max) {
    return rand() % (max - min + 1) + min;
}

int main(void) {
    srand((unsigned int) time(NULL));

    printf("Dice roll (1-6):     %d\n", random_between(1, 6));
    printf("Percentage (0-100):  %d\n", random_between(0, 100));
    printf("Temperature (-10-40): %d\n", random_between(-10, 40));

    printf("\nTen coin flips: ");
    for (int i = 0; i < 10; i++) {
        printf("%s ", (rand() % 2) ? "H" : "T");
    }
    printf("\n");
    return 0;
}

The + 1 is where off-by-one errors live. rand() % 6 gives 0 through 5, so a dice roll is rand() % 6 + 1. Writing rand() % 7 + 1 to "include 6" gives you a seven-sided die.

The Honest Note About Modulo Bias

rand() % n is not perfectly uniform unless n divides RAND_MAX + 1 exactly.

Think of it with small numbers. If RAND_MAX were 9 - so rand() returns 0 through 9, ten equally likely values - then rand() % 3 maps 0,3,6,9 to 0; 1,4,7 to 1; and 2,5,8 to 2. Result 0 occurs four ways out of ten, results 1 and 2 three ways each. Zero is 33% more likely.

The same skew exists with the real RAND_MAX, just far smaller: the leftover values are the first (RAND_MAX + 1) % n outcomes, each gaining one extra chance out of roughly 2.1 billion. For a dice roll, a shuffled deck, or a simulation, that is unmeasurable - use % and move on.

When it does matter - statistical work, anything security-related - reject the leftover values rather than folding them in:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* Unbiased value in 0..n-1 by discarding the uneven tail */
int unbiased(int n) {
    int limit = RAND_MAX - (RAND_MAX % n);
    int r;
    do {
        r = rand();
    } while (r >= limit);
    return r % n;
}

int main(void) {
    srand((unsigned int) time(NULL));

    int counts[6] = {0};
    for (int i = 0; i < 60000; i++) {
        counts[unbiased(6)]++;
    }

    for (int face = 0; face < 6; face++) {
        printf("%d appeared %d times\n", face + 1, counts[face]);
    }
    return 0;
}

The loop throws away the small range of values that would cause the skew and draws again. It terminates quickly - the rejected slice is a vanishing fraction of the whole.

For genuinely security-sensitive randomness, rand() is the wrong tool at any level of care: use arc4random_buf on macOS and BSD, getrandom() on Linux, or BCryptGenRandom on Windows.

Random Doubles

Divide by RAND_MAX to land in [0.0, 1.0], then scale:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

double random_unit(void) {
    return (double) rand() / RAND_MAX;      /* 0.0 to 1.0 */
}

double random_range(double min, double max) {
    return min + random_unit() * (max - min);
}

int main(void) {
    srand((unsigned int) time(NULL));

    for (int i = 0; i < 5; i++) {
        printf("unit: %.6f   range(-1, 1): %+.6f   price: %.2f\n",
               random_unit(),
               random_range(-1.0, 1.0),
               random_range(9.99, 99.99));
    }
    return 0;
}

The cast on (double) rand() is essential. Without it, rand() / RAND_MAX is integer division and evaluates to 0 almost always, 1 on the one-in-two-billion chance of hitting the maximum - a bug that looks like "my random doubles are all zero". See type casting for why.

Reproducible Sequences

A fixed seed gives the identical sequence every run, which is exactly what you want for a test, a debugging session, or a game with shareable level codes:

#include <stdio.h>
#include <stdlib.h>

void print_five(unsigned int seed) {
    srand(seed);
    printf("seed %-6u:", seed);
    for (int i = 0; i < 5; i++) {
        printf(" %4d", rand() % 100);
    }
    printf("\n");
}

int main(void) {
    print_five(42);
    print_five(42);      /* identical to the line above */
    print_five(2026);
    print_five(42);      /* identical again */
    return 0;
}

Seed 42 produces the same five numbers every time it is used, in this run and in any other on the same library. That reproducibility is why a simulation should let the seed be chosen: run with the clock normally, pass a fixed seed when reproducing a bug.

One caveat: the sequence for a given seed is not portable. Different C libraries use different generators, so seed 42 on glibc and seed 42 on Windows give different numbers. Reproducible on one machine, not across machines.

A Dice Game

Everything together - seeding once, a helper for the range, and an array tallying the results:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROLLS 1000

int roll_die(void) {
    return rand() % 6 + 1;
}

int main(void) {
    srand((unsigned int) time(NULL));

    printf("Five rolls of two dice:\n");
    for (int i = 0; i < 5; i++) {
        int a = roll_die(), b = roll_die();
        printf("  %d + %d = %d%s\n", a, b, a + b,
               (a + b == 7) ? "  <- seven!" : "");
    }

    /* Distribution of the sum of two dice over many rolls */
    int totals[13] = {0};
    for (int i = 0; i < ROLLS; i++) {
        totals[roll_die() + roll_die()]++;
    }

    printf("\nSum distribution over %d rolls:\n", ROLLS);
    for (int sum = 2; sum <= 12; sum++) {
        printf("%3d: ", sum);
        for (int bar = 0; bar < totals[sum] / 4; bar++) {
            printf("#");
        }
        printf(" (%d)\n", totals[sum]);
    }
    return 0;
}

The histogram should peak at 7 and taper toward 2 and 12 - there are six ways to make 7 and one way each to make 2 or 12. A generator producing a flat distribution here would be broken.

Two related pages: the standard library maps the rest of <stdlib.h>, and math functions covers <math.h>, which you will want as soon as random values feed into real calculations.