jupyter_notebooks/I_probability_hw_1_proba.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW1 Простые задачи на теорию вероятностей\n",
    "\n",
    "Решать задачи по терверу можно с помощью книжки [Теория вероятностей и математическая статистика : Базовый курс с примерами и задачами: учебное пособие Кибзун А.](https://biblioclub.ru/index.php?page=book&id=69320)\n",
    "\n",
    "## Задача 1\n",
    "\n",
    "Определить вероятность того, что случайно выбранный студент девочка. В группе 10 студентов, из которых 2 девочки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "задача 1: P(A) = 0.20\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "# событие А: случайно выбранный студент - девочка\n",
    "# число случаев\n",
    "n = 10\n",
    "# число благоприятных исходов m: 2\n",
    "m = 2\n",
    "\n",
    "def task_1(num_students, num_girls):\n",
    "    # вычисляем вероятность\n",
    "    proba = num_girls / num_students\n",
    "    return proba\n",
    "\n",
    "proba = task_1(num_students=n, num_girls=m)\n",
    "print(f\"задача 1: P(A) = {proba:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fee800af1d0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertEqual(task_1(num_students=10, num_girls=2), 0.2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 2\n",
    "\n",
    "В отеле 20 номеров, из которых 12 выходят на море. В гостиницу заселяются 12 девочек и 8 мальчиков. Ключи с видом на море выдают в начале. Какова вероятность события, что все девочки будут жить в номерах с видом на море"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "задача 1: P(A) = 0.0000079384\n"
     ]
    }
   ],
   "source": [
    "def task_2(sea_rooms, num_boys, num_girls):\n",
    "    # число случаев\n",
    "    n = math.factorial(num_boys + num_girls)\n",
    "    # число благоприятных исходов m\n",
    "    m = math.factorial(sea_rooms)*math.factorial(num_boys)\n",
    "    # вычисляем вероятность\n",
    "    proba = m / n\n",
    "    return proba\n",
    "\n",
    "# событие А: последовательность людей, где первые 8 - девочки\n",
    "proba = task_2(sea_rooms=12, num_boys=8, num_girls=12)\n",
    "\n",
    "print(f\"задача 1: P(A) = {proba:.10f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.003s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fee8016fd30>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_2(sea_rooms=12, num_boys=8, num_girls=12), 0.0000079384, places=11)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 3\n",
    "\n",
    "На полке стоят три тома. Найти вероятность того, что книги стоят в верном порядке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "задача 1: P(A) = 0.333\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def task_3():\n",
    "    # общее число случаев\n",
    "    n = math.factorial(3)\n",
    "    # число благоприятных исходов m \n",
    "    # либо либо порядок томов (1-2-3), либо (3-2-1)\n",
    "    m = 2\n",
    "    # вычисляем вероятность\n",
    "    proba = m / n\n",
    "    return proba\n",
    "\n",
    "# событие А: тома не перемешаны\n",
    "proba = task_3()\n",
    "\n",
    "print(f\"задача 1: P(A) = {proba:.3f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.007s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fe6384254e0>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_3(), 0.333, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 4\n",
    "\n",
    "Бросают две монеты. Что более вероятно - что монеты выпадут одноимёнными сторонами, или разноимёнными."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Одноимённые 0.5 Разноимённые 0.5\n"
     ]
    }
   ],
   "source": [
    "def task_4_same():\n",
    "    \"\"\"Вероятность того, что выпадут одноименными сторонами\"\"\"\n",
    "    m = 2 # РР или ОО\n",
    "    n = 4\n",
    "    return m/n\n",
    "\n",
    "def task_4_opposite():\n",
    "    \"\"\"Вероятность того, что выпадут разноименными сторонами\"\"\"\n",
    "    m = 2 # РО или ОР\n",
    "    n = 4\n",
    "    return m/n\n",
    "\n",
    "print(f'Одноимённые {task_4_same()} Разноимённые {task_4_opposite()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fee8008d470>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertEqual(task_4_opposite(), task_4_same())\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 5\n",
    "\n",
    "На столе лежат 100 карточек числами от $1$ до $100$. Какова вероятность, что наугад выбранная карта содержит \n",
    "1. 0 \n",
    "1. 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p=0.10\n",
      "p=0.19\n"
     ]
    }
   ],
   "source": [
    "def task_5_1():\n",
    "    \"\"\"Оличество карточек, в которых присутствует цифра ноль\"\"\"\n",
    "    m = 10\n",
    "    n = 100\n",
    "    return m/n\n",
    "\n",
    "def task_5_2():\n",
    "    \"\"\"Оличество карточек, в которых присутствует цифра пять\"\"\"\n",
    "    m = 19\n",
    "    n = 100\n",
    "    return m/n\n",
    "\n",
    "\n",
    "proba = task_5_1()\n",
    "print(f'p={proba:.2f}')\n",
    "\n",
    "proba = task_5_2()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.003s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fee8008d6a0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_5_1(), 0.1, places=3)\n",
    "        self.assertAlmostEqual(task_5_2(), 0.19, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 6\n",
    "\n",
    "На столе лежат три письма и три конверта. Какова вероятность, что по адресу попадут\n",
    "1. Ни одно\n",
    "1. Ровно одно\n",
    "1. Ровно два"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p=1.00\n",
      "p=1.00\n",
      "p=1.00\n"
     ]
    }
   ],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "# общее количество возможных случаев не меняется - его можно сразу посчитать\n",
    "total_case_num = 9999\n",
    "\n",
    "def task_6_1():\n",
    "    m = 1\n",
    "    n = total_case_num\n",
    "    return m/n\n",
    "\n",
    "def task_6_2():\n",
    "    m = 1\n",
    "    n = total_case_num\n",
    "    return m/n\n",
    "\n",
    "def task_6_3():\n",
    "    # опасный момент\n",
    "    m = 1\n",
    "    n = total_case_num\n",
    "    return m/n\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_6_1()\n",
    "print(f'p={proba:.2f}')\n",
    "\n",
    "proba = task_6_2()\n",
    "print(f'p={proba:.2f}')\n",
    "\n",
    "proba = task_6_3()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_6_1(), 0.333, places=3)\n",
    "        self.assertAlmostEqual(task_6_2(), 0.500, places=3)\n",
    "        self.assertAlmostEqual(task_6_3(), 0.000, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 7\n",
    "\n",
    "Из карточек {1,2,3,4,5} собирают 5-ти значное число. Найти вероятность того, что число чётное (размещения)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p=1.00\n"
     ]
    }
   ],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_7():\n",
    "    # в чётном числе в конце либо 2 либо 4\n",
    "    m = 1\n",
    "    # сколько поледовательностей можно составить?\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_7()\n",
    "print(f'p={proba:.2f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_7(), 0.4, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 8\n",
    "\n",
    "На стол бросают (по одной) три игральные кости. Найти вероятность того, что все цифры будут разными (размещение с повторением)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_8():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_8()\n",
    "print(f'p={proba:.2f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_8(), 0.556, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 9\n",
    "\n",
    "В пачке M&M's 5 красных, 8 жёлтых и 20 синих драже. Из пачки выпало 3 штуки. Найти вероятность того, что все они красные (сочетание)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_9():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_9()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_9(), 0.00183, places=5)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 10\n",
    "\n",
    "В лотерее 6 выигрышных билетов из 49-ти. Наугад берут 6 билетов. Какова вероятность того, что \n",
    "\n",
    "1. среди них будет ровно три выигрышных? \n",
    "1. хотя бы один выигрышный?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "# общее количество возможных случаев не меняется - его можно сразу посчитать\n",
    "total_case_num = 9999\n",
    "\n",
    "def task_10_1():\n",
    "    m = 1\n",
    "    n = total_case_num\n",
    "    return m/n\n",
    "\n",
    "\n",
    "def task_10_2():\n",
    "    # тут пойти от обратного - найти вероятность того, что ни один не выирышный\n",
    "    m = 1\n",
    "    n = total_case_num\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_10_1()\n",
    "print(f'p={proba:.2f}')\n",
    "\n",
    "proba = task_10_2()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_10_1(), 0.01765040, places=8)\n",
    "        self.assertAlmostEqual(task_10_2(), 0.56403502, places=8)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 11\n",
    "\n",
    "В урне 10 белых и 5 чёрных шаров. Потеряли 2 шара. Наугад извлекают три шара и все они белые. Найти вероятность того, что обы утерянных шара чёрные (условная вероятность)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_11():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_11()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_11(), 0.152, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 12\n",
    "\n",
    "В связке 20 ключей, нужно открыть одну дверь. Найти вероятность того, что до успеха придётся перебрать ровно половину"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_12():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_12()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_12(), 0.05, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 13\n",
    "\n",
    "На стол выкладывают карточки аз набора {А, А, А, Н, Н, С}. Найти вероятность того, что получится слово *АНАНАС*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_13():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_13()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_13(), 0.017, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 14\n",
    "\n",
    "В баре 30 мест, 5 человек бронируют места. Найти вероятность того, что все места будут разными."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_14():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_14()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_14(), 0.000007017, places=9)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 15\n",
    "\n",
    "В корзине  6 белых, 5 синих и 4 красных. Шары извлекают по одному без возвращения до появления красного шара. Найти вероятность того, что придётся извлечь не менее 4-х шаров."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_15():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_15()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_15(), 0.363, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 16\n",
    "\n",
    "Две ладьи (белая и чёрная) ставятся на доску наугад. Что более вероятно \n",
    "\n",
    "* (а) будут друг друга бить или\n",
    "* (б) не будут."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_16_1():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "def task_16_2():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_16_1()\n",
    "print(f'p={proba:.2f}')\n",
    "\n",
    "proba = task_16_2()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_16_1(), 0.222, places=3)\n",
    "        self.assertAlmostEqual(task_16_2(), 0.778, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 17\n",
    "\n",
    "Рассчитать вероятность «счастливого билета».\n",
    "\n",
    "Цифр в номере шесть. Счастливым считается билет, сумма первых трех цифр которого совпадает с суммой оставшихся."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_17():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_17()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_17(), 0.055, places=4)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Проверка домашек"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.002s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fe63841c2e8>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertEqual(task_1(num_students=10, num_girls=2), 0.2)\n",
    "        self.assertAlmostEqual(task_2(sea_rooms=12, num_boys=8, num_girls=12), 0.0000079384, places=11)\n",
    "        self.assertAlmostEqual(task_3(), 0.333, places=3)\n",
    "        self.assertEqual(task_4_opposite(), task_4_same())\n",
    "        self.assertAlmostEqual(task_6_1(), 1/3, places=3)\n",
    "        self.assertAlmostEqual(task_6_2(), 0.5, places=3)\n",
    "        self.assertAlmostEqual(task_6_3(), 0, places=3)\n",
    "        self.assertAlmostEqual(task_7(), 0.4, places=2)\n",
    "        self.assertAlmostEqual(task_8(), 0.556, places=3)\n",
    "        self.assertAlmostEqual(task_9(), 0.00183, places=5)\n",
    "        self.assertAlmostEqual(task_10_1(), 0.01765040, places=8)\n",
    "        self.assertAlmostEqual(task_10_2(), 0.56403502, places=8)\n",
    "        self.assertAlmostEqual(task_11(), 0.152, places=3)\n",
    "        self.assertAlmostEqual(task_12(), 0.05, places=2)\n",
    "        self.assertAlmostEqual(task_13(), 0.017, places=3)\n",
    "        self.assertAlmostEqual(task_14(), 0.703733333, places=9)\n",
    "        self.assertAlmostEqual(task_15(), 0.363, places=3)\n",
    "        self.assertAlmostEqual(task_16_1(), 0.222, places=3)\n",
    "        self.assertAlmostEqual(task_16_2(), 0.778, places=3)\n",
    "        self.assertAlmostEqual(task_17(), 0.055, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW2: формулы вычисления вероятностей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 18\n",
    "\n",
    "На ресурсе 30% пользователей iOS, На Android конверсия в покупку фильма 0.05, на iOS 0.08. Пользователь совершает покупку. Найти вероятность, что это пользователь Android."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_18():\n",
    "    # подсказка - использовать формулу полной вероятности\n",
    "    # выделить гипотезы\n",
    "    p = 1\n",
    "    return p\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_18()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_18(), 0.593, places=3)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 19\n",
    "\n",
    "Вероятность встретить частицу в течение минуты $p$. Какова вероятность встретить хотя бы одну частицу в течение 30 минут?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_19(p):\n",
    "    # подсказка - найти вероятность \"обратного\" события\n",
    "    return 1/p\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_19()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_19(0.05), 0.78536, places=6)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 20\n",
    "\n",
    "Тест на болезнь имеет вероятность ошибки 0.1 (как позитивной, так и негативной). Достоверно известно, что болеет 10% населения. Какая вероятность того, что человек болен, если у него позитивный результат теста?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p=0.00\n"
     ]
    }
   ],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_20():\n",
    "    p=0.0\n",
    "    # подсказка - использовать формулу Байеса\n",
    "    return p\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_20()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_20(), 0.5, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 21\n",
    "\n",
    "Что вероятнее с равносильным противником - выиграть 3 партии из 4-х, или 5 из 8-ми?(схема Бернулли)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import binom\n",
    "\n",
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_21_1():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    p = 1\n",
    "    # биномиально распределённая СВ\n",
    "    rv = binom(n, p)\n",
    "    # вероятность заданного числа успехов\n",
    "    p = rv.pmf(k)\n",
    "    return m/n\n",
    "\n",
    "\n",
    "def task_21_2():\n",
    "    m = 1\n",
    "    n = 1\n",
    "    p = 1\n",
    "    # биномиально распределённая СВ\n",
    "    rv = binom(n, p)\n",
    "    # вероятность заданного числа успехов\n",
    "    p = rv.pmf(k)\n",
    "    return p\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba1 = task_21_1()\n",
    "\n",
    "proba2 = task_21_2()\n",
    "\n",
    "\n",
    "print(f'p1 > p2: {proba1, proba1}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_21_1(), 0.25, places=2)\n",
    "        self.assertAlmostEqual(task_21_2(), 0.21875, places=5)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 22\n",
    "\n",
    "Каждый 10-й договор страховой компании завершается выплатой. Компания заключила 5 договоров. Найти вероятность того, что случится хотя бы случится хотя бы один случай. (схема Бернулли)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_22():\n",
    "    p = 1\n",
    "    return p\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "proba = task_22()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_22(), 0.40951, places=5)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 23\n",
    "\n",
    "В урне 10 белых, 8 синих и 2 красных шара, извлекают 3 шара. Найти вероятность того, что шары будут одного цвета (сложение вероятностей)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_23():\n",
    "    p = 1\n",
    "    return p\n",
    "\n",
    "\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_23(), 0.15, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 24\n",
    "\n",
    "Телефон находится в одной из комнат с вероятностью 0.5, 0.6, 0.7. Найти вероятность того, что телефон будет найден, если пройтись по всем комнатам. (произведение вероятностей)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p=0.20\n"
     ]
    }
   ],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_24():\n",
    "    p1 = 0.5\n",
    "    p2 = 0.6\n",
    "    p3 = 0.7\n",
    "    # посчитать через вероятность обратного события - что телефон не будет найден\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n",
    "\n",
    "proba = task_24()\n",
    "print(f'p={proba:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_24(), 0.94, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Проверка домашек"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_18(), 0.593, places=3)\n",
    "        self.assertAlmostEqual(task_19(0.05), 0.785361, places=6)\n",
    "        self.assertAlmostEqual(task_20(), 0.5, places=2)\n",
    "        self.assertAlmostEqual(task_21_1(), 0.25, places=2)\n",
    "        self.assertAlmostEqual(task_21_2(), 0.21875, places=5)\n",
    "        self.assertAlmostEqual(task_22(), 0.40951, places=5)\n",
    "        self.assertAlmostEqual(task_23(), 0.15, places=2)\n",
    "        self.assertAlmostEqual(task_24(), 0.94, places=2)\n",
    "        \n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW3: случайные величины\n",
    "\n",
    "## Задача 25\n",
    "\n",
    "Каждый день аналитик Сидоров идет на работу. По пути от метро он должен перейти две дороги со светофорами. Один светофор горит красным 60 секунд, зеленым 15 секунд. Второй — 100 секунд красным и 30 секунд зеленым.\n",
    "\n",
    "Вопрос: сколько секунд аналитик Сидоров в среднем тратит на ожидание перед светофором по пути на работу?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_25():\n",
    "    p = 1\n",
    "    return p\n",
    "\n",
    "\n",
    "# --------------------\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_25(), 62.46, places=2)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 26\n",
    "\n",
    "Какой минимальный платеж нужно установить для новых клиентов Яндекс.Маркета, чтобы этих денег хватило на количество переходов, достаточное для оценки качества трафика с Яндекс.Маркета? Конверсию в продажи для визитов с Яндекс.Маркета считайте равной 3%. Стоимость перехода пусть будет 1р. Объясните ваши расчеты."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- ВАШ КОД ТУТ ---\n",
    "\n",
    "\n",
    "def task_26():\n",
    "    p = 1\n",
    "    return m/n\n",
    "\n",
    "\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_task (__main__.TestNotebook) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7fee80092ef0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "\n",
    "class TestNotebook(unittest.TestCase):\n",
    "    def test_task(self):\n",
    "        self.assertAlmostEqual(task_26(), 1117.9056, places=4)\n",
    "\n",
    "unittest.main(argv=[''], verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}