Stepik_exam (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "215a69f5-89da-4097-ac35-4caec032ed94",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# [Итоговая работа на кортежи](https://stepik.org/lesson/416759/step/1?unit=406267) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09bbee2d-7dd4-4117-9ceb-b46ac6346fbe",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Каждый n-ый элемент\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1bdd20d6-3021-4995-a66a-d12cac34f2ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " a b c d e f g h i j k l m n\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']]\n"
     ]
    }
   ],
   "source": [
    "s = input().split(' ')\n",
    "n = int(input())\n",
    "arr = [[s[i] for i in range(j, len(s), n)] for j in range(n)]\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a43793a-a8f0-4e7a-968e-8887089a1cba",
   "metadata": {},
   "source": [
    "## Максимальный в области 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "aed3d170-53e2-482f-aa44-ffcbd79d144b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 1 4 5\n",
      " 6 7 8\n",
      " 1 1 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# i > N-1-j\n",
    "n = int(input())\n",
    "arr = [[int(i) for i in input().split()] for _ in range(n)]\n",
    "s = [arr[i][j] for i in range(n) for j in range(n) if i >= n-1-j]\n",
    "print(max(s))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d01ab93-96eb-4911-92c4-c8451599062e",
   "metadata": {},
   "source": [
    "## Транспонирование матрицы\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "923cac92-12ef-4d64-a0f7-40bf965dce50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 1 2 3\n",
      " 4 5 6\n",
      " 7 8 9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1   4   7   \n",
      "2   5   8   \n",
      "3   6   9   \n"
     ]
    }
   ],
   "source": [
    "def print_matrix(matrix, rows, cols=None, width=1):\n",
    "    if cols is None:\n",
    "        cols = rows\n",
    "        \n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            print(str(matrix[c][r]).ljust(width), end=' ')\n",
    "        print()\n",
    "\n",
    "n = int(input())\n",
    "arr = [[int(i) for i in input().split()] for _ in range(n)]\n",
    "\n",
    "print_matrix(arr, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "380f7aa8-ffc5-4e08-8f3d-e8332a809152",
   "metadata": {},
   "source": [
    "## Снежинка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0819f09c-c93b-4ea3-b2d5-79fcc31626b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 11\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* . . . . * . . . . * \n",
      ". * . . . * . . . * . \n",
      ". . * . . * . . * . . \n",
      ". . . * . * . * . . . \n",
      ". . . . * * * . . . . \n",
      "* * * * * * * * * * * \n",
      ". . . . * * * . . . . \n",
      ". . . * . * . * . . . \n",
      ". . * . . * . . * . . \n",
      ". * . . . * . . . * . \n",
      "* . . . . * . . . . * \n"
     ]
    }
   ],
   "source": [
    "def print_matrix(matrix, rows, cols=None, width=1):\n",
    "    if cols is None:\n",
    "        cols = rows\n",
    "        \n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            print(str(matrix[r][c]).ljust(width), end=' ')\n",
    "        print()\n",
    "\n",
    "n = int(input())\n",
    "arr = [['*' if (i == n//2 or j==n//2 or i == j or i == n-1-j)\n",
    "        else '.'  for i in range(n)] for j in range(n)]\n",
    "\n",
    "print_matrix(arr, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b427e9a1-e912-45f7-8319-b601f7be8683",
   "metadata": {},
   "source": [
    "## Симметричная матрица\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4e37b7fc-bfd9-48b7-8be7-3f9865dd4ac7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 0 3 10\n",
      " 4 9 3\n",
      " 7 4 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "matrix = [[int(i) for i in input().split()] for j in range(n)]\n",
    "flag = True\n",
    "\n",
    "for i in range(n):\n",
    "    for j in range(n):\n",
    "        if i + j + 1 < n:\n",
    "            if matrix[i][j] != matrix[n - 1 - j][n - 1 - i]: \n",
    "                flag = False\n",
    "    if flag == False:\n",
    "        print('NO')\n",
    "        break\n",
    "else:\n",
    "    print('YES')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a303a146-d78b-42f2-a532-e3178d19f121",
   "metadata": {},
   "source": [
    "## Латинский квадрат 🌶️\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8b77dd6-9566-4329-b3a4-bc50b5f63b70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 1 2 3\n",
      " 2 3 1\n",
      " 3 1 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "matrix = [[int(i) for i in input().split()] for j in range(n)]\n",
    "t_matrix = [[matrix[i][j] for i in range(n)] for j in range(n)]\n",
    "chk = list(range(1, n+1))\n",
    "flag = True\n",
    "\n",
    "for i in range(n):\n",
    "    if sorted(matrix[i]) == chk and sorted(t_matrix[i]) == chk:\n",
    "        continue\n",
    "    else:\n",
    "        flag = False\n",
    "        break\n",
    "\n",
    "if flag:\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fc1cd20-d750-44a6-8a6c-934813225080",
   "metadata": {},
   "source": [
    "## Ходы ферзя\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "a2ae5e1d-ef79-4cbe-9ccc-8238c35fb9fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " a1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* . . . . . . * \n",
      "* . . . . . * . \n",
      "* . . . . * . . \n",
      "* . . . * . . . \n",
      "* . . * . . . . \n",
      "* . * . . . . . \n",
      "* * . . . . . . \n",
      "Q * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "def print_matrix(matrix, rows, cols=None, width=1):\n",
    "    if cols is None:\n",
    "        cols = rows\n",
    "        \n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            print(str(matrix[r][c]).ljust(width), end=' ')\n",
    "        print()\n",
    "        \n",
    "matrix = [['.' for _ in range(8)] for h in range(8)]\n",
    "j, i = input()\n",
    "j = (ord(j) - 97)\n",
    "i = 8 - int(i)\n",
    "\n",
    "for a in range(8):\n",
    "    for b in range(8):\n",
    "        if abs(a - i) == abs(b - j) or a == i or b == j:\n",
    "            matrix[a][b] = '*'\n",
    "        else:\n",
    "            continue\n",
    "matrix[i][j] = 'Q'\n",
    "\n",
    "            \n",
    "print_matrix(matrix, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "302d152c-07bf-4480-8430-3d73e2bb6ca1",
   "metadata": {},
   "source": [
    "## Диагонали параллельные главной\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "e72616d2-3015-4161-9652-ee885a08e508",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 \n",
      "1 0 1 2 3 \n",
      "2 1 0 1 2 \n",
      "3 2 1 0 1 \n",
      "4 3 2 1 0 \n"
     ]
    }
   ],
   "source": [
    "def print_matrix(matrix, rows, cols=None, width=1):\n",
    "    if cols is None:\n",
    "        cols = rows\n",
    "        \n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            print(str(matrix[r][c]).ljust(width), end=' ')\n",
    "        print()\n",
    "        \n",
    "n = int(input())\n",
    "matrix = [[0 if j == i else abs(i-j) for i in range(n)] for j in range(n)]\n",
    "print_matrix(matrix, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "718ed143-8c1c-4792-bf6e-a0db1a3c95ee",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# [Итоговая работа на множества](https://stepik.org/lesson/479453/step/1?unit=470428)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e23dd03-76dc-4142-8559-0adeaa1bbf9c",
   "metadata": {},
   "source": [
    "## Домашнее задание\n",
    "Учитель проверяет домашнее задание в классе и получил следующие ответы: из n школьников у m домашнее задание съела собака, у k отключили свет, а p учеников постигли оба несчастья. Напишите программу, которая определяет сколько человек выполнило домашнее задание."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f1304276-77fc-40ce-8328-8a7d5696cfb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 81\n",
      " 25\n",
      " 16\n",
      " 9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49\n"
     ]
    }
   ],
   "source": [
    "n, m, k, p = [int(input()) for _ in range(4)]\n",
    "res = n - (m - p) - (k - p) - p\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c69da694-4edc-4403-a511-fa90241d5889",
   "metadata": {},
   "source": [
    "## Восход\n",
    "На спутнике «Восход» установлен прибор для измерения солнечной активности. Каждую минуту он передаёт в обсерваторию по каналу связи положительное целое число — количество энергии солнечного излучения. Для правильного анализа результатов нет необходимости держать повторяющиеся данные. Напишите программу, которая выводит максимальное количество показаний спутника, при удалении которых результат будет правильно проанализирован.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "674bd2c8-545d-4d37-adf3-c77736821368",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 100 100 100 100 100 100 100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "s = list(map(int, input().split()))\n",
    "print(len(s) - len(set(s)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea2ad92f-f030-4d60-afe6-2b07134a7ae1",
   "metadata": {},
   "source": [
    "## Города\n",
    "Тимур и Руслан играют в игру города. Они очень любят эту игру и знают много городов, особенно Тимур, однако к концу игры ввиду своего возраста забывают, какие города уже называли.\n",
    "\n",
    "Напишите программу, считывающую информацию об игре и сообщающую ребятам, что очередной город назван повторно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4c09ae8a-dfb1-41fd-8c7a-e3050302ee09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " Каир\n",
      " Рим\n",
      " Москва\n",
      " Агра\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "s = {input() for _ in range(int(input()))}\n",
    "\n",
    "if input() in s:\n",
    "    print('REPEAT')\n",
    "else:\n",
    "    print('OK')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf43b30-d6e0-4194-affb-6f091eca3eed",
   "metadata": {},
   "source": [
    "## Книги на прочтение\n",
    "Руслан получил в конце учебного года список литературы на лето. Теперь ему надо выяснить, какие книги из этого списка у него есть. У Руслана на компьютере в текстовом файле записаны все книги из его домашней библиотеки в случайном порядке.\n",
    "\n",
    "Напишите программу, определяющую для каждой книги из списка на прочтение, есть она у Руслана или нет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2afc437e-1c56-4e4c-b872-1d070f714b22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 4\n",
      " 4\n",
      " Хоббит\n",
      " Алиса в стране чудес\n",
      " Том Сойер\n",
      " Остров сокровищ\n",
      " Буратино\n",
      " Хоббит\n",
      " Остров сокровищ\n",
      " Война и мир\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n",
      "YES\n",
      "YES\n",
      "NO\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{None}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m, n = [int(input()) for _ in range(2)] \n",
    "\n",
    "home_lib = [input() for _ in range(m)]\n",
    "arr_book = [input() for _ in range(n)]\n",
    "\n",
    "[print('YES') if arr_book[i] in home_lib else print('NO') for i in range(n)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "621cfc18-bc95-4a2e-81e2-eee4c019372a",
   "metadata": {},
   "source": [
    "## Странное увлечение\n",
    "Напишите программу, которая находит общие числа двух листочков или сообщает, что день не удался"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b7173acd-be77-4a9a-81b5-85b4ce898fb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 7\n"
     ]
    }
   ],
   "source": [
    "a, b = [list(map(int, input().split())) for _ in range(2)]\n",
    "if len(set(a).intersection(set(b))) != 0:\n",
    "    print(*sorted(set(a).intersection(set(b)), reverse=True))\n",
    "else:\n",
    "    print('BAD DAY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "1bdfcb89-9102-4e03-a75a-c239b7575aca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 8 7\n",
      " 6 7 7 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a, b = [list(map(int, input().split())) for _ in range(2)]\n",
    "z = set(a).issubset(set(b))\n",
    "print(z)\n",
    "# if :\n",
    "#     print('YES')\n",
    "# else:\n",
    "#     print('NO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "f41386e3-3b3b-43f1-aaca-dce31f21e15f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 8 7\n",
      " 6 7 7 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "a, b = [list(map(int, input().split())) for _ in range(2)]\n",
    "x = (set(a).difference(b))\n",
    "# print(x)\n",
    "if len(x) == 0 and len(set(a)) == len(set(b)):\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "eed88a17-2d36-4dbd-8b37-01b2c9b7a858",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 2\n",
      " 3\n",
      " Хохлов\n",
      " Фадеев\n",
      " Ушаков\n",
      " Ершов\n",
      " Хохлов\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "['Хохлов', 'Фадеев'] ['Ушаков', 'Ершов', 'Хохлов']\n"
     ]
    }
   ],
   "source": [
    "m, n = [int(input()) for _ in range(2)] \n",
    "\n",
    "arr1 = [input() for _ in range(m)]\n",
    "arr2 = [input() for _ in range(n)]\n",
    "\n",
    "res = m - len(set(arr1).intersection(set(arr2)))\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cc41b58-c90e-4629-9a82-cf434b684957",
   "metadata": {},
   "outputs": [],
   "source": [
    "m, n = [int(input()) for _ in range(2)] \n",
    "\n",
    "arr1 = [input() for _ in range(m)]\n",
    "arr2 = [input() for _ in range(n)]\n",
    "res = (m + n) - 2 * len(set(arr1).intersection(set(arr2))) \n",
    "\n",
    "if res != 0:\n",
    "    print(res)\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "cab07ea3-cf96-4f22-9642-a1d4f540fa26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " Рыбаков\n",
      " Сафонов Игнатов\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Игнатов Рыбаков Сафонов\n"
     ]
    }
   ],
   "source": [
    "a, b = [set(input().split()) for _ in range(2)]\n",
    "print(*sorted(a.union(b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f03b4e8-363b-4f00-8cd6-e2204920ca5d",
   "metadata": {},
   "source": [
    "## [Онлайн-школа BEEGEEK 5 🌶️](https://stepik.org/lesson/445985/step/11?unit=470426)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "04602818-ad16-4fe8-aaf4-06cf5dcb8b25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 3\n",
      " Иванов\n",
      " Петров\n",
      " Васечкин\n",
      " Иванов\n",
      " Петров\n",
      " Васечкин\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "m, n = [int(input()) for _ in range(2)] \n",
    "arr = [input() for _ in range(m + n)]\n",
    "\n",
    "res = len(set(arr)) - ((m + n) - len(set(arr))) \n",
    "\n",
    "if res != 0:\n",
    "    print(res)\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "310d15f3-94e0-4124-8a1b-11208c2d0b9f",
   "metadata": {},
   "source": [
    "## [Онлайн-школа BEEGEEK 6 🌶️](https://stepik.org/lesson/445985/step/12?unit=470426)\n",
    "Руководителю онлайн-школы BEEGEEK захотелось узнать, кто из его учеников присутствовал на всех уроках с начала учебного года. Для каждого урока есть листок со списком присутствовавших учеников.\n",
    "\n",
    "Напишите программу, определяющую фамилии учеников, которые присутствовали на всех уроках."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "1e1ed1df-7d10-4eca-99f6-f3f8c87ebd24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 3\n",
      " Князев\n",
      " Сафонов\n",
      " Майоров\n",
      " 2\n",
      " Князев\n",
      " Майоров\n",
      " 1\n",
      " Майоров\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'Сафонов', 'Майоров', 'Князев'}, {'Майоров', 'Князев'}, {'Майоров'}]\n",
      "{'Сафонов', 'Майоров', 'Князев'}\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "m = int(input())\n",
    "\n",
    "arr = [set(input() for i in range(int(input())))\n",
    "       for _ in range(m)]\n",
    "\n",
    "res = reduce((lambda x, y: set(x).intersection(y)), arr)\n",
    "print(*sorted(res), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07896d30-9874-4b21-b908-a75fc54eb661",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# [Итоговая работа на словари](https://stepik.org/lesson/491382/step/1?unit=482676)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24fd1e9e-c7cd-448a-b7f5-bbb05c2504ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = dict([('foo', 100), ('bar', 200), ('baz', 300)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "202340a6-733a-4f15-a7f9-e43e48be0ceb",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = ['a','b',{'foo': 1,'bar':{'x' : 10,'y' : 20,'z' : 30},'baz': 3},'c','d']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "14fa2832-e003-4f3a-ab4f-613930929bca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C1': [10, 20, 7, 6], 'C2': [20, 1, 2, 3, 12], 'C3': [12, 20], 'C4': [7], 'C5': [2, 4, 19], 'C6': [4, 6, 7, 10], 'C7': [4, 8, 12], 'C8': [3, 14, 15], 'C9': [2, 7, 18, 18]}\n"
     ]
    }
   ],
   "source": [
    "my_dict = {'C1': [10, 20, 30, 7, 6, 23, 90], 'C2': [20, 30, 40, 1, 2, 3, 90, 12], 'C3': [12, 34, 20, 21], 'C4': [22, 54, 209, 21, 7], 'C5': [2, 4, 29, 21, 19], 'C6': [4, 6, 7, 10, 55], 'C7': [4, 8, 12, 23, 42], 'C8': [3, 14, 15, 26, 48], 'C9': [2, 7, 18, 28, 18, 28]}\n",
    "my_dict = {k: [i for i in v if i <= 20] for k, v in my_dict.items()}\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "aa93d292-7651-4f63-99d0-f691732f0881",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['angel.down@mail.ru', 'joanne@mail.ru', 'the.fame.moster@mail.ru']\n",
      "['apple.fruit@msu.edu', 'beegeek@msu.edu', 'beegeek.school@msu.edu']\n",
      "['ruslan.chaika@gmail.com', 'rustam.mini@gmail.com', 'stepik-best@gmail.com']\n",
      "['surface@yandex.ru', 'google@yandex.ru']\n",
      "['timyr@nosu.edu', 'joseph@nosu.edu', 'svetlana.gaeva@nosu.edu', 'larisa.mamuk@nosu.edu']\n",
      "['tomas-henders@hse.edu', 'cream.soda@hse.edu', 'zivert@hse.edu']\n"
     ]
    }
   ],
   "source": [
    "emails = {'nosu.edu': ['timyr', 'joseph', 'svetlana.gaeva', 'larisa.mamuk'], \n",
    "          'gmail.com': ['ruslan.chaika', 'rustam.mini', 'stepik-best'], \n",
    "          'msu.edu': ['apple.fruit', 'beegeek', 'beegeek.school'], \n",
    "          'yandex.ru': ['surface', 'google'],\n",
    "          'hse.edu': ['tomas-henders', 'cream.soda', 'zivert'],\n",
    "          'mail.ru': ['angel.down', 'joanne', 'the.fame.moster']}\n",
    "\n",
    "res = [[f'{i}@{k}' for i in v] for k,v in emails.items()]\n",
    "\n",
    "print(*sorted(res), sep='\\n')\n",
    "# res = []\n",
    "# for k,v in emails.items():\n",
    "#     for i in v:\n",
    "#         res.append(f'{i}@{k}')\n",
    "        \n",
    "# print(*sorted(res), sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "79539008-ebc5-4421-acf0-339cff5911e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " ACTG\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UGAC\n"
     ]
    }
   ],
   "source": [
    "rnk = {'G': 'C', 'C': 'G', 'T': 'A', 'A': 'U'}\n",
    "\n",
    "res = ''.join([rnk.get(i) for i in input()])\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "7ad6aa29-92a6-428e-bbd8-ca02adac0bd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " прием Хьюстон Хьюстон как слышно прием меня слышно прием хьюстон\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'прием': 3, 'Хьюстон': 2, 'как': 1, 'слышно': 2, 'меня': 1, 'хьюстон': 1}\n",
      "1 1 2 1 1 2 1 2 3 1\n"
     ]
    }
   ],
   "source": [
    "res = {}\n",
    "result = []\n",
    "[(res.update(dict([(i, res.get(i, 0) + 1)])), result.append(res.get(i))) for i in input().split()]\n",
    "print(res)\n",
    "print(*result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "1d313b20-2024-4068-b207-9453aaef6508",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " FRESHENER\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "    1: \"AEILNORSTU\",\n",
    "    2: \"DG\",\n",
    "    3: \"BCMP\",\n",
    "    4: \"FHVWY\",\n",
    "    5: \"K\",\n",
    "    8: \"JX\",\n",
    "    10: \"QZ\"\n",
    "}\n",
    "\n",
    "res = [sum([k for k, v in d.items() if i in v]) for i in input()]\n",
    "print(sum(res))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "7f3a9da6-3e2d-497b-a2ce-e6059b7df803",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://beegeek.ru?game=2&sport=hockey&time=17\n"
     ]
    }
   ],
   "source": [
    "def build_query_string(params):\n",
    "    c = 'https://beegeek.ru?'\n",
    "    res = [(f'{k}={v}') for k,v in params.items()]\n",
    "    return c + '&'.join(sorted(res))\n",
    "\n",
    "\n",
    "d = {'sport': 'hockey', 'game': 2, 'time': 17}\n",
    "\n",
    "print(build_query_string(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e121599-6edc-4671-9c49-f044e8e26956",
   "metadata": {},
   "source": [
    "## [Слияние словарей 🌶️](https://stepik.org/lesson/492141/step/5?unit=483447)\n",
    "Напишите функцию merge(), объединяющую словари в один общий. Функция должна принимать список словарей и возвращать словарь, каждый ключ которого содержит множество (тип данных set) уникальных значений собранных из всех словарей переданного списка.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "22a81ffe-af1f-47f6-8993-726ab0764581",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': {1, 5}, 'b': {17, 2, 10}, 'c': {50, 100}, 'd': {777}}\n"
     ]
    }
   ],
   "source": [
    "def merge(values):      # values - это список словарей\n",
    "    res = {}\n",
    "    [[res.setdefault(k, set()).add(v) for k, v in k.items()] for k in values]\n",
    "    return res\n",
    "\n",
    "result = merge([\n",
    "    {'a': 1, 'b': 2},\n",
    "    {'b': 10, 'c': 100},\n",
    "    {'a': 1, 'b': 17, 'c': 50},\n",
    "    {'a': 5, 'd': 777}\n",
    "])\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2b834f2-1ff0-449c-b072-70058289d6f1",
   "metadata": {},
   "source": [
    "## [Опасный вирус 😈](https://stepik.org/lesson/492141/step/6?unit=483447)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "id": "ae474694-150c-420b-8996-975ef9622ffa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 5\n",
      " my_pycode.exe W X\n",
      " log_n X W R\n",
      " ave R\n",
      " lucky_m W R\n",
      " dnsss.py W\n",
      " 6\n",
      " execute ave\n",
      " read dnsss.py\n",
      " write log_n\n",
      " execute log_n\n",
      " read ave\n",
      " write my_pycode.exe\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Access denied\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "d = {'write': 'W', 'read': 'R','execute': 'X'}\n",
    "\n",
    "res = {}\n",
    "[[res.setdefault(k, v.split()) for k, v in [input().split(' ', 1)]] for _ in range(int(input()))]\n",
    "\n",
    "result = []\n",
    "[[result.append('OK' if (d.get(k) in res.get(v)) else 'Access denied') for k, v in [input().split(' ')]] for _ in range(int(input()))]\n",
    "print(*result, sep='\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39639f70-2521-413d-b4f4-ed565827b362",
   "metadata": {},
   "source": [
    "## [Покупки в интернет-магазине 🌶️](https://stepik.org/lesson/492141/step/7?unit=483447)\n",
    "Напишите программу для подсчета количества единиц каждого вида товара из приобретенных каждым покупателем интернет-магазина."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "id": "5a5f72dd-c157-4f1d-9480-85d9d61a1604",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 2\n",
      " Максим Пирог 5\n",
      " Максим Пиро 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('Максим', {'Пиро': 4})])\n"
     ]
    }
   ],
   "source": [
    "s = 'Руслан Пирог 1'\n",
    "d = {}\n",
    "res = [[d.update({x: {y: int(z)}}) for x,y,z in [input().split()]] for _ in range(int(input()))]\n",
    "print(d.items())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95ed7dd7-dcb4-48a4-84be-03059825b40c",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}\n",
    "for i in range(int(input())):\n",
    "    a, b, c = input().split()\n",
    "    d[a] = d.get(a, {})\n",
    "    d[a][b] = d.get(a, {}).get(b, 0) + int(c)\n",
    "for i in sorted(d):\n",
    "    print(f'{i}:', sep='\\n')\n",
    "    for k in sorted(d[i]):\n",
    "        print(f'{k} {d[i][k]}', sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cb9b020-2c6c-47b7-a10b-358bebbd056b",
   "metadata": {},
   "outputs": [],
   "source": [
    "buyers = {}\n",
    "for _ in range(int(input())):\n",
    "    name, product, number = input().split()    # разбираем строку на молекулы\n",
    "    buyers.setdefault(name, {})    # если вдруг человек еще не покупал, создаем ему пустой список товаров\n",
    "    buyers[name][product] = buyers[name].get(product, 0) + int(number)    # товар в словарь, а если он есть плюсуем\n",
    "\n",
    "for buyer in sorted(buyers):      # тут мешанина из сортировок людей, коней и их слияния с количеством\n",
    "    print(buyer + ':')            # через месяц фиг поймешь\n",
    "    print(*(f'{key} {val}' for key, val in sorted(buyers[buyer].items())), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fb5336f-2f71-4f64-911d-50775142f7d4",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# [Итоговая работа на функции]()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f2cd46de-7748-4df9-a1aa-4ebfe36bde98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "emp salary "
     ]
    }
   ],
   "source": [
    "def display(**kwargs):\n",
    "    for i in kwargs:\n",
    "        print(i, end=' ')\n",
    "\n",
    "display(emp='Kelly', salary=9000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ce0c4cca-31b9-4247-9258-b28cbbdda9ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "def outer_func(a, b):\n",
    "    def inner_func(c, d):\n",
    "        return c + d + a*b\n",
    "    return inner_func\n",
    "\n",
    "res = outer_func(5, 10)(3, 2)\n",
    "\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "057c0ab3-986f-471c-8efe-b3463bdb8943",
   "metadata": {},
   "source": [
    "## [Письмо для экзамена](https://stepik.org/lesson/513589/step/15?unit=505863)\n",
    "Напишите функцию generate_letter(), которая будет собирать электронное письмо в соответствии с шаблоном"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a03f8c97-fa83-495e-8e35-12a3dc1525f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To: lara@yandex.ru \n",
      "Приветствую, Лариса!\n",
      "Вам назначен экзамен, который пройдет 10 декабря, в 12:00.\n",
      "По адресу: Часова 23, корпус 2.\n",
      "Экзамен будет проводить Тимур Гуев в кабинете 17.\n",
      "Желаем удачи на экзамене!\n",
      "\n",
      "To: lara@yandex.ru \n",
      "Приветствую, Лариса!\n",
      "Вам назначен экзамен, который пройдет 10 декабря, в 12:00.\n",
      "По адресу: Часова 23, корпус 2.\n",
      "Экзамен будет проводить Василь Ярошевич в кабинете 23.\n",
      "Желаем удачи на экзамене!\n"
     ]
    }
   ],
   "source": [
    "def generate_letter(mail, name, date, time, place, teacher='Тимур Гуев', number=17):\n",
    "    return f'To: {mail} \\nПриветствую, {name}!\\nВам назначен экзамен, который пройдет {date}, в {time}.\\nПо адресу: {place}.\\nЭкзамен будет проводить {teacher} в кабинете {number}.\\nЖелаем удачи на экзамене!'\n",
    "\n",
    "print(generate_letter('lara@yandex.ru', 'Лариса', '10 декабря', '12:00', 'Часова 23, корпус 2'))\n",
    "print()\n",
    "print(generate_letter('lara@yandex.ru', 'Лариса', '10 декабря', '12:00', \n",
    "                      'Часова 23, корпус 2', 'Василь Ярошевич', 23))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a837f44a-8ee5-4bf5-a3fb-e4130be05049",
   "metadata": {
    "tags": []
   },
   "source": [
    "## [Pretty print](https://stepik.org/lesson/513589/step/16?unit=505863)\n",
    "Напишите функцию pretty_print(), которая выводит содержимое списка с рамкой. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "54442e0d-807e-47dd-9741-ae9dbb603330",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ***************** \n",
      "# abc # def # ghi #\n",
      " ***************** \n"
     ]
    }
   ],
   "source": [
    "def pretty_print(data, side='-', delimiter='|'):\n",
    "    \n",
    "    res = f'{delimiter} {f\" {delimiter} \".join(map(str, data))} {delimiter}'\n",
    "    \n",
    "    delim = (side * (len(res) - 2)).center(len(res))\n",
    "    \n",
    "    print(f'{delim}\\n{res}\\n{delim}')\n",
    "    \n",
    "# pretty_print([1, 2, 10, 23, 123, 3000])\n",
    "pretty_print(['abc', 'def', 'ghi'], side='*', delimiter='#')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1f16f293-16ad-4024-bc34-d358abd413ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iq-option\n",
      "+12345\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "words = ['beegeek', 'stepik', 'python', 'iq-option']\n",
    "result = reduce(lambda a, b: a if len(a) > len(b) else b, words)\n",
    "print(result)\n",
    "\n",
    "\n",
    "result = reduce(lambda s, x: s + str(x), [1, 2, 3, 4, 5], '+')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "390544ee-aae3-4517-a3a3-b29e69ff47d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0moperator\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m/\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m Same as a + b, for a and b sequences.\n",
       "\u001b[1;31mType:\u001b[0m      builtin_function_or_method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "import operator\n",
    "\n",
    "def flatten(data):\n",
    "    return reduce(operator.concat, data, [])\n",
    "\n",
    "result = flatten([[1, 2], [3, 4], [], [5]])\n",
    "\n",
    "print(result)\n",
    "\n",
    "operator.concat?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6fecb158-39f3-4777-8422-b44df6611ef5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello python and stepik\n",
      "hello*python*and*stepik\n",
      "hello()()()python\n",
      "hello\n",
      "1$$2$$3$$4$$5$$6$$7$$8$$9\n"
     ]
    }
   ],
   "source": [
    "def concat(*args, sep=' '):\n",
    "    return sep.join(map(str, args))\n",
    "\n",
    "print(concat('hello', 'python', 'and', 'stepik'))\n",
    "print(concat('hello', 'python', 'and', 'stepik', sep='*'))\n",
    "print(concat('hello', 'python', sep='()()()'))\n",
    "print(concat('hello', sep='()'))\n",
    "print(concat(1, 2, 3, 4, 5, 6, 7, 8, 9, sep='$$'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "07586956-8884-42b8-bd2c-1fd3497ed5d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def product_of_odds(data):   # data - список целых чисел\n",
    "\n",
    "    result = reduce(lambda x, y: x*y, filter(lambda x: x % 2 == 1, data), 1)\n",
    "    return result\n",
    "\n",
    "\n",
    "print(product_of_odds([1, 2, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4e4f6c3f-35a0-4924-aa28-98a2b082d2cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"the\" \"world\" \"is\" \"mine\" \"take\" \"a\" \"look\" \"what\" \"you\" \"have\" \"started\"\n"
     ]
    }
   ],
   "source": [
    "words = 'the world is mine take a look what you have started'.split()\n",
    "\n",
    "print(*map(lambda x: f'\"{x}\"' , words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7e66e4f3-4dea-4565-8dcc-d71c7a51fc99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 78 45 23 908 8976 6565 10 1000 908 786\n"
     ]
    }
   ],
   "source": [
    "numbers = [18, 191, 9009, 5665, 78, 77, 45, 23, 19991, 908, 8976, 6565, 5665, 10, 1000, 908, 909, 232, 45654, 786]\n",
    "print(*filter(lambda x: str(x) != str(x)[::-1] , numbers))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a08de138-af43-405a-bac4-e1516f5047dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(39, 12), (-13, 56), (17, 0, 1), (1, 9, 2), (10, -2, 3, 4), (3,), (-1, 5, 1), (1, 1), (0, 1), (3, -8), (-1, -9, -45, 32), (11, -23), (10, -100, 21, 32)]\n"
     ]
    }
   ],
   "source": [
    "numbers = [(10, -2, 3, 4), (-13, 56), (1, 9, 2), (-1, -9, -45, 32), (-1, 5, 1), (17, 0, 1), (0, 1), (3,), (39, 12), (11, -23), (10, -100, 21, 32), (3, -8), (1, 1)]\n",
    "\n",
    "sorted_numbers = sorted(numbers, key=lambda x: sum(x)/len(x), reverse=True)\n",
    "\n",
    "print(sorted_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f61f44c7-25e8-4d0f-9081-7f5166c24e52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n",
      "9\n",
      "80\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def mul7(x):\n",
    "    return x * 7\n",
    "\n",
    "\n",
    "def add2(x, y):\n",
    "    return x + y\n",
    "\n",
    "\n",
    "def add3(x, y, z):\n",
    "    return x + y + z\n",
    "\n",
    "def call(func, *args):\n",
    "    return func(*args)\n",
    "\n",
    "print(call(mul7, 10))\n",
    "print(call(add2, 2, 7))\n",
    "print(call(add3, 10, 30, 40))\n",
    "print(call(bool, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8088c094-1bd8-4136-94f2-46f2014c947a",
   "metadata": {},
   "source": [
    "### Напишите функцию compose(), которая принимает на вход две других одноаргументных функции f и g и возвращает новую функцию. Эта новая функция также должна принимать один аргумент x и применять к нему исходные функции в нужном порядке: для функций f и g порядок применения должен выглядеть, как f(g(x))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "56eaa712-af4d-4e84-8b3c-f954cfc7f6a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28\n",
      "17\n",
      "3333333\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "def add3(x):\n",
    "    return x + 3\n",
    "\n",
    "\n",
    "def mul7(x):\n",
    "    return x * 7\n",
    "\n",
    "def compose(f, g):\n",
    "    return lambda x: f(g(x))\n",
    "    \n",
    "print(compose(mul7, add3)(1))\n",
    "print(compose(add3, mul7)(2))\n",
    "print(compose(mul7, str)(3))\n",
    "print(compose(str, mul7)(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76e03647-30bc-4e3a-a54e-c0a7fdb576f6",
   "metadata": {},
   "source": [
    "### Напишите функцию arithmetic_operation(), которая принимает символ одной из четырех арифметических операций (+, -, *, /) и возвращает функцию двух аргументов для соответствующей операции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "82b37398-eb98-49f7-89c3-e4bcd3a4db18",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "import operator\n",
    "\n",
    "\n",
    "def arithmetic_operation(operation):\n",
    "    ops = {'+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.truediv}\n",
    "    return lambda x, y: ops[operation](x,y)\n",
    "\n",
    "\n",
    "add = arithmetic_operation('+')\n",
    "div = arithmetic_operation('/')\n",
    "print(add(10, 20))\n",
    "print(div(20, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "12976e23-8906-4aa4-bb71-acccd063b9df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bee cat CatAlo cate CATERS Cats cATwalk dolphin Frog FROGs mOus mouse\n"
     ]
    }
   ],
   "source": [
    "s = 'cate Frog cat FROGs bee CATERS mouse cATwalk dolphin mOus Cats CatAlo'\n",
    "print(*sorted(s.split(), key=lambda x: x.lower()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e1864af-e814-4d5c-9a1b-dfffcaa6d823",
   "metadata": {},
   "source": [
    "### Гематрия слова\n",
    "Гематрией слова называется сумма числовых значений входящих в него букв."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "36f04d49-23cd-4724-bb08-0e310a6ac030",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 4\n",
      " basis\n",
      " after\n",
      " chief\n",
      " agenda\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "agenda\n",
      "chief\n",
      "after\n",
      "basis\n"
     ]
    }
   ],
   "source": [
    "gemat = lambda x: sum((ord(i.upper()) - 65) for i in x)\n",
    "\n",
    "res = [input() for i in range(int(input()))]\n",
    "\n",
    "print(*sorted(res, key=lambda x: (gemat(x), x)), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29b507a1-f740-4b46-a16c-41c4eedf0e78",
   "metadata": {},
   "source": [
    "## [Сортировка IP-адресов](https://stepik.org/lesson/507310/step/11?unit=499253)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4102eca0-098f-408f-9f29-904bbc1dd50b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 128.199.44.24\n",
      " 128.199.201.245\n",
      " 143.198.168.95\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "128.199.44.24\n",
      "128.199.201.245\n",
      "143.198.168.95\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "func = lambda x: reduce(lambda v,c: v*256 + c, map(int, x.split('.')))\n",
    "\n",
    "res = [input() for i in range(int(input()))]\n",
    "print(*sorted(res, key=func), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c952a52-3715-48be-93cc-c067355c025c",
   "metadata": {},
   "source": [
    "# [Итоговая работа на файлы](https://stepik.org/lesson/448983/step/1?unit=511577)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "167f3a99-fc97-44ba-b9ba-f4491f126190",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " file.txt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "with open(input(), 'r', encoding='utf-8') as file:\n",
    "    print(len(file.readlines()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f7130f0e-7f28-402f-a9b6-3a0a71c9fac0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$26127\n"
     ]
    }
   ],
   "source": [
    "with open('ledger.txt', 'r', encoding='utf-8') as file:\n",
    "    s = [int(i[1:]) for i in (file.read().split('\\n'))]\n",
    "    print(f'${sum(s)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7377da4f-b0aa-4349-b8b8-2610a51a5333",
   "metadata": {},
   "source": [
    "## Goooood students\n",
    "Вам доступен текстовый файл grades.txt, содержащий оценки студента за три теста в каждом из триместров. Строки файла имеют вид: фамилия оценка_1 оценка_2 оценка_3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "560b9001-4db7-48a0-bd84-8c8548038e96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "res = []\n",
    "with open('grades.txt', 'r', encoding='utf-8') as file:\n",
    "    s = [[int(j) >= 65 for j in i.split() if j.isdigit()] for i in (file.read().split('\\n'))]\n",
    "    res = [i for i in s if all(i)]\n",
    "    print(len(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9808236-7c2c-451e-b99b-cb33a554b6f0",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Самое длинное слово в файле\n",
    "Вам доступен текстовый файл words.txt со словами, разделенными пробелом. Напишите программу, которая находит и выводит самые длинные слова этого файла, не меняя порядка их следования."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "702aff5c-10b9-4161-88fd-798f4e3c18ee",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "responsibility\n",
      "administration\n",
      "recommendation\n",
      "transportation\n"
     ]
    }
   ],
   "source": [
    "res = []\n",
    "with open('words.txt', 'r', encoding='utf-8') as file:\n",
    "    res = ([i for i in file.read().split()])\n",
    "    \n",
    "    print(*filter(lambda x: len(x) == len(max(res, key=len)), res), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59d88561-dd14-42cb-8ee1-fcae9b37ed81",
   "metadata": {},
   "source": [
    "## Tail of a File\n",
    "На вход программе подается строка текста с именем текстового файла. Напишите программу, выводящую на экран последние \n",
    "10\n",
    "10 строк данного файла."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "b5c3a942-2574-41a4-b744-e132f6eb0829",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " population.txt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saint Helena, Ascension and Tristan da Cunha (UK)\t4000\n",
      "Falkland Islands (UK)\t3000\n",
      "Svalbard and Jan Mayen (Norway)\t2562\n",
      "Norfolk Island (Australia)\t2302\n",
      "Christmas Island (Australia)\t2072\n",
      "Niue (New Zealand)\t1613\n",
      "Tokelau (NZ)\t1411\n",
      "Vatican City\t839\n",
      "Cocos (Keeling) Islands (Australia)\t550\n",
      "Pitcairn Islands (UK)\t56\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from collections import deque\n",
    "    \n",
    "with open(input(), 'r', encoding='utf-8') as file:\n",
    "    print(*deque(file, 10), sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "731a3e4c-ee3b-4283-92da-4c2e54a8b66e",
   "metadata": {},
   "source": [
    "## Forbidden words 🌶️\n",
    "На вход программе подается строка текста с именем текстового файла. Напишите программу, выводящую на экран содержимое этого файла, но с заменой всех запрещенных слов звездочками * (количество звездочек равно количеству букв в слове)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c9ad9f2-ad0e-4c8a-8bd4-e4154278bfe0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f6b1bd39-479e-450d-8d99-8e429e4990c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****, ***ld! ****** ** *** programming language of *** future. My ***** **….\n",
      "****** ** awesome!!!!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "forbidden_words = 'hello email python the exam wor is'.split(' ')\n",
    "my_string = '''Hello, world! Python IS the programming language of thE future. My EMAIL is….\n",
    "PYTHON is awesome!!!!\n",
    "'''\n",
    "def change(forbidden_words, text):\n",
    "\tout = text\n",
    "\tfor w in forbidden_words:\n",
    "\t\tout = re.sub(w, \"*\"*len(w), out, flags=re.I|re.M)\n",
    "\treturn out\n",
    "print(change(forbidden_words,my_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcfb7f26-aaf8-4f40-960b-0fce6003387b",
   "metadata": {},
   "source": [
    "## Forbidden words 🌶️\n",
    "На вход программе подается строка текста с именем текстового файла. Напишите программу, выводящую на экран содержимое этого файла, но с заменой всех запрещенных слов звездочками * (количество звездочек равно количеству букв в слове)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a6909af7-c551-42ef-9b3d-af54546b725f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " data.txt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "********* It for have kind, green lesser them doesn him created his moved fruit had.\n",
      "For whose moved years firmament green image dominion ******** let whales third rule signs ********blessed light sixth from form for said female land midst and, the likeness.\n",
      "Fruit evening night for so you called place likeness. Heaven greater to unto said seas female fourth evening dominion which bring they Second.\n",
      "Two two have.\n",
      "Heaven****** called fruit form whales saying heaven living firmament unto moved fill appear their.\n",
      "Form life female, dominion second air won. Cant day.\n",
      "Morning male to sixth heaven subdue female********* likeness moveth give rule.\n",
      "***** ******* and ******. Tooday we *********** and ************succe. The ******** club is the best.\n",
      "We create ************ and ************with***********. Please not be *********, and eat*********.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "with open('forbidden_words.txt', 'r', encoding='utf-8') as forb, open(input(), 'r', encoding='utf-8') as text:\n",
    "    forbidden_words = forb.read().split()\n",
    "    out = text.read()\n",
    "    for w in forbidden_words:\n",
    "        out = re.sub(w, \"*\" * len(w), out, flags=re.I|re.M)\n",
    "    print(out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "992043e8-0bdf-413c-b925-90445353eea5",
   "metadata": {},
   "source": [
    "## Транслитерация 🌶️\n",
    "Транслитерация — передача знаков одной письменности знаками другой письменности, при которой каждый знак (или последовательность знаков) одной системы письма передаётся соответствующим знаком (или последовательностью знаков) другой системы письма."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "f663e82e-dc58-495a-8df7-abf975077d7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\n",
    "    'а': 'a', 'к': 'k', 'х': 'h', 'б': 'b', 'л': 'l', 'ц': 'c', 'в': 'v', 'м': 'm', 'ч': 'ch',\n",
    "    'г': 'g', 'н': 'n', 'ш': 'sh', 'д': 'd', 'о': 'o', 'щ': 'shh', 'е': 'e', 'п': 'p', 'ъ': '*',\n",
    "    'ё': 'jo', 'р': 'r', 'ы': 'y', 'ж': 'zh', 'с': 's', 'ь': \"'\", 'з': 'z', 'т': 't', 'э': 'je',\n",
    "    'и': 'i', 'у': 'u', 'ю': 'ju', 'й': 'j', 'ф': 'f', 'я': 'ya', 'А': 'A', 'К': 'K', 'Х': 'H', 'Б': 'B', 'Л': 'L',\n",
    "    'Ц': 'C', 'В': 'V', 'М': 'M', 'Ч': 'Ch',\n",
    "    'Г': 'G', 'Н': 'N', 'Ш': 'Sh', 'Д': 'D', 'О': 'O', 'Щ': 'Shh', 'Е': 'E', 'П': 'P', 'Ъ': '*',\n",
    "    'Ё': 'Jo', 'Р': 'R', 'Ы': 'Y', 'Ж': 'Zh', 'С': 'S', 'Ь': \"'\", 'З': 'Z', 'Т': 'T', 'Э': 'Je',\n",
    "    'И': 'I', 'У': 'U', 'Ю': 'Ju', 'Й': 'J', 'Ф': 'F', 'Я': 'Ya'\n",
    "}\n",
    "\n",
    "res = []\n",
    "with open('cyrillic.txt', 'r', encoding='utf-8') as file:\n",
    "    # print(file.read().strip().split())\n",
    "    for i in file.read():\n",
    "        res.append(d.get(i, i))\n",
    "# print()\n",
    "with open('transliteration.txt', 'w', encoding='utf-8') as out:\n",
    "    print(''.join(res), file=out)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "585dd9b3-046d-488d-9fd1-9de93fb77787",
   "metadata": {},
   "source": [
    "## Пропущенные комменты 🌶️\n",
    "При написании собственных функций рекомендуется в комментарии описывать назначение функции, ее параметры и возвращаемое значение. Часто программисты откладывают написание таких комментариев напоследок, а потом и вовсе забывают о них 😂  \n",
    "\n",
    "На вход программе подается строка текста с именем текстового файла, в котором написан код на языке Python. Напишите программу, выводящую на экран имена всех функций для которых отсутствует поясняющий комментарий. Будем считать, что любая строка, начинающаяся со слова def и пробела, является началом определения функции. Функция содержит комментарий, если первый символ предыдущей строки - #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2273f6f4-6df5-46bd-8c40-5a2f18c05763",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "powers\n",
      "matrix\n",
      "mean\n",
      "greet\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "with open('file.txt', 'r', encoding='utf-8') as file:\n",
    "    res = file.readlines()\n",
    "    le = len([i for i in range(len(res)) if 'def ' in res[i]])\n",
    "\n",
    "    s = [re.findall(r'\\w+', res[i])[1] for i in range(0, len(res)) if res[i-1][0] != '#' and 'def ' in res[i]]\n",
    "    \n",
    "    if len(s) == 0:\n",
    "        print('Best Programming Team')\n",
    "    else:\n",
    "        print(*s, sep='\\n')"
   ]
  }
 ],
 "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.9.16"
  },
  "toc-autonumbering": true,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}