Warum erscheinen die Ziffern 1, 2 und 3 so häufig mit der Funktion C rand()?

Was ich versuche, ist, einige Zufallszahlen (nicht unbedingt einstellig) zu generieren

29106
7438
5646
4487
9374
28671
92
13941
25226
10076

und zähle dann die Anzahl der Ziffern, die ich bekomme:

count[0] =       3  Percentage =  6.82
count[1] =       5  Percentage = 11.36
count[2] =       6  Percentage = 13.64
count[3] =       3  Percentage =  6.82
count[4] =       6  Percentage = 13.64
count[5] =       2  Percentage =  4.55
count[6] =       7  Percentage = 15.91
count[7] =       5  Percentage = 11.36
count[8] =       3  Percentage =  6.82
count[9] =       4  Percentage =  9.09

Dies ist der Code, den ich verwende:

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

int main() {

    int i;
    srand(time(NULL));
    FILE* fp = fopen("random.txt", "w");    
    // for(i = 0; i < 10; i++)
    for(i = 0; i < 1000000; i++)
        fprintf(fp, "%d\n", rand());
    fclose(fp);

    int dummy;
    long count[10] = {0,0,0,0,0,0,0,0,0,0};
    fp = fopen("random.txt", "r");
    while(!feof(fp)) {
        fscanf(fp, "%1d", &dummy);
        count[dummy]++;                 
    }
    fclose(fp);

    long sum = 0;
    for(i = 0; i < 10; i++)
        sum += count[i];

    for(i = 0; i < 10; i++)
        printf("count[%d] = %7ld  Percentage = %5.2f\n",
            i, count[i], ((float)(100 * count[i])/sum));

}

Wenn ich eine große Anzahl von Zufallszahlen (1000000) erzeuge, erhalte ich folgendes Ergebnis:

count[0] =  387432  Percentage =  8.31
count[1] =  728339  Percentage = 15.63
count[2] =  720880  Percentage = 15.47
count[3] =  475982  Percentage = 10.21
count[4] =  392678  Percentage =  8.43
count[5] =  392683  Percentage =  8.43
count[6] =  392456  Percentage =  8.42
count[7] =  391599  Percentage =  8.40
count[8] =  388795  Percentage =  8.34
count[9] =  389501  Percentage =  8.36

Beachten Sie, dass 1, 2 und 3 zu viele Treffer haben. Ich habe versucht, dies mehrmals auszuführen, und jedes Mal erhalte ich sehr ähnliche Ergebnisse.

Ich versuche zu verstehen, was dazu führen könnte, dass 1, 2 und 3 viel häufiger erscheinen als jede andere Ziffer.

In Anlehnung an das, was Matt Joiner und Pascal Cuoq betonten,

Ich habe den zu verwendenden Code geändert

for(i = 0; i < 1000000; i++)
    fprintf(fp, "%04d\n", rand() % 10000);
// pretty prints 0
// generates numbers in range 0000 to 9999

und das ist, was ich bekomme (ähnliche Ergebnisse bei mehreren Läufen):

count[0] =  422947  Percentage = 10.57
count[1] =  423222  Percentage = 10.58
count[2] =  414699  Percentage = 10.37
count[3] =  391604  Percentage =  9.79
count[4] =  392640  Percentage =  9.82
count[5] =  392928  Percentage =  9.82
count[6] =  392737  Percentage =  9.82
count[7] =  392634  Percentage =  9.82
count[8] =  388238  Percentage =  9.71
count[9] =  388352  Percentage =  9.71

Was kann der Grund dafür sein, dass 0, 1 und 2 bevorzugt werden?

Danke an alle. Verwenden

int rand2(){
    int num = rand();
    return (num > 30000? rand2():num);     
}

    fprintf(fp, "%04d\n", rand2() % 10000);

Ich bekomme

count[0] =  399629  Percentage =  9.99
count[1] =  399897  Percentage = 10.00
count[2] =  400162  Percentage = 10.00
count[3] =  400412  Percentage = 10.01
count[4] =  399863  Percentage = 10.00
count[5] =  400756  Percentage = 10.02
count[6] =  399980  Percentage = 10.00
count[7] =  400055  Percentage = 10.00
count[8] =  399143  Percentage =  9.98
count[9] =  400104  Percentage = 10.00

rand() generiert einen Wert aus 0 zu RAND_MAX. RAND_MAX ist eingestellt auf INT_MAX auf den meisten Plattformen, die sein können 32767 oder 2147483647.

Für Ihr oben angegebenes Beispiel scheint es so zu sein RAND_MAX ist 32767. Dies wird eine ungewöhnlich hohe Frequenz von platzieren 1, 2 und 3 für die höchstwertige Ziffer für die Werte von 10000 zu 32767. Sie können das in geringerem Maße beobachten, Werte bis zu 6 und 7 wird ebenfalls leicht begünstigt.

In Bezug auf die bearbeitete Frage,

Das liegt daran, dass die Ziffern auch bei Ihnen noch nicht gleichmäßig verteilt sind % 10000. Davon ausgehen RAND_MAX == 32767und rand() ist vollkommen einheitlich.

Für jeweils 10.000 Zahlen, beginnend bei 0, erscheinen alle Ziffern einheitlich (jeweils 4.000). Allerdings ist 32.767 nicht durch 10.000 teilbar. Daher liefern diese 2.768 Zahlen mehr führende 0, 1 und 2 für die endgültige Zählung.

Der genaue Beitrag dieser 2.768 Zahlen ist:

digits count
0      1857
1      1857
2      1625
3      857
4      857
5      857
6      855
7      815
8      746
9      746

Wenn Sie 12.000 für die ersten 30.000 Zahlen zur Zählung hinzufügen und dann durch die Gesamtzahl der Ziffern (4 × 32.768) dividieren, sollten Sie die erwartete Verteilung erhalten:

number  probability (%)
0       10.5721
1       10.5721
2       10.3951
3        9.80911
4        9.80911
5        9.80911
6        9.80759
7        9.77707
8        9.72443
9        9.72443

das ist nah an dem, was Sie bekommen.

Wenn Sie eine wirklich einheitliche Ziffernverteilung wünschen, müssen Sie dies tun ablehnen diese 2.768 Zahlen:

int rand_4digits() {
  const int RAND_MAX_4_DIGITS = RAND_MAX - RAND_MAX % 10000;
  int res;
  do {
    res = rand();
  } while (res >= RAND_MAX_4_DIGITS);
  return res % 10000;
}

Sieht aus wie Benfords Gesetz – siehe http://en.wikipedia.org/wiki/Benford%27s_lawoder alternativ ein nicht sehr guter RNG.

Das liegt daran, dass Sie Zahlen zwischen generieren 0 und RAND_MAX. Die generierten Zahlen sind gleichmäßig verteilt (dh ungefähr gleiche Wahrscheinlichkeit für jede Zahl), jedoch kommen die Ziffern 1,2,3 häufiger vor als andere in diesem Bereich. Versuchen Sie, dazwischen zu generieren 0 und 10wobei jede Ziffer mit der gleichen Wahrscheinlichkeit vorkommt und Sie eine schöne Verteilung erhalten.

Wenn ich verstehe, was das OP (Person, die die Frage stellt) will, wollen sie bessere Zufallszahlen machen.

rand() und random() ergeben ehrlich gesagt keine sehr guten Zufallszahlen; beide schneiden schlecht ab, wenn sie gegen diehard und dieharder getestet werden (zwei Pakete zum Testen der Qualität von Zufallszahlen).

Der Mersenne-Twister ist ein beliebter Zufallszahlengenerator, der für so ziemlich alles gut ist, außer für kryptostarke Zufallszahlen; es besteht alle Diehard(er)-Tests mit Bravour.

Wenn man kryptostarke Zufallszahlen benötigt (Zahlen, die nicht erraten werden können, selbst wenn jemand weiß, welcher bestimmte kryptostarke Algorithmus verwendet wird), gibt es eine Reihe von Stream-Chiffren. Die, die ich gerne benutze, heißt RadioGatún[32]und hier ist eine kompakte C-Darstellung davon:

/*Placed in the public domain by Sam Trenholme*/
#include <stdint.h>
#include <stdio.h> 
#define p uint32_t
#define f(a) for(c=0;c<a;c++)
#define n f(3){b[c*13]^=s[c];a[16+c]^=s[c];}k(a,b 
k(p *a,p *b){p A[19],x,y,r,q[3],c,i;f(3){q[c]=b[c
*13+12];}for(i=12;i;i--){f(3){b[c*13+i]=b[c*13+i- 
1];}}f(3){b[c*13]=q[c];}f(12){i=c+1+((c%3)*13);b[
i]^=a[c+1];}f(19){y=(c*7)%19;r=((c*c+c)/2)%32;x=a
[y]^(a[(y+1)%19]|(~a[(y+2)%19]));A[c]=(x>>r)|(x<<
(32-r));}f(19){a[c]=A[c]^A[(c+1)%19]^A[(c+4)%19];
}a[0]^=1;f(3){a[c+13]^=q[c];}}l(p *a,p *b,char *v
){p s[3],q,c,r,x,d=0;for(;;){f(3){s[c]=0;}for(r=0
;r<3;r++){for(q=0;q<4;q++){if(!(x=*v&255)){d=x=1;
}v++;s[r]|=x<<(q*8);if(d){n);return;}}}n);}}main(
int j,char **h){p a[39],b[39],c,e,g;if(j==2){f(39
){a[c]=b[c]=0;}l(a,b,h[1]);f(16){k(a,b);}f(4){k(a
,b);for(j=1;j<3;++j){g=a[j];for(e=4;e;e--){printf
("%02x",g&255);g>>=8;}}}printf("\n");}}

Es gibt auch viele andere wirklich gute Zufallszahlengeneratoren da draußen.

Wenn Sie einen Zufallswert aus dem Bereich generieren möchten [0, x), instead of doing rand()%x, you should apply formula x*((double)rand()/RAND_MAX), which will give you nicely distributed random values.

Say, RAND_MAX is equal to 15, so rand will give you integers from 0 to 15. When you use modulo operator to get random numbers from [0, 10), values [0,5] wird eine höhere Frequenz haben als [6,9]Weil 3 == 3%10 == 13%10.