Как ввести рандомное число в си. Генерация случайных чисел в языке си. Генерация истинно случайных чисел

Функция, генерирующая псевдослучайные числа, имеет прототип в файле библиотеки stdlib.h :

1
2
3
4
5
6

unsigned long int next = 1;
int rand(void )
{
next = next * 1103515245;
return ((unsigned int )(next / 65536) * 2768);
}

Если необходимо сгенерировать последовательность в диапазоне , то используется формула:

Number = rand()%(M2-M1+1) + M1;

где Number – генерируемое число. M2-M1+1 – полный диапазон представления чисел. M1 – смещение указанного диапазона относительно 0; % — остаток от деления .

Например, если требуется сгенерировать последовательность в диапазоне [-10;10], то вызов функции будет выглядеть как

Number = rand()%(10+10+1)-10

Number = rand()%(21)-10

В результате получения остатка от деления на 21 имеем число от 0 до 20. Вычитая из полученного числа 10, получим число в искомом диапазоне [-10;10].

Однако генерируемая функцией rand() последовательность будет иметь один и тот же вид при каждом запуске программы.

Для генерации различных последовательности при каждом запуске программы необходимо проинициализировать глобальную переменную next значением, отличным от 1. С этой целью используется функция
void srand(unsigned int seed)
{ next = seed; }
Чтобы инициализация next при каждом запуске программы была различной в качестве аргумента seed чаще всего используется текущее время.

Пример Заполнить массив из 20 элементов случайными числами в диапазоне от 0 до 99.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include
#include
#include
#define SIZE 20
int main() {
int a;
srand(time(NULL ));
for (int i = 0; i {
a[i] = rand() % 100;
printf("%d " , a[i]);
}
getchar();
return 0;
}

Часто возникает задача расставить уже имеющийся набор значений в произвольном порядке. С этой целью также используется генератор псевдослучайных чисел. При этом создается массив и заполняется значениями.
Сама процедура перемешивания происходит следующим образом. Генерируется два значения индексов массива случайным образом, и значения элементов с полученными индексами меняются местами. Процедура повторяется не менее N раз, где N - количество элементов массива.
В качестве примера рассмотрим перемешивание 20 значений (от 1 до 20) и повторим процедуру 20 раз.

Реализация на Си

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include
#include
#include
#define SIZE 20
int main() {
int a;
srand(time(NULL ));

for (int i = 0; i < SIZE; i++)
{
a[i] = i + 1;
printf("%2d " , a[i]);
}
for (int i = 0; i < SIZE; i++)
{
// Генерируем случайно два индекса элементов
int ind1 = rand() % 20;
int ind2 = rand() % 20;
// и меняем местами элементы с этими индексами
int temp = a;
a = a;
a = temp;
}
printf("\n" );

for (int i = 0; i < SIZE; i++)
printf("%2d " , a[i]);
getchar();
return 0;
}

Часто возникает задача произвольного выбора ранее заданных элементов массива. Причем необходимо предусмотреть отсутствие повторений в выборе этих элементов.
Алгоритм такого выбора состоит в следующем:

• Выбираем произвольно индекс элемента массива
• Если элемент с таким индексом уже был ранее выбран, двигаемся вправо, пока не дойдём до следующего не выбранного элемента. При этом следим за тем, чтобы "движение вправо" не вышло за границы массива. Если фиксируется выход за границы массива, начинаем просмотр элементов массива с начала.
• Выбираем элемент
• Фиксируем элемент как выбранный
• Повторяем указанные действия для всех остальных элементов

Реализации на Си
В результате получаем новый массив b , сформированный произвольной выборкой элементов массива a .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include
#include
#include
#define SIZE 20
int main() {
int a;
int b; // результирующий массив
srand(time(NULL ));
// Заполняем массив последовательными значениями от 1 до 20
for (int i = 0; i < SIZE; i++)
{
a[i] = i + 1;
printf("%2d " , a[i]);
}

for (int i = 0; i < SIZE; i++)
{
int ind = rand() % 20; // выбираем произвольный индекс
while (a == -1) // пока элемент "выбран"
{
ind++; // двигаемся вправо
ind %= 20; // если дошли до правой границы, возвращаемся в начало
}
b[i] = a; // записываем следующий элемент массива b
a = -1; // отмечаем элемент массива a как "выбранный"
}
printf("\n" );
// Выводим получившийся массив
for (int i = 0; i < SIZE; i++)
printf("%2d " , b[i]);
getchar();
return 0;
}

Теги: си рандом, си случайные числа, генерация случайных чисел, ГСЧ, псевдослучайные числа, метод монте-карло

Псевдослучайные числа

Г енерация псевдослучайных чисел – это сложная математическая задача. Данная статья не ставит перед собой задачи охватить эту тему. Далее понятие «случайное число» будет означать псевдослучайное, если это не оговорено особо.

С примерами использования случайных чисел вы сталкиваетесь повсюду. Псевдослучайные числа используются в дизайне и графике, для генерации уровней в компьютерных играх и симулирования ИИ. Наборы случайных чисел используются в математических алгоритмах (см. Методы Монте-Карло).

Очевидно, что задача генерации случайных чисел на классическом процессоре не может быть решена, так как работа компьютера детерминирована по определению. Тем не менее, можно сгенерировать очень длинные наборы чисел такие, что их распределение будет иметь те же свойства, что и наборы истинно случайных чисел.

Важно, что для решения той или иной задачи необходимо правильно выбирать генератор, или как минимум знать его свойства. Например, при моделировании физического процесса можно получить совершенно разные и часто неверные результаты, в зависимости от выбора генератора случайных чисел.

Посмотрим стандартный генератор.

#include #include #include int main() { int i, r; srand(42); for (i = 0; i < 10; i++) { r = rand(); printf("%d\n", r); } _getch(); return 0; }

Для начала необходимо инициализировать генератор случайных чисел (ГСЧ, или RNG - random number generator), задать зерно – seed, на основе которого в дальнейшем будет происходить генерация. Важно, что для одного и того же начального значения генератор будет возвращать одни и те же числа.

Srand(42);

Присваиваем переменной r случайное значение

R = rand();

Значение будет лежать в диапазоне от 0 до RAND_MAX.

Для того, чтобы при следующем запуске получить новый набор чисел, нужно инициализировать генератор каждый раз разными значениями. Например, можно использовать системной время:

Srand(time(NULL));

Srand(_getpid());

Функция getpid библиотеки process.h возвращает идентификатор процесса (можно также использовать getpid, не POSIX версию функции).

Центральная Предельная Теорема

Очень важно сразу напомнить или познакомить с центральной предельной теоремой. Неформальное определение – распределение суммы слабо зависимых случайных величин стремится к нормальному. Пальцеобразное объяснение: если сложить несколько случайных величин, независимо от их распределения, то распределение суммы будет нормальным. Часто можно увидеть такой код

#include #include #include int main() { int i, r, r1, r2, r3; srand(time(NULL)); r1 = rand(); r2 = rand(); r3 = rand(); r = (r1 + r2 + r3) / 3; printf("%d", r); _getch(); return 0; }

Генерация случайных чисел на заданном отрезке

Во-первых, получим случайное число от нуля до единицы:

Const float RAND_MAX_F = RAND_MAX; float get_rand() { return rand() / RAND_MAX_F; }

Для получения числа в отрезке от нуля до N умножим N на случайное число от нуля до единицы. Для получения случайного числа от M До N, сдвинем полученное число на M.

Float get_rand_range(const float min, const float max) { return get_rand() * (max - min) + min; }

Для получения целого числа, будем брать остаток от деления на длину интервала. Но остаток от деления будет возвращать число на единицу меньше, чем наш интервал, поэтому увеличим его на единицу:

Int get_rand_range_int(const int min, const int max) { return rand() % (max - min + 1) + min; }

Пример использования случайных чисел для вычисления интеграла. Пусть у нас есть некоторая гладкая функция от одной переменной. Ограничим её квадратом от a до b, и от 0 до некоторой точки, которая заведомо больше нашей функции.

Будем случайным образом кидать точки на нашем квадрате. Если они лежат выше функции (на рисунке изображены зелёными крестиками), то отнесём их к первой группе A, если ниже функции (на рисунке красные), то отнесём их ко второй группе B. Положение точек случайное и распределено равномерно (т.к. стандартный генератор даёт равномерное распределение. Этот простой пример, кстати, уже показывает, насколько важно знать свойства ГСЧ). Тогда отношение красных точек к общему числу точек будет равно отношению площади под графиком к общей площади. А общая площадь – это квадрат (b-a) на q.

Src="/images/c_random_integral.png" alt="Всё, что случайно попадает выше нашей функции - зелёное, всё что ниже - красное.
Отношение зелёного к красному будет равно отношению площади над графиком к площади под графиком."> Всё, что случайно попадает выше нашей функции - зелёное, всё что ниже - красное.
Отношение зелёного к красному будет равно отношению площади над графиком к площади под графиком.

Применим наши выкладки – найдём интеграл функции x^2 на отрезке от 0 до двух двумя способами.

#include #include #include #include #include const float RAND_MAX_F = RAND_MAX; float get_rand() { return rand() / RAND_MAX_F; } float get_rand_range(const float min, const float max) { return get_rand() * (max - min) + min; } #define ROUNDS 1000 float fun(float x) { return x * x; } float square_square(float a, float b, float q) { float h = (b - a) / (float)ROUNDS; float sum = 0; for (; a < b; a += h) { sum += fun(a) * h; } return sum; } float rand_square(float a, float b, float q) { float res; float x, y; int i; int lower = 0; float ratio; float square; srand(time(NULL)); for (i = 0; i < ROUNDS; i++) { x = get_rand_range(a, b); y = get_rand_range(0, q); res = fun(x); if (res > y) { lower++; } } ratio = (float)lower / (float)ROUNDS; square = (b - a) * q * ratio; return square; } int main() { float abs_ans = 2.66667f; float sr = rand_square(0, 2, 4); float ss = square_square(0, 2, 4); printf("Rounds = %d\n", ROUNDS); printf("Sa = %.5f\n", abs_ans); printf("Sr = %.5f\n", sr); printf("Ss = %.5f\n", ss); printf("dr = %.5f\n", fabs(sr - abs_ans)); printf("ds = %.5f\n", fabs(ss - abs_ans)); _getch(); return 0; }

Поиграйте со значением ROUNDS, измените его и посмотрите, как меняется точность вычислений.

Генерация истинно случайных чисел

Для генерации настоящих случайных чисел используют генераторы, основанные на каких-то случайных физических процессах. Например, на тепловых шумах, на подсчёте числа делений радиоактивного вещества, на атмосферных шумах и т.п. Недостаток таких генераторов – низкая скорость работы (количество сгенерированных чисел в секунду) ; конечно, такие генераторы обычно являются отдельным устройством.

Очень часто в программах возникает необходимость использования случайных чисел - от заполнения массива до криптографии. Для получения последовательности случайных чисел в языке C# имеется класс Random . Этот класс предусматривает два конструктора:

• Random () - инициализирует экземпляр класса Random с помощью начального значения, зависящего от текущего времени. Как известно, время может быть представлено в тиках - 100-наносекундных импульсах, начиная с 1 января 0001 года. И значение времени в тиках представляет собой 64-битное целое число, которое и будет использоваться для инициализации экземпляра генератора случайных чисел.
• Random (Int32 ) - инициализирует экземпляр класса Random с помощью указанного начального значения. Такая инициализация генератора случайных чисел может быть удобна на этапе отладки программы, поскольку в этом случае при каждом запуске программы будут генерироваться одни и те же "случайные" числа.

• Next() - возвращает случайное целое неотрицательное число формата Int32 .
• Next(Int32 ) - возвращает случайное целое неотрицательное число, которое меньше указанного значения.
• Next(Int32 min, Int32 max) - возвращает случайное целое число в указанном диапазоне. При этом должно соблюдаться условие min

• NextBytes(Byte ) - заполняет элементы указанного массива байтов случайными числами.
• NextDouble() - возвращает случайное число с плавающей запятой, в диапазоне )
  break ; // совпадение найдено, элемент не подходит
  }
  if (j == i)
  { // совпадение не найдено
  a[i] = num; // сохраняем элемент
  i++; // переходим к следующему элементу
  }
  }
  for (int i = 0; i < 100; i++)
  {
  
  if (i % 10 == 9)
  Console .WriteLine();
  }
  Console .ReadKey();
  }
  }
  }

  

  Однако чем ближе к концу массива, тем больше генераций необходимо производить для получения неповторяющегося значения.
  Следующий пример отображает количество вызовов метода Next() для получения каждого элемента, а также общее количество сгенерированных случайных чисел для заполнения массива из 100 элементов неповторяющимися значениями.

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53

  using System;
  namespace MyProgram
  {
  class Program
  {
  static void Main(string args)
  {
  Random rnd = new Random ();
  int a = new int ; // массив элементов
  int count = new int ; // массив количества генераций
  a = rnd.Next(0, 101);
  int c = 0; // счетчик количества генераций
  count = 1; // a генерируется только 1 раз
  for (int i = 1; i < 100;)
  {
  int num = rnd.Next(0, 101);
  c++; // сгенерировали элемент еще один раз
  int j;
  for (j = 0; j < i; j++)
  {
  if (num == a[j])
  break ;
  }
  if (j == i)
  {
  a[i] = num; i++;
  count[i] = c; c = 0; // сохраняем количество генераций
  }
  }
  // Вывод значений элементов
  Console .WriteLine("Значения элементов" );
  for (int i = 0; i < 100; i++)
  {
  Console .Write("{0,4} " , a[i]);
  if (i % 10 == 9)
  Console .WriteLine();
  }
  Console .WriteLine();
  // Вывод количества генераций
  Console .WriteLine("Количество генераций элементов" );
  int sum = 0;
  for (int i = 0; i < 100; i++)
  {
  sum += count[i];
  Console .Write("{0,4} " , count[i]);
  if (i % 10 == 9)
  Console .WriteLine();
  }
  Console .WriteLine("Общее количество генераций - {0}" , sum);
  Console .ReadKey();
  }
  }
  }
  

  void Main(string args)
  {
  Random rnd = new Random ();
  int a = new int ;
  for (int i = 0; i < 100; i++)
  a[i] = i;
  for (int i = 0; i < 50; i++)
  {
  int i1 = rnd.Next(0, 100); // первый индекс
  int i2 = rnd.Next(0, 100); // второй индекс
  // обмен значений элементов с индексами i1 и i2
  int temp = a;
  a = a;
  a = temp;
  }
  Console .WriteLine("Значения элементов" );
  for (int i = 0; i < 100; i++)
  {
  Console .Write("{0,4} " , a[i]);
  if (i % 10 == 9)
  Console .WriteLine();
  }
  Console .ReadKey();
  }
  }
  }

  

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

  Пожалуйста, приостановите работу AdBlock на этом сайте.

  Иногда может возникнуть необходимость в генерации случайных чисел. Простой пример.

  Пример: Определение победителя в конкурсе репостов.

  Имеется список из 53 человек. Необходимо выбрать из них победителя. Если вы выберете его самостоятельно, то вас могут обвинить в предвзятости. Поэтому вы решили написать программу. Она будет работать следующим образом. Вы вводите количество участников N , после чего программа выводит одно число – номер победителя.

  Как получить число от игрока, вам уже известно. А вот как заставить компьютер загадать случайное число? В этом уроке вы этому научитесь.

  Функция rand().

  Данная функция возвращает случайное целое число в диапазоне от нуля до RAND_MAX . RAND_MAX это специальная константа языка Си, в которой содержится максимальное целое число, которое может быть возвращено функцией rand() .

  Функция rand() определена в заголовочном файле stdlib.h . Поэтому, если хотите использовать rand в своей программе, не забудьте подключить этот заголовочный файл. Константа RAND_MAX тоже определена в этом файле. Вы можете найти этот файл у себя на компьютере и посмотреть её значение.

  Давайте посмотрим на эту функцию в действии. Запустим следующий код:

  Листинг 1.

  #include // чтобы пользоваться функцией printf #include // чтобы пользоваться функцией rand int main(void) { /* генерируем пять случайных целых чисел */ printf("%d\n", rand()); printf("%d\n", rand()); printf("%d\n", rand()); printf("%d\n", rand()); printf("%d\n", rand()); }

  Должно получиться что-то вроде этого.

  Рис.1 Пять случайных чисел, сгенерированных функцийе rand

  Но нам бы хотелось получить числа от 1 до 53 , а не всё подряд. Ниже описано несколько трюков, позволяющих наложить ограничения на функцию rand() .

  Ограничить случайные числа сверху.

  Кто в школе ждал момента, когда ему пригодится математика, приготовьтесь. Этот момент наступил. Чтобы ограничить сверху случайные числа, можно воспользоваться операцией получения остатка от деления, которую вы изучили в прошлом уроке. Наверное вы знаете, что остаток от деления на числа K всегда меньше числа K . Например, при делении на 4 могут получиться остатки 0, 1, 2 и 3 . Поэтому если вы хотите ограничить сверху случайные числа числом K , то просто возьмите остаток от деления на K . Вот так:

  Листинг 2.

  #include #include int main(void) { /* генерируем пять случайных целых чисел меньших 100 */ printf("%d\n", rand()%100); printf("%d\n", rand()%100); printf("%d\n", rand()%100); printf("%d\n", rand()%100); printf("%d\n", rand()%100); }

  
  

  Рис.2 Пять случайных чисел меньше 100

  Ограничить числа снизу.

  Функция rand возвращает случайные числа из отрезка . А что если нам нужны только числа большие числа M (например, 1000 )? Как быть? Всё просто. Просто прибавим к тому, что вернула функция rand, наше значение M . Тогда если функция вернёт 0 , итоговый ответ будет M , если 2394 , то итоговый ответ будет M + 2394 . Этим действием мы как бы сдвигаем все числа на M единиц вперёд.

  Задать границы функции rand сверху и снизу.

  Например, получить числа от 80 до 100 . Кажется, нужно просто объединить два способа, которые приведены выше. Получим что-то вроде этого:

  Листинг 3.

  #include #include int main(void) { /* генерируем пять случайных целых чисел больших 80 и меньших 100 */ printf("%d\n", 80 + rand()%100); printf("%d\n", 80 + rand()%100); printf("%d\n", 80 + rand()%100); printf("%d\n", 80 + rand()%100); printf("%d\n", 80 + rand()%100); }

  Попробуйте запустить эту программу. Удивлены?

  Да, такой способ работать не будет. Давайте прокрутим эту программу руками, чтобы убедиться в том, что мы допустили ошибку. Допустим rand() вернула число 143 . Остаток от деления на 100 равен 43 . Дальше 80 + 43 = 123 . Значит такой способ не работает. Подобная конструкция выдаст числа от 80 до 179 .

  Давайте разберём по действиям наше выражение. rand()%100 может выдать числа от 0 до 99 включительно. Т.е. из отрезка .
  Операция + 80 сдвигает наш отрезок на 80 единиц вправо. Получаем .
  Как видим, проблема у нас заключается в правой границе отрезка, она сдвинута вправо на 79 единиц. Это наше исходное число 80 минус 1 . Давайте наведём порядок и сдвинем правую границу назад: 80 + rand()%(100 - 80 + 1) . Тогда всё должно сработать как надо.

  В общем случае если нам нужно получить числа из отрезка , то необходимо воспользоваться следующей конструкцией:
  A + rand()%(B-A+1) .

  Согласно этой формуле перепишем нашу последнюю программу:

  Листинг 4.

  #include #include int main(void) { /* генерируем пять случайных целых чисел из отрезка */ printf("%d\n", 80 + rand()%(100 - 80 + 1)); printf("%d\n", 80 + rand()%(100 - 79)); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); }

  Результат работы:

  
  

  Рис.3 Случайные числа из диапазона

  Ну вот, теперь вы можете решить исходную задачу урока. Сгенерировать число из отрезка . Или не можете?

  Но прежде ещё немного полезной информации. Запустите последнюю программу три раза подряд и записывайте себе случайные числа, которые она генерирует. Заметили?

  Функция srand().

  Да, каждый раз появляются одни и те же одинаковые числа. «Так себе генератор!» – скажете вы. И будете не совсем правы. Действительно, генерируются всё время одинаковые числа. Но мы можем на это повлиять, для этого используется функция srand() , которая также определена в заголовочном файле stdlib.h . Она инициализирует генератор случайных чисел начальным числом.

  Скомпилируйте и запустите несколько раз вот эту программу:

  Листинг 5.

  #include #include int main(void) { srand(2); /* генерируем пять случайных целых чисел из отрезка */ printf("%d\n", 80 + rand()%(100 - 80 + 1)); printf("%d\n", 80 + rand()%(100 - 79)); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); }

  Теперь поменяйте аргумент функции srand() на другое число (надеюсь вы ещё не забыли, что такое аргумент функции?) и снова скомпилируйте и запустите программу. Последовательность чисел должна измениться. Как только мы меняем аргумент в функции srand – меняется и последовательность. Не очень практично, не правда ли? Чтобы изменить последовательность, нужно перекомпилировать программу. Вот бы это число туда подставлялось автоматически.

  И это можно сделать. Например, воспользуемся функцией time() , которая определена в заголовочном файле time.h . Данная функция, если ей в качестве аргумента передать NULL , возвращает количество секунд, прошедших c 1 января 1970 года . Вот посмотрите, как это делается.

  Листинг 6.

  #include #include #include // чтобы использовать функцию time() int main(void) { srand(time(NULL)); /* генерируем пять случайных целых чисел из отрезка */ printf("%d\n", 80 + rand()%(100 - 80 + 1)); printf("%d\n", 80 + rand()%(100 - 79)); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); }

  Вы спросите, а что такое NULL ? Резонный вопрос. А я вам пока отвечу, что это специальное зарезервированное слово такое. Могу ещё сказать, что им обозначает нулевой указатель, но т.к. это для вас никакой информации не несёт, то на данный момент рекомендую об этом не думать. А просто запомнить как некоторый хитрый трюк. В будущих уроках мы остановимся на этой штуке поподробнее.

  В языках программирования обычно предусмотрены функции, позволяющие генерировать случайные числа в определенном по умолчанию диапазоне. На самом деле генерируются не случайные, а так называемые псевдослучайные числа; они выглядят случайно, но вычисляются по вполне конкретной формуле. Но для простоты далее мы все равно будем называть их случайными.

  В языке программирования C получить случайное число можно с помощью функции rand() , которая входит в стандартную библиотеку языка. Эта функция не принимает никакие параметры.

  Задание
  Напишите программу, в которой целочисленной переменной присваивается результат выполнения функции rand() . Выведите значение переменной на экран.

  Функция rand() возвращает целое число от 0 до значения присвоенного константе RAND_MAX. Значение RAND_MAX зависит от системы и определено в заголовочном файле stdlib.h. Так, например, оно может быть равно 32767 (двухбайтовое целое) или 2147483647 (четырехбайтовое целое).

  Задание
  Определите значение RAND_MAX в вашей системе. Для этого не забудьте подключить к файлу исходного кода заголовочный файл stdlib.h.

  Код ниже выводит на экран 50 случайных чисел:

  #include #include main () { char i; for (i = 1 ; i <= 50 ; i++ ) { printf ("%15d" , rand () ) ; if (i % 5 == 0 ) printf ("\n " ) ; } }

  В теле цикла осуществляется переход на новую строку после каждых выведенных на экран пяти чисел. Для этого используется выражение, в котором находится остаток от деления i на 5, результат сравнивается с 0. Чтобы после первого числа не происходил переход на новую строку, iсначала присваивается единица, а не ноль (т.к. 0 делится на 5 без остатка).

  Задание
  Спишите код, приведенный выше. Выполните программу несколько раз, при этом обратите внимание, разные ли результаты вы получаете от выполнения к выполнению.

  Вы должны были заметить, что при каждом запуске программы числа остаются одинаковыми. Даже если вы перекомпилируете программу, результат не изменится. Данный эффект связан с тем, что начальное (инициализирующее) число, которое подставляется в формулу вычисления первого и последующих псевдослучайных чисел, для каждой системы всегда одно и то же. Однако это начальное число можно изменить с помощью функции srand() , которой в качестве параметра передается любое целое число. Понятно, что если вы зададите конкретный аргумент для функции, например, srand(1000) , то от вызова к вызову программы числа будут также одни и те же. Хотя и не те, что были бы без srand() . Поэтому появляется проблема, как сделать так, чтобы аргумент для srand() был тоже случайным? Получается замкнутый круг.

  Задание
  Переделайте программу, выводящую на экран 50 случайных чисел так, чтобы сначала у пользователя запрашивалось любое целое число с помощью scanf() , которое передавалось бы в функцию srand() .

  Пользователь программы сам может задавать инициализирующее значение. Но чаще всего это не является полноценным выходом из ситуации. Поэтому инициализирующее значение привязывают к какому-либо процессу, протекающему в операционной системе, например, к часам. Время (учитывая не только время суток, но и дату) никогда не бывает одинаковым. Значит значение для srand() , преобразованное в целое из системного времени, будет различным.

  Текущее время можно узнать с помощью функции time() , прототип которой описан в файле time.h. Передав time() в качестве параметра NULL, мы получим целое число, которое можно передать в srand() :
  srand(time(NULL));

  Задание
  Переделайте вашу программу так, чтобы инициализирующее значение зависело от системного времени.

  Получение целых случайных чисел в заданных диапазонах

  Функция rand() выдает случайное число от 0 до значения RAND_MAX. Что делать, если требуется получать случайные числа в иных диапазонах, например, от 100 до 999?

  Сначала рассмотрим более простую ситуацию: получить случайные числа от 0 до 5. Если любое целое число попытаться разделить на 5 нацело, то можно получить как 0 (когда число делится на 5 без остатка), так и 1, 2, 3, 4. Например, rand() вернула число 283. Применяя к этому числу операцию нахождения остатка от деления на 5, получим 3. Т.е. выражение rand() % 5 дает любое число в диапазоне ? Логично предположить, что следует найти остаток от деления на 6. При этом более грамотным будет следующее рассуждение: надо находить остаток от деления на размер диапазона. В данном случае он равен шести значениям: 0, 1, 2, 3, 4, 5. Чтобы найти размер диапазона надо из допустимого максимума вычесть допустимый минимум и прибавить единицу: max - min + 1. Будьте внимательны: если, например, требуется, чтобы указанный в задаче максимум не входил в диапазон, то единицу прибавлять не надо или надо вычитать единицу из максимума.

  Задание
  Напишите программу, выдающую 50 случайных чисел от 0 до 99 включительно.

  Итак, мы знаем формулу получения длины диапазона: max - min + 1. Если требуется получить число от 6 до 10 включительно, то длина диапазона будет равна 10 - 6 + 1 = 5. Выражение rand()% 5 даст любое число от 0 до 4 включительно. Но нам надо от 6 до 10. В таком случае достаточно к полученному случайному остатку прибавить 6, т.е. минимум. Другими словами, надо выполнить сдвиг. Действительно для приведенного примера:

  • если остаток был равен 0, то добавляя 6, получаем 6;
  • остаток 1, добавляем 6, получаем 7;
  • остаток 4, прибавляем 6, получаем 10;
  • остатка больше 4 не может быть.

  В таком случае формула для получения случайного числа в диапазоне выглядит так:

  Rand() % длина_диапазона + сдвиг

  где длина_диапазона вычисляется как b - a + 1, сдвиг является значением a.

  В эту формулу также вписываются случаи, когда необходимо получить случайное число от 0 до N, т.е. они являются ее частными случаями.

  Задание
  Выведите на экран ряд случайных чисел, принадлежащих диапазону от 100 до 299 включительно.

  С таким же успехом можно получать случайные отрицательные числа. Действительно, если диапазон задан как [-35, -1], то его длина будет равна -1 - (-35) + 1 = 35, что соответствует действительности; выражение получения случайного числа будет выглядеть так:

  rand() % 35 - 35

  Так, если остаток от деления составил 0, то мы получим -35, а если 34, то -1. Остальные остатки дадут значения в промежутке от -35 до -1.

  Задание
  Выведите на экран ряд случайных чисел, принадлежащих диапазону от -128 до 127 включительно.

  Получение вещественных случайных чисел

  Ситуация с вещественными числами выглядит несколько по-иному. Во-первых, мы не можем получить остаток от деления, если делимое или делитель дробное число. Во вторых при вычислении длины диапазона нельзя прибавлять единицу.

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

  Если разделить случайное число, преобразованное к вещественному типу, которое выдала функция rand() , на значение константы RAND_MAX, то получится вещественное случайное число от 0 до 1. Теперь, если это число умножить на длину диапазона, то получится число, лежащее в диапазоне от 0 до значения длины диапазона. Далее если прибавить к нему смещение к минимальной границе, то число благополучно впишется в требуемый диапазон. Таким образом формула для получения случайного вещественного числа выглядит так:

  (float) rand() / RAND_MAX * (max - min) + min

  Задание
  Заполните массив случайными числами в диапазоне от 0.51 до 1.00. Выведите значение элементов массива на экран.

  Равновероятные случайные числа

  Функция rand() генерирует любое случайное число от 0 до RAND_MAX с равной долей вероятности. Другими словами, у числа 100 есть такой же шанс выпасть, как и у числа 25876.

  Чтобы доказать это, достаточно написать программу, подсчитывающую количество выпадений каждого из значений. Если выборка (количество "испытуемых") будет достаточно большой, а диапазон (разброс значений) маленьким, то мы должны увидеть, что процент выпадений того или иного значения приблизительно такой же как у других.

  #include #include #define N 500 main () { int i; int arr[ 5 ] = { 0 } ; srand (time (NULL) ) ; for (i= 0 ; i < N; i++ ) switch (rand () % 5 ) { case 0 : arr[ 0 ] ++; break ; case 1 : arr[ 1 ] ++; break ; case 2 : arr[ 2 ] ++; break ; case 3 : arr[ 3 ] ++; break ; case 4 : arr[ 4 ] ++; break ; } for (i= 0 ; i < 5 ; i++ ) printf ("%d - %.2f%%\n " , i, ((float ) arr[ i] / N) * 100 ) ; }

  В приведенной программе массив из пяти элементов сначала заполняется нулями. Случайные числа генерируются от 0 до 4 включительно. Если выпадает число 0, то увеличивается значение первого элемента массива, если число 1, то второго, и т.д. В конце на экран выводится процент выпадения каждого из чисел.