Pourquoi rand () + rand () produit-il des nombres négatifs?

J'ai observé que la rand()fonction de bibliothèque lorsqu'elle est appelée une seule fois dans une boucle, elle produit presque toujours des nombres positifs.

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

Mais lorsque j'ajoute deux rand()appels, les nombres générés ont maintenant plus de nombres négatifs.

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

Quelqu'un peut-il expliquer pourquoi je vois des nombres négatifs dans le deuxième cas?

PS: j'initialise la graine avant la boucle comme srand(time(NULL)).

rand()est défini pour renvoyer un entier entre 0et RAND_MAX.

rand() + rand()

pourrait déborder. Ce que vous observez est probablement le résultat d' un comportement indéfini provoqué par un débordement d'entier.

Le problème est l'ajout. rand()renvoie une intvaleur de 0...RAND_MAX. Donc, si vous en ajoutez deux, vous vous lèverez RAND_MAX * 2. Si cela dépasse INT_MAX, le résultat de l'addition déborde la plage valide qu'un intpeut contenir. Le débordement des valeurs signées est un comportement indéfini et peut conduire votre clavier à vous parler en langues étrangères.

Comme il n'y a aucun avantage à ajouter deux résultats aléatoires, l'idée simple est simplement de ne pas le faire. Vous pouvez également convertir chaque résultat enunsigned int avant l'ajout si cela peut contenir la somme. Ou utilisez un type plus grand. Notez que ce longn'est pas nécessairement plus large que int, la même chose s'applique à long longif intest au moins 64 bits!

Conclusion: Évitez simplement l'ajout. Il ne fournit pas plus de "caractère aléatoire". Si vous avez besoin de plus de bits, vous pouvez concaténer les valeurs sum = a + b * (RAND_MAX + 1), mais cela nécessite également probablement un type de données plus grand que int.

Comme votre raison indiquée est d'éviter un résultat nul: cela ne peut pas être évité en ajoutant les résultats de deux rand()appels, car les deux peuvent être nuls. Au lieu de cela, vous pouvez simplement incrémenter. Si RAND_MAX == INT_MAXcela ne peut pas être fait en int. Cependant, (unsigned int)rand() + 1fera très, très probablement. Probablement (pas définitivement), car cela nécessite UINT_MAX > INT_MAX, ce qui est vrai sur toutes les implémentations que je connais (qui couvre plusieurs architectures intégrées, DSP et toutes les plates-formes de bureau, mobiles et serveurs des 30 dernières années).

Avertissement:

Bien que déjà saupoudré dans les commentaires ici, veuillez noter que l'ajout de deux valeurs aléatoires n'obtient pas une distribution uniforme, mais une distribution triangulaire comme lancer deux dés: pour obtenir 12(deux dés) les deux dés doivent s'afficher 6. car 11il existe déjà deux variantes possibles: 6 + 5ou 5 + 6, etc.

Donc, l'ajout est également mauvais de cet aspect.

Notez également que les résultats rand()générés ne sont pas indépendants les uns des autres, car ils sont générés par un générateur de nombres pseudo-aléatoires . Notez également que la norme ne spécifie pas la qualité ou la distribution uniforme des valeurs calculées.

Ceci est une réponse à une clarification de la question faite en commentaire de cette réponse ,

la raison pour laquelle j'ajoutais était d'éviter «0» comme nombre aléatoire dans mon code. rand () + rand () était la solution rapide et sale qui m'est venue à l'esprit.

Le problème était d'éviter 0. Il y a (au moins) deux problèmes avec la solution proposée. L'une est, comme les autres réponses l'indiquent, qui rand()+rand()peut invoquer un comportement indéfini. Le meilleur conseil est de ne jamais invoquer un comportement indéfini. Un autre problème est qu'il n'y a aucune garantie qui rand()ne produira pas 0 deux fois de suite.

Ce qui suit rejette zéro, évite un comportement indéfini et, dans la grande majorité des cas, sera plus rapide que deux appels à rand():

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

rand()Produisez essentiellement des nombres entre 0et RAND_MAX, et 2 RAND_MAX > INT_MAXdans votre cas.

Vous pouvez moduler avec la valeur maximale de votre type de données pour éviter un débordement. Bien sûr, cela perturbera la distribution des nombres aléatoires, mais randn'est qu'un moyen d'obtenir des nombres aléatoires rapides.

#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;
}

Peut-être pourriez-vous essayer une approche plutôt délicate en vous assurant que la valeur renvoyée par la somme de 2 rand () ne dépasse jamais la valeur de RAND_MAX. Une approche possible pourrait être sum = rand () / 2 + rand () / 2; Cela garantirait que pour un compilateur 16 bits avec une valeur RAND_MAX de 32767 même si les deux rand retournent justement 32767, même dans ce cas (32767/2 = 16383) 16383 + 16383 = 32766, cela n'entraînerait donc pas de somme négative.

la raison pour laquelle j'ajoutais était d'éviter «0» comme nombre aléatoire dans mon code. rand () + rand () était la solution rapide et sale qui m'est venue à l'esprit.

Une solution simple (d'accord, appelez ça un "Hack") qui ne produit jamais de résultat nul et ne débordera jamais est:

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

Cela limitera votre valeur maximale, mais si cela ne vous intéresse pas, cela devrait bien fonctionner pour vous.

Pour éviter 0, essayez ceci:

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

Vous devez inclure limits.h.

Alors que ce que tout le monde a dit sur le débordement probable pourrait très bien être la cause du négatif, même lorsque vous utilisez des entiers non signés. Le vrai problème est en fait d'utiliser la fonctionnalité heure / date comme graine. Si vous vous êtes vraiment familiarisé avec cette fonctionnalité, vous saurez exactement pourquoi je dis cela. Car ce qu'il fait vraiment est de donner une distance (temps écoulé) depuis une date / heure donnée. Bien que l'utilisation de la fonctionnalité date / heure comme graine d'un rand () soit une pratique très courante, ce n'est vraiment pas la meilleure option. Vous devriez chercher de meilleures alternatives, car il existe de nombreuses théories sur le sujet et je ne pourrais pas entrer dans toutes. Vous ajoutez à cette équation la possibilité de débordement et cette approche était vouée à l'échec dès le départ.

Ceux qui ont posté le rand () + 1 utilisent la solution la plus utilisée afin de garantir qu'ils n'obtiennent pas de nombre négatif. Mais cette approche n'est vraiment pas la meilleure façon non plus.

La meilleure chose que vous puissiez faire est de prendre le temps supplémentaire pour écrire et utiliser la gestion des exceptions appropriée, et n'ajouter au nombre rand () que si et / ou lorsque vous vous retrouvez avec un résultat nul. Et, pour gérer correctement les nombres négatifs. La fonctionnalité rand () n'est pas parfaite et doit donc être utilisée en conjonction avec la gestion des exceptions pour vous assurer d'obtenir le résultat souhaité.

Prendre le temps et les efforts supplémentaires pour enquêter, étudier et implémenter correctement la fonctionnalité rand () en vaut la peine. Juste mes deux cents. Bonne chance dans vos efforts ...