sem01_random_intro/sem_1_ahmed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cs6.pikabu.ru/images/big_size_comm/2017-08_6/1504088679155420172.png\" height=\"400\" width=\"800\"> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Наука о данных <br>  <br> Комбинаторика и генерация случайных чисел! </center>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Комбинаторика"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Из курса дискретной математики мы знаем как посчитать число \n",
    "\n",
    "\n",
    "* сочетаний\n",
    "$$\n",
    "C_{n}^{k}={\\frac {n!}{k!\\left(n-k\\right)!}}\n",
    "$$\n",
    "\n",
    "* размещений\n",
    "$$\n",
    "{\\displaystyle A_{n}^{k}={\\frac {n!}{(n-k)!}}}\n",
    "$$\n",
    "\n",
    "* перестановок\n",
    "$$\n",
    "P_{n}=A_{n}^{n}={\\frac  {n!}{(n-n)!}}={\\frac  {n!}{0!}}=n!\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во всех формулах нужно высчитывать факториал. В пакете `math` есть функция `factorial`, которая принимает один аргумент - целое неотрицательное число и возвращает факториал этого числа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import factorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5) / (4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Так мы можем посчитать, например, число сочетаний из *n* по _k_.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Число сочетаний из 5 по 3 равно 10\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "k = 3\n",
    "print(\"Число сочетаний из {} по {} равно\".format(n, k), int(factorial(n) / (factorial(k) * factorial(n - k))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы можем не просто найти, например, число сочетаний, но и вывести их в яновм виде. В этом нам поможет пакет `itertools`. С его помощью можно получать сочетания, перестановки и размещения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations, combinations_with_replacement, permutations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У всех функций два аргумента:\n",
    "\n",
    "1. Итерируемый объект(массив, строка и т.д.).\n",
    "2. k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3]\n",
    "s = 'abc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (1, 3), (2, 3)]\n",
      "[('a', 'b'), ('a', 'c'), ('b', 'c')]\n"
     ]
    }
   ],
   "source": [
    "# сочетания\n",
    "print(list(combinations(numbers, 2)))\n",
    "print(list(combinations(s, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]\n",
      "[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]\n"
     ]
    }
   ],
   "source": [
    "# сочетания с повторениями\n",
    "print(list(combinations_with_replacement(numbers, 2)))\n",
    "print(list(combinations_with_replacement(s, 2)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]\n",
      "[('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]\n"
     ]
    }
   ],
   "source": [
    "# размещения\n",
    "print(list(permutations(numbers, 2)))\n",
    "print(list(permutations(s, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все перестановки можно получить с помощью размещений."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]\n",
      "[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]\n"
     ]
    }
   ],
   "source": [
    "print(list(permutations(numbers, len(numbers))))\n",
    "print(list(permutations(s, len(s))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Создание списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если бы мы захотели создать массив с числами от $1$ до $N$, то мы бы сделали это следующим образом. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 10\n",
    "res = []\n",
    "\n",
    "for x in range(1, N + 1):\n",
    "    res.append(x)\n",
    "\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако то же самое можно сделать с помощью __list comprehensions__ . Код уменьшится, а также такой способ генерации списоков работает намного быстрее."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = [x for x in range(1, N + 1)]\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно не только создавать массивы, но и менять уже существующие. Найдем квадраты наших чисел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squar_res = [x**2 for x in res]\n",
    "squar_res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Генерация случайных величин\n",
    "\n",
    "Иногда для решения задач по теории вероятностей или исследования свойств статистических алгоритмов нужно сгенерировать случайную выборку из какого-нибудь распределения. Для генерации мы будем пользоваться пакетом `random`. Это самый простой способ генерации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as rd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Внутри пакета есть непрерывные распределения. Давайте попробуем сгенерировать случайное число из **нормального распределения**, $X \\sim N(\\mu, \\sigma^2)$. Того самого распределения, плотность которого выглядит как-то вот так: \n",
    "\n",
    "$$\n",
    "f(x) = \\frac{1}{\\sigma \\sqrt{2 \\pi}} \\cdot  e^{-\\frac{(x - \\mu)^2}{2 \\sigma^2}}\n",
    "$$\n",
    "\n",
    "\n",
    "Параметр ```mu``` задаёт $\\mu$, ```sigma``` — среднеквадратичное отклонение $\\sigma$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.808754511976499"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rd.normalvariate(mu=4, sigma=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь сгенерируем случайное число из **равномерного распределения**, $X \\sim U[a, b]$. Плотность этого распределения выглядит так: \n",
    "\n",
    "$$\n",
    "f(x)=\\left\\{{\\begin{matrix}{1 \\over b-a},&x\\in [a,b]\\\\0,&x\\not \\in [a,b]\\end{matrix}}\\right .\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.161932848910148"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rd.uniform(a=5, b=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И еще одним знакомым нам распределением будет __экспоненциальное распределение__, $X \\sim {\\displaystyle \\mathrm {Exp} (\\lambda )} $. А вот и его плотность:\n",
    "\n",
    "$$\n",
    "f(x)={\\begin{cases}\\lambda \\,e^{{-\\lambda x}},&x\\geq 0,\\\\0,&x<0.\\end{cases}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2953790259454355"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rd.expovariate(lambd=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы можем сгененировать целую случайную выборку с помощью list comprehensions. Давайте получим случайную выборку из равномерного распеределения, а также найдем математическое ожидание и дисперсию.\n",
    "\n",
    "$$X \\sim U[a, b]$$\n",
    "\n",
    "$${\\mathbb  {E}}\\left[X\\right]={\\frac  {a+b}{2}}$$\n",
    "\n",
    "$${\\displaystyle \\operatorname {Var} \\left[X\\right]={\\frac {(b-a)^{2}}{12}}}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10**3 # размер выборки\n",
    "\n",
    "unif = [rd.uniform(a=5, b=10) for i in range(N)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы найти  математическое ожидание и дисперсию по выборке, возмользуемся функциями __mean__ и __var__ из пакета `numpy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import mean, var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.463671723022411\n",
      "2.0419432241780227\n"
     ]
    }
   ],
   "source": [
    "print(mean(unif))\n",
    "print(var(unif))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В пакете `random` есть также несколько других полезных функций, все они на вход принимают итерируемый объект(массив, строка и т.д.).\n",
    "\n",
    "* `choice` - случайно выбирается один объект\n",
    "* `choices` - случайно выбирается k объектов (могут повторяться)\n",
    "* `sample` - случайно выбирается k **уникальных** объектов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rd.choice(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 7, 2, 6]"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rd.choices(range(10), k=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 9, 5, 1, 3]"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rd.sample(range(10), k=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В пакете `random` имеется малое количесто распределений, к тому же они непрерывные. К счастью, в пакете `scipy` есть огромное количество различных распрелений на все случаи жизни.\n",
    "\n",
    "Чтобы сварить в `scipy` любую случайную величину, нужно сделать две вещи: \n",
    "\n",
    "* Создать генератор. \n",
    "\n",
    "Внутри пакета `scipy.stats` есть [много разных распределений.](https://docs.scipy.org/doc/scipy-0.14.0/reference/stats.html) Среди всего этого обилия нужно найти нужное распределение и задать его параметры. Непрерывные распределения у нас уже были, поэтому давайте сделаем это на примере **распределения Пуассона**, $X \\sim Pois(\\lambda)$.\n",
    "\n",
    "$$\n",
    "p(k)\\equiv \\mathbb {P} (Y=k)={\\frac {\\lambda ^{k}}{k!}}\\,e^{-\\lambda }\n",
    "$$\n",
    "\n",
    "\n",
    "Параметр ```mu``` задаёт $\\lambda$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats as sts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "pois = sts.poisson(mu=5) # задали генератор "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Когда конкретный генератор готов, у него можно вызывать разные методы: \n",
    "\n",
    "* `rvs` сгенерирует нам выборку из распределения объёма `size`\n",
    "* `cdf` вычислит для нас значение функции распределения (cumulative distribution function) в указанной точке\n",
    "* `pdf` вычислит значение плотности распределения (probability density function) в указанной точке (**для непрерывных распределений**)\n",
    "* `pmf` вычислит вероятность получения заданного значения (**для дискретных распределений**)\n",
    "* `ppf` вычислит квантиль, указанного уровня(**для непрерывных распределений**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 4, 3, 3, 6, 9, 7, 2, 7, 4])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample = pois.rvs(size=100)  # сгенерируем 100 значений\n",
    "sample[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.615960654833063"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pois.cdf(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.17546736976785068"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pois.pmf(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Задачки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 21"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У вас есть числа от 1 до 10. Выведите все тройки чисел, которые в сумме равны 21."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = list(range(1, 11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 9, 10)\n",
      "(3, 8, 10)\n",
      "(4, 7, 10)\n",
      "(4, 8, 9)\n",
      "(5, 6, 10)\n",
      "(5, 7, 9)\n",
      "(6, 7, 8)\n"
     ]
    }
   ],
   "source": [
    "for comb in combinations(numbers, 3):\n",
    "    if sum(comb) == 21:\n",
    "        print(comb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Вероятность"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда не очень приятно выводить плотности для комбинации случайных величин или условные плотности, а потом еще брать интегралы. Вместо этого можно сгененрировать случайные величины и найти все, что нам требуется. \n",
    "\n",
    "Предположим, что у нас есть две случайные величины $X \\sim N(3, 2^2)$, $Y \\sim U[0, 1]$. Найдите:\n",
    "\n",
    "1. $P(X - 3Y > 0)$\n",
    "2. $P(X - 3Y > 0 | Y > 0.5)$\n",
    "3. $E[XY]$\n",
    "4. $E[XY|Y > 0.5]$\n",
    "\n",
    "Для начала сгенерируем выборку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10**5\n",
    "\n",
    "X = [rd.normalvariate(mu=3, sigma=2) for i in range(N)]\n",
    "Y = [rd.uniform(a=0, b=1) for i in range(N)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. $P(X - 3Y > 0)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обозначим новую случайную величину $Z = X - 3Y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = [z[0] - 3 * z[1] for z in zip(X, Y)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z_over_zero = [z > 0 for z in Z]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.75452"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(Z_over_zero) / N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. $P(X - 3Y > 0 | Y > 0.5)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Смотрим для каких значений в выборке выполняется наше условие. На выходе получаем массив с True и False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, False, True]"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condition = [y > 0.5 for y in Y]\n",
    "condition[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выбираем только те значения, которым удовлетворяет наше условие. В list comprehensions можно в конце добавить if."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_X = [x for x, con in zip(X, condition) if con]\n",
    "new_Y = [y for y, con in zip(Y, condition) if con]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_Z = [z[0] - 3 * z[1] for z in zip(new_X, new_Y)]\n",
    "new_Z_over_zero = [z > 0 for z in new_Z]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6450641894585759"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(new_Z_over_zero) / len(new_Z_over_zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вероятность уменьшилась относительно предыдущей. Это достаточно логично. Почему?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. $E[XY]$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обозначим новую случайную величину $R = XY$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5045837795296855"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = [r[0] * r[1] for r in zip(X, Y)]\n",
    "sum(R) / len(R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. $E[XY|Y > 0.5]$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У нас уже есть `new_X` и `new_Y`, которые удовлетворяют этому условию. Используем их."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.2519795447849185"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_R = [r[0] * r[1] for r in zip(new_X, new_Y)]\n",
    "sum(new_R) / len(new_R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задачка про удава Анатолия"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Удав Анатолий любит французские багеты. Длина французского багета равна 1 метру. За один заглот Удав Анатолий заглатывает кусок случайной длины, равномерно распределённый на отрезке $[0;1]$. Для того, чтобы съесть весь багет удаву потребуется случайное количество $N$ заглотов.\n",
    " \n",
    "Найдите $E(N)$ и $Var(N)$. \n",
    "\n",
    "Эту задачку очень сложно решить в лоб, но можно попробовать замоделировать поедание багета много раз и найти нужные нам характеристики. Кстати говоря,в сборнике сложных задач по терверу, [культурном коде](https://github.com/bdemeshev/probability_dna/raw/master/probability_dna.pdf), можно найти три разных решения этой задачки. Она там находится под номером 46."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Багеты! Давайте начнём с одной итерации эксперемента.\n",
    "\n",
    "l = 1 # длина багета\n",
    "m = 0 # число заглотов\n",
    "\n",
    "# пока длина багета больше 0\n",
    "while l > 0:\n",
    "    # делай заглоты \n",
    "    l -= rd.uniform(0, 1)\n",
    "    m += 1 # на один заглот стало больше\n",
    "\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Одну итерацию можно обернуть в функцию, чтобы удобно использовать её в дальнейшем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def eat_one_baguette():\n",
    "    l = 1\n",
    "    m = 0 \n",
    "    while l > 0:\n",
    "        l -= rd.uniform(0, 1)\n",
    "        m += 1\n",
    "\n",
    "    return(m)\n",
    "\n",
    "eat_one_baguette()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь мы можем провести много итераций эксперимента. Удобней всего это сделать через генератор списков, которым мы пользовались раньше."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10**6 # количество итераций эксперимента\n",
    "exper_results = [eat_one_baguette() for i in range(N)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь у нас есть массив с количеством поеданий в каждом эксперименте. Мы можем найти математическое ожидание и дисперсию."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.7180966\n",
      "0.7653598730684401\n"
     ]
    }
   ],
   "source": [
    "print(mean(exper_results))\n",
    "print(var(exper_results))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}