study_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "84403610",
   "metadata": {},
   "source": [
    "# Проверочные задания курса"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d7fc08d",
   "metadata": {},
   "source": [
    "## Операторы. Переменные. Типы данных. Условия "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cb79ff9",
   "metadata": {},
   "source": [
    "### Задание 1\n",
    "\n",
    "В то далёкое время, когда Паша ходил в школу, ему очень не нравилась формула Герона для вычисления площади\n",
    "треугольника, так как казалась слишком сложной. В один прекрасный момент Павел решил избавить всех школьников от\n",
    "страданий и написать и распространить по школам программу, вычисляющую площадь треугольника по трём сторонам.\n",
    "\n",
    "Одна проблема: так как эта формула не нравилась Павлу, он её не запомнил. Помогите ему завершить доброе дело и напишите\n",
    "программу, вычисляющую площадь треугольника по переданным длинам трёх его сторон по формуле Герона:\n",
    "S=sqrt(p(p−a)(p−b)(p−c)), где p=a+b+c\\2  – полупериметр треугольника. На вход программе подаются целые числа, выводом\n",
    "программы должно являться вещественное число, соответствующее площади треугольника\n",
    "\n",
    "**Sample Input**:\n",
    "```\n",
    "3\n",
    "4\n",
    "5\n",
    "```\n",
    "**Sample Output**:\n",
    "\n",
    "```\n",
    "6.0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "218d3467",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6.0\n"
     ]
    }
   ],
   "source": [
    "a = float(input())\n",
    "b = float(input())\n",
    "c = float(input())\n",
    "p = (a + b + c) / 2\n",
    "S = (p * (p - a) * (p - b) * (p - c)) ** 0.5\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fef2f53",
   "metadata": {},
   "source": [
    "### Задание 2\n",
    "\n",
    "Напишите программу, принимающую на вход целое число, которая выводит True, если переданное значение попадает\n",
    "в интервал (−15,12]∪(14,17)∪[19,+∞) и False в противном случае (регистр символов имеет значение)\n",
    "\n",
    "Обратите внимание на разные скобки, используемые для обозначения интервалов. В задании используются полуоткрытые и\n",
    "открытые интервалы\n",
    "\n",
    "**Sample Input 1**:\n",
    "\n",
    "20\n",
    "\n",
    "**Sample Output 1**:\n",
    "\n",
    "True\n",
    "\n",
    "**Sample Input 2**:\n",
    "\n",
    "-20\n",
    "\n",
    "**Sample Output 2**:\n",
    "\n",
    "False\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "083d66f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def solving(num):\n",
    "    if -15 < num <= 12 or 14 < num < 17 or num >= 19:\n",
    "        print('True')\n",
    "    else:\n",
    "        print('False')\n",
    "\n",
    "\n",
    "solving(20)\n",
    "solving(-20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d96882e",
   "metadata": {},
   "source": [
    "### Задание 3\n",
    "\n",
    "Напишите простой калькулятор, который считывает с пользовательского ввода три строки: первое число, второе число и\n",
    "операцию, после чего применяет операцию к введённым числам (\"первое число\" \"операция\" \"второе число\") и выводит\n",
    "результат на экран.\n",
    "\n",
    "Поддерживаемые операции: +, -, /, *, mod, pow, div, где\n",
    "mod — это взятие остатка от деления,\n",
    "pow — возведение в степень,\n",
    "div — целочисленное деление.\n",
    "\n",
    "Если выполняется деление и второе число равно 0, необходимо выводить строку \"Деление на 0!\"\n",
    "\n",
    "**Sample Input 1**:\n",
    "```\n",
    "5.0\n",
    "0.0\n",
    "mod\n",
    "```\n",
    "**Sample Output 1**:\n",
    "```\n",
    "Деление на 0!\n",
    "```\n",
    "**Sample Input 2**:\n",
    "```\n",
    "-12.0\n",
    "-8.0\n",
    "*\n",
    "```\n",
    "**Sample Output 2**:\n",
    "\n",
    "```\n",
    "96.0\n",
    "```\n",
    "\n",
    "**Sample Input 3**:\n",
    "```\n",
    "5.0\n",
    "10.0\n",
    "/\n",
    "```\n",
    "**Sample Output 3**:\n",
    "\n",
    "```\n",
    "0.5\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "904c19fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Деление на 0!\n",
      "96.0\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "def solving(a, b, c):\n",
    "    a, b, c = float(a), float(b), str(c)\n",
    "    if c == '+':\n",
    "        print(a + b)\n",
    "    elif c == '-':\n",
    "        print(a - b)\n",
    "    elif c == '*':\n",
    "        print(a * b)\n",
    "    elif c == 'pow':\n",
    "        print(a ** b)\n",
    "    elif (c == '/' or c == 'div' or c == 'mod') and b == 0:\n",
    "        print('Деление на 0!')\n",
    "    elif c == '/':\n",
    "        print(a / b)\n",
    "    elif c == 'div':\n",
    "        print(a // b)\n",
    "    elif c == 'mod':\n",
    "        print(a % b)\n",
    "        \n",
    "        \n",
    "solving(5, '0', 'mod')\n",
    "solving(-12, -8, '*')\n",
    "solving(5, 10, '/')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fab35160",
   "metadata": {},
   "source": [
    "### Задание 4\n",
    "\n",
    "Жители страны Малевии часто экспериментируют с планировкой комнат. Комнаты бывают треугольные, прямоугольные и круглые. Чтобы быстро вычислять жилплощадь, требуется написать программу, на вход которой подаётся тип фигуры комнаты и соответствующие параметры, которая бы выводила площадь получившейся комнаты.\n",
    "Для числа π в стране Малевии используют значение 3.14.\n",
    "\n",
    "Формат ввода, который используют Малевийцы:\n",
    "\n",
    "```python\n",
    "треугольник\n",
    "a\n",
    "b\n",
    "c\n",
    "```\n",
    "\n",
    "где a, b и c — длины сторон треугольника\n",
    "\n",
    "```python\n",
    "прямоугольник\n",
    "a\n",
    "b\n",
    "```\n",
    "\n",
    "где a и b — длины сторон прямоугольника\n",
    "\n",
    "```python\n",
    "круг\n",
    "r\n",
    "```\n",
    "\n",
    "где r — радиус окружности\n",
    "\n",
    "**Sample Input 1**:\n",
    "```\n",
    "прямоугольник\n",
    "4\n",
    "10\n",
    "```\n",
    "**Sample Output 1**:\n",
    "```\n",
    "40.0\n",
    "```\n",
    "**Sample Input 2**:\n",
    "```\n",
    "круг\n",
    "5\n",
    "```\n",
    "**Sample Output 2**:\n",
    "\n",
    "```\n",
    "78.5\n",
    "```\n",
    "**Sample Input 3**:\n",
    "\n",
    "```\n",
    "треугольник\n",
    "3\n",
    "4\n",
    "5\n",
    "```\n",
    "\n",
    "**Sample Output 3**:\n",
    "\n",
    "```\n",
    "6.0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "11599c9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "78.5\n",
      "6.0\n"
     ]
    }
   ],
   "source": [
    "def solving(figure, a=0, b=0, c=0, r=0):\n",
    "    if figure == 'треугольник':\n",
    "        p = (a + b + c) / 2\n",
    "        S = (p * (p - a) * (p - b) * (p - c)) ** 0.5\n",
    "        print(S)\n",
    "    elif figure == 'прямоугольник':\n",
    "        print(a * b)\n",
    "    elif figure == 'круг':\n",
    "        print(3.14 * r ** 2)\n",
    "    else:\n",
    "        print('Нет такой фигуры')\n",
    "        \n",
    "        \n",
    "solving('прямоугольник', a=4, b=10)\n",
    "solving('круг', r=5)\n",
    "solving('треугольник', a=3, b=4, c=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ba8eeb2",
   "metadata": {},
   "source": [
    "### Задание 5\n",
    "\n",
    "Напишите программу, которая получает на вход три целых числа, по одному числу в строке, и выводит на консоль в три\n",
    "строки сначала максимальное, потом минимальное, после чего оставшееся число\n",
    "\n",
    "**Sample Input 1**:\n",
    "```\n",
    "8\n",
    "2\n",
    "14\n",
    "```\n",
    "**Sample Output 1**:\n",
    "```\n",
    "14\n",
    "2\n",
    "8\n",
    "```\n",
    "**Sample Input 2**:\n",
    "```\n",
    "23\n",
    "23\n",
    "21\n",
    "```\n",
    "**Sample Output 2**:\n",
    "```\n",
    "23\n",
    "21\n",
    "23\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f99b4784",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14 \n",
      " 2 \n",
      " 8\n",
      "\n",
      "23 \n",
      " 21 \n",
      " 23\n"
     ]
    }
   ],
   "source": [
    "def solving(a, b, c):\n",
    "    if a >= b >= c:\n",
    "        print(a, '\\n', c, '\\n', b)\n",
    "    elif a >= c >= b:\n",
    "        print(a, '\\n', b, '\\n', c)\n",
    "    elif b >= a >= c:\n",
    "        print(b, '\\n', c, '\\n', a)\n",
    "    elif b >= c >= a:\n",
    "        print(b, '\\n', a, '\\n', c)\n",
    "    elif c >= a >= b:\n",
    "        print(c, '\\n', b, '\\n', a)\n",
    "    elif c >= b >= a:\n",
    "        print(c, '\\n', a, '\\n', b)\n",
    "\n",
    "\n",
    "solving(8, 2, 14)\n",
    "print()\n",
    "solving(23, 23, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1afec5f3",
   "metadata": {},
   "source": [
    "### Задание 6\n",
    "\n",
    "В институте биоинформатики по офису передвигается робот. Недавно студенты из группы программистов написали для него программу, по которой робот, когда заходит в комнату, считает количество программистов в ней и произносит его вслух: \"n программистов\".\n",
    "\n",
    "Для того, чтобы это звучало правильно, для каждого n n n нужно использовать верное окончание слова.\n",
    "\n",
    "Напишите программу, считывающую с пользовательского ввода целое число n n n (неотрицательное), выводящее это число в консоль вместе с правильным образом изменённым словом \"программист\", для того, чтобы робот мог нормально общаться с людьми, например: 1 программист, 2 программиста, 5 программистов.\n",
    "\n",
    "В комнате может быть очень много программистов. Проверьте, что ваша программа правильно обработает все случаи, как\n",
    "минимум до 1000 человек.\n",
    "\n",
    "Дополнительный комментарий к условию:\n",
    "Обратите внимание, что задача не так проста, как кажется на первый взгляд. Если ваше решение не проходит какой-то тест, это значит, что вы не рассмотрели какой-то из случаев входных данных (число программистов 0≤n≤1000).\n",
    "Обязательно проверяйте свои решения на дополнительных значениях, а не только на тех, что приведены в условии задания.\n",
    "\n",
    "Так как задание повышенной сложности, вручную код решений проверяться не будет. Если вы столкнулись с ошибкой в первых четырёх тестах, проверьте, что вы используете только русские символы для ответа. В остальных случаях ищите ошибку в логике работы программы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5f88254f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 программистов\n",
      "0 программистов\n",
      "1 программист\n",
      "2 программиста\n"
     ]
    }
   ],
   "source": [
    "def solving(n):\n",
    "    if n % 10 == 0 or n % 100 == 0 or 9 >= n % 10 >= 5 or 9 >= n % 100 >= 5:\n",
    "        print(n, 'программистов')\n",
    "    elif 11 <= n <= 19 or 11 <= n % 100 <= 19:\n",
    "        print(n, 'программистов')\n",
    "    elif n % 10 == 1 or n % 100 == 1:\n",
    "        print(n, 'программист')\n",
    "    elif 2 <= n % 10 >= 4 or 2 <= n % 100 >= 4:\n",
    "        print(n, 'программиста')\n",
    "    else:\n",
    "        print(n, 'программиста')\n",
    "\n",
    "\n",
    "solving(5)\n",
    "solving(0)\n",
    "solving(1)\n",
    "solving(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "defc6655",
   "metadata": {},
   "source": [
    "### Задание 7 (дополнительное)\n",
    "\n",
    "Паша очень любит кататься на общественном транспорте, а получая билет, сразу проверяет, счастливый ли ему попался.\n",
    "Билет считается счастливым, если сумма первых трех цифр совпадает с суммой последних трех цифр номера билета.\n",
    "\n",
    "Однако Паша очень плохо считает в уме, поэтому попросил вас написать программу, которая проверит равенство сумм и\n",
    "выведет \"Счастливый\", если суммы совпадают, и \"Обычный\", если суммы различны.\n",
    "\n",
    "На вход программе подаётся строка из шести цифр.\n",
    "\n",
    "Выводить нужно только слово \"Счастливый\" или \"Обычный\", с большой буквы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "32ac4cd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Счастливый\n",
      "Обычный\n"
     ]
    }
   ],
   "source": [
    "def solving(a):\n",
    "    a = str(a)\n",
    "    if int(a[0]) + int(a[1]) + int(a[2]) == int(a[3]) + int(a[4]) + int(a[5]):\n",
    "        print('Счастливый')\n",
    "    else:\n",
    "        print('Обычный')\n",
    "\n",
    "\n",
    "solving('090234')\n",
    "solving('123456')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3b749e4",
   "metadata": {},
   "source": [
    "## Циклы. Строки. Списки "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "787c7fe3",
   "metadata": {},
   "source": [
    "### Задание 1\n",
    "\n",
    "Напишите программу, которая считывает с консоли числа (по одному в строке) до тех пор, пока сумма введённых чисел не будет равна 0 и сразу после этого выводит сумму квадратов всех считанных чисел.\n",
    "\n",
    "Гарантируется, что в какой-то момент сумма введённых чисел окажется равной 0, после этого считывание продолжать не нужно.\n",
    "\n",
    "В примере мы считываем числа 1, -3, 5, -6, -10, 13; в этот момент замечаем, что сумма этих чисел равна нулю и выводим сумму их квадратов, не обращая внимания на то, что остались ещё не прочитанные значения\n",
    "\n",
    "**Sample Input**:\n",
    "```\n",
    "1\n",
    "-3\n",
    "5\n",
    "-6\n",
    "-10\n",
    "13\n",
    "4\n",
    "-8\n",
    "```\n",
    "**Sample Output**:\n",
    "\n",
    "```\n",
    "340\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2f1745ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "-3\n",
      "5\n",
      "-6\n",
      "-10\n",
      "13\n",
      "340\n"
     ]
    }
   ],
   "source": [
    "y = 1\n",
    "z = 0\n",
    "o = 1\n",
    "\n",
    "while y:\n",
    "    y -= o\n",
    "    x = int(input())\n",
    "    y += x\n",
    "    z += x ** 2\n",
    "    o = 0\n",
    "   \n",
    "    if y == 0:\n",
    "        print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d92b79af",
   "metadata": {},
   "source": [
    "### Задание 2\n",
    "\n",
    "Напишите программу, которая выводит часть последовательности 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 ... (число повторяется столько раз, чему равно). На вход программе передаётся неотрицательное целое число n — столько элементов последовательности должна отобразить программа. На выходе ожидается последовательность чисел, записанных через пробел в одну строку.\n",
    "\n",
    "Например, если n = 7, то программа должна вывести 1 2 2 3 3 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c6cb26df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "1 2 2 3 3 3 4\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "l = []\n",
    "s = 0\n",
    "\n",
    "while len(l) != n:\n",
    "    s += 1\n",
    "    p = s\n",
    "    while p != 0 and len(l) != n:\n",
    "        l.append(s)\n",
    "        p -= 1\n",
    "\n",
    "print(*l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8444c5aa",
   "metadata": {},
   "source": [
    "### Задание 3\n",
    "\n",
    "Напишите программу, которая считывает список чисел lst lst lst из первой строки и число x x x из второй строки, которая выводит все позиции, на которых встречается число x x x в переданном списке lst lst lst.\n",
    "\n",
    "Позиции нумеруются с нуля, если число x x x не встречается в списке, вывести строку \"Отсутствует\" (без кавычек, с большой буквы).\n",
    "\n",
    "Позиции должны быть выведены в одну строку, по возрастанию абсолютного значения\n",
    "\n",
    "**Sample Input 1**:\n",
    "```\n",
    "5 8 2 7 8 8 2 4\n",
    "8\n",
    "```\n",
    "**Sample Output 1**:\n",
    "```\n",
    "1 4 5\n",
    "```\n",
    "**Sample Input 2**:\n",
    "```\n",
    "5 8 2 7 8 8 2 4\n",
    "10\n",
    "```\n",
    "**Sample Output 2**:\n",
    "\n",
    "```Отсутствует\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f8d8e08c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 5 \n",
      "Отсутствует\n"
     ]
    }
   ],
   "source": [
    "def solving(numbers, x):\n",
    "    lst = [int(i) for i in numbers.split()]\n",
    "    if x in lst:\n",
    "        for i in range(len(lst)):\n",
    "            if lst[i] == x:\n",
    "                print(i, end= ' ')\n",
    "    else:\n",
    "        print('Отсутствует')\n",
    "        \n",
    "        \n",
    "solving('5 8 2 7 8 8 2 4', 8)\n",
    "print()\n",
    "solving('5 8 2 7 8 8 2 4', 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18480162",
   "metadata": {},
   "source": [
    "### Задание 4\n",
    "\n",
    "Напишите программу, на вход которой подаётся прямоугольная матрица в виде последовательности строк. После последней строки матрицы идёт строка, содержащая только строку \"end\" (без кавычек, см. Sample Input).\n",
    "\n",
    "Программа должна вывести матрицу того же размера, у которой каждый элемент в позиции i, j равен сумме элементов первой матрицы на позициях (i-1, j), (i+1, j), (i, j-1), (i, j+1). У крайних символов соседний элемент находится с противоположной стороны матрицы.\n",
    "\n",
    "В случае одной строки/столбца элемент сам себе является соседом по соответствующему направлению\n",
    "\n",
    "**Sample Input 1**:\n",
    "```\n",
    "9 5 3\n",
    "0 7 -1\n",
    "-5 2 9\n",
    "end\n",
    "```\n",
    "**Sample Output 1**:\n",
    "```\n",
    "3 21 22\n",
    "10 6 19\n",
    "20 16 -1\n",
    "```\n",
    "**Sample Input 2**:\n",
    "```\n",
    "1\n",
    "end\n",
    "```\n",
    "**Sample Output 2**:\n",
    "\n",
    "`4`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "813401e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 5 3\n",
      "0 7 -1\n",
      "-5 2 9\n",
      "end\n",
      "3 21 22\n",
      "10 6 19\n",
      "20 16 -1\n"
     ]
    }
   ],
   "source": [
    "a = [[int(i) for i in input().split()]]\n",
    "b = input()\n",
    "\n",
    "while b != 'end':\n",
    "    a.append([int(i) for i in b.split()])\n",
    "    b = input()\n",
    "\n",
    "c = [[0 for j in range(len(a[i]))] for i in range(len(a))]\n",
    "\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        c[i][j] = (a[i - 1][j] + a[i + 1 - len(a)][j] + a[i][j - 1] + a[i][j + 1 - len(a[i])])\n",
    "    print(*c[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c86f64d",
   "metadata": {},
   "source": [
    "### Задание 5 (дополнительное)\n",
    "\n",
    "Выведите таблицу размером n×n, заполненную числами от 1 до n ** 2 по спирали, выходящей из левого верхнего угла и закрученной по часовой стрелке\n",
    "\n",
    "**Пример ввода**:\n",
    "\n",
    "`5`\n",
    "\n",
    "**Вывод**:\n",
    "```\n",
    "1 2 3 4 5\n",
    "16 17 18 19 6\n",
    "15 24 25 20 7\n",
    "14 23 22 21 8\n",
    "13 12 11 10 9\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2d9a1df2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1 2 3 4 5\n",
      "16 17 18 19 6\n",
      "15 24 25 20 7\n",
      "14 23 22 21 8\n",
      "13 12 11 10 9\n"
     ]
    }
   ],
   "source": [
    "size = int(input())\n",
    "\n",
    "mtrx = [[None for item in range(size)] for item in range(size)]\n",
    "counter = 1\n",
    "start_col = 0\n",
    "end_col = size - 1\n",
    "start_row = 0\n",
    "end_row = size - 1\n",
    "while start_col <= end_col and start_row <= end_row:\n",
    "    for col in range(start_col, end_col + 1):\n",
    "        mtrx[start_row][col] = counter\n",
    "        counter += 1\n",
    "    start_row += 1\n",
    "    for row in range(start_row, end_row + 1):\n",
    "        mtrx[row][end_col] = counter\n",
    "        counter += 1\n",
    "    end_col -= 1\n",
    "    for col in range(end_col, start_col - 1, -1):\n",
    "        mtrx[end_row][col] = counter\n",
    "        counter += 1\n",
    "    end_row -= 1\n",
    "    for row in range(end_row, start_row - 1, -1):\n",
    "        mtrx[row][start_col] = counter\n",
    "        counter += 1\n",
    "    start_col += 1\n",
    "for line in mtrx:\n",
    "    print(*line)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d30fc970",
   "metadata": {},
   "source": [
    "## Функции. Словари. Интерпретатор. Файлы. Модули. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "481963f6",
   "metadata": {},
   "source": [
    "### Задание 1\n",
    "\n",
    "Напишите программу, которая принимает на стандартный вход список игр футбольных команд с результатом матча и выводит на стандартный вывод сводную таблицу результатов всех матчей.\n",
    "\n",
    "За победу команде начисляется 3 очка, за поражение — 0, за ничью — 1.\n",
    "\n",
    "Формат ввода следующий:\n",
    "В первой строке указано целое число n n n — количество завершенных игр.\n",
    "После этого идет n n n строк, в которых записаны результаты игры в следующем формате:\n",
    "Первая_команда;Забито_первой_командой;Вторая_команда;Забито_второй_командой\n",
    "\n",
    "Вывод программы необходимо оформить следующим образом:\n",
    "Команда:Всего_игр Побед Ничьих Поражений Всего_очков\n",
    "\n",
    "Конкретный пример ввода-вывода приведён ниже.\n",
    "\n",
    "Порядок вывода команд произвольный\n",
    "\n",
    "**Пример ввода**:\n",
    "```\n",
    "3\n",
    "Спартак;9;Зенит;10\n",
    "Локомотив;12;Зенит;3\n",
    "Спартак;8;Локомотив;15\n",
    "```\n",
    "**Вывод**:\n",
    "```\n",
    "Спартак:2 0 0 2 0\n",
    "Зенит:2 1 0 1 3\n",
    "Локомотив:2 2 0 0 6\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dbda86a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Спартак;9;Зенит;10\n",
      "Локомотив;12;Зенит;3\n",
      "Спартак;8;Локомотив;15\n",
      "Спартак: 2 0 0 2 0\n",
      "Зенит: 2 1 0 1 3\n",
      "Локомотив: 2 2 0 0 6\n"
     ]
    }
   ],
   "source": [
    " def solving():\n",
    "    games = [input().split(';') for i in range(int(input()))]\n",
    "    table = {}\n",
    "\n",
    "    for match in games:\n",
    "        for i in range(len(match)):\n",
    "\n",
    "            if not '0' <= match[i] <= '99' and match[i] not in table:\n",
    "                table[match[i]] = [0 for i in range(5)]\n",
    "\n",
    "                count = 0\n",
    "                for j in games:\n",
    "                    count += j.count(match[i])\n",
    "                table[match[i]][0] += count\n",
    "\n",
    "            elif '0' <= match[i] <= '99':\n",
    "                if int(match[i]) > int(match[i + 2 - len(match)]):\n",
    "                    table[match[i - 1]][4] += 3\n",
    "                    table[match[i - 1]][1] += 1\n",
    "\n",
    "                elif match[i] == match[i + 2 - len(match)]:\n",
    "                    table[match[i - 1]][4] += 1\n",
    "                    table[match[i - 1]][2] += 1\n",
    "\n",
    "                else:\n",
    "                    table[match[i - 1]][3] += 1\n",
    "\n",
    "    for team, score in table.items():\n",
    "        print(team + ':', *score)\n",
    "        \n",
    "        \n",
    "solving()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc80b484",
   "metadata": {},
   "source": [
    "### Задание 2 (дополнительное)\n",
    "\n",
    "В какой-то момент в Институте биоинформатики биологи перестали понимать, что говорят информатики: они говорили каким-то странным набором звуков.\n",
    "\n",
    "В какой-то момент один из биологов раскрыл секрет информатиков: они использовали при общении подстановочный шифр, т.е. заменяли каждый символ исходного сообщения на соответствующий ему другой символ. Биологи раздобыли ключ к шифру и теперь нуждаются в помощи:\n",
    "\n",
    "Напишите программу, которая умеет шифровать и расшифровывать шифр подстановки. Программа принимает на вход две строки одинаковой длины, на первой строке записаны символы исходного алфавита, на второй строке — символы конечного алфавита, после чего идёт строка, которую нужно зашифровать переданным ключом, и ещё одна строка, которую нужно расшифровать.\n",
    "\n",
    "Пусть, например, на вход программе передано:\n",
    "```\n",
    "abcd\n",
    "*d%#\n",
    "abacabadaba\n",
    "#*%*d*%\n",
    "```\n",
    "Это значит, что символ a исходного сообщения заменяется на символ * в шифре, b заменяется на d, c — на % и d — на #.\n",
    "Нужно зашифровать строку abacabadaba и расшифровать строку #*%*d*% с помощью этого шифра. Получаем следующие строки, которые и передаём на вывод программы:\n",
    "```\n",
    "*d*%*d*#*d*\n",
    "dacabac\n",
    "```\n",
    "\n",
    "**Пример ввода 1**:\n",
    "```\n",
    "abcd\n",
    "*d%#\n",
    "abacabadaba\n",
    "#*%*d*%\n",
    "```\n",
    "**Вывод 1**:\n",
    "```\n",
    "*d*%*d*#*d*\n",
    "dacabac\n",
    "```\n",
    "**Пример ввода 2**:\n",
    "```\n",
    "dcba\n",
    "badc\n",
    "dcba\n",
    "badc\n",
    "```\n",
    "**Вывод 2**:\n",
    "```\n",
    "badc\n",
    "dcba\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dacca693",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n",
      "*d%#\n",
      "abacabadaba\n",
      "#*%*d*%\n",
      "*d*%*d*#*d*\n",
      "dacabac\n"
     ]
    }
   ],
   "source": [
    "def solving():\n",
    "    abc1, abc2, text1, text2 = (list(input()) for i in range(4))\n",
    "    dic1 = {abc1[i]: abc2[i] for i in range(len(abc1))}\n",
    "    dic2 = {abc2[i]: abc1[i] for i in range(len(abc2))}\n",
    "\n",
    "    for i in range(len(text1)):\n",
    "        text1[i] = dic1[text1[i]]\n",
    "\n",
    "    for i in range(len(text2)):\n",
    "        text2[i] = dic2[text2[i]]\n",
    "\n",
    "    print(*text1, sep='')\n",
    "    print(*text2, sep='')\n",
    "    \n",
    "    \n",
    "solving()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80100275",
   "metadata": {},
   "source": [
    "### Задание 3\n",
    "\n",
    "Простейшая система проверки орфографии может быть основана на использовании списка известных слов.\n",
    "Если введённое слово не найдено в этом списке, оно помечается как \"ошибка\".\n",
    "\n",
    "Попробуем написать подобную систему.\n",
    "\n",
    "На вход программе первой строкой передаётся количество d d d известных нам слов, после чего на d d d строках указываются эти слова. Затем передаётся количество l l l строк текста для проверки, после чего l l l строк текста.\n",
    "\n",
    "Выведите уникальные \"ошибки\" в произвольном порядке. Работу производите без учёта регистра\n",
    "\n",
    "\n",
    "\n",
    "**Пример ввода**:\n",
    "```\n",
    "4\n",
    "champions\n",
    "we\n",
    "are\n",
    "Stepik\n",
    "3\n",
    "We are the champignons\n",
    "We Are The Champions\n",
    "Stepic\n",
    "```\n",
    "**Вывод**:\n",
    "```\n",
    "stepic\n",
    "champignons\n",
    "the\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "96beaa81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "champions\n",
      "we\n",
      "are\n",
      "Stepik\n",
      "3\n",
      "We are the champignons\n",
      "We Are The Champions\n",
      "Stepic\n",
      "stepic\n",
      "the\n",
      "champignons\n"
     ]
    }
   ],
   "source": [
    "def solving():\n",
    "    d = {input().lower() for i in range(int(input()))}\n",
    "    l = [input().lower().split() for i in range(int(input()))]\n",
    "    s = set(j for i in l for j in i if j not in d)\n",
    "    print(*s, sep='\\n')\n",
    "    \n",
    "    \n",
    "solving()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb7a0078",
   "metadata": {},
   "source": [
    "### Задание 4\n",
    "\n",
    "\n",
    "\n",
    "Группа биологов в институте биоинформатики завела себе черепашку.\n",
    "\n",
    "После дрессировки черепашка научилась понимать и запоминать указания биологов следующего вида:\n",
    "север 10\n",
    "запад 20\n",
    "юг 30\n",
    "восток 40\n",
    "где первое слово — это направление, в котором должна двигаться черепашка, а число после слова — это положительное расстояние в сантиметрах, которое должна пройти черепашка.\n",
    "\n",
    "Но команды даются быстро, а черепашка ползёт медленно, и программисты догадались, что можно написать программу, которая определит, куда в итоге биологи приведут черепашку. Для этого программисты просят вас написать программу, которая выведет точку, в которой окажется черепашка после всех команд. Для простоты они решили считать, что движение начинается в точке (0, 0), и движение на восток увеличивает первую координату, а на север — вторую.\n",
    "\n",
    "Программе подаётся на вход число команд n n n, которые нужно выполнить черепашке, после чего n n n строк с самими командами. Вывести нужно два числа в одну строку: первую и вторую координату конечной точки черепашки. Все координаты целочисленные.\n",
    "\n",
    "**Пример ввода**:\n",
    "```\n",
    "4\n",
    "север 10\n",
    "запад 20\n",
    "юг 30\n",
    "восток 40\n",
    "```\n",
    "**Вывод**:\n",
    "```\n",
    "20 -20\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "186a93d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "север 10\n",
      "запад 20\n",
      "юг 30\n",
      "восток 40\n",
      "20 -20\n"
     ]
    }
   ],
   "source": [
    "def solving():\n",
    "    coordinates = [input().split() for i in range(int(input()))]\n",
    "    x = 0\n",
    "    y = 0\n",
    "\n",
    "    for i in coordinates:\n",
    "        for j in range(len(i)):\n",
    "            if i[j] == 'север':\n",
    "                x += int(i[j + 1])\n",
    "            elif i[j] == 'юг':\n",
    "                x -= int(i[j + 1])\n",
    "            elif i[j] == 'восток':\n",
    "                y += int(i[j + 1])\n",
    "            elif i[j] == 'запад':\n",
    "                y -= int(i[j + 1])\n",
    "\n",
    "    print(y, x)\n",
    "    \n",
    "\n",
    "solving()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "715061fd",
   "metadata": {},
   "source": [
    "### Задание 5\n",
    "\n",
    "Дан файл с таблицей в формате TSV с информацией о росте школьников разных классов.\n",
    "\n",
    "Напишите программу, которая прочитает этот файл и подсчитает для каждого класса средний рост учащегося.\n",
    "\n",
    "Файл состоит из набора строк, каждая из которых представляет собой три поля:\n",
    "Класс Фамилия Рост\n",
    "\n",
    "Класс обозначается только числом. Буквенные модификаторы не используются. Номер класса может быть от 1 до 11 включительно. В фамилии нет пробелов, а в качестве роста используется натуральное число, но при подсчёте среднего требуется вычислить значение в виде вещественного числа.\n",
    "\n",
    "Выводить информацию о среднем росте следует в порядке возрастания номера класса (для классов с первого по одиннадцатый). Если про какой-то класс нет информации, необходимо вывести напротив него прочерк.\n",
    "\n",
    "В качестве ответа прикрепите файл с полученными данными о среднем росте.\n",
    "\n",
    "**Пример ввода**:\n",
    "```\n",
    "6\tВяххи\t159\n",
    "11\tФедотов\t172\n",
    "7\tБондарев\t158\n",
    "6\tЧайкина\t153\n",
    "```\n",
    "**Вывод**:\n",
    "```\n",
    "1 -\n",
    "2 -\n",
    "3 -\n",
    "4 -\n",
    "5 -\n",
    "6 156.0\n",
    "7 158.0\n",
    "8 -\n",
    "9 -\n",
    "10 -\n",
    "11 172.0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0a80a06",
   "metadata": {},
   "outputs": [],
   "source": [
    "filepath = input()\n",
    "\n",
    "\n",
    "def solving(filepath):\n",
    "    classes = {i: [] for i in range(1, 12)}\n",
    "    with open(filepath) as f:\n",
    "        for line in f:\n",
    "            cls, name, height = line.strip().split('\\t')\n",
    "            classes[int(cls)].append(int(height))\n",
    "\n",
    "    for cls, heights in classes.items():\n",
    "        print(cls, sum(heights) / len(heights) if heights else '-')\n",
    "        \n",
    "        \n",
    "solving(filepath)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51c776e",
   "metadata": {},
   "source": [
    "## Базовые принципы языка Python "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dafa525c",
   "metadata": {},
   "source": [
    "### Функции и стек вызовов\n",
    "\n",
    "Сочетанием из n элементов по k называется подмножество этих n элементов размера k.\n",
    "Два сочетания называются различными, если одно из сочетаний содержит элемент, который не содержит другое.\n",
    "Числом сочетаний из n по k называется количество различных сочетаний из n по k. Обозначим это число за C(n, k).\n",
    "\n",
    "Пример:\n",
    "Пусть n = 3, т. е. есть три элемента (1, 2, 3). Пусть k = 2.\n",
    "Все различные сочетания из 3 элементов по 2: (1, 2), (1, 3), (2, 3).\n",
    "Различных сочетаний три, поэтому C(3, 2) = 3.\n",
    "\n",
    "Несложно понять, что C(n, 0) = 1, так как из n элементов выбрать 0 можно единственным образом, а именно, ничего не выбрать.\n",
    "Также несложно понять, что если k > n, то C(n, k) = 0, так как невозможно, например, из трех элементов выбрать пять.\n",
    "\n",
    "Для вычисления C(n, k) в других случаях используется следующая рекуррентная формула:\n",
    "C(n, k) = C(n - 1, k) + C(n - 1, k - 1).\n",
    "\n",
    "Реализуйте программу, которая для заданных n и k вычисляет C(n, k).\n",
    "\n",
    "Вашей программе на вход подается строка, содержащая два целых числа n и k (1 ≤ n ≤ 10, 0 ≤ k ≤ 10).\n",
    "Ваша программа должна вывести единственное число: C(n, k).\n",
    "\n",
    "Примечание:\n",
    "Считать два числа n и k вы можете, например, следующим образом:\n",
    "\n",
    "```python\n",
    "n, k = map(int, input().split())\n",
    "```\n",
    "\n",
    "**Sample Input 1**:\n",
    "\n",
    "3 2\n",
    "\n",
    "**Sample Output 1**:\n",
    "\n",
    "3\n",
    "\n",
    "**Sample Input 2**:\n",
    "\n",
    "10 5\n",
    "\n",
    "**Sample Output 2**:\n",
    "\n",
    "252"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c98f864a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "n, k = map(int, input().split())\n",
    "\n",
    "def C(n, k):\n",
    "    if k == 0:\n",
    "        return 1\n",
    "    elif n < k:\n",
    "        return 0\n",
    "    else:\n",
    "        return C(n - 1, k) + C(n - 1, k - 1)\n",
    "\n",
    "print(C(n, k))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8531d033",
   "metadata": {},
   "source": [
    "### Пространства имён и области видимости\n",
    "\n",
    "Реализуйте программу, которая будет эмулировать работу с пространствами имен. Необходимо реализовать поддержку создания пространств имен и добавление в них переменных.\n",
    "\n",
    "В данной задаче у каждого пространства имен есть уникальный текстовый идентификатор – его имя.\n",
    "\n",
    "Вашей программе на вход подаются следующие запросы:\n",
    "\n",
    "    create <namespace> <parent> –  создать новое пространство имен с именем <namespace> внутри пространства <parent>\n",
    "    add <namespace> <var> – добавить в пространство <namespace> переменную <var>\n",
    "    get <namespace> <var> – получить имя пространства, из которого будет взята переменная <var> при запросе из пространства <namespace>, или None, если такого пространства не существует\n",
    "\n",
    "Рассмотрим набор запросов\n",
    "\n",
    "    **add global a**\n",
    "    **create foo global**\n",
    "    **add foo b**\n",
    "    **create bar foo**\n",
    "    **add bar a**\n",
    "\n",
    "Структура пространств имен описанная данными запросами будет эквивалентна структуре пространств имен, созданной при выполнении данного кода\n",
    "\n",
    "```python\n",
    "a = 0\n",
    "\n",
    "\n",
    "def foo():\n",
    "  b = 1\n",
    "\n",
    "  def bar():\n",
    "    a = 2\n",
    "```\n",
    "\n",
    "В основном теле программы мы объявляем переменную a, тем самым добавляя ее в пространство global. Далее мы объявляем функцию foo, что влечет за собой создание локального для нее пространства имен внутри пространства global. В нашем случае, это описывается командой create foo global. Далее мы объявляем внутри функции foo функцию bar, тем самым создавая пространство bar внутри пространства foo, и добавляем в bar переменную a.\n",
    "\n",
    "Добавим запросы get к нашим запросам\n",
    "\n",
    "    **get foo a**\n",
    "    **get foo c**\n",
    "    **get bar a**\n",
    "    **get bar b**\n",
    "\n",
    "Представим как это могло бы выглядеть в коде\n",
    "\n",
    "```python\n",
    "a = 0\n",
    "\n",
    "\n",
    "def foo():\n",
    "  b = 1\n",
    "  get(a)\n",
    "  get(c)\n",
    "\n",
    "  def bar():\n",
    "    a = 2\n",
    "    get(a)\n",
    "    get(b)\n",
    "```\n",
    "\n",
    "Результатом запроса get будет имя пространства, из которого будет взята нужная переменная.\n",
    "Например, результатом запроса get foo a будет global, потому что в пространстве foo не объявлена переменная a, но в пространстве global, внутри которого находится пространство foo, она объявлена. Аналогично, результатом запроса get bar b будет являться foo, а результатом работы get bar a будет являться bar.\n",
    "\n",
    "Результатом get foo c будет являться None, потому что ни в пространстве foo, ни в его внешнем пространстве global не была объявлена переменная с.\n",
    "\n",
    "Более формально, результатом работы get <namespace> <var> является <namespace>, если в пространстве <namespace> была объявлена переменная <var> get <parent> <var> – результат запроса к пространству, внутри которого было создано пространство <namespace>, если переменная не была объявлена None, если не существует <parent>, т. е <namespace> – это global\n",
    "\n",
    "**Формат входных данных**\n",
    "\n",
    "В первой строке дано число n (1 ≤ n ≤ 100) – число запросов.\n",
    "В каждой из следующих n строк дано по одному запросу.\n",
    "Запросы выполняются в порядке, в котором они даны во входных данных.\n",
    "Имена пространства имен и имена переменных представляют из себя строки длины не более 10, состоящие из строчных латинских букв.\n",
    "Формат выходных данных\n",
    "\n",
    "Для каждого запроса get выведите в отдельной строке его результат.\n",
    "\n",
    "**Sample Input**:\n",
    "    \n",
    "```\n",
    "9\n",
    "add global a\n",
    "create foo global\n",
    "add foo b\n",
    "get foo a\n",
    "get foo c\n",
    "create bar foo\n",
    "add bar a\n",
    "get bar a\n",
    "get bar b\n",
    "```\n",
    "\n",
    "**Sample Output**:\n",
    "\n",
    "```\n",
    "global\n",
    "None\n",
    "bar\n",
    "foo\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b5777fad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "add global a\n",
      "create foo global\n",
      "add foo b\n",
      "get foo a\n",
      "global\n",
      "get foo c\n",
      "None\n",
      "create bar foo\n",
      "add bar a\n",
      "get bar a\n",
      "bar\n",
      "get bar b\n",
      "foo\n"
     ]
    }
   ],
   "source": [
    "namespaces = {'global': {'var': []}}\n",
    "names = set()\n",
    "\n",
    "for i in range(int(input())):\n",
    "    n = (input().split())\n",
    "\n",
    "    if n[0] == 'create':  # Создание пространства имен внутри \"родителя\"\n",
    "        namespaces[n[1]] = {'parent': n[2], 'var': []}\n",
    "\n",
    "    elif n[0] == 'add':  # Создание переменной внутри пространства\n",
    "        if n[1] not in namespaces:\n",
    "            namespaces[n[1]] = {'parent': None, 'var': [n[2]]}\n",
    "            names.add(n[2])\n",
    "\n",
    "        else:\n",
    "            namespaces[n[1]]['var'].append(n[2])\n",
    "            names.add(n[2])\n",
    "\n",
    "    elif n[0] == 'get':  # Получить имя пространства, из которого будет взята переменная <var> при запросе из\n",
    "        # пространства <namespace>, или None, если такого пространства не существует\n",
    "\n",
    "        if n[1] in namespaces:\n",
    "            while True:\n",
    "\n",
    "                if n[2] not in names:\n",
    "                    print('None')\n",
    "                    break\n",
    "\n",
    "                elif n[1] == 'global' and n[2] not in namespaces['global']['var']:\n",
    "                    print('None')\n",
    "                    break\n",
    "\n",
    "                elif n[2] in namespaces[n[1]]['var']:\n",
    "                    print(n[1])\n",
    "                    break\n",
    "\n",
    "                elif n[2] not in namespaces[n[1]]['var']:\n",
    "                    n[1] = namespaces[n[1]]['parent']\n",
    "\n",
    "        else:\n",
    "            print('None')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45fc3381",
   "metadata": {},
   "source": [
    "###  Введение в классы 1\n",
    "\n",
    "Реализуйте класс MoneyBox, для работы с виртуальной копилкой.\n",
    "\n",
    "Каждая копилка имеет ограниченную вместимость, которая выражается целым числом – количеством монет, которые можно положить в копилку. Класс должен поддерживать информацию о количестве монет в копилке, предоставлять возможность добавлять монеты в копилку и узнавать, можно ли добавить в копилку ещё какое-то количество монет, не превышая ее вместимость.\n",
    "\n",
    "Класс должен иметь следующий вид\n",
    "\n",
    "```python\n",
    "class MoneyBox:\n",
    "    def __init__(self, capacity):\n",
    "        # конструктор с аргументом – вместимость копилки\n",
    "\n",
    "    def can_add(self, v):\n",
    "        # True, если можно добавить v монет, False иначе\n",
    "\n",
    "    def add(self, v):\n",
    "        # положить v монет в копилку\n",
    "```\n",
    "\n",
    "При создании копилки, число монет в ней равно 0.\n",
    "Примечание:\n",
    "Гарантируется, что метод add(self, v) будет вызываться только если can_add(self, v) – True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1def719",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MoneyBox:\n",
    "    \n",
    "    def __init__(self, capacity):\n",
    "        self.cap = capacity\n",
    "        self.inBox = 0\n",
    "\n",
    "    def can_add(self, v):\n",
    "        return self.inBox + v <= self.cap\n",
    "            \n",
    "    def add(self, v):\n",
    "        if self.can_add(v):\n",
    "            self.inBox += v\n",
    "            return self.cap - self.inBox"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "147c183e",
   "metadata": {},
   "source": [
    "###  Введение в классы 2\n",
    "\n",
    "Вам дается последовательность целых чисел и вам нужно ее обработать и вывести на экран сумму первой пятерки чисел из этой последовательности, затем сумму второй пятерки, и т. д.\n",
    "\n",
    "Но последовательность не дается вам сразу целиком. С течением времени к вам поступают её последовательные части. Например, сначала первые три элемента, потом следующие шесть, потом следующие два и т. д.\n",
    "\n",
    "Реализуйте класс Buffer, который будет накапливать в себе элементы последовательности и выводить сумму пятерок последовательных элементов по мере их накопления.\n",
    "\n",
    "Одним из требований к классу является то, что он не должен хранить в себе больше элементов, чем ему действительно необходимо, т. е. он не должен хранить элементы, которые уже вошли в пятерку, для которой была выведена сумма.\n",
    "\n",
    "Класс должен иметь следующий вид\n",
    "\n",
    "```python\n",
    "class Buffer:\n",
    "    def __init__(self):\n",
    "        # конструктор без аргументов\n",
    "    \n",
    "    def add(self, *a):\n",
    "        # добавить следующую часть последовательности\n",
    "\n",
    "    def get_current_part(self):\n",
    "        # вернуть сохраненные в текущий момент элементы последовательности в порядке, в котором они были     \n",
    "        # добавлены\n",
    "```\n",
    "\n",
    "\n",
    "Пример работы с классом\n",
    "\n",
    "```python\n",
    "buf = Buffer()\n",
    "buf.add(1, 2, 3)\n",
    "buf.get_current_part() # вернуть [1, 2, 3]\n",
    "buf.add(4, 5, 6) # print(15) – вывод суммы первой пятерки элементов\n",
    "buf.get_current_part() # вернуть [6]\n",
    "buf.add(7, 8, 9, 10) # print(40) – вывод суммы второй пятерки элементов\n",
    "buf.get_current_part() # вернуть []\n",
    "buf.add(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) # print(5), print(5) – вывод сумм третьей и четвертой пятерки\n",
    "buf.get_current_part() # вернуть [1]\n",
    "```\n",
    "\n",
    "\n",
    "Обратите внимание, что во время выполнения метода add выводить сумму пятерок может потребоваться несколько раз до тех пор, пока в буфере не останется менее пяти элементов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ba54e49",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Buffer:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.lst = []\n",
    "\n",
    "    def add(self, *a):\n",
    "        self.lst.extend(a)\n",
    "\n",
    "        while len(self.lst) >= 5:\n",
    "            print(sum(self.lst[:5]))\n",
    "            del self.lst[:5]\n",
    "\n",
    "    def get_current_part(self):\n",
    "        return self.lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30955362",
   "metadata": {},
   "source": [
    "### Наследование классов 1\n",
    "\n",
    "Вам дано описание наследования классов в следующем формате.\n",
    "<имя класса 1> : <имя класса 2> <имя класса 3> ... <имя класса k>\n",
    "Это означает, что класс 1 отнаследован от класса 2, класса 3, и т. д.\n",
    "\n",
    "Или эквивалентно записи:\n",
    "\n",
    "```python\n",
    "class Class1(Class2, Class3 ... ClassK):\n",
    "    pass\n",
    "```\n",
    "\n",
    "Класс A является прямым предком класса B, если B отнаследован от A:\n",
    "\n",
    "```python\n",
    "class B(A):\n",
    "    pass\n",
    "```\n",
    "\n",
    "Класс A является предком класса B, если\n",
    "\n",
    "    A = B;\n",
    "    A - прямой предок B\n",
    "    существует такой класс C, что C - прямой предок B и A - предок C\n",
    "\n",
    "\n",
    "Например:\n",
    "\n",
    "```python\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "class C(B):\n",
    "    pass\n",
    "```\n",
    "\n",
    "\\# A -- предок С\n",
    "\n",
    "\n",
    "\n",
    "Вам необходимо отвечать на запросы, является ли один класс предком другого класса\n",
    "\n",
    "**Важное примечание**:\n",
    "Создавать классы не требуется.\n",
    "Мы просим вас промоделировать этот процесс, и понять существует ли путь от одного класса до другого.\n",
    "Формат входных данных\n",
    "\n",
    "В первой строке входных данных содержится целое число n - число классов.\n",
    "\n",
    "В следующих n строках содержится описание наследования классов. В i-й строке указано от каких классов наследуется i-й класс. Обратите внимание, что класс может ни от кого не наследоваться. Гарантируется, что класс не наследуется сам от себя (прямо или косвенно), что класс не наследуется явно от одного класса более одного раза.\n",
    "\n",
    "В следующей строке содержится число q - количество запросов.\n",
    "\n",
    "В следующих q строках содержится описание запросов в формате <имя класса 1> <имя класса 2>.\n",
    "Имя класса – строка, состоящая из символов латинского алфавита, длины не более 50.\n",
    "Формат выходных данных\n",
    "\n",
    "Для каждого запроса выведите в отдельной строке слово \"Yes\", если класс 1 является предком класса 2, и \"No\", если не является.\n",
    "\n",
    "**Sample Input**:\n",
    "```\n",
    "4\n",
    "A\n",
    "B : A\n",
    "C : A\n",
    "D : B C\n",
    "4\n",
    "A B\n",
    "B D\n",
    "C D\n",
    "D A\n",
    "```\n",
    "**Sample Output**:\n",
    "```\n",
    "Yes\n",
    "Yes\n",
    "Yes\n",
    "No\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "15eb10b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "A\n",
      "B : A\n",
      "C : A\n",
      "D : B C\n",
      "4\n",
      "A B\n",
      "Yes\n",
      "B D\n",
      "Yes\n",
      "C D\n",
      "Yes\n",
      "D A\n",
      "No\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "\n",
    "parents = {}\n",
    "for _ in range(n):\n",
    "    a = input().split()\n",
    "    parents[a[0]] = [] if len(a) == 1 else a[2:]\n",
    "\n",
    "def is_parent(child, parent):\n",
    "    return child == parent or any(map(lambda p: is_parent(p, parent), parents[child]))\n",
    "\n",
    "q = int(input())\n",
    "for _ in range(q):\n",
    "    a, b = input().split()\n",
    "    print(\"Yes\" if is_parent(b, a) else \"No\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "187d3aa8",
   "metadata": {},
   "source": [
    "### Наследование классов 2\n",
    "\n",
    "Реализуйте структуру данных, представляющую собой расширенную структуру стек. Необходимо поддерживать добавление элемента на вершину стека, удаление с вершины стека, и необходимо поддерживать операции сложения, вычитания, умножения и целочисленного деления.\n",
    "\n",
    "Операция сложения на стеке определяется следующим образом. Со стека снимается верхний элемент (top1), затем снимается следующий верхний элемент (top2), и затем как результат операции сложения на вершину стека кладется элемент, равный top1 + top2.\n",
    "\n",
    "Аналогичным образом определяются операции вычитания (top1 - top2), умножения (top1 * top2) и целочисленного деления (top1 // top2).\n",
    "\n",
    "Реализуйте эту структуру данных как класс ExtendedStack, отнаследовав его от стандартного класса list.\n",
    "Требуемая структура класса:\n",
    "\n",
    "```python\n",
    "class ExtendedStack(list):\n",
    "    def sum(self):\n",
    "        # операция сложения\n",
    "\n",
    "    def sub(self):\n",
    "        # операция вычитания\n",
    "\n",
    "    def mul(self):\n",
    "        # операция умножения\n",
    "\n",
    "    def div(self):\n",
    "        # операция целочисленного деления\n",
    "```\n",
    " \n",
    "*Примечание*\n",
    "Для добавления элемента на стек используется метод append, а для снятия со стека – метод pop.\n",
    "Гарантируется, что операции будут совершаться только когда в стеке есть хотя бы два элемента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c5ffa48e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExtendedStack(list):\n",
    "    def sum(self):\n",
    "        x = self.pop()\n",
    "        y = self.pop()\n",
    "        self.append(x + y)\n",
    "        return self\n",
    "\n",
    "    def sub(self):\n",
    "        x = self.pop()\n",
    "        y = self.pop()\n",
    "        self.append(x - y)\n",
    "        return self\n",
    "\n",
    "\n",
    "    def mul(self):\n",
    "        x = self.pop()\n",
    "        y = self.pop()\n",
    "        self.append(x * y)\n",
    "        return self\n",
    "\n",
    "    def div(self):\n",
    "        x = self.pop()\n",
    "        y = self.pop()\n",
    "        self.append(x // y)\n",
    "        return self\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c837bc59",
   "metadata": {},
   "source": [
    "### Наследование классов 3\n",
    "\n",
    "\n",
    "\n",
    "Одно из применений множественного наследование – расширение функциональности класса каким-то заранее определенным способом. Например, если нам понадобится логировать какую-то информацию при обращении к методам класса.\n",
    "\n",
    "Рассмотрим класс Loggable:\n",
    "\n",
    "```python\n",
    "import time\n",
    "\n",
    "class Loggable:\n",
    "    def log(self, msg):\n",
    "        print(str(time.ctime()) + \": \" + str(msg))\n",
    "```\n",
    "\n",
    "У него есть ровно один метод log, который позволяет выводить в лог (в данном случае в stdout) какое-то сообщение, добавляя при этом текущее время.\n",
    "Реализуйте класс LoggableList, отнаследовав его от классов list и Loggable таким образом, чтобы при добавлении элемента в список посредством метода append в лог отправлялось сообщение, состоящее из только что добавленного элемента.\n",
    "\n",
    "*Примечание*\n",
    "Ваша программа не должна содержать класс Loggable. При проверке вашей программе будет доступен этот класс, и он будет содержать метод log, описанный выше.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38eaa7be",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LoggableList(list, Loggable):\n",
    "    def append(self, msg):\n",
    "        super(LoggableList, self).append(msg)\n",
    "        self.log(msg)"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}