{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=right>\n",
    "    <tr>\n",
    "        <td align=center>\n",
    "            <font size=6><b>Программирование $-$ 2026.</b></font>  \n",
    "        </td>\n",
    "        <td align=right>\n",
    "<img src=\"logoMM.png\" align=right width=120>\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Множества\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Описание/cоздание "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4, 6, 8, 10, 12, 14, 16}\n",
      "{'Привет-привет!', 3.1415, 'Hello!', 'Привет'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "A = {2, 4, 6, 8, 10, 12, 14, 16, 2}\n",
    "B = {'Привет-привет!', 'Hello!', 'Привет', 3.1415}\n",
    "print(A)\n",
    "print(B)\n",
    "print(type(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty = set() # пустое множество"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1 Из строк или списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'и', 'в', 'т', '-', '!', 'р', 'П', 'п', 'е'} {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "C = set('Привет-привет!')\n",
    "D = set([1,2,3,4,5,1,2,3,4,5])\n",
    "print(C, D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 Генераторы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 5, 7, 9} {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "E = set(i for i in range(1,10) if i%2!=0)\n",
    "F = {i for i in range(1,10) if i%2!=0}\n",
    "print(E, F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Важно:** элементы множества &ndash; неизменяемые. Не бывает множества списков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "cannot use 'list' as a set element (unhashable type: 'list')",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mTypeError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m A = {[\u001b[32m1\u001b[39m,\u001b[32m2\u001b[39m], [\u001b[32m3\u001b[39m,\u001b[32m4\u001b[39m]} \u001b[38;5;66;03m# Ошибка!\u001b[39;00m\n",
      "\u001b[31mTypeError\u001b[39m: cannot use 'list' as a set element (unhashable type: 'list')"
     ]
    }
   ],
   "source": [
    "A = {[1,2], [3,4]} # Ошибка!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Операции над множествами\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Размер"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# Размер (количество элементов)\n",
    "n = len(A)\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4, 6, 8, 10, 12, 14, 16, 18}\n"
     ]
    }
   ],
   "source": [
    "# Добавление элемента\n",
    "A.add(18)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4, 6, 8, 10, 12, 14, 16, 18}\n"
     ]
    }
   ],
   "source": [
    "# Пример: \n",
    "# альтернативное создание множества A\n",
    "A = set()\n",
    "for i in range(2,20,2):\n",
    "    A.add(i)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Принадлежность элемента множеству\n",
    "print(2 in A)\n",
    "print('Привет' in B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "B = {32, 1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "# создадим два множества \n",
    "# для иллюстрации остальных операций\n",
    "A = {i for i in range(11)}\n",
    "B = {2**i for i in range(6)}\n",
    "print(f'A = {A}\\nB = {B}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A ∪ B  = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 32, 16}\n",
      "A ∪ B  = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 32, 16}\n"
     ]
    }
   ],
   "source": [
    "# Объединение множеств\n",
    "# способ 1\n",
    "AB1 = A | B \n",
    "# способ 2\n",
    "AB2 = A.union(B)\n",
    "print(f'A ∪ B  = {AB1}\\nA ∪ B  = {AB2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A ⋂ B  = {8, 1, 2, 4}\n",
      "A ⋂ B  = {8, 1, 2, 4}\n"
     ]
    }
   ],
   "source": [
    "# Пересечение множеств\n",
    "# способ 1\n",
    "AB1 = A & B\n",
    "# способ 2\n",
    "AB2 = A.intersection(B)\n",
    "print(f'A ⋂ B  = {AB1}\\nA ⋂ B  = {AB2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A \\ B  = {0, 3, 5, 6, 7, 9, 10}\n",
      "A \\ B  = {0, 3, 5, 6, 7, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "# Разность множеств\n",
    "# способ 1\n",
    "AB1 = A - B\n",
    "# способ 2\n",
    "AB2 = A.difference(B)\n",
    "print(f'A \\\\ B  = {AB1}\\nA \\\\ B  = {AB2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 3, 5, 6, 7, 9, 10}\n",
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 16, 32}\n",
      "{32, 1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "# Аналоги операций a += b, a -= b  и т.п.\n",
    "\n",
    "# удаляем из множества A все элементы, \n",
    "# входящие в множество B\n",
    "A -= B  \n",
    "# или так\n",
    "A.difference_update(B)\n",
    "print(A)\n",
    "\n",
    "# добавляем в множество A\n",
    "# всех элементов из множества B\n",
    "A |= B \n",
    "# или так\n",
    "A.update(B)\n",
    "print(A)\n",
    "\n",
    "# оставляем в множестве A только \n",
    "# те элеменнты, которые есть в B\n",
    "A &= B \n",
    "# или так\n",
    "A.intersection_update(B)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {1,2,3,4,5}\n",
    "B = {5,4,3,2,1}\n",
    "# Проверка на вложение\n",
    "print(A <= B)\n",
    "# или так:\n",
    "print(A.issubset(B))\n",
    "print(A < B)\n",
    "B = {5,4,3,2,1}\n",
    "print(A < B)\n",
    "\n",
    "# а можно и так: \n",
    "A >= B\n",
    "A.issuperset(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Множество vs Список: скорость поиска\n",
    "\n",
    "Как время поиска элемента в списке и множестве зависит от их размера?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Создаем список...\n",
      "Создаем множество...\n",
      "Готово!\n"
     ]
    }
   ],
   "source": [
    "# создадим большой список и большое множество\n",
    "from time import time\n",
    "n = 2*10**7\n",
    "print('Создаем список...')\n",
    "a = [i**2 for i in range(n)]\n",
    "print('Создаем множество...')\n",
    "b = set(a)\n",
    "k1 = (n//2)**2 # этот элемент есть в списке/множестве\n",
    "k2 = k1 + 1     # такого элемента нет\n",
    "print('Готово!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Поиск в списке: ответ True получен за 0.15868830680847168 сек\n",
      "Поиск в списке: ответ False получен за 1.2608308792114258 сек\n"
     ]
    }
   ],
   "source": [
    "# Поиск в списке\n",
    "start = time()\n",
    "res1 = k1 in a\n",
    "finish = time()\n",
    "print(f'Поиск в списке: ответ {res1} получен за {finish-start} сек')\n",
    "start = time()\n",
    "res2 = k2 in a\n",
    "finish = time()\n",
    "print(f'Поиск в списке: ответ {res2} получен за {finish-start} сек')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Поиск в множестве: ответ True получен за 8.654594421386719e-05 сек\n",
      "Поиск в множестве: ответ False получен за 8.630752563476562e-05 сек\n"
     ]
    }
   ],
   "source": [
    "# Поиск в множестве\n",
    "start = time()\n",
    "res1 = k1 in b\n",
    "finish = time()\n",
    "print(f'Поиск в множестве: ответ {res1} получен за {finish-start} сек')\n",
    "start = time()\n",
    "res2 = k2 in b\n",
    "finish = time()\n",
    "print(f'Поиск в множестве: ответ {res2} получен за {finish-start} сек')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Как так?**\n",
    "\n",
    "Иллюстрация на примере простого кода:\n",
    "```python\n",
    "s = {\"яблоко\", \"банан\", \"вишня\", \"груша\", \"слива\"} \n",
    "print(\"банан\" in s) \n",
    "```\n",
    "\n",
    "См. файл `Механика множества Python.pdf`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4747133628603962472"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hash(\"яблоко\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "***ВЫВОД:*** Поиск в множестве выполняется за константное (ну почти) время"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задачи по теме \"Множества\"\n",
    "\n",
    "### pythontutor.ru"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Для организации входных данных\n",
    "from random import randint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задача 1. Количество различных чисел**  \n",
    "Дан список чисел. Определите, сколько в нем встречается различных чисел.  \n",
    "*Примечание. Эту задачу на Питоне можно решить в одну строчку.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, -1, -2, -2, 3, -4, 0, -3, 2, -5, -2, 2]\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Дано\n",
    "a = [randint(-5,5) for i in range(12)]\n",
    "print(a)\n",
    "# Решение\n",
    "print(len(set(a)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задача 2. Количество различных чисел**  \n",
    "Даны два списка чисел. Посчитайте, сколько чисел содержится одновременно как в первом списке, так и во втором.  \n",
    "*Примечание. Эту задачу на Питоне можно решить в одну строчку.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, -3, 3, 4, -4, -4, 3, -3, 5, 0, -2, -2]\n",
      "[-4, 0, 0, -1, -2, 3, -3, 4, -2, -4, 3, -1]\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Дано\n",
    "a = [randint(-5,5) for i in range(12)]\n",
    "print(a)\n",
    "b = [randint(-5,5) for i in range(12)]\n",
    "print(b)\n",
    "# Решение\n",
    "print(len(set(a) & set(b)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задача 3. Пересечение множеств**  \n",
    "Даны два списка чисел. Найдите все числа, которые входят как в первый, так и во второй список и выведите их в порядке возрастания.  \n",
    "*Примечание. И даже эту задачу на Питоне можно решить в одну строчку.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, -2, 3, -4, -4, -1, -2, 5, -4, -1, -5, -4]\n",
      "[0, -3, 5, 5, 4, 2, 4, -3, 1, 4, 3, 1]\n",
      "[3, 5]\n"
     ]
    }
   ],
   "source": [
    "# Дано\n",
    "a = [randint(-5,5) for i in range(12)]\n",
    "print(a)\n",
    "b = [randint(-5,5) for i in range(12)]\n",
    "print(b)\n",
    "# Решение\n",
    "print(sorted(set(a) & set(b)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задачи с сайта\n",
    "\n",
    "<a href=\"https://leetcode.com/\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/0/0a/LeetCode_Logo_black_with_text.svg\" width=200></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Один ряд клавиш**. Дан список слов `words`. Выберите из него те слова, которые могут быть напечатаны, используя ровно один ряд русской клавиатуры (допускается также нажатие клавиш `Shift` или `CapsLock`) "
   ]
  },
  {
   "attachments": {
    "f6306441ffbe64eba9c3ae10f302eb73.webp": {
     "image/webp": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![f6306441ffbe64eba9c3ae10f302eb73.webp](attachment:f6306441ffbe64eba9c3ae10f302eb73.webp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_words(words):\n",
    "    r1 = set('йцукенгшщзхъ')\n",
    "    r2 = set('фывапролджэ')\n",
    "    r3 = set('ячсмитьбю')\n",
    "    res = []\n",
    "    for w in words:\n",
    "        s = set(w.lower())\n",
    "        if s<=r1 or s<=r2 or s<=r3:\n",
    "            res.append(w)\n",
    "    return res        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "w1 = ['флора', 'форма', 'право', 'вектор',\n",
    "      'Митя', 'Витя', 'Паша', 'Юля',\n",
    "      'чит',  'бить', 'порка', 'цена', \n",
    "      'фара', 'плод', 'жить', 'ворон']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['флора', 'право', 'Митя', 'чит', 'бить', 'фара', 'плод']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_words(w1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Сумма уникальных элементов**. Дан список целых чисел `nums`. Найдите сумму тех элементов списка, которые встречаются в нем только один раз"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Плохое правильное решение***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_unique(nums):\n",
    "    s = 0\n",
    "    for x in nums:\n",
    "        if nums.count(x)==1:\n",
    "            s += x\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert sum_of_unique([1,5,3,5])==4, 'Ошибка тестирования 1'\n",
    "assert sum_of_unique([1,1,1,1])==0, 'Ошибка тестирования 2'\n",
    "assert sum_of_unique([1,2,3,4])==10, 'Ошибка тестирования 3'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "N = 10**4\n",
    "random.seed(123456)\n",
    "nums = [random.randint(-N,N) for i in range(N)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2173142433166504\n"
     ]
    },
    {
     "ename": "AssertionError",
     "evalue": "Превышен допустимый интервал времени",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mAssertionError\u001b[39m                            Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[33]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m      4\u001b[39m dt = time()-t\n\u001b[32m      5\u001b[39m \u001b[38;5;28mprint\u001b[39m(dt)\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m dt<\u001b[32m1\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mПревышен допустимый интервал времени\u001b[39m\u001b[33m\"\u001b[39m\n",
      "\u001b[31mAssertionError\u001b[39m: Превышен допустимый интервал времени"
     ]
    }
   ],
   "source": [
    "from time import time\n",
    "t = time()\n",
    "assert sum_of_unique(nums)==191442, 'Ошибка тестирования 4'\n",
    "dt = time()-t\n",
    "print(dt)\n",
    "assert dt<1, \"Превышен допустимый интервал времени\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Хорошее правильное  решение***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_unique(nums):\n",
    "    a = set() # все элементы\n",
    "    b = set() # точно дубли\n",
    "    for x in nums:\n",
    "        if x in a:\n",
    "            b.add(x)\n",
    "        else:\n",
    "            a.add(x)      \n",
    "    return sum(a-b)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert sum_of_unique([1,2,3,2])==4, 'Ошибка тестирования 1'\n",
    "assert sum_of_unique([1,1,1,1])==0, 'Ошибка тестирования 2'\n",
    "assert sum_of_unique([1,2,3,4])==10, 'Ошибка тестирования 3'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0021245479583740234\n"
     ]
    }
   ],
   "source": [
    "t = time()\n",
    "assert sum_of_unique(nums)==191442, 'Ошибка тестирования 4'\n",
    "dt2 = time()-t\n",
    "print(dt2)\n",
    "assert dt2<1, \"Превышен допустимый интервал времени\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "572.9756480754124"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Во сколько раз ускорили работу?\n",
    "dt/dt2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.14.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}