C Números Aleatórios (rand)

Jogos jogam dados, sorteios escolhem um ganhador, quizzes embaralham as perguntas. Em todos eles o programa precisa de números que não dá para prever. O C tem duas funções para isso, no <stdlib.h>: rand, que sorteia, e srand, que "embaralha" o sorteio. Nesta aula você vai entender por que o computador, que só sabe fazer contas, consegue parecer sortudo, por que o seu programa sorteia sempre os mesmos números (e como consertar), como sortear dentro de um intervalo e os erros mais comuns.

Todos os programas foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c, com gcc -std=c23 -Wall -Wextra arquivo.c -o programa.

A ideia: o caderno de números

Imagine que a professora da Ana tem um caderno com milhões de números escritos em sequência, sem nenhum padrão que se perceba: 1804289383, 846930886, 1681692777… Quando alguém pede "um número aleatório", ela lê o próximo número do caderno.

• Para quem recebe, os números parecem sorte.
• Mas se ela começar sempre da primeira página, a turma de amanhã recebe os mesmos números, na mesma ordem.
• Para cada aula ser diferente, ela precisa abrir o caderno numa página diferente. O número da página é a semente.

O rand funciona assim. Os números não são sorte de verdade: são o resultado de uma conta, feita a partir do número anterior. Por isso se chamam pseudoaleatórios ("falsos aleatórios"). A conta é escolhida para que eles pareçam aleatórios, e para jogos e sorteios do dia a dia isso basta.

1. rand() e RAND_MAX

rand() ("random", aleatório) não recebe nada e devolve um int entre 0 e RAND_MAX, uma constante que também vem do <stdlib.h>:

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

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

#include <stdlib.h>

A "standard library", biblioteca padrão: traz rand, srand e RAND_MAX.

RAND_MAX

O maior número que o rand pode devolver. O C só garante que ele vale pelo menos 32767; no Linux (e no editor) é 2147483647, o maior int.

rand()

Cada chamada devolve o próximo número da sequência.

$ gcc -std=c23 -Wall -Wextra dado.c -o dado
$ ./dado
RAND_MAX = 2147483647
1804289383 846930886 1681692777 1714636915 1957747793
$ ./dado
RAND_MAX = 2147483647
1804289383 846930886 1681692777 1714636915 1957747793     « os mesmos cinco, de novo

Rodou duas vezes e saíram exatamente os mesmos números. É o caderno aberto sempre na primeira página: sem você escolher uma semente, o C usa a semente 1. No editor, a sequência é outra (o primeiro número lá é 0), mas também se repete a cada Rodar.

2. Um dado de 1 a 6

Números de até 2 bilhões não servem para um jogo de tabuleiro. Para trazer o resultado para um intervalo pequeno, usamos o resto da divisão (%, de Operadores Aritméticos): o resto de uma divisão por 6 é sempre um número de 0 a 5.

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

int main(void) {
    for (int i = 0; i < 10; i++) {
        int dado = rand() % 6 + 1;
        printf("%d ", dado);
    }
    printf("\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra dado6.c -o dado6
$ ./dado6
2 5 4 2 6 2 5 1 4 2
$ ./dado6
2 5 4 2 6 2 5 1 4 2

Dez jogadas de dado, todas entre 1 e 6. Mas, de novo, a mesma partida toda vez. A seção 3 resolve isso.

Dentro de 1 a 6: 1000 de 1000

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

int main(void) {
    int dentro = 0;
    for (int i = 0; i < 1000; i++) {
        int dado = rand() % 6;      // conserte: tem de dar de 1 a 6
        if (dado >= 1 && dado <= 6) {
            dentro++;
        }
    }
    printf("Dentro de 1 a 6: %d de 1000\n", dentro);
    return 0;
}

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

int main(void) {
    int dentro = 0;
    for (int i = 0; i < 1000; i++) {
        int dado = rand() % 6 + 1;
        if (dado >= 1 && dado <= 6) {
            dentro++;
        }
    }
    printf("Dentro de 1 a 6: %d de 1000\n", dentro);
    return 0;
}

3. A semente: srand

srand(numero) ("seed random", semear o aleatório) escolhe a página do caderno: a partir dela, o rand segue outra sequência. Para cada execução ser diferente, precisamos de uma semente que mude sozinha. O clássico é o relógio: time(NULL), do <time.h>, devolve quantos segundos se passaram desde 1º de janeiro de 1970, um número que muda a cada segundo.

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

int main(void) {
    srand(time(NULL));
    for (int i = 0; i < 10; i++) {
        printf("%d ", rand() % 6 + 1);
    }
    printf("\n");
    return 0;
}

#include <time.h>

Traz a função time.

time(NULL)

A hora atual, em segundos. O NULL quer dizer "só me devolva o número" (veja Ponteiro Nulo, no Nível 2).

srand(time(NULL));

Usa a hora como semente. Fica no começo do main, antes do primeiro rand(), e roda uma vez só.

$ gcc -std=c23 -Wall -Wextra semente.c -o semente
$ ./semente
1 2 6 5 6 6 3 4 3 3
$ sleep 1                     « espera um segundo
$ ./semente
2 5 5 1 4 6 3 6 4 4           « outra partida

Agora cada execução é uma partida diferente. O sleep 1 está ali porque a semente só muda de um segundo para o outro: dois programas iniciados no mesmo segundo recebem a mesma semente e sorteiam a mesma coisa. Para um jogo, não faz diferença.

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

int main(void) {
    srand(time(NULL));
    for (int i = 0; i < 10; i++) {
        printf("%d ", rand() % 6 + 1);
    }
    printf("\n");
    return 0;
}

Semente fixa: repetir o sorteio de propósito

Às vezes a repetição é exatamente o que você quer. Se o jogo tem um defeito que só aparece com certos sorteios, você precisa reproduzir aquela partida para encontrá-lo. Para isso, use uma semente fixa, qualquer número:

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

int main(void) {
    srand(42);
    for (int i = 0; i < 10; i++) {
        printf("%d ", rand() % 6 + 1);
    }
    printf("\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra fixa.c -o fixa
$ ./fixa
1 1 6 4 5 5 2 1 6 6
$ ./fixa
1 1 6 4 5 5 2 1 6 6

Com srand(42), a sequência é sempre a mesma neste computador. No editor do guia, a mesma semente dá 3 2 5 1 3 2 5 3 1 3: outra biblioteca, outra conta. Um teste que espera "o primeiro dado é 1" funciona no Linux e falha no editor (ou no Windows, ou no macOS). Use a semente fixa para repetir partidas na mesma máquina, nunca para prometer números exatos.

4. Sortear entre um mínimo e um máximo

O dado foi um caso especial. Para sortear de qualquer min a qualquer max, a conta geral é:

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

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

int main(void) {
    srand(time(NULL));
    printf("Dado:      %d\n", sortear(1, 6));
    printf("Moeda:     %s\n", sortear(0, 1) == 0 ? "cara" : "coroa");
    printf("Mega-Sena: %d\n", sortear(1, 60));
    printf("Mês:       %d\n", sortear(1, 12));
    printf("Desconto:  %d%%\n", sortear(5, 15));
    return 0;
}

max - min + 1

Quantos números existem no intervalo. De 5 a 15 são 11 números (5, 6, …, 15), e não 10: o + 1 conta os dois extremos.

rand() % (max - min + 1)

Um número de 0 a 10 (para o desconto).

… + min

Empurra o intervalo para começar no min: de 0–10 para 5–15.

sortear(0, 1) == 0 ? "cara" : "coroa"

Uma moeda: sorteia 0 ou 1 e escolhe o texto com o operador ternário.

$ gcc -std=c23 -Wall -Wextra sortear.c -o sortear
$ ./sortear
Dado:      1
Moeda:     coroa
Mega-Sena: 10
Mês:       7
Desconto:  13%
$ sleep 1
$ ./sortear
Dado:      4
Moeda:     cara
Mega-Sena: 60
Mês:       11
Desconto:  7%

Repare no srand: ele fica no main, e não dentro de sortear. A função é chamada cinco vezes; a semente é plantada uma vez só. (A seção "Quando dá errado" mostra o que acontece se o srand for parar dentro de um laço.)

Todas as faces saem por igual?

Um dado honesto dá cada face mais ou menos 1/6 das vezes. Jogando 6000 vezes, cada face deveria sair perto de 1000:

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

int main(void) {
    int contagem[7] = {0};

    srand(time(NULL));
    for (int i = 0; i < 6000; i++) {
        int dado = rand() % 6 + 1;
        contagem[dado]++;
    }
    for (int face = 1; face <= 6; face++) {
        printf("face %d: %d vezes\n", face, contagem[face]);
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra frequencia.c -o frequencia
$ ./frequencia
face 1: 1038 vezes
face 2: 1016 vezes
face 3: 980 vezes
face 4: 934 vezes
face 5: 1055 vezes
face 6: 977 vezes

O array tem 7 posições para usar o próprio número da face como índice (a posição 0 fica sem uso; veja Arrays). Nenhuma face deu exatamente 1000, e isso é normal: com um dado de verdade também não daria. O importante é que todas ficaram perto.

5. Números com vírgula

Para sortear um double entre 0 e 1, divida o rand() por um número um pouco maior que o maior resultado possível:

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

int main(void) {
    srand(7);
    for (int i = 0; i < 4; i++) {
        double x = rand() / (RAND_MAX + 1.0);
        printf("%.4f\n", x);
    }
    double preco = 10.0 + rand() / (RAND_MAX + 1.0) * 5.0;
    printf("Preço entre 10 e 15: %.2f\n", preco);
    return 0;
}

rand() / (RAND_MAX + 1.0)

Um número de 0 até quase 1 (o 1 nunca sai, porque o rand() nunca chega a RAND_MAX + 1). O 1.0 faz a conta ser com vírgula; com 1, seria divisão inteira, e há um problema pior, mostrado logo abaixo.

10.0 + … * 5.0

Estica o intervalo de 0–1 para 0–5 e empurra para 10–15.

$ gcc -std=c23 -Wall -Wextra fracao.c -o fracao
$ ./fracao
0.4869
0.8680
0.5926
0.2147
Preço entre 10 e 15: 10.05

Com RAND_MAX + 1 (sem o .0), a soma é feita com int, e RAND_MAX já é o maior int. O gcc avisa:

$ gcc -std=c23 -Wall -Wextra fracaoerr.c -o fracaoerr
fracaoerr.c: In function ‘main’:
fracaoerr.c:5:35: warning: integer overflow in expression of type ‘int’ results in ‘-2147483648’ [-Woverflow]
    5 |     double x = rand() / (RAND_MAX + 1);
      |                                   ^
$ ./fracaoerr
0.000000

"Estouro de inteiro na expressão do tipo int, que resulta em −2147483648". O RAND_MAX + 1 deu a volta e virou negativo (Inteiros), e a divisão inteira de um rand() por esse número dá sempre 0. No editor, o Clang avisa: overflow in expression; result is -2'147'483'648 with type 'int' [-Winteger-overflow].

6. Embaralhar uma lista

A turma da Ana tem 8 alunos, numerados de 1 a 8, e a ordem das apresentações tem de ser sorteada. Sortear 8 números de 1 a 8 não funciona: o mesmo aluno poderia sair duas vezes. O certo é embaralhar a lista, como um baralho. O jeito clássico é o embaralhamento de Fisher-Yates: de trás para a frente, troque cada item com um item sorteado entre os que ainda não foram fixados.

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

void embaralhar(int v[], int n) {
    for (int i = n - 1; i > 0; i--) {
        int j = rand() % (i + 1);
        int temp = v[i];
        v[i] = v[j];
        v[j] = temp;
    }
}

int main(void) {
    int alunos[8] = {1, 2, 3, 4, 5, 6, 7, 8};

    srand(time(NULL));
    embaralhar(alunos, 8);

    printf("Ordem das apresentações:");
    for (int i = 0; i < 8; i++) {
        printf(" %d", alunos[i]);
    }
    printf("\n");
    return 0;
}

for (int i = n - 1; i > 0; i--)

Começa pelo último lugar da fila e vai até o segundo.

int j = rand() % (i + 1);

Sorteia uma posição de 0 a i: qualquer um dos alunos que ainda não ganharam lugar fixo, incluindo o próprio i.

temp, v[i] = v[j], v[j] = temp

Troca os dois de lugar, com uma variável de apoio. Depois disso, a posição i está decidida e não mexe mais.

void embaralhar(int v[], int n)

A função recebe o array e muda o array do main (arrays não são copiados; o porquê está em Ponteiros e Arrays).

$ gcc -std=c23 -Wall -Wextra embaralhar.c -o embaralhar
$ ./embaralhar
Ordem das apresentações: 5 7 2 1 3 6 8 4
$ sleep 1
$ ./embaralhar
Ordem das apresentações: 2 8 1 6 7 5 3 4

Cada aluno aparece exatamente uma vez, numa ordem diferente a cada execução. O mesmo código embaralha cartas, perguntas de quiz ou músicas de uma playlist.

Os limites do rand: qual usar

O viés do resto

O % tem um pequeno defeito. Imagine um rand de brinquedo que só sorteia de 0 a 9 (10 números), e você quer de 0 a 2 com % 3:

Como 10 não se divide por 3, o 0 sai mais. Com o RAND_MAX de 2 bilhões e um intervalo pequeno (um dado, uma Mega-Sena), a diferença é tão pequena que não se percebe. Ela só importa com intervalos enormes, perto do próprio RAND_MAX.

Quando dá errado

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

int main(void) {
    for (int i = 0; i < 10; i++) {
        srand(time(NULL));
        printf("%d ", rand() % 6 + 1);
    }
    printf("\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra laco.c -o laco
$ ./laco
4 4 4 4 4 4 4 4 4 4

$ ./zeroseis
1 4 3 1 5 1 4 0 3 1 2 1 2 1 5 4 0 0 4 4

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

int main(void) {
    int premios = 0;
    printf("Sorteando...\n");
    int sorteado = rand() % premios;
    printf("Prêmio %d\n", sorteado);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra zero.c -o zero
$ ./zero
Sorteando...
Exceção de ponto flutuante (imagem do núcleo gravada) ./zero
$ echo $?
136

$ gcc -std=c23 -Wall -Wextra seminclude.c -o seminclude
seminclude.c: In function ‘main’:
seminclude.c:4:5: error: implicit declaration of function ‘srand’ [-Wimplicit-function-declaration]
    4 |     srand(time(NULL));
      |     ^~~~~
seminclude.c:4:11: error: implicit declaration of function ‘time’ [-Wimplicit-function-declaration]
    4 |     srand(time(NULL));
      |           ^~~~
seminclude.c:2:1: note: ‘time’ is defined in header ‘<time.h>’; this is probably fixable by adding ‘#include <time.h>’
    1 | #include <stdio.h>
  +++ |+#include <time.h>
    2 |
seminclude.c:5:20: error: implicit declaration of function ‘rand’ [-Wimplicit-function-declaration]
    5 |     printf("%d\n", rand() % 6 + 1);
      |                    ^~~~

Referência rápida

Exercícios

Missão final: a rifa da festa junina

Menor sorteado: 10
Maior sorteado: 20
Fora do intervalo: 0

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

int sortear(int min, int max) {
    return rand() % max;    // conserte: de min a max
}

int main(void) {
    srand(time(NULL));
    int menor = 1000;
    int maior = -1000;
    int fora = 0;

    for (int i = 0; i < 10000; i++) {
        int bilhete = sortear(10, 20);
        if (bilhete < menor) {
            menor = bilhete;
        }
        if (bilhete > maior) {
            maior = bilhete;
        }
        if (bilhete < 10 || bilhete > 20) {
            fora++;
        }
    }
    printf("Menor sorteado: %d\n", menor);
    printf("Maior sorteado: %d\n", maior);
    printf("Fora do intervalo: %d\n", fora);
    return 0;
}

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

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

int main(void) {
    srand(time(NULL));
    int menor = 1000;
    int maior = -1000;
    int fora = 0;

    for (int i = 0; i < 10000; i++) {
        int bilhete = sortear(10, 20);
        if (bilhete < menor) {
            menor = bilhete;
        }
        if (bilhete > maior) {
            maior = bilhete;
        }
        if (bilhete < 10 || bilhete > 20) {
            fora++;
        }
    }
    printf("Menor sorteado: %d\n", menor);
    printf("Maior sorteado: %d\n", maior);
    printf("Fora do intervalo: %d\n", fora);
    return 0;
}

Com o código errado, rand() % 20 dá de 0 a 19: o menor sorteado é 0, o 20 nunca sai e quase metade dos bilhetes fica fora. (O aviso unused parameter 'min' também denunciava o erro: a função ignorava o mínimo.) Essa conferência funciona com qualquer semente e em qualquer computador: em 10 000 sorteios de 11 números, todos acabam aparecendo.

Resumo

• rand() (do <stdlib.h>) devolve um int de 0 a RAND_MAX. Os números são pseudoaleatórios: saem de uma conta.
• Sem semente, a sequência é sempre a mesma. srand(time(NULL)), uma vez, no começo do main, muda a sequência a cada execução. Dentro de um laço, ele repete o mesmo número.
• Uma semente fixa (srand(42)) repete a partida, útil para achar defeitos. Cada biblioteca C tem a sua conta: o editor sorteia outros números que o Linux.
• De min a max: rand() % (max - min + 1) + min. Com vírgula: rand() / (RAND_MAX + 1.0). Ordem sem repetir: embaralhe (Fisher-Yates).
• rand() % 0 derruba o programa (Exceção de ponto flutuante, 136).
• O rand serve para jogos e simulações, nunca para senhas.
• Próxima aula, no Nível 2: Memória e Endereços. Para usar tudo isto num jogo completo, veja o Projeto: Jogo de Adivinhação.