{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "intro",
   "metadata": {},
   "source": [
    "# Семинар 1. Среда и задачи с памятью $O(1)$\n",
    "\n",
    "На этой паре вы поставите рабочую среду, решите несколько задач в стиле контеста и сдадите **этот** файл в LMS.\n",
    "\n",
    "Дополнительная память $O(1)$ здесь значит простое: несколько переменных. Весь вход в список складывать не нужно — так вы привыкнете думать о памяти до сложных структур данных.\n",
    "\n",
    "Задачи 1–8 — основа занятия. Девятая и десятая — если после восьмой осталось время.\n",
    "\n",
    "Можно спрашивать соседа и семинариста. Готовое решение копировать не стоит: тесты это *не заметят*, а на зачёте рядом никого не будет.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "jupyter",
   "metadata": {},
   "source": [
    "## Как устроен ноутбук\n",
    "\n",
    "Два типа ячеек: **Markdown** (текст, как этот) и **Code** (Python).\n",
    "\n",
    "Два режима. В **командном** вы работаете с ячейкой целиком: добавить, удалить, запустить. В режиме **правки** курсор внутри ячейки, вы меняете текст. В командный режим — `Esc`, в правку — `Enter`.\n",
    "\n",
    "Полезные сочетания:\n",
    "\n",
    "- `Shift+Enter` — выполнить ячейку и перейти к следующей;\n",
    "- `Ctrl+Enter` — выполнить и остаться в ней.\n",
    "\n",
    "Скачайте с сайта курса [этот файл `.ipynb`](https://learn.ai.msu.ru/algo/1/01/seminar.ipynb) и файл [`lab01_tests.py`](https://learn.ai.msu.ru/algo/1/01/lab01_tests.py) **в одну папку**. Без файла тестов проверка ниже не запустится. Откройте ноутбук из этой папки.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "env",
   "metadata": {},
   "source": [
    "## Среда\n",
    "\n",
    "Если ячейка ниже уже печатает `4`, Python у вас есть — ничего не переустанавливайте.\n",
    "\n",
    "Если интерпретатора ещё нет, в терминале:\n",
    "\n",
    "```bash\n",
    "curl -LsSf https://astral.sh/uv/install.sh | sh\n",
    "uv python install 3.12\n",
    "uv venv\n",
    "source .venv/bin/activate\n",
    "uv pip install jupyterlab\n",
    "jupyter lab\n",
    "```\n",
    "\n",
    "На Windows активация: `.venv\\Scripts\\activate`. Как ставить `uv`: https://docs.astral.sh/uv/getting-started/installation/\n",
    "\n",
    "Подойдёт и обычный Python 3 с IDLE, VS Code или уже установленным Jupyter. Если установка не идёт — напишите семинаристу и переходите к задачам: среда нужна, но не взамен решения.\n",
    "\n",
    "Проверка:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "env_check",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Python готов к работе')\n",
    "print(2 + 2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "how_tests",
   "metadata": {},
   "source": [
    "## Ввод, вывод и тесты\n",
    "\n",
    "В контесте программа читает данные и печатает ответ:\n",
    "\n",
    "- `input()` возвращает **строку** до конца строки;\n",
    "- `int(...)` делает из неё целое число;\n",
    "- `print(...)` пишет ответ.\n",
    "\n",
    "Решение в этом ноутбуке — **функция без аргументов**. Внутри те же `input` и `print`. Тест сам подставляет готовые входы. **Не заполняйте поле ввода Jupyter** — числа с клавиатуры не нужны.\n",
    "\n",
    "В каждой задаче уже стоит заглушка: она что-то читает и всегда печатает один и тот же неверный ответ. Сначала запустите ячейку: увидите «не OK», вход теста, «ожидалось» и «получено». Потом замените тело функции и запустите снова.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "import_tests",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from pathlib import Path\n",
    "\n",
    "sys.path[:0] = [str(Path.cwd())]\n",
    "\n",
    "from lab01_tests import (\n",
    "    test_task0,\n",
    "    test_task1,\n",
    "    test_task2,\n",
    "    test_task3,\n",
    "    test_task4,\n",
    "    test_task5,\n",
    "    test_task6,\n",
    "    test_task7,\n",
    "    test_task8,\n",
    "    test_task9,\n",
    ")\n",
    "\n",
    "print('Тесты подключены')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t0_lesson",
   "metadata": {},
   "source": [
    "## Разряды числа: `//` и `%`\n",
    "\n",
    "Как из числа 179 достать первую цифру? Разделить на 100 и отбросить дробную часть. В Python это оператор `//` — целое деление. Последняя цифра — остаток от деления на 10: `%`. Среднюю можно получить, сначала отбросив единицы (`n // 10`), затем взяв остаток от деления на 10.\n",
    "\n",
    "В ячейке ниже разберите число. Сумма трёх цифр для 179 должна получиться 17. Подставьте, например, 987 и посмотрите, что изменится.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t0_demo",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Поменяйте 179 на другое трёхзначное и перезапустите ячейку\n",
    "n = 179\n",
    "print('сотни:', n // 100)\n",
    "print('десятки:', (n // 10) % 10)\n",
    "print('единицы:', n % 10)\n",
    "print('сумма:', n // 100 + (n // 10) % 10 + n % 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t0_md",
   "metadata": {},
   "source": [
    "Теперь тем же приёмом решите задачу: сумма цифр произвольного трёхзначного числа со входа.\n",
    "\n",
    "### Задача 1. Сумма цифр трёхзначного числа\n",
    "\n",
    "Дано трёхзначное число. Найдите сумму его цифр.\n",
    "\n",
    "**Вход.** Одно целое число от 100 до 999.\n",
    "\n",
    "**Выход.** Одно число — сумма цифр.\n",
    "\n",
    "```\n",
    "-> 179\n",
    "<- 17\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t0_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task0():\n",
    "    n = int(input())\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task0(task0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t1_lesson",
   "metadata": {},
   "source": [
    "## Одно логическое условие\n",
    "\n",
    "Операции `and` и `or` собирают несколько проверок в одно выражение. Год високосный, если он кратен 4 и **не** кратен 100, **или** кратен 400. Отдельный `if` на каждый случай не нужен: одно условие и два ответа — `YES` или `NO`.\n",
    "\n",
    "Посмотрите остатки для типичных годов:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t1_demo",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Поменяйте годы и перезапустите ячейку\n",
    "print('2000 % 400 =', 2000 % 400)\n",
    "print('1900 % 100 =', 1900 % 100)\n",
    "print('2004 % 4 =', 2004 % 4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t1_md",
   "metadata": {},
   "source": [
    "Соберите из таких проверок одно условие и ответьте `YES` или `NO`.\n",
    "\n",
    "### Задача 2. Високосный год\n",
    "\n",
    "Требуется определить, является ли данный год високосным. Год високосный, если его номер кратен 4, но не кратен 100, а также если он кратен 400.\n",
    "\n",
    "**Вход.** Натуральное $N$ — номер года ($0 < N < 100000$).\n",
    "\n",
    "**Выход.** `YES`, если год високосный, и `NO` иначе.\n",
    "\n",
    "```\n",
    "-> 1\n",
    "<- NO\n",
    "\n",
    "-> 2000\n",
    "<- YES\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t1_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task1():\n",
    "    year = int(input())\n",
    "    print('NO')\n",
    "\n",
    "\n",
    "test_task1(task1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t2_lesson",
   "metadata": {},
   "source": [
    "## Вложенные решения: сначала «существует ли»\n",
    "\n",
    "Когда исходов несколько и они **взаимоисключающие**, удобно идти снаружи внутрь. Для треугольника сначала проверьте неравенство: каждая сторона строго меньше суммы двух других. Если нет — треугольника не существует. Если да — сравните квадраты сторон и выберите один тип: прямоугольный, остроугольный или тупоугольный.\n",
    "\n",
    "Не стоит писать четыре независимых `if` подряд: они легко начнут спорить друг с другом.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t2_md",
   "metadata": {},
   "source": [
    "Сначала решите, существует ли треугольник, затем выберите один из трёх типов.\n",
    "\n",
    "### Задача 3. Тип треугольника\n",
    "\n",
    "Определите тип треугольника с данными сторонами.\n",
    "\n",
    "**Вход.** Три неотрицательных целых числа — стороны. Каждое число с новой строки.\n",
    "\n",
    "**Выход.** Одно слово:\n",
    "\n",
    "- `right` — прямоугольный,\n",
    "- `acute` — остроугольный,\n",
    "- `obtuse` — тупоугольный,\n",
    "- `impossible` — треугольника с такими сторонами нет.\n",
    "\n",
    "```\n",
    "-> 3\n",
    "-> 4\n",
    "-> 5\n",
    "<- right\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t2_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task2():\n",
    "    a = int(input())\n",
    "    b = int(input())\n",
    "    c = int(input())\n",
    "    print('impossible')\n",
    "\n",
    "\n",
    "test_task2(task2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t3_lesson",
   "metadata": {},
   "source": [
    "## Цикл без списка\n",
    "\n",
    "`while` повторяет тело, пока условие истинно. Число можно **печатать сразу**, не складывая в список через `append`: так меньше памяти, и условие следующей задачи просит именно цикл.\n",
    "\n",
    "Идея: держать очередное натуральное $k$ и, пока $k^2$ не превосходит $N$, печатать квадрат и увеличивать $k$.\n",
    "\n",
    "Напечатайте квадраты, не большие 20:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t3_demo",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Поменяйте 20 на другое N и перезапустите ячейку\n",
    "limit = 20\n",
    "k = 1\n",
    "while k * k <= limit:\n",
    "    print(k * k, end=' ')\n",
    "    k += 1\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t3_md",
   "metadata": {},
   "source": [
    "Напечатайте в цикле все квадраты, не превосходящие заданное $N$.\n",
    "\n",
    "### Задача 4. Список квадратов\n",
    "\n",
    "По данному натуральному $N$ напечатайте все квадраты натуральных чисел, не превосходящие $N$, в порядке возрастания.\n",
    "\n",
    "В этой задаче необходимо использовать цикл.\n",
    "\n",
    "**Вход.** Целое $N$, не больше $10000$.\n",
    "\n",
    "**Выход.** Последовательность чисел через пробел.\n",
    "\n",
    "```\n",
    "-> 50\n",
    "<- 1 4 9 16 25 36 49\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t3_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task3():\n",
    "    n = int(input())\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task3(task3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t4_lesson",
   "metadata": {},
   "source": [
    "## Одна переменная, которая растёт\n",
    "\n",
    "Иногда «последовательность» не нужно хранить: достаточно обновлять текущее значение. Если вклад каждый год увеличивается на $p$ процентов, а копейки отбрасываются, новый размер — целое деление:\n",
    "\n",
    "`x = x * (100 + p) // 100`\n",
    "\n",
    "Годы считайте в отдельной переменной, пока вклад меньше цели. Список сумм по годам не нужен.\n",
    "\n",
    "Один шаг от 100 рублей и 10 процентов:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t4_demo",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Поменяйте x или p и перезапустите ячейку\n",
    "x, p = 100, 10\n",
    "x = x * (100 + p) // 100\n",
    "print('через год:', x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t4_md",
   "metadata": {},
   "source": [
    "Повторяйте такой шаг, пока вклад не достигнет цели, и посчитайте годы.\n",
    "\n",
    "### Задача 5. Банковский вклад\n",
    "\n",
    "Вклад составляет $x$ рублей. Ежегодно он увеличивается на $p$ процентов, после чего дробная часть копеек отбрасывается. Определите, через сколько лет вклад составит не менее $y$ рублей.\n",
    "\n",
    "**Вход.** Три натуральных числа: $x$, $p$, $y$.\n",
    "\n",
    "**Выход.** Число лет.\n",
    "\n",
    "```\n",
    "-> 100 10 200\n",
    "<- 8\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t4_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task4():\n",
    "    x, p, y = map(int, input().split())\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task4(task4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t5_lesson",
   "metadata": {},
   "source": [
    "## Двоичный порядок: только удвоение\n",
    "\n",
    "Нужно наименьшее целое $k$ такое, что $2^k \\ge N$. В следующей задаче **нельзя** возводить в степень и **нельзя** писать `if`. Заведите `power = 1` и `k = 0` и в цикле удваивайте `power`, пока оно меньше $N$, каждый раз увеличивая $k`.\n",
    "\n",
    "Сколько удвоений нужно, чтобы из 1 получить число не меньше 10?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t5_demo",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Поменяйте 10 на другое N и перезапустите ячейку\n",
    "n = 10\n",
    "power = 1\n",
    "k = 0\n",
    "while power < n:\n",
    "    power *= 2\n",
    "    k += 1\n",
    "print('шагов:', k)\n",
    "print('степень двойки:', power)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t5_md",
   "metadata": {},
   "source": [
    "Тем же удвоением найдите наименьшее $k$ для произвольного $N$.\n",
    "\n",
    "### Задача 6. Двоичный логарифм\n",
    "\n",
    "По данному натуральному $N$ выведите такое наименьшее целое $k$, что $2^k \\ge N$.\n",
    "\n",
    "Необходимо использовать цикл. Инструкция `if` запрещена. Возведение в степень использовать нельзя.\n",
    "\n",
    "**Вход.** Натуральное $N$, не больше $10000$.\n",
    "\n",
    "**Выход.** Число $k$.\n",
    "\n",
    "```\n",
    "-> 10\n",
    "<- 4\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t5_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task5():\n",
    "    n = int(input())\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task5(task5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t6_lesson",
   "metadata": {},
   "source": [
    "## Редукция: прочитали, обновили, забыли\n",
    "\n",
    "Представьте поток чисел неизвестной длины. Как понять, что он кончился, не спрашивая заранее, сколько их будет? Часто в конец ставят **сторожевое** значение — здесь ноль, который в саму последовательность не входит.\n",
    "\n",
    "Весь поток в список копировать не нужно: вы не обязаны помнить все числа, только ответ. Две переменные: текущий максимум и сколько раз он встретился. Прочитали число — либо сменили максимум и обнулили счётчик, либо увеличили счётчик, если число равно максимуму. После этого само число можно забыть.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t6_md",
   "metadata": {},
   "source": [
    "Пройдите последовательность до нуля и посчитайте, сколько раз встретился максимум.\n",
    "\n",
    "### Задача 7. Количество элементов, равных максимуму\n",
    "\n",
    "Последовательность состоит из натуральных чисел и завершается числом 0. Определите, сколько элементов равны её наибольшему элементу. Числа после нуля считывать не нужно.\n",
    "\n",
    "**Вход.** Целые числа, последнее из них — 0 (ноль в последовательность не входит). До завершающего нуля присутствует хотя бы одно натуральное число.\n",
    "\n",
    "**Выход.** Одно число.\n",
    "\n",
    "```\n",
    "-> 1\n",
    "-> 3\n",
    "-> 3\n",
    "-> 1\n",
    "-> 0\n",
    "<- 2\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t6_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task6():\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task6(task6)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t7_lesson",
   "metadata": {},
   "source": [
    "## Поток строк до маркера\n",
    "\n",
    "Иногда длина входа заранее неизвестна: вы читаете строки, пока не встретите **маркер конца**. В следующей задаче это номер начальника `A999AA`. Его и всех, кто после него, штрафовать не нужно.\n",
    "\n",
    "Для каждой предыдущей машины смотрите скорость и три цифры номера. На одну строку хватает нескольких переменных — список всех машин не нужен. Цифры можно вытащить из середины номера или разобрать через `//` и `%`, как в первой задаче.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t7_md",
   "metadata": {},
   "source": [
    "Читайте машины до номера начальника и копите сумму штрафов.\n",
    "\n",
    "### Задача 8. Гаишник\n",
    "\n",
    "Зарплата патрульного складывается из штрафов за скорость строго больше 60 км/ч. Штраф зависит от номера: три одинаковые цифры — 1000, ровно две совпадают — 500, все разные — 100. Рабочий день кончается номером начальника `A999AA` (латинская буква `A`); начальника штрафовать нельзя.\n",
    "\n",
    "**Вход.** Строки «скорость и номер» (буква, три цифры, две буквы). Число строк заранее неизвестно. Кто приехал после начальника, не штрафуется.\n",
    "\n",
    "**Выход.** Одно целое — сумма штрафов за день.\n",
    "\n",
    "```\n",
    "-> 80 E101PA\n",
    "-> 61 M555OH\n",
    "-> 60 H222OM\n",
    "-> 10 A999AA\n",
    "<- 1500\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t7_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task7():\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task7(task7)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "extra_hdr",
   "metadata": {},
   "source": [
    "## Если осталось время\n",
    "\n",
    "Две задачи ниже — для тех, кто уже закрыл тестами первые восемь. Новых конструкций почти нет: снова счётчики и несколько переменных вместо списка.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t8_lesson",
   "metadata": {},
   "source": [
    "## Четыре счётчика вместо массива\n",
    "\n",
    "У плоскости четыре четверти. Точку на оси никуда не кладут. Чтобы найти самую населённую четверть, достаточно четырёх переменных-счётчиков, без списка точек. Если максимум одинаковый у нескольких четвертей, берут четверть с меньшим номером.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t8_md",
   "metadata": {},
   "source": [
    "Четырьмя счётчиками найдите самую населённую четверть.\n",
    "\n",
    "### Задача 9. Точки на плоскости\n",
    "\n",
    "Дан набор точек с целочисленными координатами. Определите номер координатной четверти, в которой точек больше всего. Точки с нулевой координатой не принадлежат ни одной четверти. Если таких четвертей несколько, выведите четверть с меньшим номером.\n",
    "\n",
    "Нумерация координатных четвертей:\n",
    "- I: $x>0,\\ y>0$;\n",
    "- II: $x<0,\\ y>0$;\n",
    "- III: $x<0,\\ y<0$;\n",
    "- IV: $x>0,\\ y<0$.\n",
    "\n",
    "**Вход.** Сначала $N$, затем $N$ строк с координатами $x$ $y$.\n",
    "\n",
    "**Выход.** Номер четверти и число точек в ней.\n",
    "\n",
    "```\n",
    "-> 3\n",
    "-> -5 -5\n",
    "-> -5 -2\n",
    "-> 1 1\n",
    "<- 3 2\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t8_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task8():\n",
    "    n = int(input())\n",
    "    print('1 0')\n",
    "\n",
    "\n",
    "test_task8(task8)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t9_lesson",
   "metadata": {},
   "source": [
    "## Два наибольших и два наименьших\n",
    "\n",
    "Максимальное произведение двух чисел — не всегда два самых больших: два отрицательных могут дать ещё больший плюс. Массив и сортировку здесь использовать нельзя. Достаточно помнить два наибольших и два наименьших среди уже прочитанных чисел и в конце сравнить два произведения.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "t9_md",
   "metadata": {},
   "source": [
    "Двумя наибольшими и двумя наименьшими найдите максимальное произведение.\n",
    "\n",
    "### Задача 10. Максимальное произведение\n",
    "\n",
    "Среди $N$ целых чисел найдите два, произведение которых максимально. Массивы использовать запрещено.\n",
    "\n",
    "**Вход.** Сначала $N$ ($2 \\le N \\le 10000$), затем $N$ целых чисел по одному в строке.\n",
    "\n",
    "**Выход.** Одно число — произведение.\n",
    "\n",
    "```\n",
    "-> 5\n",
    "-> 2\n",
    "-> 8\n",
    "-> 1\n",
    "-> 3\n",
    "-> 2\n",
    "<- 24\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "t9_code",
   "metadata": {},
   "outputs": [],
   "source": [
    "def task9():\n",
    "    n = int(input())\n",
    "    print(0)\n",
    "\n",
    "\n",
    "test_task9(task9)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "submit",
   "metadata": {},
   "source": [
    "## Сдача\n",
    "\n",
    "Перед отправкой проверьте:\n",
    "\n",
    "- сохранили ноутбук: `File → Save`;\n",
    "- рядом с ноутбуком лежит `lab01_tests.py`;\n",
    "- ячейка с импортом тестов выполнена;\n",
    "- отправили **этот** файл `.ipynb` в задание семинара 1 на [courses.ai.msu.ru](https://courses.ai.msu.ru).\n",
    "\n",
    "Если LMS не открывается, пришлите файл семинаристу в личные сообщения до конца дня.\n",
    "\n",
    "Недорешенные задачи не мешают отправке: сдайте то, что успели. Красный тест у заглушки — нормально.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}