{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Основы программирования в Python\n",
    "\n",
    "## Домашнее задание №2\n",
    "\n",
    "*Формат задания и некоторые задачи заимствованы из [домашнего задания](http://nbviewer.jupyter.org/url/python.math-hse.info/static/assignments_release/dj2017/ps01/ps01.ipynb) по [курсу](http://math-info.hse.ru/s17/1) «Введение в программирование» (Магистерская программа «Журналистика данных», НИУ ВШЭ, 2017-18). *\n",
    "\n",
    "За разные задачи можно получить разное число баллов. Если не указано обратное, задача весит 1 балл. Максимум за ДЗ можно набрать 6 баллов (это соответствует оценке 10), но вы можете решить больше задач, чем требуется, чтобы потренироваться.\n",
    "\n",
    "Для предварительной проверки задания нужно сделать следующее:\n",
    "\n",
    "1. Скачать данный `ipynb`-файл на свой компьютер, открыть его в Jupyter Notebook.\n",
    "2. Активировать тесты (см. ниже).\n",
    "3. Вставить решение каждой задачи в ячейку для кода, следующую за его условием, там, где написан комментарий `# YOUR CODE HERE`. Отступ вашего кода должен составлять 4 пробела. Ничего не менять вокруг!\n",
    "4. Запустить ячейку, в которую вы вставили код с решением. Ввести какие-то входные данные, проверить визуально правильность вывода.\n",
    "5. Запустить следующую ячейку (в ней содержится тест). Если запуск ячейки с тестом не приводит к появлению ошибки (assertion), значит, всё в порядке, задача решена. Если приводит к появлению ошибки, значит, тест не пройден и нужно искать ошибку.\n",
    "\n",
    "**Внимание!** Если в какой-то момент забыть ввести входные данные и перейти на следующую ячейку, есть риск, что Notebook перестанет откликаться. В этом случае надо перезапустить ядро: *Kernel → Restart*. При этом потеряются все значения переменных, но сам код останется.\n",
    "\n",
    "Чтобы сдать ДЗ, его надо загрузить по ссылке на Dropbox в виде `ipynb`-файла. Получить `ipynb`-файл можно, выбрав в Jupyter пункт меню *File → Download as... → Notebook (.ipynb)*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Активировать тесты\n",
    "Запустите следующую ячейку, чтобы иметь возможность запускать тесты. Тесты проверяют, что возвращает написанный вами код, и сравнивают это с ожидаемым результатом. Если результат совпадает с ожидаемым, после исполнения теста ничего не происходит, если не совпадает – на экран выводится сообщение об ошибке.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Фабрика тестов для проверки программ, принимающих данные через input()\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "class Tester(object):\n",
    "    def __init__(self, inp):\n",
    "        self.outputs = []\n",
    "        self.inputs = deque(inp)\n",
    "    def print(self, *args, sep = \" \", end = \"\\n\"):\n",
    "        text = sep.join(map(str, args)) + end\n",
    "        newlines = text.splitlines(keepends=True)\n",
    "        if self.outputs and self.outputs[-1] and self.outputs[-1][-1] != \"\\n\" and newlines:\n",
    "            self.outputs[-1] += newlines[0]\n",
    "            self.outputs.extend(newlines[1:])\n",
    "        else:\n",
    "            self.outputs.extend(newlines)\n",
    "            \n",
    "    def input(self, *args):\n",
    "        assert self.inputs, \"Вы пытаетесь считать больше элементов, чем предусмотрено условием\"\n",
    "        return self.inputs.popleft()\n",
    "    def __enter__(self):\n",
    "        global print\n",
    "        global input\n",
    "        print = self.print\n",
    "        input = self.input\n",
    "        return self.outputs\n",
    "    def __exit__(self, *args):\n",
    "        global print\n",
    "        global input\n",
    "        del print\n",
    "        del input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 0 (не оценивается, решена для примера)\n",
    "\n",
    "Напишите программу, которая запрашивает у пользователя целое число и выводит на экран сообщение вида:\n",
    "     \n",
    "     Следующее число: [число].\n",
    "     \n",
    "**Пример**\n",
    "\n",
    "*Входные данные*\n",
    "\n",
    "    Введите целое число: 7\n",
    "\n",
    "*Выходные данные*\n",
    "\n",
    "    Следующее число 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nnext():\n",
    "    n = int(input(\"Введите целое число: \"))\n",
    "    res = n + 1\n",
    "    print(f\"Следующее число: {res}.\")\n",
    "nnext()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = [(\"-1\", \"Следующее число: 0.\"), \n",
    "             (\"-20\", \"Следующее число: -19.\"), \n",
    "             (\"5\", \"Следующее число: 6.\"), \n",
    "             (\"11\", \"Следующее число: 12.\"),\n",
    "             (\"460\", \"Следующее число: 461.\")\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester(inp.split()) as t:\n",
    "        nnext()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t[0].strip() == out, \"Неверный ответ, были введены числа \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 1\n",
    "Напишите программу, которая запрашивает у пользователя размер обуви и выводит на экран размер подходящих скальных туфель (туфли для скалолазания), учитывая, что обычно размер скальных туфель на 2 размера меньше обычного.\n",
    "\n",
    "**Пример**\n",
    "\n",
    "*Входные данные*\n",
    "\n",
    "    Введите размер обуви: 38\n",
    "\n",
    "*Выходные данные*\n",
    "\n",
    "    36"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "a39f18da18a351c38371b0727169451d",
     "grade": false,
     "grade_id": "p0",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def shoes():\n",
    "    # YOUR CODE HERE\n",
    "shoes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "573b3cf6e3c0d29dcb4a5149d5cb8ac5",
     "grade": true,
     "grade_id": "p0-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [(\"38\", 36), \n",
    "             (\"41\", 39), \n",
    "             (\"35\", 33), \n",
    "             (\"39\", 37),\n",
    "             (\"46\", 44)\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester(inp.split()) as t:\n",
    "        shoes()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 2\n",
    "Напишите программу, которая последовательно запрашивает с клавиатуры три целых числа (после ввода каждого числа пользователь нажимает *Enter* — иными словами, каждое число вводится на отдельной строке) и выводит их произведение.\n",
    "\n",
    "**Пример.**\n",
    "\n",
    "*Входные данные:*\n",
    "\n",
    "    1\n",
    "    2\n",
    "    3\n",
    "\n",
    "*Выходные данные:*\n",
    "\n",
    "    6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "7e6b5eb5b61efbc121076358d52a057d",
     "grade": false,
     "grade_id": "p1",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def prod3():\n",
    "    # YOUR CODE HERE\n",
    "prod3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "36022f90bc39c00f4d1ec9a268ce70f2",
     "grade": true,
     "grade_id": "p1_test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (\"0 0 0\", 0),\n",
    "    (\"0 3 10\", 0),\n",
    "    (\"3 0 10\", 0),\n",
    "    (\"2 4 0\", 0),\n",
    "    (\"2 4 5\", 40),\n",
    "    (\"-1 2 100\", -200),\n",
    "    (\"-20 -30 200\", 200*20*30),\n",
    "    (\"-5 -180 -12\", -5*180*12)\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester(inp.split()) as t:\n",
    "        prod3()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 3\n",
    "\n",
    "Напишите программу, которая запрашивает у пользователя его имя и выводит на экран сообщение в одну строчку (пробелы важны):\n",
    "\n",
    "    Имя... какое хорошее имя!\n",
    " \n",
    "**Примеры:**\n",
    "\n",
    "*Входные данные:*\n",
    "\n",
    "    Анна\n",
    "\n",
    "*Выходные данные:*\n",
    "\n",
    "    Анна... какое хорошее имя!\n",
    "\n",
    "*Входные данные:*\n",
    "\n",
    "    Николай\n",
    "\n",
    "*Выходные данные:*\n",
    "\n",
    "    Николай... какое хорошее имя!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "6213bf4add532bae23786ef1119ba02e",
     "grade": false,
     "grade_id": "p2",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def good_name():\n",
    "    # YOUR CODE HERE\n",
    "good_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "6207f593b30c80c005eecd74772434c5",
     "grade": true,
     "grade_id": "p2-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (\"Анна\", \"Анна... какое хорошее имя!\"),\n",
    "    (\"Петя\", \"Петя... какое хорошее имя!\"),\n",
    "    (\"Мэри\", \"Мэри... какое хорошее имя!\"),\n",
    "    (\"Саша\", \"Саша... какое хорошее имя!\")\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester([inp]) as t:\n",
    "        good_name()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t[0] == out+\"\\n\", \"Неверный ответ, была введена строка \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 4\n",
    "\n",
    "Напишите программу, которая последовательно запрашивает с клавиатуры два положительных числа (целых или с плавающей точкой) и выводит на экран их [среднее геометрическое](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B5%D0%B4%D0%BD%D0%B5%D0%B5_%D0%B3%D0%B5%D0%BE%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5). Считайте, что пользователь вводит только неотрицательные числа. После ввода каждого числа пользователь нажимает *Enter*.\n",
    "\n",
    "**Примеры:**\n",
    "\n",
    "*Входные данные:*\n",
    "\n",
    "    3\n",
    "    12\n",
    "\n",
    "*Выходные данные:*\n",
    "\n",
    "    6.0\n",
    "\n",
    "*Входные данные:*\n",
    "\n",
    "    5\n",
    "    4    \n",
    "\n",
    "*Выходные данные:*\n",
    "\n",
    "    4.47213595499958"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "bfbb27aeeff0887c4c5fd767f49c428a",
     "grade": false,
     "grade_id": "p3",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def geom_mean():\n",
    "    # YOUR CODE HERE\n",
    "geom_mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "d3b83b7e90a41381ff0977564de3e7f8",
     "grade": true,
     "grade_id": "p3-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (\"3 12\", 6.),\n",
    "    (\"5 10\", 7.0710678118654755),\n",
    "    (\"18 24\", 20.784609690826528),\n",
    "    (\"0.1 8.1\", 0.9),\n",
    "    (\"0.05 0.12\", 0.07745966692414834),\n",
    "    (\"12.25 23.189\", 16.8542353727483)\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester(inp.split()) as t:\n",
    "        geom_mean()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert abs(float(t[0]) - out) < 1E-6,\"Неверный ответ, были введены числа \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 5\n",
    "\n",
    "В среднем за неделю Питон получает пять сообщений от Анаконды ($\\lambda = 5$). Пользователь с клавиатуры вводит число сообщений, которые Анаконда может прислать Питону (число $k$). Напишите программу, которая выводит на экран вероятность, с которой Питон получит $k$ сообщений от Анаконды за неделю, с точностью до *трёх* знаков после запятой. Сообщение, выводимое на экран, должно быть таким (вместо выражений в квадратных скобках подставляются значения):\n",
    "\n",
    "    Число сообщений от Анаконды за неделю равно [k], вероятность равна [значение].\n",
    "\n",
    "Вероятность того, что Питон получит ровно $k$ сообщений, определяется следующим образом (распределение Пуассона):\n",
    "\n",
    "$$P(X = k) = e^{-\\lambda}\\cdot \\frac{\\lambda^k}{k!},$$ где $k!$ – «ка факториал», произведение всех целых чисел от 1 до $k$ включительно. \n",
    "\n",
    "**Подсказка:** функцию для вычисления факториала можно вызвать из модуля `math` (`factorial()`).\n",
    "\n",
    "**Пример:**\n",
    "\n",
    "*Входные данные*\n",
    "\n",
    "    Введите число сообщений: 2\n",
    "\n",
    "*Выходные данные*\n",
    "\n",
    "    Число сообщений от Анаконды за неделю равно 2, вероятность равна 0.084."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "97c11d4b6d2d43d02800b505b4b2d613",
     "grade": false,
     "grade_id": "p4",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def pois():\n",
    "    # YOUR CODE HERE\n",
    "pois()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "03583312c720b4407fd758d0d5627a14",
     "grade": true,
     "grade_id": "p4-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (\"0\", [\"Число сообщений от Анаконды за неделю равно 0, вероятность равна 0.007.\\n\"]),\n",
    "    (\"1\", [\"Число сообщений от Анаконды за неделю равно 1, вероятность равна 0.034.\\n\"]),\n",
    "    (\"2\", [\"Число сообщений от Анаконды за неделю равно 2, вероятность равна 0.084.\\n\"]),\n",
    "    (\"5\", [\"Число сообщений от Анаконды за неделю равно 5, вероятность равна 0.175.\\n\"]),\n",
    "    (\"7\", [\"Число сообщений от Анаконды за неделю равно 7, вероятность равна 0.104.\\n\"])\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester([inp]) as t:\n",
    "        pois()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t == out,\"Неверный ответ, было введено число \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 6\n",
    "\n",
    "Напишите программу, которая запрашивает у пользователя сумму (в рублях), которую он хочет перевести своему другу на карту другого банка, и возвращает сумму списания (в рублях) с учётом комиссии банка 5%.\n",
    "\n",
    "*Примечание:* считайте, что сумма перевода – целое число.\n",
    "\n",
    "**Пример:** \n",
    "\n",
    "*Входные данные*\n",
    "\n",
    "    Введите сумму для перевода: 1000\n",
    "\n",
    "*Выходные данные*\n",
    "\n",
    "    Сумма списания: 1050.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "2f329072027064ca1556839ec75193ec",
     "grade": false,
     "grade_id": "p5",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def bank():\n",
    "    # YOUR CODE HERE\n",
    "bank()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "db26704a83dad384d6727beee1404cd0",
     "grade": true,
     "grade_id": "p5-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (\"0\", [\"Сумма списания: 0.0\\n\"]),\n",
    "    (\"100\", [\"Сумма списания: 105.0\\n\"]),\n",
    "    (\"257\", [\"Сумма списания: 269.85\\n\"]),\n",
    "    (\"5450\", [\"Сумма списания: 5722.5\\n\"]),\n",
    "    (\"13200\", [\"Сумма списания: 13860.0\\n\"])\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester([inp]) as t:\n",
    "        bank()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t == out,\"Неверный ответ, было введено число \" + inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 7 (2 балла)\n",
    "\n",
    "Дано целое число $n$. Выведите следующее за ним четное число. При решении этой задачи нельзя использовать условный оператор `if` и циклы.\n",
    "\n",
    "**Подсказка.** Бывает оператор целочисленного деления `//` и взятия остатка при делении `%`. Например, результат выполнения операции `15 % 7` равен `1`.\n",
    "\n",
    "**Примеры**\n",
    "\n",
    "_Входные данные_\n",
    "\n",
    "    7\n",
    "\n",
    "_Выходные данные_\n",
    "\n",
    "    8\n",
    "\n",
    "_Входные данные_\n",
    "\n",
    "    8\n",
    "\n",
    "_Выходные данные_\n",
    "\n",
    "    10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "0f79019eb3e406ec69e358f27813514b",
     "grade": false,
     "grade_id": "p7",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def next_even():\n",
    "    # YOUR CODE HERE\n",
    "next_even()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "bbd6d541188f5f6114a363e2367861d6",
     "grade": true,
     "grade_id": "p7-test",
     "locked": true,
     "points": 2,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (1, 2),\n",
    "    (2, 4),\n",
    "    (100, 102),\n",
    "    (0, 2),\n",
    "    (11, 12),\n",
    "    (594843, 594844),\n",
    "    (-1, 0),\n",
    "    (-100, -98)\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester([str(inp)]) as t:\n",
    "        next_even()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t[0].strip() == str(out),\"Неверный ответ, было введено число \" + str(inp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задача 8 (3 балла)\n",
    "Электронные часы показывают время в формате h:mm:ss, то есть сначала записывается количество часов (в 24-часовом формате), потом обязательно двузначное количество минут, затем обязательно двузначное количество секунд. Количество минут и секунд при необходимости дополняются до двузначного числа нулями.\n",
    "\n",
    "С начала суток прошло n секунд. Выведите, что покажут часы.\n",
    "\n",
    "Запрещается пользоваться условным оператором, циклами и любыми библиотеками.\n",
    "\n",
    "**Входные данные**\n",
    "\n",
    "Вводится целое число $n$.\n",
    "\n",
    "**Выходные данные**\n",
    "\n",
    "Выведите ответ на задачу, соблюдая требуемый формат.\n",
    "\n",
    "**Примеры**\n",
    "\n",
    "_Входные данные_\n",
    "\n",
    "    3602\n",
    "\n",
    "_Выходные данные_\n",
    "\n",
    "    1:00:02\n",
    "\n",
    "_Входные данные_\n",
    "\n",
    "    129700\n",
    "\n",
    "_Выходные данные_\n",
    "\n",
    "    12:01:40\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "673974d30c2412c10006a2d49f459e06",
     "grade": false,
     "grade_id": "p8",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def clock():\n",
    "    # YOUR CODE HERE\n",
    "clock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "dd8d5511c0bd8e8c820727d9d55e31fe",
     "grade": true,
     "grade_id": "p8-test",
     "locked": true,
     "points": 3,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_data = [\n",
    "    (3602, \"1:00:02\"),\n",
    "    (129700, \"12:01:40\"),\n",
    "    (12739182731927, \"13:58:47\"),\n",
    "    (0, \"0:00:00\"),\n",
    "    (1, \"0:00:01\"),\n",
    "    (60, \"0:01:00\"),\n",
    "    (3600, \"1:00:00\"),\n",
    "    (3599, \"0:59:59\"),\n",
    "    (43200, \"12:00:00\"),\n",
    "    (86400, \"0:00:00\")\n",
    "]\n",
    "\n",
    "for inp, out in test_data:\n",
    "    with Tester([str(inp)]) as t:\n",
    "        clock()\n",
    "        assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n",
    "        assert t[0] == out+\"\\n\", \"Неверный ответ, было введено число \" + str(inp)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}