Почему цифры 1, 2 и 3 появляются так часто использующий C рэнд () функция?

Это потому, что вы генерируете числа между 0 и RAND_MAX. Сгенерированные числа распределены равномерно (то есть приблизительно одинаковая вероятность для каждого числа), однако цифры 1,2,3 встречаются чаще, чем другие в этом диапазоне. Попробуйте произвести генерацию между 0 и 10, где каждая цифра встречается с одинаковой вероятностью, и вы получите хорошее распределение.

Если я понимаю, чего хочет ОП (человек, задающий вопрос), он хочет получать более точные случайные числа. Откровенно говоря,

rand () и random () не делают хороших случайных чисел; они оба показывают плохие результаты при тестировании на стойкость и стойкость (два пакета для проверки качества случайных чисел).

Твистер Мерсенна - популярный генератор случайных чисел, который хорош практически для всего, кроме криптостойких случайных чисел; он безупречно проходит все жесткие (эр) тесты.

Если кому-то нужны криптостойкие случайные числа (числа, которые невозможно угадать, даже если кто-то знает, какой конкретный криптостойкий алгоритм используется), существует ряд потоковых шифров. Тот, который мне нравится использовать, называется RadioGatún [32], и вот его компактное C-представление:

/*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");}}

Есть также много других действительно хороших генераторов случайных чисел.

Похоже на закон Бенфорда - см. http://en.wikipedia.org/wiki/Benford%27s_law или не очень хороший ГСЧ.

Когда вы хотите сгенерировать случайное значение из диапазона [0, x), вместо того, чтобы делать rand()%x, вы должны применить формулу x*((double)rand()/RAND_MAX), которая даст вам красиво распределенные случайные значения.

Скажем, RAND_MAX равен 15, поэтому rand даст вам целые числа от 0 до 15. Когда вы используете оператор modulo для получения случайных чисел из [0, 10), значения [0,5] будут иметь большую частоту, чем [6,9], потому что 3 == 3%10 == 13%10.

Что касается отредактированного вопроса,

Это потому, что цифры все еще распределяются неравномерно, даже если вы % 10000 . Предположим, что RAND_MAX == 32767 и rand () совершенно однородны.

Для каждых 10 000 чисел, отсчитываемых от 0, все цифры будут отображаться одинаково (по 4 000 каждая). Однако 32 767 не делятся на 10 000. Следовательно, эти 2768 чисел предоставят больше ведущих 0, 1 и 2 для окончательного подсчета.

Точный вклад этих 2768 чисел таков:

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

прибавление 12 000 для начальных 30 000 чисел к счету, а затем разделение на общее количество цифр (4 × 32 768) даст вам ожидаемое распределение:

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

что близко к тому, что вы получаете.

Если вы хотите по-настоящему равномерное распределение цифр, вам нужно отклонить эти 2768 чисел:

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