Docs ejecutables de C: Números aleatorios

Q: ¿Cómo genero un número aleatorio en C?

Incluye , siembra una vez al inicio de main con srand((unsigned) time(NULL)) (que necesita ) y luego llama a rand() para cada valor. rand() devuelve un int entre 0 y RAND_MAX, ambos incluidos.

Q: ¿Cómo obtengo un número aleatorio entre dos valores en C?

Usa rand() % (max - min + 1) + min. Para una tirada de dado entre 1 y 6 eso es rand() % 6 + 1. El % n mapea el resultado a 0..n-1 y sumar min desplaza la ventana; solo asegúrate de que el conteo incluya ambos extremos, que es lo que hace el + 1.

Q: ¿Por qué mi programa de C imprime los mismos números aleatorios cada vez?

Porque nunca llamaste a srand. Sin semilla, rand() se comporta como si estuviera sembrado con 1, así que cada ejecución produce la secuencia idéntica. Llama a srand((unsigned) time(NULL)) una vez al inicio del programa; una vez, no antes de cada llamada a rand(), lo que empeoraría las cosas.

Q: ¿Qué es el sesgo del módulo en la generación de números aleatorios?

rand() % n solo es perfectamente uniforme cuando n divide exactamente a RANDMAX + 1. Si no, los primeros valores aparecen una vez de más a lo largo del rango completo, haciéndolos apenas más probables. Con RANDMAX en 2147483647 y una n pequeña, la desviación está muy por debajo de lo que nota un juego o una simulación, pero para criptografía o estadística usa un bucle de rechazo o un generador adecuado.

Los números aleatorios de C vienen de dos funciones de <stdlib.h>: rand(), que produce el siguiente valor, y srand(), que fija el punto de partida. No son realmente aleatorios: son una secuencia pseudoaleatoria, calculada de forma determinista a partir de una semilla, lo cual es una limitación para la criptografía y una virtud para las pruebas.

rand() y RAND_MAX

rand() devuelve un int en algún punto entre 0 y RAND_MAX, ambos incluidos. RAND_MAX es una macro con garantía de ser al menos 32767; en Linux y macOS es 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;
}

Ejecútalo dos veces. Los números son idénticos ambas veces, y eso no es un error.

Sembrar con srand

Sin ninguna llamada a srand, la secuencia se comporta como si hubieras llamado a srand(1). Misma semilla, misma secuencia, en cada ejecución. Para obtener números distintos en cada ejecución, siembra con algo que cambie; por convención, la hora actual:

#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) de <time.h> devuelve los segundos transcurridos desde el inicio de 1970, así que cada ejecución recibe una semilla distinta. La conversión a unsigned int calla un aviso sobre el estrechamiento de time_t.

Tres reglas sobre la siembra, y la gente se equivoca en todas:

Siembra exactamente una vez, al inicio de main. Llamar a srand antes de cada rand() es el antipatrón clásico: dentro de un bucle que termina en menos de un segundo, time(NULL) devuelve el mismo valor en cada iteración, así que vuelves a sembrar con el mismo número y rand() devuelve el mismo primer valor cada vez. La salida es una columna de números "aleatorios" idénticos.

No vuelvas a sembrar para "mejorar" la aleatoriedad. La calidad del generador viene de que su estado interno avance; reiniciar ese estado tira la secuencia a la basura.

time(NULL) tiene una resolución de un segundo. Dos programas lanzados en el mismo segundo obtienen la misma secuencia. Eso está bien para un juego y está mal para cualquier cosa donde importe la independencia.

Un número dentro de un rango

El modismo estándar usa el operador de resto:

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

Para obtener de min a max inclusive, la cantidad de valores posibles es 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("Tirada de dado (1-6):  %d\n", random_between(1, 6));
    printf("Porcentaje (0-100):    %d\n", random_between(0, 100));
    printf("Temperatura (-10-40):  %d\n", random_between(-10, 40));

    printf("\nDiez lanzamientos de moneda: ");
    for (int i = 0; i < 10; i++) {
        printf("%s ", (rand() % 2) ? "C" : "X");
    }
    printf("\n");
    return 0;
}

El + 1 es donde viven los errores de desplazamiento por uno. rand() % 6 da de 0 a 5, así que una tirada de dado es rand() % 6 + 1. Escribir rand() % 7 + 1 para "incluir el 6" te da un dado de siete caras.

La nota honesta sobre el sesgo del módulo

rand() % n no es perfectamente uniforme salvo que n divida exactamente a RAND_MAX + 1.

Piénsalo con números pequeños. Si RAND_MAX fuera 9 —así que rand() devuelve de 0 a 9, diez valores igual de probables— entonces rand() % 3 mapea 0,3,6,9 al 0; 1,4,7 al 1; y 2,5,8 al 2. El resultado 0 ocurre de cuatro formas de diez, y los resultados 1 y 2 de tres formas cada uno. El cero es un 33% más probable.

La misma desviación existe con el RAND_MAX real, solo que mucho menor: los valores sobrantes son los primeros (RAND_MAX + 1) % n resultados, cada uno ganando una oportunidad extra de entre unos 2.100 millones. Para una tirada de dado, un mazo barajado o una simulación, eso es inmedible: usa % y sigue adelante.

Cuando sí importa —trabajo estadístico, cualquier cosa relacionada con la seguridad— rechaza los valores sobrantes en lugar de doblarlos hacia dentro:

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

/* Valor sin sesgo en 0..n-1, descartando la cola desigual */
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("el %d aparecio %d veces\n", face + 1, counts[face]);
    }
    return 0;
}

El bucle tira el pequeño rango de valores que causaría la desviación y vuelve a sacar. Termina rápido: el trozo rechazado es una fracción insignificante del total.

Para aleatoriedad genuinamente sensible a la seguridad, rand() es la herramienta equivocada por mucho cuidado que pongas: usa arc4random_buf en macOS y BSD, getrandom() en Linux o BCryptGenRandom en Windows.

Decimales aleatorios

Divide entre RAND_MAX para aterrizar en [0.0, 1.0] y luego escala:

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

double random_unit(void) {
    return (double) rand() / RAND_MAX;      /* de 0.0 a 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("unidad: %.6f   rango(-1, 1): %+.6f   precio: %.2f\n",
               random_unit(),
               random_range(-1.0, 1.0),
               random_range(9.99, 99.99));
    }
    return 0;
}

La conversión en (double) rand() es esencial. Sin ella, rand() / RAND_MAX es división entera y da 0 casi siempre, y 1 con la probabilidad de uno entre dos mil millones de dar con el máximo: un error que se ve como "todos mis decimales aleatorios son cero". Mira conversión de tipos para saber por qué.

Secuencias reproducibles

Una semilla fija da la secuencia idéntica en cada ejecución, que es exactamente lo que quieres para una prueba, una sesión de depuración o un juego con códigos de nivel compartibles:

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

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

int main(void) {
    print_five(42);
    print_five(42);      /* identica a la linea de arriba */
    print_five(2026);
    print_five(42);      /* identica otra vez */
    return 0;
}

La semilla 42 produce los mismos cinco números cada vez que se usa, en esta ejecución y en cualquier otra con la misma biblioteca. Esa reproducibilidad es por lo que una simulación debería permitir elegir la semilla: ejecuta con el reloj normalmente y pasa una semilla fija cuando reproduzcas un error.

Una salvedad: la secuencia para una semilla dada no es portable. Distintas bibliotecas de C usan generadores distintos, así que la semilla 42 en glibc y la semilla 42 en Windows dan números distintos. Reproducible en una máquina, no entre máquinas.

Un juego de dados

Todo junto: sembrar una vez, un auxiliar para el rango y un array que lleva la cuenta de los resultados.

#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("Cinco tiradas de dos dados:\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) ? "  <- siete!" : "");
    }

    /* Distribucion de la suma de dos dados en muchas tiradas */
    int totals[13] = {0};
    for (int i = 0; i < ROLLS; i++) {
        totals[roll_die() + roll_die()]++;
    }

    printf("\nDistribucion de sumas en %d tiradas:\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;
}

El histograma debería tener su pico en el 7 y decaer hacia el 2 y el 12: hay seis formas de sumar 7 y una sola de sumar 2 o 12. Un generador que produjera aquí una distribución plana estaría roto.

Dos páginas relacionadas: la biblioteca estándar mapea el resto de <stdlib.h>, y funciones matemáticas cubre <math.h>, que querrás en cuanto los valores aleatorios alimenten cálculos de verdad.

Preguntas frecuentes

¿Cómo genero un número aleatorio en C?

Incluye <stdlib.h>, siembra una vez al inicio de main con srand((unsigned) time(NULL)) (que necesita <time.h>) y luego llama a rand() para cada valor. rand() devuelve un int entre 0 y RAND_MAX, ambos incluidos.

¿Cómo obtengo un número aleatorio entre dos valores en C?

Usa rand() % (max - min + 1) + min. Para una tirada de dado entre 1 y 6 eso es rand() % 6 + 1. El % n mapea el resultado a 0..n-1 y sumar min desplaza la ventana; solo asegúrate de que el conteo incluya ambos extremos, que es lo que hace el + 1.

¿Por qué mi programa de C imprime los mismos números aleatorios cada vez?

Porque nunca llamaste a srand. Sin semilla, rand() se comporta como si estuviera sembrado con 1, así que cada ejecución produce la secuencia idéntica. Llama a srand((unsigned) time(NULL)) una vez al inicio del programa; una vez, no antes de cada llamada a rand(), lo que empeoraría las cosas.

¿Qué es el sesgo del módulo en la generación de números aleatorios?

rand() % n solo es perfectamente uniforme cuando n divide exactamente a RAND_MAX + 1. Si no, los primeros valores aparecen una vez de más a lo largo del rango completo, haciéndolos apenas más probables. Con RAND_MAX en 2147483647 y una n pequeña, la desviación está muy por debajo de lo que nota un juego o una simulación, pero para criptografía o estadística usa un bucle de rechazo o un generador adecuado.

Conceptos relacionados