Por que rand () + rand () produz números negativos?

Observei que a rand()função de biblioteca, quando é chamada apenas uma vez dentro de um loop, quase sempre produz números positivos.

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

Mas quando adiciono duas rand()chamadas, os números gerados agora têm mais números negativos.

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

Alguém pode explicar por que estou vendo números negativos no segundo caso?

PS: Inicializo a semente antes do loop como srand(time(NULL)).

rand()é definido para retornar um número inteiro entre 0e RAND_MAX.

rand() + rand()

poderia transbordar. O que você observa é provavelmente o resultado de um comportamento indefinido causado pelo excesso de números inteiros.

O problema é a adição. rand()retorna um intvalor de 0...RAND_MAX. Então, se você adicionar dois deles, você fará o que quiser RAND_MAX * 2. Se isso exceder INT_MAX, o resultado da adição excederá o intervalo válido que intpode ser mantido. O excesso de valores assinados é um comportamento indefinido e pode levar o teclado a falar com você em línguas estrangeiras.

Como não há ganho aqui em adicionar dois resultados aleatórios, a idéia simples é simplesmente não fazê-lo. Como alternativa, você pode converter cada resultado unsigned intantes da adição, se isso puder conter a soma. Ou use um tipo maior. Observe que longnão é necessariamente maior que int, o mesmo se aplica a long longse inttiver pelo menos 64 bits!

Conclusão: Apenas evite a adição. Não fornece mais "aleatoriedade". Se você precisar de mais bits, poderá concatenar os valores sum = a + b * (RAND_MAX + 1), mas isso provavelmente também requer um tipo de dados maior que int.

Como o motivo declarado é evitar um resultado zero: isso não pode ser evitado adicionando os resultados de duas rand()chamadas, pois ambas podem ser zero. Em vez disso, você pode apenas incrementar. Se RAND_MAX == INT_MAX, isso não pode ser feito em int. No entanto, (unsigned int)rand() + 1fará muito, muito provavelmente. Provavelmente (não definitivamente), porque exige UINT_MAX > INT_MAX, o que é verdade em todas as implementações que eu conheço (que abrange várias arquiteturas incorporadas, DSPs e todas as plataformas de desktop, dispositivos móveis e servidores dos últimos 30 anos).

Aviso:

Embora já tenha sido polvilhado nos comentários aqui, observe que a adição de dois valores aleatórios não obtém uma distribuição uniforme, mas uma distribuição triangular como rolar dois dados: para obter 12(dois dados), ambos os dados precisam ser mostrados 6. pois 11já existem duas variantes possíveis: 6 + 5ou 5 + 6, etc.

Portanto, a adição também é ruim nesse aspecto.

Observe também que os resultados rand()gerados não são independentes um do outro, pois são gerados por um gerador de números pseudo - aleatórios . Observe também que o padrão não especifica a qualidade ou a distribuição uniforme dos valores calculados.

Esta é uma resposta a um esclarecimento da pergunta feita no comentário a esta resposta ,

a razão pela qual eu adicionei foi evitar '0' como o número aleatório no meu código. rand () + rand () foi a solução rápida e suja que prontamente me veio à mente.

O problema era evitar 0. Há (pelo menos) dois problemas com a solução proposta. Uma é, como as outras respostas indicam, que rand()+rand()pode invocar um comportamento indefinido. O melhor conselho é nunca chamar um comportamento indefinido. Outra questão é que não há garantia que rand()não produza 0 duas vezes seguidas.

O seguinte rejeita zero, evita comportamento indefinido e, na grande maioria dos casos, será mais rápido que duas chamadas para rand():

int rnum;
for (rnum = rand(); rnum == 0; rnum = rand()) {}
// or do rnum = rand(); while (rnum == 0);

Produza basicamente rand()números entre 0e RAND_MAX, e 2 RAND_MAX > INT_MAXno seu caso.

Você pode modular com o valor máximo do seu tipo de dados para evitar o estouro. Esse curso interromperá a distribuição dos números aleatórios, mas randé apenas uma maneira de obter números aleatórios rápidos.

#include <stdio.h>
#include <limits.h>

int main(void)
{
    int i=0;

    for (i=0; i<100; i++)
        printf(" %d : %d \n", rand(), ((rand() % (INT_MAX/2))+(rand() % (INT_MAX/2))));

    for (i=0; i<100; i++)
        printf(" %d : %ld \n", rand(), ((rand() % (LONG_MAX/2))+(rand() % (LONG_MAX/2))));

    return 0;
}

Pode ser que você tente uma abordagem complicada, garantindo que o valor retornado pela soma de 2 rand () nunca exceda o valor de RAND_MAX. Uma abordagem possível poderia ser sum = rand () / 2 + rand () / 2; Isso garantiria que, para um compilador de 16 bits com o valor RAND_MAX de 32767, mesmo que ambos os rand retornassem 32767, mesmo assim (32767/2 = 16383) 16383 + 16383 = 32766, portanto, não resultaria em soma negativa.

a razão pela qual eu adicionei foi evitar '0' como o número aleatório no meu código. rand () + rand () foi a solução rápida e suja que prontamente me veio à mente.

Uma solução simples (ok, chame de "Hack") que nunca produz um resultado zero e nunca transborda é:

x=(rand()/2)+1    // using divide  -or-
x=(rand()>>1)+1   // using shift which may be faster
                  // compiler optimization may use shift in both cases

Isso limitará seu valor máximo, mas se você não se importa com isso, isso deve funcionar bem para você.

Para evitar 0, tente o seguinte:

int rnumb = rand()%(INT_MAX-1)+1;

Você precisa incluir limits.h.

Embora o que todo mundo tenha dito sobre o provável estouro possa muito bem ser a causa do negativo, mesmo quando você usa números inteiros não assinados. O verdadeiro problema é realmente usar a funcionalidade de hora / data como a semente. Se você realmente se familiarizou com essa funcionalidade, saberá exatamente por que digo isso. O que realmente faz é dar uma distância (tempo decorrido) desde uma determinada data / hora. Embora o uso da funcionalidade de data / hora como a semente de um rand () seja uma prática muito comum, realmente não é a melhor opção. Você deve procurar alternativas melhores, pois existem muitas teorias sobre o assunto e eu não poderia entrar em todas elas. Você adiciona a essa equação a possibilidade de transbordamento e essa abordagem estava condenada desde o início.

Aqueles que postaram o rand () + 1 estão usando a solução que mais usa para garantir que eles não obtenham um número negativo. Mas, essa abordagem também não é realmente a melhor.

A melhor coisa que você pode fazer é dedicar um tempo extra para escrever e usar o tratamento adequado de exceções, e adicionar apenas ao número rand () se e / ou quando você terminar com um resultado zero. E, para lidar com números negativos corretamente. A funcionalidade rand () não é perfeita e, portanto, precisa ser usada em conjunto com o tratamento de exceções para garantir que você obtenha o resultado desejado.

Dedicar tempo e esforço extras para investigar, estudar e implementar adequadamente a funcionalidade rand () vale bem o tempo e o esforço. Apenas meus dois centavos. Boa sorte em seus empreendimentos...