rand () donne presque le même nombre à chaque fois

Les ordinateurs ne génèrent pas vraiment de nombres aléatoires. Ainsi, lorsque vous exécutez votre code deux fois sur la même seconde, il renvoie la même valeur. Afin d'avoir un meilleur résultat, vous pouvez ajouter la valeur de getpid () dans srand.

Gardez à l'esprit que ce n'est toujours pas vraiment aléatoire.

time () a une résolution de 1 seconde. Ainsi, votre programme ne générera à une valeur différente qu'après une demi-seconde en moyenne.

Si votre compilateur prend en charge C11, vous pouvez utiliser une fonction de résolution plus élevée, timespec_get () . Votre srand (time (0)); se transformera alors en ce qui suit:

srand(time(0)+clock());

Ici ts.tv_nsec est la partie nanoseconde de l'horodatage, dont la résolution devrait être suffisamment bonne pour votre objectif.

Si votre compilateur ne prend pas en charge C11, vous pouvez toujours avoir une meilleure source de graine aléatoire que time ( ) , avec une résolution d'environ une milliseconde (la résolution réelle est donnée par la macro CLOCKS_PER_SEC ): la fonction clock () . Ensuite, votre code d'amorçage sera

srand(clock());

Notez cependant qu'il peut en fait être une mauvaise source d'entropie, surtout si votre système d'exploitation n'est pas occupé, de sorte que le programme fonctionnerait quelque peu rythme prévisible. C'est parce que le début de l'ère de clock () est lié à l'exécution du programme, pas au temps réel. Il vaudrait peut-être mieux par ex. utilisez une somme de clock () et time (0) pour obtenir une valeur plus imprévisible:

struct timespec ts;
timespec_get(&ts, TIME_UTC);
srand(ts.tv_nsec);

Si votre rand est interrompu, vous pouvez essayer l'un des xorshift pseudo-aléatoire générateurs de nombres. Ils ne sont pas parfaits mais la mise en œuvre qui en résulte est très courte. Cela pourrait être suffisant pour votre propre usage.

Voici un exemple d'implémentation: j'ai utilisé cet un comme référence. / p>

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

uint64_t    xorshift64s(uint64_t seed)
{
    static uint64_t i = 1;

    if (seed != 0)
        i = seed;
    i ^= i >> 12;
    i ^= i << 25;
    i ^= i >> 27;
    i *= 0x2545f4914f6cdd1d;
    return (i >> 32);
}


int main()
{
    srand(time(0));
    int i = (rand() % 6401);
    printf("rand    : Random number between 0 and 6400: %d\n", i);
    xorshift64s(time(0));
    int j = (xorshift64s(0) % 6401);
    printf("xorshift: Random number between 0 and 6400: %d\n", j);
    return 0;
}

Si quelqu'un d'autre rencontre ce problème, je pense avoir trouvé une solution de contournement. Je sais que ce n'est pas une solution parfaite, mais c'est la seule qui a fonctionné pour moi. Je pense que le générateur de nombres aléatoires utilisé dans mon compilateur n'aime pas du tout des graines similaires. Avec cet extrait de code, il génère en fait des nombres semi-aléatoires assez acceptables:

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

int main()
{
    srand((unsigned int)time(0) * 100000000);
    int i = (rand() % 6401);
    printf("Random number between 0 and 6400: %d\n", i);
    return 0;
}

C'est là que j'ai obtenu mon compilateur de poubelle de btw: http://tdm-gcc.tdragon.net/download

Les nombres générés par rand ne sont pas vraiment aléatoires, ils sont générés avec une formule. C'est pourquoi l'ensemencement est à la fois possible et nécessaire. Selon la formule utilisée, il peut y avoir une forte corrélation entre la graine et les premiers nombres aléatoires.

Les remèdes sont d'utiliser une meilleure formule (quelque chose qui n'est pas rand ), d'utiliser une graine plus aléatoire ou de gaspiller quelques nombres aléatoires juste après l'ensemencement.