Язык программирования C Пятое издание
 Скачать 1.85 Mb.
|
|
Упражнение 17.19. Почему можно вызывать функцию m[4].str() без предварительной проверки соответствия элемента m[4]? Упражнение 17.20. Напишите собственную версию программы для проверки номеров телефонов. Упражнение 17.21. Перепишите программу номеров телефонов из раздела 8.3.2 так, чтобы использовать функцию valid(), определенную в этом разделе. Page 929/1103 Упражнение 17.22. Перепишите программу номеров телефонов так, чтобы она позволила разделять три части номера телефона любыми символами. Упражнение 17.23. Напишите регулярное выражение для поиска почтовых индексов. У них может быть пять или девять цифр. Первые пять цифр могут быть отделены от остальных четырех тире. 17.3.4. Использование функции regex_replace() Регулярные выражения зачастую используются не только для поиска, но и для замены одной последовательности другой. Например, может потребоваться преобразовать американские номера телефонов в формат "ddd.ddd.dddd", где код города и три последующие цифры разделены точками. Когда необходимо найти и заменить регулярное выражение в исходной последовательности, используется функция regex_replace(). Подобно функции поиска, функция regex_replace(), описанная в табл. 17.12, получает входную символьную последовательность и объект класса regex. Следует также передать строку, которая описывает необходимый вывод. Таблица 17.12. Функции замены регулярного выражения m.format(dest, fmt , mft) m.format( fmt , mft) Создает форматированный вывод, используя формат строки fmt , соответствие в m и необязательные флаги match_flag_type в mft. Первая версия пишет в итератор вывода dest (см. раздел 10.5.1) и получает формат fmt , который может быть строкой или парой указателей, обозначающих диапазон в символьном массиве. Вторая версия возвращает строку, которая содержит вывод и получает формат fmt , являющийся строкой или указателем на символьный массив с нулевым символом в конце. По умолчанию mft имеет значение format_default regex_replace(dest, seq , r, fmt , mft) regex_replace( seq , r, fmt , mft) Перебирает последовательность seq , используя функцию regex_search() для поиска соответствий объекту r класса regex. Использует формат строки fmt и необязательные флаги match_flag_type в mft для формирования вывода. Первая версия пишет в итератор вывода dest и получает пару итераторов для обозначения последовательности seq . Вторая возвращает строку, содержащую вывод, a Page 930/1103 seq может быть строкой или указателем на символьный массив с нулевым символом в конце. Во всех случаях формат fmt может быть строкой или указателем на символьный массив с нулевым символом в конце. По умолчанию mft имеет значение match_default Строку замены составляют подлежащие включению символы вместе с подвыражениями из соответствующей подстроки. В данном случае следует использовать второе, пятое и седьмое подвыражения из строки замены. Первое, третье, четвертое и шестое подвыражения игнорируются, поскольку они использовались в первоначальном форматировании номера, но не являются частью формата замены. Для ссылки на конкретное подвыражение используется символ $, сопровождаемый индексом подвыражения: string fmt = "$2.$5.$7"; // переформатировать номера в ddd.ddd.dddd Схему регулярного выражения и строку замены можно использовать следующим образом: regex r(phone); // regex для поиска схемы string number = "(908) 555-1800"; cout << regex_replace(number, r, fmt) << endl; Вывод этой программы будет таким: 908.555.1800 Замена только части исходной последовательности Куда интересней использование обработки регулярных выражений для замены номеров телефонов в большом файле. Предположим, например, что имеется файл имен и номеров телефонов, содержащий такие данные: morgan (201) 555-2368 862-555-0123/ drew (973)555.0130 lee (609) 555-0132 2015550175 800.555-0000 Их следует преобразовать в такой формат: morgan 201.555.2368 862.555.0123 drew 973.555.0130 lee 609.555.0132 201.555.0175 800.555.0000 Это преобразование можно осуществить следующим образом: int main() { string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})"; regex r(phone); // Page 931/1103 regex для поиска схемы smatch m; string s; string fmt = "$2.$5.$7"; // переформатировать номера в ddd.ddd.dddd // прочитать каждую запись из входного файла while (getline(cin, s)) cout << regex_replace(s, r, fmt) << endl; return 0; } Каждая запись читается в строку s и передается функции regex_replace(). Эта функция находит и преобразует все соответствия исходной последовательности. Флаги, контролирующие соответствия и формат Кроме флагов обработки регулярных выражений, библиотека определяет также флаги, позволяющие контролировать процесс поиска соответствия и форматирования при замене. Их значения приведены в табл. 17.13. Эти флаги могут быть переданы функции regex_search(), или функции regex_match(), или функциям-членам формата класса smatch. Таблица 17.13. Флаги соответствия Определено в regex_constants::match_flag_type match_default Эквивалент format_default match_not_bol He рассматривать первый символ как начало строки match_not_eol Не рассматривать последний символ как конец строки match_not_bow Не рассматривать первый символ как начало слова match_not_eow Не рассматривать последний символ как конец слова match_any Если соответствий несколько, может быть возвращено любое из них match_not_null Не соответствует пустой последовательности match_continuous Соответствие должно начинаться с первого символа во вводе match_prev_avail У исходной последовательности есть символы перед первым format_default Строка замены использует правила ECMAScript format_sed Строка замены использует правила POSIX sed format_no_copy Не выводить несоответствующие части ввода format_first_only Заменить только первое вхождение Флаги соответствия и формата имеют тип match_flag_type. Их значения определяются в пространстве имен regex_constants. Подобно пространству имен placeholders, используемому с функциями bind() (см. раздел 10.3.4), пространство имен regex_constants определено в пространстве имен std. Для использования имени из пространства regex_constants его следует квалифицировать именами обоих пространств имен: using std::regex_constants::format_no_copy; Это объявление указывает, что когда код использует флаг format_no_copy, необходим объект из пространства имен std::regex_constants. Вместо этого можно использовать и альтернативную форму using, рассматриваемую в разделе 18.2.2: Page 932/1103 using namespace std::regex_constants; Использование флагов формата По умолчанию функция regex_replace() выводит всю исходную последовательность. Части, которые не соответствуют регулярному выражению, выводятся без изменений, а соответствующие части оформляются, как указано строкой формата. Это стандартное поведение можно изменить, указав флаг format_no_copy в вызове функции regex_replace(): // выдать только номера телефона: используется новая строка формата string fmt2 = "$2.$5.$7 "; // поместить пробел как разделитель после // последнего числа // указать regex_replace() копировать только заменяемый текст cout << regex_replace(s, r, fmt2, format_no_copy) << endl; С учетом того же ввода эта версия программы создает такой вывод: 201.555.2368 862.555.0123 973.555.0130 609.555.0132 201.555.0175 800.555.0000 Упражнения раздела 17.3.4 Упражнение 17.24. Напишите собственную версию программы для переформатирования номеров телефонов. Упражнение 17.25. Перепишите свою программу телефонных номеров так, чтобы она выводила только первый номер для каждого человека. Упражнение 17.26. Перепишите свою программу телефонных номеров так, чтобы она выводила только второй и последующие номера телефонов для людей с несколькими номерами телефонов. Упражнение 17.27. Напишите программу, которая переформатировала бы почтовый индекс с девятью цифрами как ddddd-dddd. 17.4. Случайные числа Программы нередко нуждаются в источнике случайных чисел. До нового стандарта языки С и С++ полагались на простую библиотечную функцию языка С по имени rand(). Эта функция создает псевдослучайные целые числа, равномерно распределенные в диапазоне от нуля до зависимого от системы максимального значения, которое по крайней мере не меньше 32767. У функции rand() несколько проблем: многим, если не всем, программам нужны случайные Page 933/1103 числа в совершенно другом диапазоне, отличном от используемого функцией rand(). Некоторые приложения требуют случайных чисел с плавающей запятой, другим нужны числа с неоднородным распределением. Когда разработчики пытаются преобразовывать диапазон, тип или распределение чисел, созданных функцией rand(), их случайность зачастую теряется. Библиотека случайных чисел, определенная в заголовке random, решает эти проблемы за счет набора взаимодействующих классов: классов процессора случайных чисел (random-number engine) и классов распределения случайного числа (random-number distribution). Эти классы описаны в табл. 17.14. Процессор создает последовательность беззнаковых случайных чисел, а распределение использует процессор для создания случайных чисел определенного типа в заданном диапазоне, распределенном согласно указанному вероятностному распределению. Таблица 17.14. Компоненты библиотеки случайных чисел Процессор Типы, создающие последовательность случайных беззнаковых целых чисел Распределение Типы, использующие процессор для возвращения чисел согласно заданному распределению вероятности Программы С++ больше не должны использовать библиотечную функцию rand(). Для этого следует использовать класс default_random_engine наряду с соответствующим объектом распределения. 17.4.1. Процессоры случайных чисел и распределения Процессоры случайных чисел — это классы объектов функции (см. раздел 14.8), определяющие оператор вызова, не получающий никаких аргументов и возвращающий случайное беззнаковое число. Вызвав объект типа процессора случайных чисел, можно получить простые случайные числа: default_random_engine е; // создает случайное беззнаковое число for (size_t i = 0; i < 10; ++i) // e() "вызывает" объект для создания следующего случайного числа cout << е() << " "; На системе авторов эта программа выводит: 16807 282475249 1622650073 984943658 1144108930 470211272 ... Здесь был определен объект е типа default_random_engine. В цикле for происходит вызов объекта е, возвращающий следующее случайное число. Библиотека определяет несколько процессоров случайных чисел, отличающихся Page 934/1103 производительностью и качеством случайности. Каждый компилятор определяет один из этих процессоров как стандартный процессор случайных чисел (default random engine) (тип default_random_engine). Этот тип предназначен для процессоров с наиболее общеприменимыми свойствами (табл. 17.15). Список типов и функций процессоров, определенных стандартом, приведен в разделе А.3.2. В большинстве случаев вывод процессора сам по себе непригоден для использования, поскольку, как уже упоминалось, это простые случайные числа. Проблема в том, что эти числа обычно охватывают диапазон, отличный от необходимого. Правильное преобразование диапазона случайного числа на удивление трудно.Типы распределения и процессоры Чтобы получить число в определенном диапазоне, используется объект типа распределения: // однородное распределение от 0 до 9 включительно uniform_int_distribution<unsigned> u(0,9); default_random_engine e; // создает случайные беззнаковые целые числа for (size_t i = 0; i < 10; ++i) // u использует e как источник чисел // каждый вызов возвращает однородно распределенное значение // в заданном диапазоне cout << u(e) << " "; Вывод таков: 0 1 7 4 5 2 0 6 6 9 Здесь u определяется как объект типа uniform_int_distribution<unsigned>. Этот тип создает однородно распределенные беззнаковые значения. При определении объекта этого типа можно задать минимум и максимум необходимых значений. Определение u(0, 9) указывает, что необходимы числа в диапазоне от 0 до 9 включительно . Распределение случайного числа использует включающие диапазоны, позволяющие получить любое возможное целочисленное значение в нем. Подобно типам процессоров, типы распределения также являются классами объектов функции. Типы распределения определяют оператор вызова, получающий процессор случайных чисел как аргумент. Объект распределения использует свой аргумент процессора Page 935/1103 для создания случайного числа, которое объект распределения сопоставит с определенным распределением. Обратите внимание на то, что объект процессора передается непосредственно, u(e). Если бы вызов был написан как u(е()), то произошла бы попытка передать следующее созданное е значение в u, что привело бы к ошибке при компиляции. Поскольку некоторые распределения вызывают процессор несколько раз, передается сам процессор, а не очередной результат его вызова. Когда упоминается генератор случайных чисел (random-number generator), имеется в виду комбинация объекта распределения с объектом процессора.Сравнение процессора случайных чисел и функции rand() Читатели, знакомые с библиотечной функцией rand() языка С, вероятно заметили, что вывод вызова объекта default_random_engine подобен выводу функции rand(). Процессоры предоставляют целые беззнаковые числа в определенном системой диапазоне. Функция rand() имеет диапазон от 0 до RAND_MAX. Диапазон процессора возвращается при вызове функций-членов min() и max() объекта его типа: cout << "min: " << e.min() << " max: " << e.max() << endl; На системе авторов эта программа выводит следующее min: 1 max: 2147483646 Таблица 17.15. Операции с процессором случайного числа Engine e; Стандартный конструктор; использует заданное по умолчанию начальное число для типа процессора Engine e(s); Использует как начальное число целочисленное значение s e.seed(s) Переустанавливает состояние процессора, используя начальное число s e.min() e.max() Наименьшие и наибольшие числа, создаваемые данным генератором Engine::result_type Целочисленный беззнаковый тип, создаваемый данным процессором e.discard(u) Перемещает процессор на u шагов; u имеет тип unsigned long long Процессоры создают последовательности чисел У генераторов случайных чисел есть одно свойство, которое зачастую вызывает сомнения у новичков: даже при том, что создаваемые числа случайны, при каждом запуске данный генератор возвращает ту же последовательность чисел. Факт неизменности последовательности очень полезен во время проверки. С другой стороны, разработчики, использующие генераторы случайных чисел, должны учитывать этот факт. Предположим, например, что необходима функция, создающая вектор из 100 случайных целых чисел, равномерно распределенных в диапазоне от 0 до 9. Могло бы показаться, что эту функцию следует написать следующим образом: // безусловно неправильный способ создания // вектора случайных целых чисел // Page 936/1103 эта функция выводит те же 100 чисел при каждом вызове! vector<unsigned> bad_randVec() { default_random_engine e; uniform_int_distribution<unsigned> u(0,9); vector<unsigned> ret; for (size_t i = 0; i < 100; ++i) ret.push_back(u(e)); return ret; } Однако при каждом вызове эта функция возвратит тот же вектор: vector<unsigned> v1(bad_randVec()); vector<unsigned> v2(bad_randVec()); // выводит equal cout << ((v1 == v2) ? "equal" : "not equal") << endl; Этот код выводит "equal", поскольку векторы v1 и v2 имеют те же значения. Для правильного написания этой функции объекты процессора и распределения следует сделать статическими (см. раздел 6.1.1): // возвращает вектор из 100 равномерно распределенных случайных чисел vector<unsigned> good_randVec() { // поскольку процессоры и распределения хранят состояние, их следует // сделать статическими, чтобы при каждом вызове создавались новые // числа static default_random_engine е; static uniform_int_distribution<unsigned> u(0,9); vector<unsigned> ret; for (size_t i = 0; i < 100; ++i) Page 937/1103 ret.push_back(u(e)); return ret; } Поскольку объекты e и u являются статическими, они хранят свое состояние на протяжении вызовов функции. Первый вызов будет использовать первые 100 случайных чисел из последовательности, созданной вызовом u(e), а второй вызов создаст следующие 100 чисел и т.д. Каждый генератор случайных чисел всегда создает ту же последовательность чисел. Функция с локальным генератором случайных чисел должна сделать объекты процессора и распределения статическими. В противном случае функция будет создавать ту же последовательность при каждом вызове. Начальное число генератора Тот факт, что генератор возвращает ту же последовательность чисел, полезен во время отладки. Но после проверки программы необходимо заставить ее создавать разные случайные результаты при каждом запуске. Для этого предоставляется начальное число (seed). Начальное число — это значение, которое процессор может использовать для начала создания чисел с нового пункта в последовательности. Начальное число генератора можно задать одним из двух способов: предоставить его при создании объекта процессора либо вызвать функцию-член seed() класса процессора: default_random_engine e1; // использует стандартное начальное число default_random_engine e2(2147483646); // использует заданное значение // начального числа // e3 и e4 создадут ту же последовательность, // поскольку они используют то же начальное число default_random_engine e3; // использует стандартное начальное число e3.seed(32767); // вызывает функцию seed() для установки нового // значения начального числа default_random_engine e4(32767); // Page 938/1103 устанавливает начальное число 32767 for (size_t i = 0; i != 100; ++i) { if (e1() == e2()) cout << "unseeded match at iteration: " << i << endl; if (e3() ! = e4()) cout << "seeded differs at iteration: " << i << endl; Здесь определены четыре процессора. Первые два, e1 и e2, имеют разные начальные числа и должны создавать разные последовательности. У двух вторых, e3 и e4, то же значение начального числа. Эти два объекта создадут ту же последовательность. Выбор подходящего начального числа, как и почти все при создании хороших наборов случайных чисел, на удивление сложен. Вероятно, наиболее распространен подход вызова системной функции time(). Эта функция, определенная в заголовке ctime, возвращает количество секунд, начиная с заданной эпохи. Функция time() получает один параметр, являющийся указателем на структуру для записи времени. Если этот указатель нулевой, функция только возвращает время: default_random_engine e1(time(0)); // почти случайное начальное число Поскольку функция time() возвращает время как количество секунд, такое начальное число применимо только для приложений, создающих начальное число на уровне секунд или больших интервалов. Функция time() обычно не используется как источник начального числа, если программа многократно запускается как часть автоматизированного процесса, поскольку она могла бы быть запущена с тем же начальным числом несколько раз. Упражнения раздела 17.4.1 Упражнение 17.28. Напишите функцию, создающую и возвращающую равномерно распределенную последовательность случайных беззнаковых целых чисел при каждом вызове. Упражнение 17.29. Позвольте пользователю предоставлять начальное число как необязательный аргумент функции, написанной в предыдущем упражнении. Упражнение 17.30. Снова пересмотрите предыдущую функцию, позволив ей получать минимальное и максимальное значения для возвращаемых случайных чисел. 17.4.2. Другие виды распределений Процессоры создают беззнаковые числа, и у каждого числа в диапазоне процессора есть та же вероятность быть созданным. Приложения зачастую нуждаются в числах других типов или распределений. Библиотека удовлетворяет обе эти потребности, определяя различные классы распределений, которые, будучи использованы с процессором, дают желаемый результат. Список операций, поддерживаемых типами распределения, приведен в табл. Page 939/1103 17.16. Таблица 17.16. Операции с распределениями Dist d; Стандартный конструктор; создает объект d готовым к использованию. Другие конструкторы зависят от типа Dist ; см. раздел А.3. Конструкторы распределений являются явными (см. раздел 7.5.4) d(e) Последовательные вызовы с тем же объектом е создадут последовательность случайных чисел согласно типу распределения d; е — объект процессора случайных чисел d.min() d.max() Возвращает наименьшее и наибольшее числа, создаваемые d(е) d.reset() Восстанавливает состояние объекта d, чтобы последующее его использование не зависело от уже созданных значений Создание случайных вещественных чисел Программы нередко нуждаются в источнике случайных значений с плавающей точкой. В частности, в диапазоне от нуля до единицы. Наиболее распространен неправильный способ получения случайного числа с плавающей точкой из функции rand() за счет деления результата ее выполнения на значение RAND_MAX, являющееся заданным системой верхним пределом случайного числа, возвращаемого функцией rand(). Этот подход неправильный потому, что у случайных целых чисел обычно меньшая точность, чем у чисел с плавающей запятой, поэтому некоторые значения с плавающей точкой никогда не будут получены. Новые библиотечные средства позволяют легко получить случайное число с плавающей точкой. Достаточно определить объект типа uniform_real_distribution и позволить библиотеке соотнести случайные целые числа с числам с плавающей запятой. Подобно типу uniform_int_distribution, здесь также можно задать минимальные и максимальные значения при определении объекта: default_random_engine е; // создает случайные беззнаковые целые числа // однородное распределение от 0 до 1 включительно uniform_real_distribution<double> u(0,1); for (size_t i = 0; i < 10; ++i) cout << u(e) << " "; Этот код почти идентичен предыдущей программе, которая создавала беззнаковые значения. Но поскольку здесь использован другой тип распределения, данная версия дает другие результаты: 0.131538 0.45865 0.218959 0.678865 0.934693 0.519416 ... Использование типа по умолчанию для результата распределения За одним исключением, рассматриваемым в разделе 17.4.2, типы распределения являются шаблонами с одним параметром типа шаблона, представляющим тип создаваемых Page 940/1103 распределением чисел. Эти типы всегда создают либо тип с плавающей точкой, либо целочисленный тип. У каждого шаблона распределения есть аргумент шаблона по умолчанию (см. раздел 16.1.3). Типы распределения, создающие значения с плавающей точкой, по умолчанию создают значения типа double. Распределения, создающие целочисленные результаты, используют по умолчанию тип int. Поскольку у типов распределения есть только один параметр шаблона, при необходимости использовать значение по умолчанию следует не забыть расположить за именем шаблона пустые угловые скобки, чтобы указать на применение типа по умолчанию (см. раздел 16.1.3): // пустые <> указывают на использование // для результата типа по умолчанию uniform_real_distribution<> u(0,1); // по умолчанию double Создание чисел с неравномерным распределением Кроме корректного создания случайных чисел в заданном диапазоне, новая библиотека позволяет также получить числа, распределенные неравномерно. Действительно, библиотека определяет 20 типов распределений! Эти типы перечисляются в разделе А.3. Для примера создадим серию нормально распределенных значений и нарисуем полученное распределение. Поскольку тип normal_distribution создает числа с плавающей запятой, данная программа будет использовать функцию lround() из заголовка cmath для округления каждого результата до ближайшего целого числа. Создадим 200 чисел с центром в значении 4 и среднеквадратичным отклонением 1,5. Поскольку используется нормальное распределение, можно ожидать любых чисел, но приблизительно 1% из них будет в диапазоне от 0 до 8 включительно. Программа подсчитает, сколько значений соответствует каждому целому числу в этом диапазоне: default_random_engine е; // создает случайные целые числа normal_distribution<> n(4,1.5); // середина 4, среднеквадратичное // отклонение 1.5 vector<unsigned> vals(9); // девять элементов со значением 0 for (size_t i = 0; i != 200; ++i) { unsigned v = lround(n(e)); // округление до ближайшего целого Page 941/1103 if (v < vals.size()) // если результат в диапазоне ++vals[v]; // подсчитать, как часто встречается каждое число } for (size_t j = 0; j != vals.size(); ++j) cout << j << ": " << string(vals[j], '*') << endl; Начнем с определения объектов генератора случайных чисел и вектора vals. Вектор vals будет использован для расчета частоты создания каждого числа в диапазоне 0…9. В отличие от большинства других программ, использующих вектор, создадим его сразу с необходимым размером. Так, каждый его элемент инициализируется значением 0. В цикле for происходит вызов функции lround(n(е)) для округления возвращенного вызовом n(е) значения до ближайшего целого числа. Получив целое число, соответствующее случайному числу с плавающей точкой, используем его для индексирования вектора счетчиков. Поскольку вызов n(е) может создавать числа и вне диапазона от 0 до 9, проверим полученное число на принадлежность диапазону прежде, чем использовать его для индексирования вектора vals. Если число принадлежит диапазону, увеличиваем соответствующий счетчик. Когда цикл заканчивается, вывод содержимого вектора vals выглядит следующим образом: 0: *** 1: ******** 2: ******************** 3: ************************************** 4: ********************************************************** 5: ****************************************** 6: *********************** 7: ******* 8: * Выведенные строки содержат столько звездочек, сколько раз встретилось соответствующее значение, созданное генератором случайных чисел. Обратите внимание: эта фигура не совершенно симметрична. Если бы она была симметрична, то возникли бы подозрения в качестве генератора случайных чисел. Класс bernoulli_distribution Как уже упоминалось, есть одно распределение, которое не получает параметр шаблона. Это распределение bernoulli_distribution, являющееся обычным классом, а не шаблоном. Это распределение всегда возвращает логическое значение true с заданной вероятностью. По умолчанию это вероятность .5. В качестве примера распределения этого вида напишем программу, которая играет с пользователем. Игру начинает один из игроков (пользователь или программа). Чтобы выбрать первого игрока, можно использовать объект класса uniform_int_distribution с Page 942/1103 диапазоном от 0 до 1. В качестве альтернативы этот выбор можно сделать, используя распределение Бернулли. С учетом, что игру начинает функция play(), для взаимодействия с пользователем может быть использован следующий цикл: string resp; default_random_engine e; // e имеет состояние, поэтому располагается // вне цикла! bernoulli_distribution b; // по умолчанию четность 50/50 do { bool first = b(e); // если true, программа ходит первой cout << (first ? "We go first" : "You get to go first") << endl; // играть в игру, угадывая, кто ходит первым cout << ((play(first)) ? "sorry, you lost" : "congrats, you won") << endl; cout << "play again? Enter 'yes' or 'no'" << endl; } while (cin >> resp && resp[0] == 'y'); Для повторного запроса на продолжение игры используем цикл do while (см. раздел 5.4.4). Поскольку процессоры возвращают ту же последовательность чисел (см. раздел 17.4.1), их объявляют за пределами циклов. В противном случае при каждой итерации создавался бы новый процессор, выдающий каждый раз те же значения. Распределения также могут хранить состояние и также должны определяться вне циклов. Одна из причин использования в этой программе распределения bernoulli_distribution заключается в том, что это предоставит программе лучший шанс пойти первой: bernoulli_distribution b(.55); // предоставить программе небольшое // преимущество Такое определение b предоставит программе 55/45 шансов на первый ход. Упражнения раздела 17.4.2 Page 943/1103 |