{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Генератор случайных чисел\n",
    "\n",
    "Случайные целые и дробные числа, случайный выбор из списка — и зачем генератору seed, чтобы «случайный» результат повторялся.\n",
    "\n",
    "Курс NumPy · урок `np-random` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/random).\n",
    "\n",
    "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n",
    "ячейка проверки: она печатает ✓ / ✗ и итог."
   ],
   "id": "intro"
  },
  {
   "cell_type": "code",
   "metadata": {
    "cellView": "form",
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "# @title Подготовка урока — выполните эту ячейку первой\n",
    "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n",
    "import base64, os, zlib\n",
    "\n",
    "for _name, _min in {\"numpy\":\"2.0\"}.items():\n",
    "    try:\n",
    "        _have = __import__(_name).__version__\n",
    "    except ImportError:\n",
    "        print(f\"Нет пакета {_name}: выполните %pip install {_name} и перезапустите ядро\")\n",
    "        continue\n",
    "    if tuple(int(x) for x in _have.split(\".\")[:2]) < tuple(int(x) for x in _min.split(\".\")):\n",
    "        print(f\"Урок написан для {_name} {_min} и новее, у вас {_have}: выполните %pip install -U {_name} и перезапустите ядро\")\n",
    "\n",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n",
    "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n",
    "\n",
    "_TIMEOUT = 2.0  # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n",
    "\n",
    "\n",
    "def _call_with_timeout(target, seconds: float) -> bool:\n",
    "    \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n",
    "    import sys\n",
    "    import threading\n",
    "\n",
    "    if sys.platform == \"emscripten\":  # Python в браузере: потоков нет, таймаут обеспечивает страница\n",
    "        target()\n",
    "        return True\n",
    "    # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n",
    "    for megabytes in (256, 64, 0):\n",
    "        try:\n",
    "            threading.stack_size(megabytes * 1024 * 1024)\n",
    "            worker = threading.Thread(target=target, daemon=True)\n",
    "            worker.start()\n",
    "        except (ValueError, RuntimeError, MemoryError):\n",
    "            continue\n",
    "        worker.join(seconds)\n",
    "        return not worker.is_alive()\n",
    "    target()  # потоки недоступны — запускаем без таймаута\n",
    "    return True\n",
    "\n",
    "\n",
    "def _test_info(fn) -> dict:\n",
    "    \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n",
    "    limit = getattr(fn, \"timeout\", _TIMEOUT)\n",
    "    hint = getattr(fn, \"timeout_hint\", \"\")\n",
    "    message = (\n",
    "        f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n",
    "        \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n",
    "    )\n",
    "    return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n",
    "\n",
    "\n",
    "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n",
    "    \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n",
    "    line = None\n",
    "    if user_file:  # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n",
    "        tb = error.__traceback__\n",
    "        while tb is not None:\n",
    "            if tb.tb_frame.f_code.co_filename == user_file:\n",
    "                line = tb.tb_lineno\n",
    "            tb = tb.tb_next\n",
    "    status, message = \"error\", f\"{type(error).__name__}: {error}\"\n",
    "    if isinstance(error, NotImplementedError):\n",
    "        status, message, line = \"not_written\", \"функция ещё не написана\", None\n",
    "    elif isinstance(error, AssertionError):\n",
    "        status, message = \"failed\", str(error) or \"проверка не прошла\"\n",
    "    elif isinstance(error, RecursionError):\n",
    "        message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n",
    "    elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n",
    "        message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n",
    "    return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n",
    "\n",
    "\n",
    "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n",
    "    \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n",
    "\n",
    "    Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n",
    "    passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n",
    "    итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n",
    "    вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n",
    "    \"\"\"\n",
    "    import os\n",
    "    import sys\n",
    "\n",
    "    if verbose:\n",
    "        try:  # ✓ и кириллица в консоли Windows со старой кодировкой\n",
    "            sys.stdout.reconfigure(encoding=\"utf-8\")\n",
    "        except Exception:  # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n",
    "            pass\n",
    "\n",
    "    tests = list(_TESTS)\n",
    "    results: list[dict] = []\n",
    "    not_written = hung = False\n",
    "    for index, fn in enumerate(tests):\n",
    "        info = _test_info(fn)\n",
    "        outcome: dict = {}\n",
    "\n",
    "        def target(fn=fn, outcome=outcome):\n",
    "            try:\n",
    "                fn()\n",
    "            except BaseException as e:\n",
    "                outcome[\"error\"] = e\n",
    "\n",
    "        if on_start:\n",
    "            on_start(index)\n",
    "        if not _call_with_timeout(target, info[\"timeout\"]):\n",
    "            results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n",
    "            for other in tests[index + 1:]:\n",
    "                results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n",
    "            hung = True\n",
    "            break\n",
    "        error = outcome.get(\"error\")\n",
    "        if error is None:\n",
    "            result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n",
    "        else:\n",
    "            result = _error_result(info[\"title\"], error, user_file)\n",
    "            not_written = not_written or result[\"status\"] == \"not_written\"\n",
    "        results.append(result)\n",
    "        if on_result:\n",
    "            on_result(index, result)\n",
    "\n",
    "    if not_written:  # пока функция не написана, «даром» пройденные тесты не засчитываются\n",
    "        for r in results:\n",
    "            if r[\"status\"] == \"passed\":\n",
    "                r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n",
    "    for r in results:\n",
    "        if len(r[\"message\"]) > 300:\n",
    "            r[\"message\"] = r[\"message\"][:300] + \"…\"\n",
    "\n",
    "    if verbose:\n",
    "        if not_written:\n",
    "            print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n",
    "        for r in results:\n",
    "            mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n",
    "            print(f\"{mark} {r['title']}\")\n",
    "            if r[\"message\"]:\n",
    "                print(f\"    {r['message']}\")\n",
    "        passed = sum(r[\"status\"] == \"passed\" for r in results)\n",
    "        print(\"─\" * 40)\n",
    "        print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n",
    "        if hung:\n",
    "            print(\"Выполнение остановлено: один из тестов завис.\")\n",
    "            sys.stdout.flush()\n",
    "            os._exit(1)\n",
    "    return results\n",
    "\n",
    "\n",
    "def _check(*tests, names=()):\n",
    "    \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n",
    "    for name in names:\n",
    "        if \".\" in name:  # «Класс.метод» из заготовки: класс должен быть объявлен\n",
    "            if not isinstance(globals().get(name.split(\".\")[0]), type):\n",
    "                print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n",
    "                return\n",
    "            continue\n",
    "        if name not in globals():\n",
    "            print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n",
    "            return\n",
    "        if globals()[name] is Ellipsis:\n",
    "            print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n",
    "            return\n",
    "    globals()[\"_TESTS\"] = list(tests)\n",
    "    _run_tests()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "setup"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Случайные числа нужны, чтобы моделировать: бросать кости, перемешивать участников, проверять идеи на\n",
    "придуманных данных. В NumPy их выдаёт **генератор** (generator). Его создают один раз функцией\n",
    "`np.random.default_rng`, а потом просят у него числа методами:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Генератор и первые числа\n",
    "import numpy as np\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "print(rng.integers(1, 11, size=5))\n",
    "print(rng.random(3))\n",
    "print(rng.integers(0, 100, size=(2, 4)))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rng"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `rng.integers(начало, конец, size=n)` — `n` случайных целых от `начало` до `конец` (конец не входит —\n",
    "  как у `arange`);\n",
    "- `rng.random(n)` — `n` дробных чисел от 0 (включительно) до 1 (не включая).\n",
    "\n",
    "Параметр `size` можно задать и формой — `size=(3, 4)` даст таблицу случайных чисел.\n",
    "\n",
    "## Seed: повторяемая случайность\n",
    "\n",
    "Число в скобках `default_rng(42)` — **seed** («зерно»): с какого места начинается последовательность. С одним\n",
    "и тем же seed генератор выдаёт **одни и те же** числа — при каждом запуске и на любом компьютере:"
   ],
   "id": "text-15"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Одинаковый seed — одинаковые числа\n",
    "a = np.random.default_rng(2025).integers(1, 100, size=5)\n",
    "b = np.random.default_rng(2025).integers(1, 100, size=5)\n",
    "print(a)\n",
    "print(b)\n",
    "print((a == b).all())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "seed"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: результат меняется при каждом запуске.**\n",
    ">\n",
    "> Без seed (`np.random.default_rng()`) числа каждый раз новые. Для игры это хорошо, а для анализа — нет: вы не\n",
    "> сможете повторить расчёт, а проверка в упражнении — сравнить ответ. В курсе генератор всегда создаётся\n",
    "> с seed. И ещё: каждый вызов **продвигает** генератор — второй `rng.integers(…)` вернёт уже другие числа. Чтобы\n",
    "> получить ту же последовательность снова, создайте генератор заново с тем же seed."
   ],
   "id": "component-29"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Двадцать бросков кубика\n",
    "\n",
    "Создайте генератор `rng` с seed 42 и сохраните в `rolls` 20 бросков игрального кубика — случайные целые\n",
    "от 1 до 6.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`np.random.default_rng(42)`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Числа от 1 до 6 — `rng.integers(1, 7, size=20)`: конец не входит.\n",
    "\n",
    "</details>"
   ],
   "id": "dice-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "rng = ...\n",
    "rolls = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "dice"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_rolls():\n",
    "    \"rolls — 20 бросков от 1 до 6\"\n",
    "    assert isinstance(rolls, np.ndarray), f\"rolls — это {type(rolls).__name__}, а нужен массив\"\n",
    "    assert len(rolls) == 20, f\"бросков {len(rolls)}, а нужно 20\"\n",
    "    assert rolls.min() >= 1 and rolls.max() <= 6, f\"значения от {rolls.min()} до {rolls.max()}, а у кубика — от 1 до 6: верхняя граница в integers не входит\"\n",
    "\n",
    "\n",
    "def test_seed():\n",
    "    \"генератор создан с seed 42\"\n",
    "    assert rolls.tolist() == [1, 5, 4, 3, 3, 6, 1, 5, 2, 1, 4, 6, 5, 5, 5, 5, 4, 1, 6, 3], (\n",
    "        \"числа не те: создайте генератор с seed 42 заново и сразу возьмите 20 бросков\"\n",
    "    )\n",
    "\n",
    "_check(test_rolls, test_seed, names=[\"rng\",\"rolls\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "dice-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "rng = np.random.default_rng(42)\n",
    "rolls = rng.integers(1, 7, size=20)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "dice-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Какие числа может вернуть `rng.integers(1, 7)`?\n",
    "\n",
    "- от 1 до 7\n",
    "- от 1 до 6\n",
    "- от 0 до 6\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "от 1 до 6\n",
    "\n",
    "Как у `range` и `arange`, конец не входит: 7 не выпадет никогда. Это и есть обычный кубик.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-44"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Доля и вероятность\n",
    "\n",
    "С логическими масками из модуля 4 случайные числа сразу превращаются в оценки вероятностей: `rng.random(n) <\n",
    "0.3` — это `n` «событий», каждое происходит с вероятностью 0.3. Доля `True` будет близка к 0.3, и тем ближе,\n",
    "чем больше `n`:"
   ],
   "id": "text-53"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Событие с вероятностью 0.3\n",
    "rng = np.random.default_rng(1)\n",
    "for n in [10, 100, 10000]:\n",
    "    print(n, (rng.random(n) < 0.3).mean())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "events"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Тысяча монеток\n",
    "\n",
    "Создайте генератор с seed 3 и смоделируйте 1000 бросков монеты: сохраните в `heads` маску «выпал орёл»\n",
    "(вероятность 0.5), а в `share` — долю орлов.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`rng.random(1000) < 0.5` — маска орлов.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Доля `True` — среднее маски.\n",
    "\n",
    "</details>"
   ],
   "id": "coin-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "rng = ...\n",
    "heads = ...\n",
    "share = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "coin"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_heads():\n",
    "    \"heads — маска из 1000 бросков\"\n",
    "    assert isinstance(heads, np.ndarray), f\"heads — это {type(heads).__name__}, а нужна маска\"\n",
    "    assert heads.dtype == bool, f\"тип heads — {heads.dtype}, а маска — логический массив, результат сравнения\"\n",
    "    assert heads.shape == (1000,), f\"у heads форма {heads.shape}, а бросков 1000\"\n",
    "\n",
    "\n",
    "def test_share():\n",
    "    \"share — доля орлов\"\n",
    "    assert abs(share - 0.502) < 1e-9, f\"share = {share}: создайте генератор с seed 3 заново\"\n",
    "\n",
    "_check(test_heads, test_share, names=[\"rng\",\"heads\",\"share\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "coin-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "rng = np.random.default_rng(3)\n",
    "heads = rng.random(1000) < 0.5\n",
    "share = heads.mean()\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "coin-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Случайный выбор: choice\n",
    "\n",
    "`rng.choice(варианты, size=n)` выбирает `n` элементов из массива или списка. По умолчанию элементы могут\n",
    "повторяться — как при бросках кубика. `replace=False` запрещает повторы — как при вытягивании шаров из барабана:"
   ],
   "id": "text-69"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# choice с повторами и без\n",
    "rng = np.random.default_rng(11)\n",
    "print(rng.choice([\"орёл\", \"решка\"], size=6))\n",
    "print(rng.choice(np.arange(1, 11), size=5, replace=False))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "choice"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Лотерея 6 из 49\n",
    "\n",
    "Создайте генератор с seed 7 и сохраните в `ticket` шесть **разных** чисел от 1 до 49, отсортированных\n",
    "по возрастанию.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Варианты — `np.arange(1, 50)`; без повторов — `replace=False`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Отсортировать — `np.sort(...)`.\n",
    "\n",
    "</details>"
   ],
   "id": "lottery-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "rng = ...\n",
    "ticket = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "lottery"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_ticket():\n",
    "    \"ticket — шесть разных чисел от 1 до 49 по возрастанию\"\n",
    "    assert isinstance(ticket, np.ndarray) and len(ticket) == 6, \"ticket — это должен быть массив из 6 чисел\"\n",
    "    got = ticket.tolist()\n",
    "    assert len(set(got)) == 6, f\"в билете повторы {got}: вспомните параметр replace\"\n",
    "    assert got == sorted(got), f\"числа не по возрастанию {got}\"\n",
    "    assert min(got) >= 1 and max(got) <= 49, \"числа должны быть от 1 до 49\"\n",
    "    assert got == [28, 29, 32, 39, 42, 43], f\"ticket = {got}: создайте генератор с seed 7 заново и выбирайте из чисел от 1 до 49\"\n",
    "\n",
    "_check(test_ticket, names=[\"rng\",\"ticket\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "lottery-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "rng = np.random.default_rng(7)\n",
    "ticket = np.sort(rng.choice(np.arange(1, 50), size=6, replace=False))\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "lottery-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Кто выступает первым\n",
    "\n",
    "Создайте генератор с seed 5 и выберите из списка `speakers` одного человека — того, кто выступает первым.\n",
    "Сохраните имя в `first`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Без `size` метод `choice` возвращает один элемент.\n",
    "\n",
    "</details>"
   ],
   "id": "winner-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "speakers = [\"Анна\", \"Иван\", \"Мария\", \"Олег\"]\n",
    "rng = ...\n",
    "first = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "winner"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_first():\n",
    "    \"first — одно имя из speakers\"\n",
    "    assert not isinstance(first, np.ndarray) or first.ndim == 0, \"first — массив; без size метод choice вернёт одно имя\"\n",
    "    assert first in [\"Анна\", \"Иван\", \"Мария\", \"Олег\"], f\"first = {first} — это не имя из списка speakers\"\n",
    "    assert first == \"Мария\", f\"first = {first}: создайте генератор с seed 5 заново\"\n",
    "\n",
    "_check(test_first, names=[\"rng\",\"first\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "winner-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "speakers = [\"Анна\", \"Иван\", \"Мария\", \"Олег\"]\n",
    "rng = np.random.default_rng(5)\n",
    "first = rng.choice(speakers)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "winner-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итоги\n",
    "\n",
    "- `rng = np.random.default_rng(seed)` — генератор; одинаковый seed — одинаковые числа.\n",
    "- `rng.integers(a, b, size=n)` — целые от `a` до `b − 1`; `rng.random(n)` — дробные от 0 до 1, не включая 1.\n",
    "- `rng.random(n) < p` — `n` событий с вероятностью `p`; доля `True` оценивает вероятность.\n",
    "- `rng.choice(варианты, size=n, replace=False)` — выбор без повторов.\n",
    "- Каждый вызов продвигает генератор; чтобы повторить результат, создайте его заново с тем же seed."
   ],
   "id": "text-91"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/random](https://ds-edu-trainer.vercel.app/reference/numpy/random)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}