diff --git a/.gitignore b/.gitignore
index 9bbabeeb2499f8a293470cee44a515e5efefc25b..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +0,0 @@
-md.txt
-output.ipynb
-todo.txt
\ No newline at end of file
diff --git a/2.1/1.py b/2.1/1.py
deleted file mode 100644
index 522b0176342c8bd0ee65649f113282651ccf623f..0000000000000000000000000000000000000000
--- a/2.1/1.py
+++ /dev/null
@@ -1 +0,0 @@
-print("Привет, Яндекс!")
\ No newline at end of file
diff --git a/2.1/10.py b/2.1/10.py
deleted file mode 100644
index c87b97169fbaf71397bf66b3d7825426f654360e..0000000000000000000000000000000000000000
--- a/2.1/10.py
+++ /dev/null
@@ -1,3 +0,0 @@
-kid_name, num = input(), int(input())
-print(f"Группа №{num // 100}.", f"{num % 10}. {kid_name}.", f"Шкафчик: {num}.", sep="\n")
-print(f"Кроватка: {(num % 100) // 10}.")
\ No newline at end of file
diff --git a/2.1/11.py b/2.1/11.py
deleted file mode 100644
index 80ab1f643f4d17f4b7a6c95b390276e5e1f0431e..0000000000000000000000000000000000000000
--- a/2.1/11.py
+++ /dev/null
@@ -1,3 +0,0 @@
-s = input()
-s = s[1] + s[0] + s[3] + s[2]
-print(s)
\ No newline at end of file
diff --git a/2.1/12.py b/2.1/12.py
deleted file mode 100644
index e0540c77464b8f9a7fed9a9c9180b92027135284..0000000000000000000000000000000000000000
--- a/2.1/12.py
+++ /dev/null
@@ -1,13 +0,0 @@
-n1, n2 = input(), input()
-max_len = max(len(n1), len(n2))
-if len(n1) < max_len:
- n1 = "0" * (max_len - len(n1)) + n1
-
-if len(n2) < max_len:
- n2 = "0" * (max_len - len(n2)) + n2
-
-res = ""
-for i in range(max_len - 1, -1, -1):
- res = str((int(n1[i]) + int(n2[i])) % 10) + res
-
-print(res)
\ No newline at end of file
diff --git a/2.1/13.py b/2.1/13.py
deleted file mode 100644
index 7648cb00474e0d1a904c66cf3b2270ad6c0fbf75..0000000000000000000000000000000000000000
--- a/2.1/13.py
+++ /dev/null
@@ -1,3 +0,0 @@
-kid_c, cand_c = int(input()), int(input())
-print(cand_c // kid_c)
-print(cand_c % kid_c)
\ No newline at end of file
diff --git a/2.1/14.py b/2.1/14.py
deleted file mode 100644
index adf7428fffcb4185c0e21dd15c1f93a3a160bca7..0000000000000000000000000000000000000000
--- a/2.1/14.py
+++ /dev/null
@@ -1,2 +0,0 @@
-red_c, green_c, blue_c = int(input()), int(input()), int(input())
-print(red_c + blue_c + 1)
\ No newline at end of file
diff --git a/2.1/15.py b/2.1/15.py
deleted file mode 100644
index 479a00a3094ad397a28be50d6528d8dc791b5112..0000000000000000000000000000000000000000
--- a/2.1/15.py
+++ /dev/null
@@ -1,16 +0,0 @@
-n, m, t = int(input()), int(input()), int(input())
-n += t // 60
-m += t % 60
-while m > 59:
- m -= 60
- n += 1
-while n > 23:
- n -= 24
-
-s = ""
-for arg in [n, m]:
- if arg < 10:
- s += "0"
- s += str(arg)
-s = s[:2] + ":" + s[2:]
-print(s)
\ No newline at end of file
diff --git a/2.1/16.py b/2.1/16.py
deleted file mode 100644
index 8a0dafd011e984374ed0a14c8ccbbf8d7cc557fe..0000000000000000000000000000000000000000
--- a/2.1/16.py
+++ /dev/null
@@ -1,12 +0,0 @@
-a, b, c = int(input()), int(input()), int(input())
-dist = a - b
-
-if dist < 0:
- dist *= -1
-
-time = str(dist / c).split(".")
-if len(time[1]) < 2:
- time[1] += "0"
-elif len(time) > 2:
- time[1] = time[1][:2]
-print(".".join(time))
\ No newline at end of file
diff --git a/2.1/17.py b/2.1/17.py
deleted file mode 100644
index 3ea245465037ddef59a089a3fa0196f5d0641028..0000000000000000000000000000000000000000
--- a/2.1/17.py
+++ /dev/null
@@ -1 +0,0 @@
-print(int(input()) + int(input(), 2))
\ No newline at end of file
diff --git a/2.1/18.py b/2.1/18.py
deleted file mode 100644
index 1601c62a9c1243576ffaab1e0b446f71b5c55984..0000000000000000000000000000000000000000
--- a/2.1/18.py
+++ /dev/null
@@ -1 +0,0 @@
-print(-1 * int(input(), 2) + int(input()))
\ No newline at end of file
diff --git a/2.1/19.py b/2.1/19.py
deleted file mode 100644
index 6853e1da0c8bc8b6012a783a21d8343c24bd5d78..0000000000000000000000000000000000000000
--- a/2.1/19.py
+++ /dev/null
@@ -1,8 +0,0 @@
-name, cost, weight, mon = input(), int(input()), int(input()), int(input())
-print("=" * 16, "Чек", "=" * 16, sep="")
-print("Товар:", " " * (29 - len(str(name))), name, sep="")
-print("Цена:", " " * (19 - len(str(weight)) - len(str(cost))), f"{weight}кг * {cost}руб/кг", sep="")
-print("Ртого:", " " * (26 - len(str(weight * cost))), f"{weight * cost}СЂСѓР±", sep="")
-print("Внесено:", " " * (24 - len(str(mon))), f"{mon}руб", sep="")
-print("Сдача:", " " * (26 - len(str(mon - (weight * cost)))), f"{mon - (weight * cost)}руб", sep="")
-print("=" * 35)
\ No newline at end of file
diff --git a/2.1/2.py b/2.1/2.py
deleted file mode 100644
index fc09fd2b377e49b554848b7e77b670c92cf57322..0000000000000000000000000000000000000000
--- a/2.1/2.py
+++ /dev/null
@@ -1,3 +0,0 @@
-print("Как Вас зовут?")
-name = input()
-print(f"Привет, {name}")
\ No newline at end of file
diff --git a/2.1/20.py b/2.1/20.py
deleted file mode 100644
index ae8b79681e9f41b39c9e7f294aa38c9e7b4a74c9..0000000000000000000000000000000000000000
--- a/2.1/20.py
+++ /dev/null
@@ -1,4 +0,0 @@
-n, m, k1, k2 = int(input()), int(input()), int(input()), int(input())
-x = int((n * m - k2 * n) / (k1 - k2))
-y = n - x
-print(x, y)
\ No newline at end of file
diff --git a/2.1/21.ipynb b/2.1/21.ipynb
deleted file mode 100644
index f1a671d03cdb2cb982e6526553fc590cac6779d1..0000000000000000000000000000000000000000
--- a/2.1/21.ipynb
+++ /dev/null
@@ -1,666 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Привет, Яндекс!**\n",
- "Когда мы приходим на встречу, то первым делом здороваемся. Давайте тоже поприветствуем Яндекс.\n",
- "### **Формат вывода:**\n",
- "Одна строка: «Привет, Яндекс!»\n",
- "### **Пример**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "||Привет, Яндекс!|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(\"Привет, Яндекс!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Привет, всем!**\n",
- "Но вообще, хорошо бы узнать имя собеседника, а уже потом его приветствовать.<br>Напишите диалоговую программу, которая сначала познакомится со своим пользователем, а затем поздоровается с ним.\n",
- "### **Формат ввода:**\n",
- "Одна строка — имя пользователя программы.\n",
- "### **Формат вывода:**\n",
- "В первой строке написан вопрос: «Как Вас зовут?» Во второй строке — приветствие пользователя: «Привет, %username%».»\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Ann<br> <br>|Как Вас зовут?<br>Привет, Ann|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Bob<br> <br>|Как Вас зовут?<br>Привет, Bob|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(\"Как Вас зовут?\")\n",
- "name = input()\n",
- "print(f\"Привет, {name}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Рзлишняя автоматизация**\n",
- "«Повторение — мать учения!В» Рё «Если это можно автоматизировать — автоматизируй!В»<br>Ртим принципам следуют РјРЅРѕРіРёРµ программисты. РќРѕ что будет, если РёС… объединить?\n",
- "### **Формат ввода:**\n",
- "Одна строка — весьма полезная информация.\n",
- "### **Формат вывода:**\n",
- "Трижды повторённая весьма полезная информация.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2 + 2 = 4<br> <br> <br>|2 + 2 = 4<br>2 + 2 = 4<br>2 + 2 = 4|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2 + 2 = 4<br> <br> <br>|2 + 2 = 4<br>2 + 2 = 4<br>2 + 2 = 4|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "trash = input()\n",
- "for _ in range(3):\n",
- " print(trash)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Сдача**\n",
- "Чаще всего автоматизация идёт на пользу.<br>Одна из задач, в которой лучше исключить человеческий фактор, — подсчёт сдачи.<br>Определите, какую сдачу нужно выдать тому, кто купил 2,5кг черешни по цене 38 руб/кг.\n",
- "### **Формат ввода:**\n",
- "Одно натуральное число - номинал купюры пользователя (≥100).\n",
- "### **Формат вывода:**\n",
- "Одно натуральное число — размер сдачи.\n",
- "### **Пример**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|100|5|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "mon = int(input())\n",
- "cost = int(2.5 * 38)\n",
- "print(mon - cost)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Магазин**\n",
- "Кроме черешни в магазине продаётся множество других товаров, которые продаются на развес.<br>Давайте автоматизируем расчёт сдачи и для них!\n",
- "### **Формат ввода:**\n",
- "Три натуральных числа:\n",
- "* цена товара;\n",
- "* вес товара;\n",
- "* количество денег у пользователя.\n",
- "### **Формат вывода:**\n",
- "Трижды повторённая весьма полезная информация.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2<br>3<br>10|4<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|187<br>43<br>8041|0<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "cost, weight, mon = int(input()), int(input()), int(input())\n",
- "print(mon - (cost * weight))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Чек**\n",
- "Сдачу посчитать, конечно, все могут, но красивый чек напечатать — не так просто.\n",
- "### **Формат ввода:**\n",
- "* название товара;\n",
- "* цена товара;\n",
- "* вес товара;\n",
- "* количество денег у пользователя.\n",
- "### **Формат вывода:**\n",
- "Чек<br><название товара> - <вес>РєРі - <цена>СЂСѓР±/РєРі<br>Ртого: <итоговая стоимость>СЂСѓР±<br>Внесено: <количество денег РѕС‚ пользователя>СЂСѓР±<br>Сдача: <сдача>СЂСѓР±\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|черешня<br>2<br>3<br>10<br> <br>|Чек<br>черешня - 3РєРі - 2СЂСѓР±/РєРі<br>Ртого: 6СЂСѓР±<br>Внесено: 10СЂСѓР±<br>Сдача: 4СЂСѓР±|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|манго<br>187<br>43<br>8041<br> <br>|Чек<br>манго - 43РєРі - 187СЂСѓР±/РєРі<br>Ртого: 8041СЂСѓР±<br>Внесено: 8041СЂСѓР±<br>Сдача: 0СЂСѓР±|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "name, cost, weight, mon = input(), int(input()), int(input()), int(input())\n",
- "print(\"Чек\", f\"{name} - {weight}РєРі - {cost}СЂСѓР±/РєРі\", f\"Ртого: {cost * weight}СЂСѓР±\", sep=\"\\n\")\n",
- "print(f\"Внесено: {mon}руб\", f\"Сдача: {mon - (cost * weight)}руб\", sep=\"\\n\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Делу — время, потехе — час**\n",
- "Давайте передохнём от автоматизации и сделаем что-то действительно интересное.\n",
- "### **Формат ввода:**\n",
- "Одно натуральное число N\n",
- "### **Формат вывода:**\n",
- "N строк с фразой: \"Купи слона!\"\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1|Купи слона!|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br> <br> <br>|Купи слона!<br>Купи слона!<br>Купи слона!|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "for _ in range(n):\n",
- " print(\"Купи слона!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Наказание**\n",
- "Наше развлечение не осталось незамеченным...<br>Рнаказание нам выбрали соответствующее.<br><br>В первой строке записано одно натуральное число N<br>Во второй строке записана часть наказания.<br><br>N строк вида: Я больше никогда не буду писать \"<часть наказания>\"!\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2<br>Купи слона!|Я больше никогда не буду писать \"Купи слона!\"!<br>Я больше никогда не буду писать \"Купи слона!\"!|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>Попка дурак!|Я больше никогда не буду писать \"Попка дурак!\"!<br>Я больше никогда не буду писать \"Попка дурак!\"!<br>Я больше никогда не буду писать \"Попка дурак!\"!|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "s = input()\n",
- "for _ in range(n):\n",
- " print(f'Я больше никогда не буду писать \"{s}\"!')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Деловая колбаса**\n",
- "Настало время для действительно серьёзных задач...<br>В детском саду 2 ребенка съедают 2 куска колбасы за 2 минуты. Сколько кусков колбасы за N минут съедят M детей?\n",
- "### **Формат ввода**\n",
- "В первой строке записано натуральное число N≥1<br>Во второй строке записано натуральное число M≥1\n",
- "### **Формат вывода**\n",
- "Одно натуральное число — количество кусков колбасы, съеденных детьми\n",
- "### **Примечание**\n",
- "Гарантируется, что в результате вычислений будет получено натуральное число.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2<br>2|2<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>10|10<br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# скорость ребёнка = 0.5 колбаса/мин\n",
- "t, kid_c = int(input()), int(input())\n",
- "print(int(0.5 * t * kid_c))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Детский сад — штаны на лямках**\n",
- "В продолжение темы детского сада давайте и там что-нибудь автоматизируем.<br>За каждым ребёнком закреплён шкафчик и кровать. Номер шкафчика состоит из трёх цифр:<br>\n",
- "* номер группы в саду;\n",
- "* номер кроватки, закреплённой за ребёнком;\n",
- "* порядковый номер ребёнка в списке группы.\n",
- "\n",
- "Воспитатель просит сделать программу, которая по имени ребенка и номеру его шкафчика формирует «красивую» карточку для личного дела.\n",
- "### **Формат ввода**\n",
- "В первой строке записано имя ребенка.<br>Во второй строке записан номер шкафчика.\n",
- "### **Формат вывода**\n",
- "Карточка в виде:<br>\n",
- "Группа №<номер группы>. <br><номер ребёнка в списке>. <имя ребенка>. <br>Шкафчик: <номер шкафчика>. <br>Кроватка: <номер кроватки>.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Ванечка<br>832<br> <br> <br>|Группа №8.<br>2. Ванечка.<br>Шкафчик: 832.<br>Кроватка: 3.|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Машенька<br>141<br> <br> <br>|Группа №1.<br>1. Машенька.<br>Шкафчик: 141.<br>Кроватка: 4.|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "kid_name, num = input(), int(input())\n",
- "print(f\"Группа №{num // 100}.\", f\"{num % 10}. {kid_name}.\", f\"Шкафчик: {num}.\", sep=\"\\n\")\n",
- "print(f\"Кроватка: {(num % 100) // 10}.\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Автоматизация игры**\n",
- "Всё в том же детском саду ребята очень любят играть с цифрами.<br>Одна из таких игр — перестановка цифр четырёхзначного числа.<br>Напишите программу для робота-няни, которая из числа вида abcd составляет число badc.\n",
- "### **Формат ввода**\n",
- "Одно четырёхзначное число.\n",
- "### **Формат вывода**\n",
- "Одно четырёхзначное число — результат перестановки.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1234|2143|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1412|4121|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "s = s[1] + s[0] + s[3] + s[2]\n",
- "print(s)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Рнтересное сложение**\n",
- "Один малыш из детского сада услышал от старшей сестры о некоем действии с числами — сложении.<br>Ркак это часто бывает — он не до конца разобрался, как работает сложение. Например, не совсем понял, как произвести перенос разряда.<br>Теперь он хочет научить сложению остальных ребят и просит написать программу, которая поможет ему в качестве наглядного материала.\n",
- "### **Формат ввода**\n",
- "В первой и второй строках записаны натуральные числа меньше 1000.\n",
- "### **Формат вывода**\n",
- "Одно число — результат сложения введённых чисел без учёта переносов.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|123<br>99|112<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|405<br>839<br>|234<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n1, n2 = input(), input()\n",
- "max_len = max(len(n1), len(n2))\n",
- "if len(n1) < max_len:\n",
- " n1 = \"0\" * (max_len - len(n1)) + n1\n",
- "\n",
- "if len(n2) < max_len:\n",
- " n2 = \"0\" * (max_len - len(n2)) + n2\n",
- "\n",
- "res = \"\"\n",
- "for i in range(max_len - 1, -1, -1):\n",
- " res = str((int(n1[i]) + int(n2[i])) % 10) + res\n",
- "\n",
- "print(res)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Дед Мороз и конфеты**\n",
- "Настало самое главное событие в детском саду — новогодний утренник.<br>Хорошо замаскированная робоняня в роли Деда Мороза решила раздать детям конфеты так, чтобы каждому досталось поровну. Напишите для робоняни алгоритм, который поможет распределить конфеты.\n",
- "### **Формат ввода**\n",
- "В первой строке указано количество детей на утреннике.<br>Во второй строке — количество конфет в конфетном отсеке робоняни.\n",
- "### **Формат вывода**\n",
- "Сначала выведите количество конфет, которое выдано каждому ребенку, а затем количество конфет, что осталось в конфетном отсеке.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>100<br>|33<br>1|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|20<br>500<br>|25<br>0|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "kid_c, cand_c = int(input()), int(input())\n",
- "print(cand_c // kid_c)\n",
- "print(cand_c % kid_c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Шарики и ручки**\n",
- "РРЅРѕРіРґР° ребята РІ детском саду скучают, поэтому РѕРЅРё постоянно придумывают себе РЅРµ очень сложные, РЅРѕ веселые, РїРѕ РёС… мнению, РёРіСЂС‹.<br>Р’ РіСЂСѓРїРїРµ есть ящик СЃ шариками, количество которых детям заранее неизвестно, следующих цветов:<br>\n",
- "* красный;\n",
- "* зеленый;\n",
- "* СЃРёРЅРёР№.\n",
- "\n",
- "РРіСЂР° заключается РІ том, что каждый ребенок РїРѕРґС…РѕРґРёС‚ Рє ящику Рё, РЅРµ глядя, вытаскивает РѕРґРёРЅ шарик, победителем считается тот, кто первым вытащит зелёный шарик.<br>Как РІС‹ думаете, через какое максимальное количество С…РѕРґРѕРІ дети выяснят победителя РёРіСЂС‹?\n",
- "### **Формат ввода**\n",
- "Три натуральных числа, каждое на новой строке (количество красных, зеленых и синих шаров соответственно).\n",
- "### **Формат вывода**\n",
- "Одно число — максимальное количество ходов, которое потребуется для определения победителя.\n",
- "### **Пример**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1<br>2<br>3<br>|5<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "red_c, green_c, blue_c = int(input()), int(input()), int(input())\n",
- "print(red_c + blue_c + 1)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **В ожидании доставки**\n",
- "Сегодня в N часов M минут хозяин магазина заказал доставку нового товара. Оператор сказал, что продукты доставят через T минут.<br>Сколько будет времени на электронных часах, когда привезут долгожданные продукты?<br><br>В первой строке записано натуральное число N ($0≤N<24$).<br>Во второй строке записано натуральное число M ($0≤M<60$).<br>В третьей строке записано натуральное число T ($30≤T<10^{9}$).<br><br>Одна строка, представляющая циферблат электронных часов.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|8<br>0<br>65<br>|09:05<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>15<br>2752<br>|08:07<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n, m, t = int(input()), int(input()), int(input())\n",
- "n += t // 60\n",
- "m += t % 60\n",
- "while m > 59:\n",
- " m -= 60\n",
- " n += 1\n",
- "while n > 23:\n",
- " n -= 24\n",
- "\n",
- "s = \"\"\n",
- "for arg in [n, m]:\n",
- " if arg < 10:\n",
- " s += \"0\"\n",
- " s += str(arg)\n",
- "s = s[:2] + \":\" + s[2:]\n",
- "print(s)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Доставка**\n",
- "Продуктовый склад и магазин находятся на одной дороге города Н.<br>Склад находится на отметке A км, а магазин — B км. Средняя скорость автомобиля, доставляющего товары, C км/ч.<br>За какое время продукты попадают со склада в магазин?\n",
- "### **Формат ввода**\n",
- "Три натуральных числа A, B и C, каждое на отдельной строке.\n",
- "### **Формат вывода**\n",
- "Одно рациональное число с точностью до сотых.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>32<br>5|4.40<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1<br>100<br>30|3.30<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b, c = int(input()), int(input()), int(input())\n",
- "dist = a - b\n",
- "\n",
- "if dist < 0:\n",
- " dist *= -1\n",
- "\n",
- "time = str(dist / c).split(\".\")\n",
- "if len(time[1]) < 2:\n",
- " time[1] += \"0\"\n",
- "elif len(time) > 2:\n",
- " time[1] = time[1][:2]\n",
- "print(\".\".join(time))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Ошибка кассового аппарата**\n",
- "Мы уже помогали магазину с расчётами и формированием чеков, но сегодня кассовый аппарат вместо привычных продавцу десятичных чисел начал выдавать двоичные.<br>Техподдержка приедет только завтра, а магазин должен продолжать работать. Надо помочь.\n",
- "### **Формат ввода**\n",
- "В первой строке записано десятичное число — общая сумма купленных в магазине товаров на данный момент.<br>Во второй строке указано двоичное число — сумма за последнюю покупку.\n",
- "### **Формат вывода**\n",
- "Одно десятичное число — сумма выручки за день с учётом последней покупки.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|123<br>1101|136<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|783<br>10110111|966<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(int(input()) + int(input(), 2))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Сдача 10**\n",
- "Кстати, несмотря на ошибку аппарата, сдачу тоже нужно отдавать.\n",
- "### **Формат ввода**\n",
- "Цена покупки — двоичное число, выданное кассовым аппаратом.<br>Номинал купюры пользователя — десятичное число (≥100).\n",
- "### **Формат вывода**\n",
- "Одно десятичное число — сдача, которую требуется отдать пользователю.\n",
- "### **Примечание**\n",
- "Все числа, используемые в задаче, целые.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1001001<br>100|27<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|101111100<br>500|120<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(-1 * int(input(), 2) + int(input()))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Украшение чека**\n",
- "Давайте приведём в порядок чек, который печатали ранее.<br>Все строки должны быть длиной в 35 символов.\n",
- "### **Формат ввода**\n",
- "Название товара;<br>цена товара;<br>вес товара;<br>количество денег у пользователя.\n",
- "### **Формат вывода**\n",
- "Красивый чек в формате:<br>\n",
- "================Чек================<br>Товар:                         <РїСЂРѕРґСѓРєС‚><br>Цена:             <число>РєРі * <число>СЂСѓР±/РєРі<br>Ртого:   &eС‚sp;               <число>СЂСѓР±<br>Внесено:                     <число>СЂСѓР±<br>Сдача:                     <число>СЂСѓР±<br>===================================\n",
- "### **Примечание**\n",
- "В данный момент примеры ниже визуализируются неправильно.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|черешня<br>2<br>3<br>10<br> <br> <br> <br>|================Чек================<br>Товар:                         черешня<br>Цена:                       3РєРі * 2СЂСѓР±/РєРі<br>Ртого:                             6СЂСѓР±<br>Внесено:                       10СЂСѓР±<br>Сдача:                             4СЂСѓР±<br>===================================|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|манго<br>187<br>43<br>8041<br> <br> <br> <br>|================Чек================<br>Товар:                           манго<br>Цена: nbsp; nbsp;             43РєРі * 187СЂСѓР±/РєРі<br>Ртого:                           8041СЂСѓР±<br>Внесено:                     8041СЂСѓР±<br>Сдача:                             0СЂСѓР±<br>===================================|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "name, cost, weight, mon = input(), int(input()), int(input()), int(input())\n",
- "print(\"=\" * 16, \"Чек\", \"=\" * 16, sep=\"\")\n",
- "print(\"Товар:\", \" \" * (29 - len(str(name))), name, sep=\"\")\n",
- "print(\"Цена:\", \" \" * (19 - len(str(weight)) - len(str(cost))), f\"{weight}кг * {cost}руб/кг\", sep=\"\")\n",
- "print(\"Ртого:\", \" \" * (26 - len(str(weight * cost))), f\"{weight * cost}СЂСѓР±\", sep=\"\")\n",
- "print(\"Внесено:\", \" \" * (24 - len(str(mon))), f\"{mon}руб\", sep=\"\")\n",
- "print(\"Сдача:\", \" \" * (26 - len(str(mon - (weight * cost)))), f\"{mon - (weight * cost)}руб\", sep=\"\")\n",
- "print(\"=\" * 35)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Мухи отдельно, котлеты отдельно**\n",
- "Вернёмся в магазин, хозяин которого уже привык полагаться на всемогущую автоматизацию.<br><br>Помогите ему разобраться с одной проблемой. Далее его история: «Пару дней назад я купил две партии котлет и по случайности высыпал их на один прилавок. Общий вес котлет составил $N$ килограмм, а ценник — $M$ рублей за килограмм.<br>Сегодня я обнаружил, что накладные на эти виды котлет потерялись, но я помню, что первый вид котлет стоил $K_1$ рублей за килограмм, а второй — $K_2$ .<br><br>Помогите мне вспомнить вес каждой партии котлет, чтобы поставить их на учёт.\n",
- "### **Формат ввода**\n",
- "В первой строке записано натуральное число $N$<br>Во второй строке — натуральное число $M$<br>В третьей строке — натуральное число $K_1$ <br>В четвёртой строке — натуральное число $K_2$ <br>Причём доподлинно известно, что второй вид котлет стоит меньше, чем первый.\n",
- "### **Формат вывода**\n",
- "Два натуральных числа, записанных через пробел — вес обеих партий котлет.\n",
- "### **Пример**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|32<br>285<br>300<br>240|24 8<br> <br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n, m, k1, k2 = int(input()), int(input()), int(input()), int(input())\n",
- "x = int((n * m - k2 * n) / (k1 - k2))\n",
- "y = n - x\n",
- "print(x, y)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "name": "python",
- "version": "3.11.4"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/2.1/3.py b/2.1/3.py
deleted file mode 100644
index aa467070c9ad8bccaa12f95c8b824d05b5e4d3b4..0000000000000000000000000000000000000000
--- a/2.1/3.py
+++ /dev/null
@@ -1,3 +0,0 @@
-trash = input()
-for _ in range(3):
- print(trash)
\ No newline at end of file
diff --git a/2.1/4.py b/2.1/4.py
deleted file mode 100644
index ca8a85b76650113db550c70b9f5049335bfa2c22..0000000000000000000000000000000000000000
--- a/2.1/4.py
+++ /dev/null
@@ -1,3 +0,0 @@
-mon = int(input())
-cost = int(2.5 * 38)
-print(mon - cost)
\ No newline at end of file
diff --git a/2.1/5.py b/2.1/5.py
deleted file mode 100644
index 4415ee11a3b5401975f27ac4f066be5ad56dab49..0000000000000000000000000000000000000000
--- a/2.1/5.py
+++ /dev/null
@@ -1,2 +0,0 @@
-cost, weight, mon = int(input()), int(input()), int(input())
-print(mon - (cost * weight))
\ No newline at end of file
diff --git a/2.1/6.py b/2.1/6.py
deleted file mode 100644
index 10975ef8db912aa7615317078c785c738e6d3059..0000000000000000000000000000000000000000
--- a/2.1/6.py
+++ /dev/null
@@ -1,3 +0,0 @@
-name, cost, weight, mon = input(), int(input()), int(input()), int(input())
-print("Чек", f"{name} - {weight}РєРі - {cost}СЂСѓР±/РєРі", f"Ртого: {cost * weight}СЂСѓР±", sep="\n")
-print(f"Внесено: {mon}руб", f"Сдача: {mon - (cost * weight)}руб", sep="\n")
\ No newline at end of file
diff --git a/2.1/7.py b/2.1/7.py
deleted file mode 100644
index ce64811de876b29000becc08758b4928cd7bc48b..0000000000000000000000000000000000000000
--- a/2.1/7.py
+++ /dev/null
@@ -1,3 +0,0 @@
-n = int(input())
-for _ in range(n):
- print("Купи слона!")
\ No newline at end of file
diff --git a/2.1/8.py b/2.1/8.py
deleted file mode 100644
index 84083435d60f077e34a0acb251f765b5cecd4a26..0000000000000000000000000000000000000000
--- a/2.1/8.py
+++ /dev/null
@@ -1,4 +0,0 @@
-n = int(input())
-s = input()
-for _ in range(n):
- print(f'Я больше никогда не буду писать "{s}"!')
\ No newline at end of file
diff --git a/2.1/9.py b/2.1/9.py
deleted file mode 100644
index 7b82064070ebd47a256d3075ba20e4ebe0a6dda7..0000000000000000000000000000000000000000
--- a/2.1/9.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# скорость ребёнка = 0.5 колбаса/мин
-t, kid_c = int(input()), int(input())
-print(int(0.5 * t * kid_c))
\ No newline at end of file
diff --git a/2.2/1.py b/2.2/1.py
deleted file mode 100644
index 46321cb12aa0a773a2384e7e3de380285a8ff8a9..0000000000000000000000000000000000000000
--- a/2.2/1.py
+++ /dev/null
@@ -1,7 +0,0 @@
-name = input("Как Вас зовут?\n")
-print(f"Здравствуйте, {name}!")
-status = input("Как дела?\n")
-if status == "хорошо":
- print("Я за вас рада!")
-else:
- print("Всё наладится!")
\ No newline at end of file
diff --git a/2.2/10.py b/2.2/10.py
deleted file mode 100644
index 4af39d0e7ded31dfd61f153017994b73e0b1e114..0000000000000000000000000000000000000000
--- a/2.2/10.py
+++ /dev/null
@@ -1,6 +0,0 @@
-n = int(input())
-
-s1 = ((n % 100) // 10) + (n % 10)
-s2 = (n // 100) + ((n % 100) // 10)
-
-print(max(s1, s2), min(s1, s2), sep="")
\ No newline at end of file
diff --git a/2.2/11.py b/2.2/11.py
deleted file mode 100644
index 1d203422e7d3f8ddf3a099a2f61bb467cd10fda9..0000000000000000000000000000000000000000
--- a/2.2/11.py
+++ /dev/null
@@ -1,6 +0,0 @@
-arr = [int(i) for i in input()]
-arr.sort()
-if arr[0] + arr[2] == arr[1] * 2:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/2.2/12.py b/2.2/12.py
deleted file mode 100644
index 7a806929bcb2bbcdc9b0a12d9f5f1d338058cac7..0000000000000000000000000000000000000000
--- a/2.2/12.py
+++ /dev/null
@@ -1,14 +0,0 @@
-arr = [int(input()) for _ in range(3)]
-
-summ = sum(arr)
-
-f = True
-
-for i in arr:
- if i >= summ - i:
- f = False
-
-if f:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/2.2/13.py b/2.2/13.py
deleted file mode 100644
index ff5765fae7da207a6b1cf1b5b20bd401f08dc266..0000000000000000000000000000000000000000
--- a/2.2/13.py
+++ /dev/null
@@ -1,6 +0,0 @@
-arr = [input() for _ in range(3)]
-
-for i in arr[0]:
- if i in arr[1] and i in arr[2]:
- print(i)
- break
\ No newline at end of file
diff --git a/2.2/14.py b/2.2/14.py
deleted file mode 100644
index 3dd313d9ee6fda14e0f84eed00fdde11da079f02..0000000000000000000000000000000000000000
--- a/2.2/14.py
+++ /dev/null
@@ -1,7 +0,0 @@
-num = input()
-arr = []
-arrtest = [num[0] + num[1], num[1] + num[0], num[1] + num[2], num[2] + num[1], num[0] + num[2], num[2] + num[0]]
-for i in arrtest:
- if int(i) >= 10:
- arr.append(int(i))
-print(min(arr), max(arr))
\ No newline at end of file
diff --git a/2.2/15.py b/2.2/15.py
deleted file mode 100644
index 6835000fed3cce495d0fdfb58eae7ac02535d487..0000000000000000000000000000000000000000
--- a/2.2/15.py
+++ /dev/null
@@ -1,4 +0,0 @@
-a, b = input(), input()
-nums = [int(i) for i in sorted([a[0], a[1], b[0], b[1]])]
-
-print(f"{nums[3]}{(nums[1] + nums[2]) % 10}{nums[0]}")
\ No newline at end of file
diff --git a/2.2/16.py b/2.2/16.py
deleted file mode 100644
index 56a50853637ff9005daf91c7854d4593a43d73f2..0000000000000000000000000000000000000000
--- a/2.2/16.py
+++ /dev/null
@@ -1,11 +0,0 @@
-names = ("Петя", "Вася", "Толя")
-speed = {int(input()): names[i] for i in range(3)}
-text = []
-speed_list = list(speed.keys())
-speed_sorted = sorted(speed_list)
-text = ["", "", "", " II I III "]
-text[0] = (10 * " " + speed[speed_sorted[2]] + " " * 10)
-text[1] = (2 * " " + speed[speed_sorted[1]] + " " * 18)
-text[2] = (18 * " " + speed[speed_sorted[0]] + " " * 2)
-
-print(*text, sep="\n")
\ No newline at end of file
diff --git a/2.2/17.py b/2.2/17.py
deleted file mode 100644
index 09a7b48378b6d310b317087c12598d51ecd1187c..0000000000000000000000000000000000000000
--- a/2.2/17.py
+++ /dev/null
@@ -1,25 +0,0 @@
-a, b, c = [float(input()) for _ in range(3)]
-if a == b == c == 0:
- print("Infinite solutions")
-elif a == b == 0:
- print("No solution")
-elif a == 0:
- x = (-1 * c) / b
-
- print("%.2f" % x)
-
-else:
- d = b ** 2 - 4 * a * c
- if d > 0:
- x1 = min((-1 * b + d ** 0.5) / (2 * a), (-1 * b - d ** 0.5) / (2 * a))
- x2 = max((-1 * b + d ** 0.5) / (2 * a), (-1 * b - d ** 0.5) / (2 * a))
-
- print("%.2f" % x1, "%.2f" % x2)
-
- elif d == 0:
- x = (-1 * b) / (2 * a)
-
- print("%.2f" % x)
-
- elif d < 0:
- print("No solution")
\ No newline at end of file
diff --git a/2.2/18.py b/2.2/18.py
deleted file mode 100644
index 9bb9bb330631b9450d3fa385b11f132f1adf2ad8..0000000000000000000000000000000000000000
--- a/2.2/18.py
+++ /dev/null
@@ -1,8 +0,0 @@
-a, b, c = sorted([int(input()) for _ in range(3)])
-
-if (a ** 2 + b ** 2 == c ** 2):
- print("100%")
-elif (a ** 2 + b ** 2 < c ** 2):
- print("велика")
-else:
- print("крайне мала")
\ No newline at end of file
diff --git a/2.2/19.py b/2.2/19.py
deleted file mode 100644
index df78de42250176a349b881d14527d67c2856bf80..0000000000000000000000000000000000000000
--- a/2.2/19.py
+++ /dev/null
@@ -1,23 +0,0 @@
-x, y = float(input()), float(input())
-
-if x ** 2 + y ** 2 > 100:
- print("Вы вышли в море и рискуете быть съеденным акулой!")
-else:
- if x >= 0 and y >= 0:
- if x ** 2 + y ** 2 <= 25:
- print("Опасность! Покиньте зону как можно скорее!")
- else:
- print("Зона безопасна. Продолжайте работу.")
- elif x < 0 and y > 0:
- if y > 5:
- print("Зона безопасна. Продолжайте работу.")
- else:
- if y > 5 / 3 * x + 35 / 3:
- print("Зона безопасна. Продолжайте работу.")
- else:
- print("Опасность! Покиньте зону как можно скорее!")
- elif y < 0:
- if y < 0.25 * x ** 2 + 0.5 * x - 8.75:
- print("Зона безопасна. Продолжайте работу.")
- else:
- print("Опасность! Покиньте зону как можно скорее!")
\ No newline at end of file
diff --git a/2.2/2.py b/2.2/2.py
deleted file mode 100644
index d00d392504610c55e166f1dc3851451f289cd449..0000000000000000000000000000000000000000
--- a/2.2/2.py
+++ /dev/null
@@ -1,5 +0,0 @@
-a, b = int(input()), int(input())
-if a > b:
- print("Петя")
-else:
- print("Вася")
\ No newline at end of file
diff --git a/2.2/20.py b/2.2/20.py
deleted file mode 100644
index 8eb41f7bed42b79aca7ecc022c03f4077543a0df..0000000000000000000000000000000000000000
--- a/2.2/20.py
+++ /dev/null
@@ -1,7 +0,0 @@
-arr = sorted([input() for _ in range(3)])
-
-for s in arr:
- if "зайка" in s:
- print(s, len(s))
- break
-
\ No newline at end of file
diff --git a/2.2/22.ipynb b/2.2/22.ipynb
deleted file mode 100644
index a785e2d30cbc72ae8329a2be96e7b842c31f18e0..0000000000000000000000000000000000000000
--- a/2.2/22.ipynb
+++ /dev/null
@@ -1,793 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Просто здравствуй, просто как дела**\n",
- "Умение вести диалог — важный навык для воспитанного человека.<br><br>Напишите диалоговую программу, которая сначала познакомится с пользователем, а затем поинтересуется его настроением.\n",
- "### **Формат ввода**\n",
- "В первой строке записано имя пользователя.<br>Во второй — ответ на вопрос: «хорошо» или «плохо».\n",
- "### **Формат вывода**\n",
- "В первой строке должен быть вопрос «Как Вас зовут?»<br>Во второй строке — «Здравствуйте, %username%!»<br>В третьей строке — вопрос «Как дела?»<br>В четвёртой строке реакция на ответ пользователя:<br>\n",
- "* если пользователь ответил «хорошо», следует вывести сообщение «Я за вас рада!»;\n",
- "* если пользователь ответил «плохо», следует вывести сообщение «Всё наладится!».\n",
- "\n",
- "\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Аня<br>хорошо<br> <br> <br>|Как Вас зовут?<br>Здравствуйте, Аня!<br>Как дела?<br>Я за вас рада!|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Боря<br>плохо<br> <br> <br>|Как Вас зовут?<br>Здравствуйте, Боря!<br>Как дела?<br>Всё наладится!|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "name = input(\"Как Вас зовут?\\n\")\n",
- "print(f\"Здравствуйте, {name}!\")\n",
- "status = input(\"Как дела?\\n\")\n",
- "if status == \"хорошо\":\n",
- " print(\"Я за вас рада!\")\n",
- "else:\n",
- " print(\"Всё наладится!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Кто быстрее?**\n",
- "Р’ главной велогонке РіРѕРґР° участвует более тысячи гонщиков. РРј предстоит пройти трассу длиной 43872Рј. Самая сложная Рё ответственная задача — определение победителя.<br><br>Нам известны средние скорости РґРІСѓС… фаворитов — Пети Рё Васи. Помогите выяснить, кто РёР· РЅРёС… пришёл Рє финишу первым.\n",
- "### **Формат ввода**\n",
- "В первой строке записана средняя скорость Пети.<br>Во второй — Васи.\n",
- "### **Формат вывода**\n",
- "РРјСЏ победителя РіРѕРЅРєРё.\n",
- "### **Примечание**\n",
- "Гарантируется, что победителем стал только один.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>5|Петя<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5<br>7|Вася<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b = int(input()), int(input())\n",
- "if a > b:\n",
- " print(\"Петя\")\n",
- "else:\n",
- " print(\"Вася\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Кто быстрее на этот раз?**\n",
- "Р’РЅРѕРІСЊ велогонщики собрались узнать, кто РёР· РЅРёС… быстрее. РРј предстоит пройти трассу длиной 43872Рј, Рё нам нужно РІРЅРѕРІСЊ определить победителя.<br><br>РќР° этот раз нам известны средние скорости трёх фаворитов — Пети, Васи Рё Толи. Кто РёР· РЅРёС… пришёл Рє финишу первым?\n",
- "### **Формат ввода**\n",
- "В первой строке записана средняя скорость Пети.<br>Во второй — Васи.<br>В третьей — Толи.\n",
- "### **Формат вывода**\n",
- "РРјСЏ победителя РіРѕРЅРєРё.\n",
- "### **Примечание**\n",
- "Гарантируется, что победителем стал только один.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>5<br>7|Петя<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5<br>7<br>10|Толя<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b, c = int(input()), int(input()), int(input())\n",
- "m = max(a, b, c)\n",
- "if a == m:\n",
- " print(\"Петя\")\n",
- "elif b == m:\n",
- " print(\"Вася\")\n",
- "elif c == m:\n",
- " print(\"Толя\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Список победителей**\n",
- "Длина трассы — 43872м, и зрители хотят узнать имя победителя.<br><br>Нам известны средние скорости трёх фаворитов – Пети, Васи и Толи. Помогите подвести итоги гонки.\n",
- "### **Формат ввода**\n",
- "В первой строке записана средняя скорость Пети.<br>Во второй — Васи.<br>В третьей — Толи.\n",
- "### **Формат вывода**\n",
- "Рмена победителей РІ РїРѕСЂСЏРґРєРµ занятых мест.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>5<br>7|1. Петя<br>2. Толя<br>3. Вася<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5<br>7<br>10|1. Толя<br>2. Вася<br>3. Петя<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b, c = int(input()), int(input()), int(input())\n",
- "names = [\"Петя\", \"Вася\", \"Толя\"]\n",
- "s_d = [a, b, c]\n",
- "cnt = 1\n",
- "for speed in sorted([a, b, c], reverse=True):\n",
- " print(f\"{cnt}. {names[s_d.index(speed)]}\")\n",
- " cnt += 1"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Яблоки**\n",
- "У Пети было 7 яблок, а у Васи 6.<br><br>Затем Петя отдал 3 яблока Васе, а у Толи взял 2 яблока.<br><br>Вася попросил у Толи 5 яблок, но он отдал Гене 2.<br><br>Затем Дима дал Пете $N$ яблок, а Васе $M$.<br><br>Так у кого в итоге яблок больше — у Пети или Васи?\n",
- "### **Формат ввода**\n",
- "В первой строке записано натуральное число $N$.<br>Во второй — $M$.\n",
- "### **Формат вывода**\n",
- "РРјСЏ ребёнка, Сѓ которого больше яблок.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>5|Вася<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>2|Петя<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "p, v = 7, 6\n",
- "p -= 1\n",
- "v += 3\n",
- "v += 3\n",
- "\n",
- "n, m = int(input()), int(input())\n",
- "\n",
- "p += n\n",
- "v += m\n",
- "if p > v:\n",
- " print(\"Петя\")\n",
- "else:\n",
- " print(\"Вася\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Сила прокрастинации**\n",
- "Вася любит полениться. Особенно ему нравится, когда в году появляется такой лишний денёк, которого обычно не бывает. Напишите программу, которая поможет Васе определить, удастся ли ему побездельничать в определённом году или нет.<br><br>Одно число — год.<br><br>Одно слово «YES» (удастся) или «NO» (не удастся).\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2022|NO|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2020|YES|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "year = int(input())\n",
- "if year % 400 == 0:\n",
- " print(\"YES\")\n",
- "else:\n",
- " if year % 100 == 0:\n",
- " print(\"NO\")\n",
- " else:\n",
- " if year % 4 == 0:\n",
- " print(\"YES\")\n",
- " else:\n",
- " print(\"NO\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **А роза упала на лапу Азора**\n",
- "Существуют такое интересное понятие как палиндром — число, слово, предложение и так далее, которое и слева-направо, и справа-налево читается одинаково.<br><br>Напишите программу, которая проверяет, является ли число палиндромом.\n",
- "### **Формат ввода**\n",
- "Одно четырёхзначное число\n",
- "### **Формат вывода**\n",
- "YES если число является палиндромом, иначе — NO.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1234|NO|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2332|YES|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "if s == s[::-1]:\n",
- " print(\"YES\")\n",
- "else:\n",
- " print(\"NO\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Зайка — 1**\n",
- "В долгой дороге дети могут капризничать, поэтому родители их развлекают с помощью игр. Одна из них — поиск различных зверушек в придорожной растительности.<br><br>Давайте немного поиграем и выясним, не спрятался ли зайка во введённом предложении.\n",
- "### **Формат ввода**\n",
- "Строка описывающая придорожную местность.\n",
- "### **Формат вывода**\n",
- "YES — если в этой местности есть зайка, иначе — NO.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|березка елочка зайка волк березка|YES|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|сосна сосна сосна елочка грибочки медведь|NO|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "if \"зайка\" in s:\n",
- " print(\"YES\")\n",
- "else:\n",
- " print(\"NO\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Первому игроку приготовиться**\n",
- "Во многих играх порядок определяется броском кубика или монетки, — а в нашей первым ходит тот, чьё имя лексикографически меньше.<br><br>Определите, кто из игроков будет ходить первым.\n",
- "### **Формат ввода**\n",
- "Три имени игроков, каждое из которых записано с новой строки.\n",
- "### **Формат вывода**\n",
- "РРјСЏ РёРіСЂРѕРєР°, который будет ходить первым.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Вова<br>Аня<br>Боря|Аня<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Толя<br>Коля<br>Вася|Вася<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "arr = []\n",
- "\n",
- "for _ in range(3):\n",
- " arr.append(input())\n",
- "\n",
- "arr.sort()\n",
- "print(arr[0])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Лучшая защита — шифрование**\n",
- "Коля испугался, что Аня подсмотрит все его пароли в блокноте, и решил их зашифровать. Для этого он берёт изначальный пароль — трёхзначное число — и по нему строит новое число по следующим правилам:<br>\n",
- "* находится сумма цифр, стоящих в двух младших разрядах (десятки и единицы);\n",
- "* находится сумма цифр, стоящих в двух старших разрядах (сотни и десятки)\n",
- "* Рти РґРІРµ СЃСѓРјРјС‹, записанные РґСЂСѓРі Р·Р° РґСЂСѓРіРѕРј, РІ РїРѕСЂСЏРґРєРµ РЅРµ возрастания, формируют РЅРѕРІРѕРµ число.\n",
- "\n",
- "Помогите реализовать алгоритм шифрования.\n",
- "### **Формат ввода**\n",
- "Одно трёхзначное число\n",
- "### **Формат вывода**\n",
- "Результат шифрования\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|123|53|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|741|115|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "\n",
- "s1 = ((n % 100) // 10) + (n % 10)\n",
- "s2 = (n // 100) + ((n % 100) // 10)\n",
- "\n",
- "print(max(s1, s2), min(s1, s2), sep=\"\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Красота спасёт мир**\n",
- "Одно из древних поверий гласит, что трёхзначное число красиво, если сумма его минимальной и максимальной цифр равна оставшейся цифре умноженной на 2.<br><br>Напишите систему определяющую красоту числа.\n",
- "### **Формат ввода**\n",
- "Одно трёхзначное число\n",
- "### **Формат вывода**\n",
- "YES — если число красивое, иначе — NO\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|123|YES|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|748|NO|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "arr = [int(i) for i in input()]\n",
- "arr.sort()\n",
- "if arr[0] + arr[2] == arr[1] * 2:\n",
- " print(\"YES\")\n",
- "else:\n",
- " print(\"NO\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Музыкальный инструмент**\n",
- "Есть много музыкальных инструментов, но Вася обожает треугольник.<br><br>У него завалялось немного алюминиевых трубочек разной длины, и он задаётся вопросом, а можно ли из них сделать любимый музыкальный инструмент.\n",
- "### **Формат ввода**\n",
- "Три числа — длины трубочек, каждое с новой строки.\n",
- "### **Формат вывода**\n",
- "YES — если Васе удастся создать музыкальный треугольник, иначе — NO\n",
- "### **Примечание**\n",
- "Обратите внимание, что в треугольнике любая сторона меньше суммы двух других.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>3<br>3|YES<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1<br>2<br>3|NO<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "arr = [int(input()) for _ in range(3)]\n",
- "\n",
- "summ = sum(arr)\n",
- "\n",
- "f = True\n",
- "\n",
- "for i in arr:\n",
- " if i >= summ - i:\n",
- " f = False\n",
- "\n",
- "if f:\n",
- " print(\"YES\")\n",
- "else:\n",
- " print(\"NO\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Властелин Чисел: Братство общей цифры**\n",
- "Во времена магии и драконов существовало мнение, что числа обладают великой силой, способной изменить мир.<br><br>Всё началось с написания великих чисел. Три числа были переданы эльфам. Семь — отданы повелителям гномов. А девять... были переданы человеческому роду.<br><br>Но все они оказались обмануты, потому что существовало ещё одно число. В стране Нумия на бумаге из тёмного папируса властелин Зерон тайно написал Единую Цифру, подчиняющую себе все великие числа.<br><br>Давайте выясним, что это за цифра.\n",
- "### **Формат ввода**\n",
- "В первой строке записано двузначное число одного из эльфов.<br>Во второй строке — Гномов.<br>В третьей — Людей.\n",
- "### **Формат вывода**\n",
- "Одна цифра — общая у всех трёх чисел в одинаковой позиции\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|12<br>13<br>14|1<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|23<br>13<br>63|3<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "arr = [input() for _ in range(3)]\n",
- "\n",
- "for i in arr[0]:\n",
- " if i in arr[1] and i in arr[2]:\n",
- " print(i)\n",
- " break"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Властелин Чисел: Две Башни**\n",
- "Во времена, когда люди верили в великую силу чисел, оказалось, что волшебник Пифуман предал все народы и стал помогать Зерону.<br><br>Чтобы посетить башни обоих злодеев одновременно, нам следует разделить магию числа, которое защищало нас в дороге.<br><br>Чтобы поделить трёхзначное число, нам нужно составить из него минимально и максимально возможные двухзначные числа.\n",
- "### **Формат ввода**\n",
- "Одно трёхзначное число.\n",
- "### **Формат вывода**\n",
- "Два защитных числа для каждого отряда, записанные через пробел.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|103|10 31|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|787|77 87|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "num = input()\n",
- "arr = []\n",
- "arrtest = [num[0] + num[1], num[1] + num[0], num[1] + num[2], num[2] + num[1], num[0] + num[2], num[2] + num[0]]\n",
- "for i in arrtest:\n",
- " if int(i) >= 10:\n",
- " arr.append(int(i))\n",
- "print(min(arr), max(arr))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Властелин Чисел: Возвращение Цезаря**\n",
- "До победы над злом остался один шаг — разрушить логово Зерона.<br><br>Для этого нужно создать трёхзначное магическое число, которое будет сильнее двух двухзначных защитных чисел Зерона.<br><br>Самый простой способ создать сильное число:<br>\n",
- "* первой взять максимальную цифру из всех защитных чисел;\n",
- "* последней — минимальную;\n",
- "* в середину поставить сумму оставшихся без учёта переноса разряда.\n",
- "\n",
- "Помогите одолеть зло.\n",
- "### **Формат ввода**\n",
- "В двух строках записаны защитные числа Зерона.\n",
- "### **Формат вывода**\n",
- "Одно трёхзначное число, которое приведёт к победе.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|31<br>11|321<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|49<br>17|911<br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b = input(), input()\n",
- "nums = [int(i) for i in sorted([a[0], a[1], b[0], b[1]])]\n",
- "\n",
- "print(f\"{nums[3]}{(nums[1] + nums[2]) % 10}{nums[0]}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Легенды велогонок возвращаются: кто быстрее?**\n",
- "В новом сезоне за первенство в велогонках вновь борются лучшие из лучших. Протяжённость заключительной трассы — 43872м, и все хотят знать, кто получит золотую медаль.<br><br>Нам известны средние скорости трёх претендентов на победу – Пети, Васи и Толи. Кто из них победит?\n",
- "### **Формат ввода**\n",
- "В первой строке записана средняя скорость Пети.<br>Во второй — Васи.<br>В третьей — Толи.\n",
- "### **Формат вывода**\n",
- "Красивый пьедестал (ширина ступеней 8 символов).\n",
- "### **Примечание**\n",
- "В данный момент визуализация тестов работает некорректно.<br>Ответ на первый тест:<br>\n",
- " Петя <br> Толя <br> Вася <br> II I III \n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|10<br>5<br>7<br> <br>| Петя <br> Толя <br> Вася <br> II I III <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5<br>7<br>10<br> <br>| Толя <br> Вася <br> Петя <br> II I III <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "names = (\"Петя\", \"Вася\", \"Толя\")\n",
- "speed = {int(input()): names[i] for i in range(3)}\n",
- "text = []\n",
- "speed_list = list(speed.keys())\n",
- "speed_sorted = sorted(speed_list)\n",
- "text = [\"\", \"\", \"\", \" II I III \"]\n",
- "text[0] = (10 * \" \" + speed[speed_sorted[2]] + \" \" * 10)\n",
- "text[1] = (2 * \" \" + speed[speed_sorted[1]] + \" \" * 18)\n",
- "text[2] = (18 * \" \" + speed[speed_sorted[0]] + \" \" * 2)\n",
- "\n",
- "print(*text, sep=\"\\n\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Корень зла**\n",
- "Не все любят математику, а кто-то даже считает её настоящим злом во плоти, хотя от неё никуда не деться. К примеру, Python изначально разрабатывался только для решения математических задач, поэтому давайте используем его, чтобы найти корни квадратного уравнения.\n",
- "### **Формат ввода**\n",
- "Вводится 3 вещественных числа $a$, $b$, $c$ — коэффициенты уравнения вида: $ax^2+bx+c=0$.\n",
- "### **Формат вывода**\n",
- "Если у уравнения нет решений — следует вывести «No solution».<br>Если корней конечное число — их нужно вывести через пробел в порядке возрастания с точностью до сотых.<br>Если корней неограниченное число — следует вывести «Infinite solutions».\n",
- "### **Примечание**\n",
- "Обратите внимание, что ограничения на значения коэффициентов отсутствуют.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1<br>-2<br>1|1.00<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3.5<br>-2.4<br>-7.3|-1.14 1.83<br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b, c = [float(input()) for _ in range(3)]\n",
- "if a == b == c == 0:\n",
- " print(\"Infinite solutions\")\n",
- "elif a == b == 0:\n",
- " print(\"No solution\")\n",
- "elif a == 0:\n",
- " x = (-1 * c) / b\n",
- " \n",
- " print(\"%.2f\" % x) \n",
- "\n",
- "else:\n",
- " d = b ** 2 - 4 * a * c\n",
- " if d > 0:\n",
- " x1 = min((-1 * b + d ** 0.5) / (2 * a), (-1 * b - d ** 0.5) / (2 * a))\n",
- " x2 = max((-1 * b + d ** 0.5) / (2 * a), (-1 * b - d ** 0.5) / (2 * a))\n",
- "\n",
- " print(\"%.2f\" % x1, \"%.2f\" % x2)\n",
- "\n",
- " elif d == 0:\n",
- " x = (-1 * b) / (2 * a)\n",
- "\n",
- " print(\"%.2f\" % x) \n",
- " \n",
- " elif d < 0:\n",
- " print(\"No solution\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Территория зла**\n",
- "В давние времена считалось, что если какая-то местность является треугольником, то в ней заключено страшное зло.<br><br>При этом люди оценивали риск встретить зло по форме этого треугольника:<br>\n",
- "* в остроугольном треугольнике вероятность встретить зло крайне мала;\n",
- "* в тупоугольном — велика;\n",
- "* в прямоугольном — 100%.\n",
- "\n",
- "Напишите программу, которая по длине сторон треугольной местности, определяет вероятность встретить зло.\n",
- "### **Формат ввода**\n",
- "Три числа — длины сторон треугольной местности.\n",
- "### **Формат вывода**\n",
- "Вероятность встретить зло согласно поверью:<br>\n",
- "* крайне мала;\n",
- "* велика;\n",
- "* 100%.\n",
- "\n",
- "\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>5<br>4|100%<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|6<br>3<br>4|велика<br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "a, b, c = sorted([int(input()) for _ in range(3)])\n",
- "\n",
- "if (a ** 2 + b ** 2 == c ** 2):\n",
- " print(\"100%\")\n",
- "elif (a ** 2 + b ** 2 < c ** 2):\n",
- " print(\"велика\")\n",
- "else:\n",
- " print(\"крайне мала\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Автоматизация безопасности**\n",
- "Группа исследователей собирается высадиться на остров невероятно ровной формы, но разведка при помощи спутника выяснила, что на острове есть зона зыбучих песков.<br><br>Для повышения безопасности экспедиции было решено разработать систему оповещения, которая предупредит исследователей об опасности. А для снижения расходов на производство было решено заказать программное обеспечение.<br><br><br><br>Напишите программу, которая по координатам исследователя, будет сообщать о безопасности в этой точке.\n",
- "### **Формат ввода**\n",
- "Два рациональных числа — координаты исследователя.\n",
- "### **Формат вывода**\n",
- "Одно из сообщений:<br>\n",
- "Опасность! Покиньте зону как можно скорее!<br>Зона безопасна. Продолжайте работу.<br>Вы вышли в море и рискуете быть съеденным акулой!\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3.5<br>-3.2|Опасность! Покиньте зону как можно скорее!<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|-5.2<br>3.4|Зона безопасна. Продолжайте работу.<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "x, y = float(input()), float(input())\n",
- "\n",
- "if x ** 2 + y ** 2 > 100:\n",
- " print(\"Вы вышли в море и рискуете быть съеденным акулой!\")\n",
- "else:\n",
- " if x >= 0 and y >= 0:\n",
- " if x ** 2 + y ** 2 <= 25:\n",
- " print(\"Опасность! Покиньте зону как можно скорее!\")\n",
- " else:\n",
- " print(\"Зона безопасна. Продолжайте работу.\")\n",
- " elif x < 0 and y > 0:\n",
- " if y > 5:\n",
- " print(\"Зона безопасна. Продолжайте работу.\")\n",
- " else:\n",
- " if y > 5 / 3 * x + 35 / 3:\n",
- " print(\"Зона безопасна. Продолжайте работу.\")\n",
- " else:\n",
- " print(\"Опасность! Покиньте зону как можно скорее!\")\n",
- " elif y < 0:\n",
- " if y < 0.25 * x ** 2 + 0.5 * x - 8.75:\n",
- " print(\"Зона безопасна. Продолжайте работу.\")\n",
- " else:\n",
- " print(\"Опасность! Покиньте зону как можно скорее!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Зайка — 2**\n",
- "По пути домой родители вновь решили сыграть с детьми в поиск зверушек.\n",
- "### **Формат ввода**\n",
- "Три строки описывающих придорожную местность.\n",
- "### **Формат вывода**\n",
- "Строка в которой есть зайка, а затем её длина.<br>Если таких строк несколько, выбрать ту, что меньше всех лексикографически.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|березка елочка зайка волк березка<br>сосна сосна сосна елочка грибочки медведь<br>сосна сосна сосна белочка сосна белочка|березка елочка зайка волк березка 33<br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|зайка березка<br>березка зайка<br>березка елочка березка|березка зайка 13<br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "arr = sorted([input() for _ in range(3)])\n",
- "\n",
- "for s in arr:\n",
- " if \"зайка\" in s:\n",
- " print(s, len(s))\n",
- " break"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "name": "python",
- "version": "3.11.1"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/2.2/3.py b/2.2/3.py
deleted file mode 100644
index d58ee40ae5b9359d7b3b963fd71be089bfa0b253..0000000000000000000000000000000000000000
--- a/2.2/3.py
+++ /dev/null
@@ -1,8 +0,0 @@
-a, b, c = int(input()), int(input()), int(input())
-m = max(a, b, c)
-if a == m:
- print("Петя")
-elif b == m:
- print("Вася")
-elif c == m:
- print("Толя")
\ No newline at end of file
diff --git a/2.2/4.py b/2.2/4.py
deleted file mode 100644
index 895db49c55360fd6235872d722bbb86ad9ec5ec5..0000000000000000000000000000000000000000
--- a/2.2/4.py
+++ /dev/null
@@ -1,7 +0,0 @@
-a, b, c = int(input()), int(input()), int(input())
-names = ["Петя", "Вася", "Толя"]
-s_d = [a, b, c]
-cnt = 1
-for speed in sorted([a, b, c], reverse=True):
- print(f"{cnt}. {names[s_d.index(speed)]}")
- cnt += 1
\ No newline at end of file
diff --git a/2.2/5.py b/2.2/5.py
deleted file mode 100644
index c842cca1468d85ce714408647be53b3da854e93d..0000000000000000000000000000000000000000
--- a/2.2/5.py
+++ /dev/null
@@ -1,13 +0,0 @@
-p, v = 7, 6
-p -= 1
-v += 3
-v += 3
-
-n, m = int(input()), int(input())
-
-p += n
-v += m
-if p > v:
- print("Петя")
-else:
- print("Вася")
\ No newline at end of file
diff --git a/2.2/6.py b/2.2/6.py
deleted file mode 100644
index 5db988c29bec87f2024de7990433298209d17ac2..0000000000000000000000000000000000000000
--- a/2.2/6.py
+++ /dev/null
@@ -1,11 +0,0 @@
-year = int(input())
-if year % 400 == 0:
- print("YES")
-else:
- if year % 100 == 0:
- print("NO")
- else:
- if year % 4 == 0:
- print("YES")
- else:
- print("NO")
\ No newline at end of file
diff --git a/2.2/7.py b/2.2/7.py
deleted file mode 100644
index b26d5fbd88c25bf39ad3c1b329fb254834db49dd..0000000000000000000000000000000000000000
--- a/2.2/7.py
+++ /dev/null
@@ -1,5 +0,0 @@
-s = input()
-if s == s[::-1]:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/2.2/8.py b/2.2/8.py
deleted file mode 100644
index f397b24814ce32eaa7470c24bf34ab0aec6bccce..0000000000000000000000000000000000000000
--- a/2.2/8.py
+++ /dev/null
@@ -1,5 +0,0 @@
-s = input()
-if "зайка" in s:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/2.2/9.py b/2.2/9.py
deleted file mode 100644
index e3f01f1720c659f52e3cb4d9356020667194a22c..0000000000000000000000000000000000000000
--- a/2.2/9.py
+++ /dev/null
@@ -1,7 +0,0 @@
-arr = []
-
-for _ in range(3):
- arr.append(input())
-
-arr.sort()
-print(arr[0])
\ No newline at end of file
diff --git a/2.2/markdown-image.png b/2.2/markdown-image.png
deleted file mode 100644
index 248d7f7e855aeebcd067909b6b3feef35cfda651..0000000000000000000000000000000000000000
Binary files a/2.2/markdown-image.png and /dev/null differ
diff --git a/2.3/1.py b/2.3/1.py
deleted file mode 100644
index 552eeb45912577ec753908f2069c1a95474a115c..0000000000000000000000000000000000000000
--- a/2.3/1.py
+++ /dev/null
@@ -1,7 +0,0 @@
-s = input()
-
-while s != "РўСЂРё!":
- print("Режим ожидания...")
- s = input()
-
-print("Ёлочка, гори!")
\ No newline at end of file
diff --git a/2.3/10.py b/2.3/10.py
deleted file mode 100644
index ce144f17fb64d8f4bf66a295340615d9266f2e58..0000000000000000000000000000000000000000
--- a/2.3/10.py
+++ /dev/null
@@ -1,16 +0,0 @@
-x, y = 0, 0
-while True:
- s = input()
- if s == "РЎРўРћРџ":
- break
- elif s == "СЕВЕР":
- y += int(input())
- elif s == "ЮГ":
- y -= int(input())
- elif s == "Р—РђРџРђР”":
- x -= int(input())
- elif s == "Р’РћРЎРўРћРљ":
- x += int(input())
-
-print(y)
-print(x)
\ No newline at end of file
diff --git a/2.3/11.py b/2.3/11.py
deleted file mode 100644
index 6037db605fa69f150913ef39bbcc3cb1cbbfddc2..0000000000000000000000000000000000000000
--- a/2.3/11.py
+++ /dev/null
@@ -1 +0,0 @@
-print(sum([int(i) for i in input()]))
\ No newline at end of file
diff --git a/2.3/12.py b/2.3/12.py
deleted file mode 100644
index fe5db91af75a64014aef15acc3b88d4d1e4e0a5c..0000000000000000000000000000000000000000
--- a/2.3/12.py
+++ /dev/null
@@ -1 +0,0 @@
-print(max([int(i) for i in input()]))
\ No newline at end of file
diff --git a/2.3/13.py b/2.3/13.py
deleted file mode 100644
index 66dea0c3f9f4b09637d80e3217f9ec4fea6432e1..0000000000000000000000000000000000000000
--- a/2.3/13.py
+++ /dev/null
@@ -1 +0,0 @@
-print(sorted([input() for i in range(int(input()))])[0])
\ No newline at end of file
diff --git a/2.3/14.py b/2.3/14.py
deleted file mode 100644
index c3a0ba85f1be09f08243457b58be7f55a2d4bebc..0000000000000000000000000000000000000000
--- a/2.3/14.py
+++ /dev/null
@@ -1,11 +0,0 @@
-n = int(input())
-
-if n == 1 or n == 0 or n == -1:
- print("NO")
-else:
- for i in range(2, n // 2 + 1):
- if n % i == 0:
- print("NO")
- break
- else:
- print("YES")
\ No newline at end of file
diff --git a/2.3/15.py b/2.3/15.py
deleted file mode 100644
index 5da051dea362c4641274e5423f82cd68c3c90a12..0000000000000000000000000000000000000000
--- a/2.3/15.py
+++ /dev/null
@@ -1,8 +0,0 @@
-n = int(input())
-c = 0
-
-for _ in range(n):
- if "зайка" in input():
- c += 1
-
-print(c)
\ No newline at end of file
diff --git a/2.3/16.py b/2.3/16.py
deleted file mode 100644
index 9691da75359a6086c44422640a9837bc426e1072..0000000000000000000000000000000000000000
--- a/2.3/16.py
+++ /dev/null
@@ -1,6 +0,0 @@
-s = input()
-
-if s == s[::-1]:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/2.3/17.py b/2.3/17.py
deleted file mode 100644
index 0a3056f564eb284bf3d1d6c6769c11e184c0ed2a..0000000000000000000000000000000000000000
--- a/2.3/17.py
+++ /dev/null
@@ -1,9 +0,0 @@
-s = input()
-
-s1 = ""
-
-for i in s:
- if int(i) % 2 == 1:
- s1 += i
-
-print(s1)
\ No newline at end of file
diff --git a/2.3/18.py b/2.3/18.py
deleted file mode 100644
index 2c68dfdffd2b917024dd0ef3677a3f4ae56f0f83..0000000000000000000000000000000000000000
--- a/2.3/18.py
+++ /dev/null
@@ -1,17 +0,0 @@
-n = int(input())
-arr = []
-
-if n == 1:
- print(1)
-else:
- while True:
- for i in range(2, n // 2):
- if n % i == 0:
- arr.append(i)
- n //= i
- break
- else:
- arr.append(n)
- break
-
-print(*arr, sep=" * ")
\ No newline at end of file
diff --git a/2.3/19.py b/2.3/19.py
deleted file mode 100644
index 79a62aabd4b09d52fe4775f268ac2c35270dae7f..0000000000000000000000000000000000000000
--- a/2.3/19.py
+++ /dev/null
@@ -1,17 +0,0 @@
-n = 500
-print(n)
-s = input()
-maxnum, minnum = 1001, 0
-
-while s != "Угадал!":
-
- if s == "Больше":
- minnum = n
- n += (maxnum - n) // 2
-
- elif s == "Меньше":
- maxnum = n
- n -= (n - minnum) // 2
-
- print(n)
- s = input()
\ No newline at end of file
diff --git a/2.3/2.py b/2.3/2.py
deleted file mode 100644
index cbaf534cde19d8404cd469c5647f070c55ce6118..0000000000000000000000000000000000000000
--- a/2.3/2.py
+++ /dev/null
@@ -1,9 +0,0 @@
-s = input()
-c = 0
-
-while s != "Приехали!":
- if "зайка" in s:
- c += 1
- s = input()
-
-print(c)
\ No newline at end of file
diff --git a/2.3/20.py b/2.3/20.py
deleted file mode 100644
index 3945375aa460c111778fea8308c5edfe0fcbba31..0000000000000000000000000000000000000000
--- a/2.3/20.py
+++ /dev/null
@@ -1,16 +0,0 @@
-c = -1
-prev_h = 0
-
-for i in range(int(input())):
- b = int(input())
-
- h = b % 256
- r = (b // 256) % 256
- m = b // (256 ** 2)
-
- hs = (37 * (m + r + prev_h)) % 256
- prev_h = h
- if h > 99 or h != hs:
- c = i
- break
-print(c)
\ No newline at end of file
diff --git a/2.3/23.ipynb b/2.3/23.ipynb
deleted file mode 100644
index 2c3be9bcfcb0e42c53e679b7162ddea20b204b6f..0000000000000000000000000000000000000000
--- a/2.3/23.ipynb
+++ /dev/null
@@ -1,762 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Раз, два, три! Ёлочка, гори!**\n",
- "В детском саду проводят новогодний утренник. Со знанием чисел и их порядком у детей пока есть небольшие проблемы, но цифру три знают все без исключения.<br><br>Напишите программу, которая зажигает Ёлочку, когда все дети прокричат «Три!»\n",
- "### **Формат ввода**\n",
- "Вводятся крики детей.\n",
- "### **Формат вывода**\n",
- "Выводить «Режим ожидания...», пока дети не прокричат «Три!».<br>В конце вывести «Ёлочка, гори!»\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Раз!<br>Два!<br>Три!<br>|Режим ожидания...<br>Режим ожидания...<br>Ёлочка, гори!|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Десять!<br>Девять!<br>Раз!<br>Три!<br>|Режим ожидания...<br>Режим ожидания...<br>Режим ожидания...<br>Ёлочка, гори!|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "\n",
- "while s != \"РўСЂРё!\":\n",
- " print(\"Режим ожидания...\")\n",
- " s = input()\n",
- "\n",
- "print(\"Ёлочка, гори!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Зайка — 3**\n",
- "В задачнике ко второй лекции мы помогали детям искать зайца.<br>На этот раз мы будем искать и считать сразу нескольких зайчат.\n",
- "### **Формат ввода**\n",
- "Вводятся строки, описывающие придорожную местность.<br>В конце поездки вводится «Приехали!»\n",
- "### **Формат вывода**\n",
- "Количество строк, в которых есть зайка.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|березка елочка зайка волк березка<br>сосна сосна сосна елочка грибочки медведь<br>сосна сосна сосна белочка сосна белочка<br>Приехали!|1<br> <br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|зайка березка<br>березка зайка<br>березка елочка березка<br>Приехали!|2<br> <br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "c = 0\n",
- "\n",
- "while s != \"Приехали!\":\n",
- " if \"зайка\" in s:\n",
- " c += 1\n",
- " s = input()\n",
- "\n",
- "print(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Считалочка**\n",
- "Ребята в детском саду учат числа, и мы можем им в этом помочь.<br>Ребята дают нам два числа — начало и конец последовательности чисел.<br>Наша задача вывести все числа от начала до конца, заполнив промежуток между ними.\n",
- "### **Формат ввода**\n",
- "Два числа в порядке возрастания, каждое с новой строки.\n",
- "### **Формат вывода**\n",
- "Все числа от начала до конца (включительно), записанные через пробел.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1<br>10|1 2 3 4 5 6 7 8 9 10<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|-3<br>3|-3 -2 -1 0 1 2 3<br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "x1, x2 = int(input()), int(input())\n",
- "\n",
- "arr = []\n",
- "\n",
- "for i in range(x1, x2 + 1):\n",
- " arr.append(i)\n",
- "\n",
- "print(*arr)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Считалочка 2.0**\n",
- "Дети продолжают запоминать цифры, а мы им помогать.<br>Нам вновь называют начало и конец последовательности чисел, а мы выводим их и числа между.\n",
- "### **Формат ввода**\n",
- "Два числа, каждое с новой строки.\n",
- "### **Формат вывода**\n",
- "Все числа от начала до конца (включительно), записанные через пробел.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1<br>10|1 2 3 4 5 6 7 8 9 10<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>-3|3 2 1 0 -1 -2 -3<br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "x1, x2 = int(input()), int(input())\n",
- "\n",
- "arr = []\n",
- "\n",
- "if x1 < x2:\n",
- " for i in range(x1, x2 + 1):\n",
- " arr.append(i)\n",
- "else:\n",
- " for i in range(x1, x2 - 1, -1):\n",
- " arr.append(i)\n",
- "\n",
- "print(*arr)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Внимание! Акция!**\n",
- "В продуктовом магазине объявили акцию: «На все товары с ценой не менее 500 тугриков предоставляется скидка 10%».<br>Нас попросили разработать программное обеспечение кассового автомата, которое будет считать итоговую сумму покупки с учётом скидки.\n",
- "### **Формат ввода**\n",
- "Вводится некоторое количество рациональных чисел — стоимость товаров.<br>Список завершается значением 0.\n",
- "### **Формат вывода**\n",
- "Требуется вывести сумму всех товаров с учётом объявленной акции.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|100<br>500<br>333<br>0|883.0<br> <br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|512<br>499<br>342.50<br>0|1302.3<br> <br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = float(input())\n",
- "\n",
- "c = 0\n",
- "while n != 0:\n",
- " if n >= 500:\n",
- " c += 0.9 * n\n",
- " else:\n",
- " c += n\n",
- "\n",
- " n = float(input())\n",
- "\n",
- "print(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **РќРћР”**\n",
- "Р’ РѕРґРЅРѕРј РёР· местных РќРРчасто требуется находить наибольший общий делитель (РќРћР”) РґРІСѓС… чисел.<br>Вам уже доверяют, как РѕРґРЅРѕРјСѓ РёР· лучших «автоматизаторов» РІ РѕРєСЂСѓРіРµ, так что руководство РќРРрешило заказать РџРћ Сѓ вас.\n",
- "### **Формат ввода**\n",
- "Вводится два натуральных числа, каждое на своей строке.\n",
- "### **Формат вывода**\n",
- "Требуется вывести одно натуральное число — НОД двух данных чисел.\n",
- "### **Примечание**\n",
- "Самый распространенный способ поиска НОД — алгоритм Евклида.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|12<br>42|6<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|512<br>625|1<br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n1, n2 = int(input()), int(input())\n",
- "\n",
- "for i in range(min(n1, n2), 0, -1):\n",
- " if n2 % i == 0 and n1 % i == 0:\n",
- " print(i)\n",
- " break"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **РќРћРљ**\n",
- "Спустя время РќРРпотребовалось находить наименьшее общее кратное (РќРћРљ) РґРІСѓС… чисел. Рљ нам РІРЅРѕРІСЊ обратились Р·Р° помощью.\n",
- "### **Формат ввода**\n",
- "Вводится два натуральных числа, каждое на своей строке.\n",
- "### **Формат вывода**\n",
- "Требуется вывести одно натуральное число — НОК двух данных чисел.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|12<br>42|84<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|512<br>625|320000<br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n1, n2 = int(input()), int(input())\n",
- "\n",
- "com = 0\n",
- "\n",
- "for i in range(min(n1, n2), 0, -1):\n",
- " if n2 % i == 0 and n1 % i == 0:\n",
- " com = i\n",
- " break\n",
- "\n",
- "print((n1 // com) * (n2 // com) * com)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Рзлишняя автоматизация 2.0**\n",
- "А что будет, если вновь, как в первой главе, объединить два принципа — повторение и автоматизацию?\n",
- "### **Формат ввода**\n",
- "В первой строке записана весьма полезная информация. Во второй натуральное число $N$ — количество раз, которое её нужно повторить, чтобы она закрепилась.\n",
- "### **Формат вывода**\n",
- "N раз повторенная весьма полезная информация.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|2 + 2 = 4<br>3<br> <br>|2 + 2 = 4<br>2 + 2 = 4<br>2 + 2 = 4<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|Нельзя нажимать неизвестные кнопки!<br>4<br> <br> <br>|Нельзя нажимать неизвестные кнопки!<br>Нельзя нажимать неизвестные кнопки!<br>Нельзя нажимать неизвестные кнопки!<br>Нельзя нажимать неизвестные кнопки!<br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s, n = input(), int(input())\n",
- "\n",
- "for _ in range(n):\n",
- " print(s)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Факториал**\n",
- "Учёным срочно нужно ПО, которое находит факториал числа.\n",
- "### **Формат ввода**\n",
- "Вводится одно неотрицательное число.\n",
- "### **Формат вывода**\n",
- "Требуется вывести одно натуральное число — факториал заданного числа.<br><br>Примечания<br>Факториал нуля принят равным 1.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3|6|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5|120|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "\n",
- "o = 1\n",
- "\n",
- "for i in range(2, n + 1):\n",
- " o *= i\n",
- "\n",
- "print(o)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Маршрут построен**\n",
- "Навигация была важна во все времена.<br>Нам достался архив маршрутов движения, но их оказалось так много, что без автоматизации мы с ними не справимся во век. Каждый маршрут представляет собой последовательность шагов в одном из четырех направлений:<br>\n",
- "* СЕВЕР;\n",
- "* Р’РћРЎРўРћРљ;\n",
- "* ЮГ;\n",
- "* Р—РђРџРђР”.\n",
- "\n",
- "Напишите программу, чтобы по заданному маршруту она определяла, в какой именно точке мы окажемся.<br>Для простоты будем считать, что в начале маршрута мы находимся в точке (0; 0).\n",
- "### **Формат ввода**\n",
- "Вводятся инструкции маршрута в виде:<br><количество шагов><br>Ввод завершается строкой СТОП.\n",
- "### **Формат вывода**\n",
- "Два целых числа — координаты конечной точки маршрута.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|СЕВЕР<br>2<br>ВОСТОК<br>2<br>СТОП|2<br>2<br> <br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|СЕВЕР<br>2<br>ЮГ<br>3<br>ЗАПАД<br>4<br>СТОП|-1<br>-4<br> <br> <br> <br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "x, y = 0, 0\n",
- "while True:\n",
- " s = input()\n",
- " if s == \"РЎРўРћРџ\":\n",
- " break\n",
- " elif s == \"СЕВЕР\":\n",
- " y += int(input())\n",
- " elif s == \"ЮГ\":\n",
- " y -= int(input())\n",
- " elif s == \"Р—РђРџРђР”\":\n",
- " x -= int(input())\n",
- " elif s == \"Р’РћРЎРўРћРљ\":\n",
- " x += int(input())\n",
- "\n",
- "print(y)\n",
- "print(x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Цифровая сумма**\n",
- "РРЅРѕРіРґР° требуется манипулировать СЃ цифрами чисел.<br>РћРґРЅРѕ РёР· самых простых действий, которое можно совершить — найти СЃСѓРјРјСѓ цифр числа. Напишите программу, чтобы выполнить это действие.\n",
- "### **Формат ввода**\n",
- "Вводится одно натуральное число.\n",
- "### **Формат вывода**\n",
- "Требуется вывести одно натуральное число — сумму цифр исходного.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|12345|15|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|100500|6|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(sum([int(i) for i in input()]))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Сильная цифра**\n",
- "Давайте попробуем выполнить ещё одно простое действие — найдём максимальную цифру числа.\n",
- "### **Формат ввода**\n",
- "Вводится одно натуральное число.\n",
- "### **Формат вывода**\n",
- "Требуется вывести одно натуральное число — максимальную цифру исходного.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|12345|5|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|100500|5|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(max([int(i) for i in input()]))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Первому игроку приготовиться 2.0**\n",
- "Во многих играх порядок ходов определяется броском кубика или монетки, а в нашей первым ходит тот, чье имя лексикографически меньше. Определите, кто из игроков будет ходить первым.\n",
- "### **Формат ввода**\n",
- "В первой строке записано одно натуральное число $N$ — количество игроков.<br>В каждой из последующих $N$ строк указано одно имя игрока.\n",
- "### **Формат вывода**\n",
- "РРјСЏ РёРіСЂРѕРєР°, который будет ходить первым.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>Вова<br>Аня<br>Боря|Аня<br> <br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|4<br>Толя<br>Коля<br>Вася<br>Юля|Вася<br> <br> <br> <br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(sorted([input() for i in range(int(input()))])[0])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Простая задача**\n",
- "РћРґРёРЅ РёР· самых интересных РІРёРґРѕРІ чисел РІ математике — простые числа. РС… объединяет то, что делятся РѕРЅРё лишь РЅР° 1 Рё само себя. До СЃРёС… РїРѕСЂ РёС… изучают учёные РїРѕ всему РјРёСЂСѓ. Также РѕРЅРё применяются РІ вычислительной технике: СЃ РёС… помощью можно писать алгоритмы, чтобы шифровать данные. Давайте напишем программу, чтобы определять — простое перед нами число или нет.\n",
- "### **Формат ввода**\n",
- "Вводится одно натуральное число.\n",
- "### **Формат вывода**\n",
- "Требуется вывести сообщение YES если число простое, иначе — NO.\n",
- "### **Примечание**\n",
- "Простым называется число, которое имеет ровно два делителя.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1|NO|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|67|YES|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "\n",
- "if n == 1 or n == 0 or n == -1:\n",
- " print(\"NO\")\n",
- "else:\n",
- " for i in range(2, n // 2 + 1):\n",
- " if n % i == 0:\n",
- " print(\"NO\")\n",
- " break\n",
- " else:\n",
- " print(\"YES\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Зайка - 4**\n",
- "Давайте вновь поиграем с детьми и поможем им найти заек.\n",
- "### **Формат ввода**\n",
- "В первой строке записано натуральное число $N$ — количество выделенных придорожных местностей. В каждой из $N$ последующих строках — описание придорожной местности.\n",
- "### **Формат вывода**\n",
- "Количество строк, в которых есть зайка.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|3<br>березка елочка зайка волк березка<br>сосна сосна сосна елочка грибочки медведь<br>сосна сосна сосна белочка сосна белочка|1<br> <br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|4<br>зайка березка<br>березка зайка<br>березка елочка березка<br>елочка елочка елочка|2<br> <br> <br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "c = 0\n",
- "\n",
- "for _ in range(n):\n",
- " if \"зайка\" in input():\n",
- " c += 1\n",
- "\n",
- "print(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **А роза упала на лапу Азора 2.0**\n",
- "Вспомним о палиндромах, которые в обоих направлениях читаются одинаково. Напишите программу, которая проверяет, является ли число палиндромом.\n",
- "### **Формат ввода**\n",
- "Одно натуральное число.\n",
- "### **Формат вывода**\n",
- "YES — если число является палиндромом, иначе — NO.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1234|NO|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|123454321|YES|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "\n",
- "if s == s[::-1]:\n",
- " print(\"YES\")\n",
- "else:\n",
- " print(\"NO\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Чётная чистота**\n",
- "Мы уже достаточно знатоки, чтобы очистить число от определённых цифр, поэтому давайте напишем программу, которая уберёт все чётные цифры из числа.\n",
- "### **Формат ввода**\n",
- "Одно натуральное число.\n",
- "### **Формат вывода**\n",
- "Одно натуральное число — результат очистки.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|1234|13|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|123454321|13531|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s = input()\n",
- "\n",
- "s1 = \"\"\n",
- "\n",
- "for i in s:\n",
- " if int(i) % 2 == 1:\n",
- " s1 += i\n",
- "\n",
- "print(s1)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Простая задача 2.0**\n",
- "В банке решили переписать программу для шифрования данных и попросили, чтобы вы взяли на себя часть данной задачи. Напишите программу для разложения числа на простые множители. Только внимательно, ведь работать придётся вновь с простыми числами.\n",
- "### **Формат ввода**\n",
- "Вводится одно натуральное число.\n",
- "### **Формат вывода**\n",
- "Требуется составить математическое выражение — произведение простых неубывающих чисел, которое в результате даёт исходное.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|120|2 * 2 * 2 * 3 * 5|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|98|2 * 7 * 7|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = int(input())\n",
- "arr = []\n",
- "\n",
- "if n == 1:\n",
- " print(1)\n",
- "else:\n",
- " while True:\n",
- " for i in range(2, n // 2):\n",
- " if n % i == 0:\n",
- " arr.append(i)\n",
- " n //= i\n",
- " break\n",
- " else:\n",
- " arr.append(n)\n",
- " break\n",
- " \n",
- "print(*arr, sep=\" * \")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **РРіСЂР° РІ «Угадайку»**\n",
- "На каждую попытку пользователь отвечает одной из фраз:<br>\n",
- "* Больше;\n",
- "* Меньше;\n",
- "* Угадал!\n",
- "* Данная задача проверяется интерактивно. Другими словами, пока вы не выведите своё число, система не предоставит вам данных.\n",
- "\n",
- "\n",
- "### **Пример**\n",
- "Предположим, что было загадано число 123<br><br>Диалог вашей программы с пользователем/системой должен выглядеть так:<br><br>500<br>Меньше<br>250<br>Меньше<br>125<br>Меньше<br>63<br>Больше<br>94<br>Больше<br>109<br>Больше<br>117<br>Больше<br>121\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "n = 500\n",
- "print(n)\n",
- "s = input()\n",
- "maxnum, minnum = 1001, 0\n",
- "\n",
- "while s != \"Угадал!\":\n",
- "\n",
- " if s == \"Больше\":\n",
- " minnum = n\n",
- " n += (maxnum - n) // 2\n",
- "\n",
- " elif s == \"Меньше\":\n",
- " maxnum = n\n",
- " n -= (n - minnum) // 2\n",
- "\n",
- " print(n)\n",
- " s = input()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Хайпанём немножечко!**\n",
- "Блокчейн (blockchain) переводится как «цепочка блоков». Рто СЃРїРѕСЃРѕР± хранения данных, защищённый РѕС‚ подделки. РћРЅ лежит, например, РІ РѕСЃРЅРѕРІРµ криптовалюты биткоин.<br><br>Блокчейн — это действительно последовательность блоков, Р° РІ каждом блоке находится некоторая полезная информация. Так последовательность биткоина — СЃРїРёСЃРѕРє транзакций Р·Р° определённый период времени: кто, РєРѕРјСѓ, РєРѕРіРґР° Рё сколько денег передал. Ртот СЃРїРёСЃРѕРє снабжён случайным числом Рё некоторыми служебными данными, РІ том числе хэшем — числом, которое РїРѕ определённой формуле зависит РѕС‚ остальной части блока Рё хэша предыдущего блока.<br><br>РҐСЌС€ должен быть меньше определённого числа. РџСЂРё этом формула, РїРѕ которой вычисляется С…СЌС€, устроена так, что невозможно получить достаточно маленький С…СЌС€ иначе, чем перебирая различные значения случайного числа. Поэтому если злоумышленник решит подделать блокчейн — например, вставить РІ его середину блок СЃ записью Рѕ том, что РІСЃРµ люди передали ему РІСЃРµ СЃРІРѕРё деньги, — то столкнётся СЃ проблемой. Ему придётся подобрать РЅРѕРІРѕРµ случайное число РЅРµ только РІ поддельном блоке, РЅРѕ Рё РІРѕ всех последующих, ведь С…СЌС€ каждого следующего блока зависит РѕС‚ хэша предыдущего.<br><br>Рто требует невероятно больших вычислительных мощностей, поэтому блокчейн РІ целом защищён РѕС‚ подобных атак.<br><br>Напишите программу, которая РїСЂРѕРІРѕРґРёС‚ проверку правильности хэшей РІ модельном блокчейне СЃ простой С…СЌС€-функцией. Блок $b_n$ СЃ номером n включает полезную информацию $m_n$ , представленную натуральным числом, $r_n$ — случайное число РѕС‚ 0 РґРѕ 255 Рё $h_n$ — С…СЌС€ (целое число РѕС‚ 0 РґРѕ 255). РЈ каждого блока С…СЌС€ вычисляется РїРѕ формуле $h_n=<37*(m_n+r_n+h_{nв€’1} )$ (РїРѕ модулю 256), РїСЂРё вычислении хэша начального блока $h_0$ вместо хэша предыдущего блока берётся ноль. РџСЂРё этом каждый блок представлен РѕРґРЅРёРј числом $b_n=h_n+r_n*256+m_n*256^2$ . Также требуется, чтобы С…СЌС€ $h_n$ был меньше 100.\n",
- "### **Формат ввода**\n",
- "На первой строке вводится натуральное число $N$ — количество блоков. Далее следуют $N$ чисел $b_n$ , каждое на отдельной строке.\n",
- "### **Формат вывода**\n",
- "Следует вывести номер первого блока, у которого неправильный хэш (не меньше 100 или не совпадает с вычисленным по указанной в условии формуле), или -1, если все хэши в блокчейне правильные. Нумерация блоков идёт с нуля, так что они имеют номера от 0 до N-1.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5<br>6122802<br>14406496<br>15230209<br>2541121<br>1758741|-1<br> <br> <br> <br> <br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|5<br>1865535<br>13479687<br>16689153<br>1839958<br>5214020|3<br> <br> <br> <br> <br> <br>|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "c = -1\n",
- "prev_h = 0\n",
- "\n",
- "for i in range(int(input())):\n",
- " b = int(input())\n",
- "\n",
- " h = b % 256\n",
- " r = (b // 256) % 256\n",
- " m = b // (256 ** 2)\n",
- "\n",
- " hs = (37 * (m + r + prev_h)) % 256\n",
- " prev_h = h\n",
- " if h > 99 or h != hs:\n",
- " c = i\n",
- " break\n",
- "print(c)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "name": "python",
- "version": "3.11.1"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/2.3/3.py b/2.3/3.py
deleted file mode 100644
index 2820b2857c5540758e2b08e4dd80eb831d1df208..0000000000000000000000000000000000000000
--- a/2.3/3.py
+++ /dev/null
@@ -1,8 +0,0 @@
-x1, x2 = int(input()), int(input())
-
-arr = []
-
-for i in range(x1, x2 + 1):
- arr.append(i)
-
-print(*arr)
\ No newline at end of file
diff --git a/2.3/4.py b/2.3/4.py
deleted file mode 100644
index 8827b5d7df092d98b0a2a1fb928c4f044e8fe927..0000000000000000000000000000000000000000
--- a/2.3/4.py
+++ /dev/null
@@ -1,12 +0,0 @@
-x1, x2 = int(input()), int(input())
-
-arr = []
-
-if x1 < x2:
- for i in range(x1, x2 + 1):
- arr.append(i)
-else:
- for i in range(x1, x2 - 1, -1):
- arr.append(i)
-
-print(*arr)
\ No newline at end of file
diff --git a/2.3/5.py b/2.3/5.py
deleted file mode 100644
index aa8f8e6a10c8f5224f2e6ddbd4343fb52d6de8b9..0000000000000000000000000000000000000000
--- a/2.3/5.py
+++ /dev/null
@@ -1,12 +0,0 @@
-n = float(input())
-
-c = 0
-while n != 0:
- if n >= 500:
- c += 0.9 * n
- else:
- c += n
-
- n = float(input())
-
-print(c)
\ No newline at end of file
diff --git a/2.3/6.py b/2.3/6.py
deleted file mode 100644
index d06e719ef599bf4057246f4a5486eee92dcf9d1c..0000000000000000000000000000000000000000
--- a/2.3/6.py
+++ /dev/null
@@ -1,6 +0,0 @@
-n1, n2 = int(input()), int(input())
-
-for i in range(min(n1, n2), 0, -1):
- if n2 % i == 0 and n1 % i == 0:
- print(i)
- break
\ No newline at end of file
diff --git a/2.3/7.py b/2.3/7.py
deleted file mode 100644
index 33dc0e1115ed7bc676834f8037030919761e286f..0000000000000000000000000000000000000000
--- a/2.3/7.py
+++ /dev/null
@@ -1,10 +0,0 @@
-n1, n2 = int(input()), int(input())
-
-com = 0
-
-for i in range(min(n1, n2), 0, -1):
- if n2 % i == 0 and n1 % i == 0:
- com = i
- break
-
-print((n1 // com) * (n2 // com) * com)
\ No newline at end of file
diff --git a/2.3/8.py b/2.3/8.py
deleted file mode 100644
index 2fa957030fedf28b6ec5447758f773b34e8a3730..0000000000000000000000000000000000000000
--- a/2.3/8.py
+++ /dev/null
@@ -1,4 +0,0 @@
-s, n = input(), int(input())
-
-for _ in range(n):
- print(s)
\ No newline at end of file
diff --git a/2.3/9.py b/2.3/9.py
deleted file mode 100644
index 5e00683d06e94f8d31eacb2e5c6724fd949c3888..0000000000000000000000000000000000000000
--- a/2.3/9.py
+++ /dev/null
@@ -1,8 +0,0 @@
-n = int(input())
-
-o = 1
-
-for i in range(2, n + 1):
- o *= i
-
-print(o)
\ No newline at end of file
diff --git a/2.4/1.py b/2.4/1.py
deleted file mode 100644
index b0089c992a99864839cc2379973f935fab05e2da..0000000000000000000000000000000000000000
--- a/2.4/1.py
+++ /dev/null
@@ -1,13 +0,0 @@
-n = int(input())
-
-m = [[0] * n for i in range(n)]
-
-for i in range(n):
- m[0][i] = i + 1
-
-for i in range(1, n):
- for j in range(n):
- m[i][j] = (i + 1) * (j + 1)
-
-for arr in m:
- print(*arr)
\ No newline at end of file
diff --git a/2.4/10.py b/2.4/10.py
deleted file mode 100644
index d6c3593acd0130827b8250505b664dd96f23d9d9..0000000000000000000000000000000000000000
--- a/2.4/10.py
+++ /dev/null
@@ -1,14 +0,0 @@
-n = int(input())
-print("Рђ Р‘ Р’")
-
-arr = [1, 1, n - 2]
-print(*arr)
-
-for i in range(2, n - 1):
- arr = [1, i, n - 1 - i]
- print(*arr)
-
-for i in range(2, n - 1):
- for j in range(1, n - i):
- arr = [i, j, n - j - i]
- print(*arr)
\ No newline at end of file
diff --git a/2.4/11.py b/2.4/11.py
deleted file mode 100644
index eaece61ae4a99c9108c598d86f09b33329142919..0000000000000000000000000000000000000000
--- a/2.4/11.py
+++ /dev/null
@@ -1,16 +0,0 @@
-c = 0
-for _ in range(int(input())):
- n = int(input())
- f = False
- if n == 1 or n == 0 or n == -1:
- continue
- else:
- for i in range(2, n // 2 + 1):
- if n % i == 0:
- f = True
- break
- if f:
- continue
- c += 1
-
-print(c)
\ No newline at end of file
diff --git a/2.4/12.py b/2.4/12.py
deleted file mode 100644
index 9ea0b3d46d6b42599db2b31ce6526d42c6d17053..0000000000000000000000000000000000000000
--- a/2.4/12.py
+++ /dev/null
@@ -1,10 +0,0 @@
-a, b = int(input()), int(input())
-
-lenn = len(str(a * b))
-
-for i in range(1, a + 1):
- arr = []
- for j in range(1, b + 1):
- n = b * (i - 1) + j
- arr.append(" " * (lenn - len(str(n))) + str(n))
- print(*arr)
\ No newline at end of file
diff --git a/2.4/13.py b/2.4/13.py
deleted file mode 100644
index 9c46da8507a22a8477aa8bd104640f2609049908..0000000000000000000000000000000000000000
--- a/2.4/13.py
+++ /dev/null
@@ -1,10 +0,0 @@
-a, b = int(input()), int(input())
-
-lenn = len(str(a * b))
-
-for i in range(1, a + 1):
- arr = []
- for j in range(1, b + 1):
- n = a * (j - 1) + i
- arr.append(" " * (lenn - len(str(n))) + str(n))
- print(*arr)
\ No newline at end of file
diff --git a/2.4/14.py b/2.4/14.py
deleted file mode 100644
index 13923021ce01f1aca16c7f51c942bfe31e918e60..0000000000000000000000000000000000000000
--- a/2.4/14.py
+++ /dev/null
@@ -1,15 +0,0 @@
-a, b = int(input()), int(input())
-
-lenn = len(str(a * b))
-
-for i in range(1, a + 1):
- arr = []
- if i % 2 == 1:
- for j in range(1, b + 1):
- n = b * (i - 1) + j
- arr.append(" " * (lenn - len(str(n))) + str(n))
- else:
- for j in range(b, 0, -1):
- n = b * (i - 1) + j
- arr.append(" " * (lenn - len(str(n))) + str(n))
- print(*arr)
\ No newline at end of file
diff --git a/2.4/15.py b/2.4/15.py
deleted file mode 100644
index 370ae575fe5a32281290f2960ebaa5cf61ea9432..0000000000000000000000000000000000000000
--- a/2.4/15.py
+++ /dev/null
@@ -1,15 +0,0 @@
-a, b = int(input()), int(input())
-
-lenn = len(str(a * b))
-
-
-for i in range(1, a + 1):
- arr = []
- for j in range(1, b + 1):
- if j % 2 == 1:
- n = a * (j - 1) + i
- arr.append(" " * (lenn - len(str(n))) + str(n))
- else:
- n = a * (j) - (i - 1)
- arr.append(" " * (lenn - len(str(n))) + str(n))
- print(*arr)
\ No newline at end of file
diff --git a/2.4/16.py b/2.4/16.py
deleted file mode 100644
index 6626af9839cbe083e0018866375733ab7fe147ec..0000000000000000000000000000000000000000
--- a/2.4/16.py
+++ /dev/null
@@ -1,22 +0,0 @@
-n = int(input())
-ln = int(input())
-
-a = []
-for i in range(1, n + 1):
- if (ln - len(str(i))) % 2 == 0:
- a.append(" " * ((ln - len(str(i))) // 2) + str(i) + " " * ((ln - len(str(i))) // 2) + "|")
- if (ln - len(str(i))) % 2 == 1:
- a.append(" " * ((ln - len(str(i))) // 2) + str(i) + " " * ((ln - len(str(i))) // 2 + 1) + "|")
-a[-1] = a[-1][:-1]
-print(*a, sep="")
-
-for i in range(2, n + 1):
- a = []
- print("-" * ((ln * n) + (n - 1)))
- for j in range(1, n + 1):
- if (ln - len(str(i * j))) % 2 == 0:
- a.append(" " * ((ln - len(str(i * j))) // 2) + str(i * j) + " " * ((ln - len(str(i * j))) // 2) + "|")
- if (ln - len(str(i * j))) % 2 == 1:
- a.append(" " * ((ln - len(str(i * j))) // 2) + str(i * j) + " " * ((ln - len(str(i * j))) // 2 + 1) + "|")
- a[-1] = a[-1][:-1]
- print(*a, sep="")
\ No newline at end of file
diff --git a/2.4/17.py b/2.4/17.py
deleted file mode 100644
index 27801b0d6c707531322ef1052befc2e49e63786b..0000000000000000000000000000000000000000
--- a/2.4/17.py
+++ /dev/null
@@ -1,7 +0,0 @@
-c = 0
-for _ in range(int(input())):
- s = input()
- if s == s[::-1]:
- c += 1
-
-print(c)
\ No newline at end of file
diff --git a/2.4/18.py b/2.4/18.py
deleted file mode 100644
index c0a50c094c633b9258967c8b5b2719178793bb5b..0000000000000000000000000000000000000000
--- a/2.4/18.py
+++ /dev/null
@@ -1,25 +0,0 @@
-n = int(input())
-a, b = 1, 1
-arr = []
-
-while True:
- t = []
- f = False
- for _ in range(b):
- t.append(str(a))
-
- if a == n:
- f = True
- break
-
- a += 1
- arr.append(t)
- if f:
- break
-
- b += 1
-
-ln = len(" ".join(arr[-1]))
-
-for t in arr:
- print(f'{" ".join(t):^{ln}}')
\ No newline at end of file
diff --git a/2.4/19.py b/2.4/19.py
deleted file mode 100644
index 516188ecdf6040812451f11bede1648342876fdf..0000000000000000000000000000000000000000
--- a/2.4/19.py
+++ /dev/null
@@ -1,22 +0,0 @@
-n = int(input())
-
-matrix = [[None] * n for _ in range(n)]
-ln = len(str(n - n // 2))
-
-for i in range(n):
- for j in range(n):
-
- if i >= n // 2:
- a = n - i
- else:
- a = i + 1
-
- if j >= n // 2:
- b = n - j
- else:
- b = j + 1
-
- matrix[i][j] = " " * (ln - len(f"{min(a, b)}")) + f"{min(a, b)}"
-
-for a in matrix:
- print(*a)
\ No newline at end of file
diff --git a/2.4/2.py b/2.4/2.py
deleted file mode 100644
index 721a599532eb7c36c2e8987fe1c797f3eaff3803..0000000000000000000000000000000000000000
--- a/2.4/2.py
+++ /dev/null
@@ -1,5 +0,0 @@
-n = int(input())
-
-for i in range(n):
- for j in range(n):
- print(f"{(j + 1)} * {(i + 1)} = {(i + 1) * (j + 1)}")
\ No newline at end of file
diff --git a/2.4/20.py b/2.4/20.py
deleted file mode 100644
index a9e3b8de53643076442c2c81f29a599cc89e6d79..0000000000000000000000000000000000000000
--- a/2.4/20.py
+++ /dev/null
@@ -1,16 +0,0 @@
-n = int(input())
-m = 0
-m_b = 0
-
-for b in range(2, 11):
- s = ""
- num = n
- while num:
- s += str(num % b)
- num //= b
-
- if (res := sum([int(i) for i in s])) > m:
- m = res
- m_b = b
-
-print(m_b)
\ No newline at end of file
diff --git a/2.4/2024-10-24_02-02-14.png b/2.4/2024-10-24_02-02-14.png
deleted file mode 100644
index dfea455a366a06d4fc1a340d4a8ff77f8069cb6d..0000000000000000000000000000000000000000
Binary files a/2.4/2024-10-24_02-02-14.png and /dev/null differ
diff --git a/2.4/24.ipynb b/2.4/24.ipynb
deleted file mode 100644
index 952c425f0a1a8ab9255424496ca5a68bca4bc7c2..0000000000000000000000000000000000000000
--- a/2.4/24.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells":[{"cell_type":"markdown","metadata":{},"source":["## **Таблица умножения**\n","Местная фабрика канцелярских товаров заказала Сѓ вас программу, которая генерирует таблицы умножения.<br>Давайте поддержим локального производителя!\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅРѕ натуральное число — требуемый размер таблицы.\n","### **Формат вывода**\n","Таблица умножения заданного размера.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br> <br> <br>|1 2 3<br>2 4 6<br>3 6 9<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br> <br> <br> <br> <br>|1 2 3 4 5<br>2 4 6 8 10<br>3 6 9 12 15<br>4 8 12 16 20<br>5 10 15 20 25<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","\n","m = [[0] * n for i in range(n)]\n","\n","for i in range(n):\n"," m[0][i] = i + 1\n","\n","for i in range(1, n):\n"," for j in range(n):\n"," m[i][j] = (i + 1) * (j + 1)\n","\n","for arr in m:\n"," print(*arr)"]},{"cell_type":"markdown","metadata":{},"source":["## **РќРµ таблица умножения**\n","Фабрика вернулась СЃ РЅРѕРІРѕР№ задачкой — РґСЂСѓРіРёРј вариантом таблицы умножения. РћРЅР° нужна РІ РІРёРґРµ СЃРїРёСЃРєР°. Продолжим помогать местному бизнесу.\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅРѕ натуральное число — требуемый размер «таблицы».\n","### **Формат вывода**\n","РќРµ таблица умножения заданного размера.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br> <br> <br> <br> <br> <br> <br> <br> <br>|1 * 1 = 1<br>2 * 1 = 2<br>3 * 1 = 3<br>1 * 2 = 2<br>2 * 2 = 4<br>3 * 2 = 6<br>1 * 3 = 3<br>2 * 3 = 6<br>3 * 3 = 9<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|1 * 1 = 1<br>2 * 1 = 2<br>3 * 1 = 3<br>4 * 1 = 4<br>5 * 1 = 5<br>1 * 2 = 2<br>2 * 2 = 4<br>3 * 2 = 6<br>4 * 2 = 8<br>5 * 2 = 10<br>1 * 3 = 3<br>2 * 3 = 6<br>3 * 3 = 9<br>4 * 3 = 12<br>5 * 3 = 15<br>1 * 4 = 4<br>2 * 4 = 8<br>3 * 4 = 12<br>4 * 4 = 16<br>5 * 4 = 20<br>1 * 5 = 5<br>2 * 5 = 10<br>3 * 5 = 15<br>4 * 5 = 20<br>5 * 5 = 25<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","\n","for i in range(n):\n"," for j in range(n):\n"," print(f\"{(j + 1)} * {(i + 1)} = {(i + 1) * (j + 1)}\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Новогоднее настроение**\n","Великий математик Виталий Евгеньевич каждый Новый РіРѕРґ РїСЂРѕРІРѕРґРёС‚ РЅР° работе. Коллеги всегда любили Рё ценили его, поэтому РІ этом РіРѕРґСѓ решили сделать ему СЃСЋСЂРїСЂРёР· — украсить кабинет учёного математическими ёлками. Помогите математикам Рё напишите программу, которая РїРѕ введённому числу строит математическую ёлку.\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅРѕ натуральное число — количество чисел РІ математической ёлке.\n","### **Формат вывода**\n","Требуемая РЅРѕРІРѕРіРѕРґРЅСЏСЏ ёлка.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|14<br> <br> <br> <br> <br>|1<br>2 3<br>4 5 6<br>7 8 9 10<br>11 12 13 14<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|6<br> <br> <br>|1<br>2 3<br>4 5 6<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","a = 1\n","b = 1\n","arr = []\n","\n","while True:\n"," f = False\n"," for _ in range(1, b + 1):\n"," arr.append(a)\n"," if a == n:\n"," print(*arr)\n"," f = True\n"," break\n"," a += 1\n"," \n"," if f:\n"," break\n","\n"," print(*arr)\n","\n"," arr = []\n"," b += 1"]},{"cell_type":"markdown","metadata":{},"source":["## **Суммарная СЃСѓРјРјР°**\n","Найти СЃСѓРјРјСѓ цифр числа РЅРµ так сложно, РЅРѕ что, если чисел несколько?<br>Напишите программу для выполнения этого действия.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке указано число $N$ Р’Рѕ всех последующих $N$ строках написано РїРѕ РѕРґРЅРѕРјСѓ числу.\n","### **Формат вывода**\n","Требуется вывести общую СЃСѓРјРјСѓ цифр всех введённых чисел (РєСЂРѕРјРµ $N$).\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br>1<br>2<br>3<br>4<br>5|15<br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>123<br>654<br>789|45<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["print(sum([sum([int(i) for i in input()]) for _ in range(int(input()))]))"]},{"cell_type":"markdown","metadata":{},"source":["## **Зайка — 5**\n","Р’ долгой РґРѕСЂРѕРіРµ дети РІРЅРѕРІСЊ заскучали, Рё родителям приходится РёС… развлекать РїРѕРёСЃРєРѕРј зверушек Р·Р° РѕРєРЅРѕРј. Давайте вместе СЃ РЅРёРјРё найдём заек.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке указано натуральное число $N$ — количество выделенных придорожных местностей. Р’ последующих строках записаны слова характеризующие выделенную местность.<br>Рнформация Рѕ каждой местности завершается словом «ВСЁ».\n","### **Формат вывода**\n","Количество местностей, РІ которых есть зайка.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>березка<br>елочка<br>зайка<br>волк<br>березка<br>Р’РЎРЃ<br>СЃРѕСЃРЅР°<br>СЃРѕСЃРЅР°<br>СЃРѕСЃРЅР°<br>елочка<br>грибочки<br>медведь<br>Р’РЎРЃ<br>СЃРѕСЃРЅР°<br>СЃРѕСЃРЅР°<br>СЃРѕСЃРЅР°<br>белочка<br>СЃРѕСЃРЅР°<br>белочка<br>Р’РЎРЃ|1<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>зайка<br>березка<br>Р’РЎРЃ<br>зайка<br>зайка<br>Р’РЎРЃ<br>березка<br>елочка<br>березка<br>Р’РЎРЃ<br>елочка<br>елочка<br>елочка<br>Р’РЎРЃ|2<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["c = 0\n","\n","for _ in range(int(input())):\n"," s = input()\n"," arr = []\n","\n"," while s != \"Р’РЎРЃ\":\n"," arr.append(s)\n"," s = input()\n","\n"," if \"зайка\" in arr:\n"," c += 1\n","\n","print(c)"]},{"cell_type":"markdown","metadata":{},"source":["## **РќРћР” 2.0**\n","Р’ РѕРґРЅРѕРј РёР· местных РќРРчасто требуется находить наибольший общий делитель (РќРћР”) нескольких чисел. Вам уже доверяют, так что РІРЅРѕРІСЊ пришли СЃ этой задачей.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано РѕРґРЅРѕ число $N$ — количество данных. Р’ каждой РёР· последующих $N$ строк записано РїРѕ РѕРґРЅРѕРјСѓ натуральному числу.\n","### **Формат вывода**\n","Требуется вывести РѕРґРЅРѕ натуральное число — РќРћР” всех данных чисел (РєСЂРѕРјРµ $N$).\n","### **Примечание**\n","Самый распространённый СЃРїРѕСЃРѕР± РїРѕРёСЃРєР° РќРћР” — Алгоритм Евклида.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br>12<br>42|6<br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>102<br>39<br>768|3<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = []\n","for _ in range(int(input())):\n"," arr.append(int(input()))\n"," if len(arr) <= 1:\n"," continue\n"," a, b = sorted(arr)\n","\n"," while a != b:\n"," b, a = a, b - a\n"," a, b = sorted([a, b])\n","\n"," arr = [a]\n","\n","print(arr[0])"]},{"cell_type":"markdown","metadata":{},"source":["## **РќР° старт! Внимание! Марш!**\n","РџРѕ правилам велогонки, после квалификации каждый гонщик стартует СЃ задержкой РЅР° секунду больше, чем Сѓ гонщика перед РЅРёРј.<br>Первый гонщик стартует РЅР° счёт 3. Напишите программу, которая сможет автоматизировать старт всех гонщиков, участвующих РІ велогонке.\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅРѕ натуральное число — количество участников велогонки.\n","### **Формат вывода**\n","Требуется вывести отсчёт.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 1!!!<br>До старта 4 секунд(С‹)<br>До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 2!!!<br>До старта 5 секунд(С‹)<br>До старта 4 секунд(С‹)<br>До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 3!!!<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 1!!!<br>До старта 4 секунд(С‹)<br>До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 2!!!<br>До старта 5 секунд(С‹)<br>До старта 4 секунд(С‹)<br>До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 3!!!<br>До старта 6 секунд(С‹)<br>До старта 5 секунд(С‹)<br>До старта 4 секунд(С‹)<br>До старта 3 секунд(С‹)<br>До старта 2 секунд(С‹)<br>До старта 1 секунд(С‹)<br>Старт 4!!!<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["for i in range(int(input())):\n"," for j in range(3 + i, 0, -1):\n"," print(f\"До старта {j} секунд(С‹)\")\n"," print(f\"Старт {i + 1}!!!\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Максимальная СЃСѓРјРјР°**\n","Ребята РІ детском саду СЃРЅРѕРІР° играют СЃ числами. Рпусть числа РѕРЅРё знают плохо, придумывать РёС… РѕРЅРё очень любят.<br>РћРЅРё договорились, что Р±СѓРґСѓС‚ называть числа РїРѕ очереди Рё тот, кто назовёт число СЃ наибольшей СЃСѓРјРјРѕР№ цифр, будет считаться победителем. Р’ качестве СЃСѓРґСЊРё РѕРЅРё выбрали бедную воспитательницу, Рё РѕРЅР° попросила нас Рѕ помощи. Напишите программу, которая определит победителя.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ — количество детей РІ РіСЂСѓРїРїРµ. Далее вводятся РёРјСЏ ребенка Рё его число (каждое РЅР° своей строке).\n","### **Формат вывода**\n","Требуется вывести РёРјСЏ победителя.<br>Если РґРІР° ребенка назвали числа СЃ одинаковой СЃСѓРјРјРѕР№ цифр, победителем должен быть признан тот, кто С…РѕРґРёР» позже.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br>РђРЅСЏ<br>123<br>Боря<br>234|Боря<br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>РђРЅСЏ<br>1234<br>Боря<br>234<br>Ваня<br>2323|Ваня<br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arrs, arrn = [], []\n","for _ in range(int(input())):\n"," arrs.append(input())\n"," arrn.append(sum([int(i) for i in input()]))\n","\n","print(arrs[len(arrs) - 1 - (arrn[::-1].index(max(arrn)))])"]},{"cell_type":"markdown","metadata":{},"source":["## **Большое число**\n","Дети никак РЅРµ успокоятся Рё продолжают «мучить» числа. Сейчас РѕРЅРё хотят общими силами составить очень большое число. Каждый ребёнок называет число состоящее РёР· цифр, которые РѕРЅ знает. Напишите программу, которая строит число, состоящее РёР· максимальных цифр каждого ребёнка.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке указано число $N$ — количество детей РІ РіСЂСѓРїРїРµ. Р’ каждой РёР· последующих $N$ строк записано число.\n","### **Формат вывода**\n","РћРґРЅРѕ большое число.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br>123<br>234|34<br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>1234<br>7234<br>2323|473<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = []\n","\n","for _ in range(int(input())):\n"," arr.append(str(max([int(i) for i in input()])))\n","\n","print(\"\".join(arr))"]},{"cell_type":"markdown","metadata":{},"source":["## **РњС‹ делили апельсин**\n","РђРЅСЏ, Боря Рё Р’РѕРІР° решили съесть апельсин.<br>Подскажите ребятам, как РёРј его разделить. Напишите программу, которая выводит РІСЃРµ возможные СЃРїРѕСЃРѕР±С‹ разделки апельсина.\n","### **Формат РІРІРѕРґР°**\n","Р’ единственной строке записано количество долек апельсина.\n","### **Формат вывода**\n","Таблица вариантов разделения апельсина.<br><br>Примечания<br>Каждому ребёнку должна достаться хотя Р±С‹ РѕРґРЅР° долька апельсина.<br>РќРё РѕРґРЅРѕР№ дольки РЅРµ должно остаться.<br>Выводить варианты РІ РїРѕСЂСЏРґРєРµ увеличения количества долек Сѓ РђРЅРё, затем Бори Рё затем уже Р’РѕРІС‹.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br> <br>|Рђ Р‘ Р’<br>1 1 1<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br> <br> <br> <br> <br> <br> <br>|Рђ Р‘ Р’<br>1 1 3<br>1 2 2<br>1 3 1<br>2 1 2<br>2 2 1<br>3 1 1<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","print(\"Рђ Р‘ Р’\")\n","\n","arr = [1, 1, n - 2]\n","print(*arr)\n","\n","for i in range(2, n - 1):\n"," arr = [1, i, n - 1 - i]\n"," print(*arr)\n","\n","for i in range(2, n - 1):\n"," for j in range(1, n - i):\n"," arr = [i, j, n - j - i]\n"," print(*arr)"]},{"cell_type":"markdown","metadata":{},"source":["## **Простая задача 3.0**\n","Р’СЃРїРѕРјРЅРёРј, что простые числа — те натуральные числа, Сѓ которых РґРІР° делителя: РѕРЅРѕ само Рё 1.<br>Напишите программу для определения количества простых чисел среди введённых.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ Р’Рѕ всех последующих $N$ строках — РїРѕ РѕРґРЅРѕРјСѓ числу.\n","### **Формат вывода**\n","Требуется вывести общее количество простых чисел среди введённых (РєСЂРѕРјРµ $N$).\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br>1<br>2<br>3<br>4<br>5|3<br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|6<br>11<br>13<br>15<br>63<br>71<br>51|3<br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["c = 0\n","for _ in range(int(input())):\n"," n = int(input())\n"," f = False\n"," if n == 1 or n == 0 or n == -1:\n"," continue\n"," else:\n"," for i in range(2, n // 2 + 1):\n"," if n % i == 0:\n"," f = True\n"," break\n"," if f:\n"," continue\n"," c += 1\n","\n","print(c)"]},{"cell_type":"markdown","metadata":{},"source":["## **Числовой прямоугольник**\n","Ребята РІ детском саду учатся считать, Рё чтобы РёРј было интереснее, воспитательница решила оформить СЃРїРёСЃРѕРє изучаемых чисел особым образом.<br>Дети справляются весьма быстро, поэтому ей требуется программа способная строить числовые прямоугольники. Напишите программу, которая строит числовой прямоугольник требуемого размера.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ — высота числового прямоугольника.<br>Р’Рѕ второй строке указано число $M$ — ширина числового прямоугольника.\n","### **Формат вывода**\n","Нужно вывести сформированный числовой прямоугольник требуемого размера.<br>Чтобы прямоугольник был красивым, каждый его столбец должен быть одинаковой ширины.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br> <br> <br>|3<br>1 2 3<br>4 5 6<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br> <br> <br> <br> <br>|6<br> 1 2 3 4 5 6<br> 7 8 9 10 11 12<br>13 14 15 16 17 18<br>19 20 21 22 23 24<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["a, b = int(input()), int(input())\n","\n","lenn = len(str(a * b))\n","\n","for i in range(1, a + 1):\n"," arr = []\n"," for j in range(1, b + 1):\n"," n = b * (i - 1) + j\n"," arr.append(\" \" * (lenn - len(str(n))) + str(n))\n"," print(*arr)"]},{"cell_type":"markdown","metadata":{},"source":["## **Числовой прямоугольник 2.0**\n","Давайте РІРЅРѕРІСЊ поможем воспитательнице учить ребят числам. Напишите программу, которая строит числовой прямоугольник требуемого размера.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ — высота числового прямоугольника.<br>Р’Рѕ второй строке указано число $M$ — ширина числового прямоугольника.\n","### **Формат вывода**\n","Нужно вывести сформированный числовой прямоугольник требуемого размера.<br>Чтобы прямоугольник был красивым, каждый его столбец должен обладать одинаковой шириной.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br>3|1 3 5<br>2 4 6|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>6<br> <br> <br>| 1 5 9 13 17 21<br> 2 6 10 14 18 22<br> 3 7 11 15 19 23<br> 4 8 12 16 20 24<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["a, b = int(input()), int(input())\n","\n","lenn = len(str(a * b))\n","\n","for i in range(1, a + 1):\n"," arr = []\n"," for j in range(1, b + 1):\n"," n = a * (j - 1) + i\n"," arr.append(\" \" * (lenn - len(str(n))) + str(n))\n"," print(*arr)"]},{"cell_type":"markdown","metadata":{},"source":["## **Числовая змейка**\n","РЈРІС‹, обыкновенные прямоугольники детям быстро наскучили. Теперь воспитательнице требуется новая программа. Напишите программу, которая строит числовую змейку требуемого размера.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ — высота числового прямоугольника.<br>Р’Рѕ второй строке указано число $M$ — ширина числового прямоугольника.\n","### **Формат вывода**\n","Нужно вывести сформированную числовую змейку требуемого размера.<br>Чтобы прямоугольник был красивым, каждый его столбец следует сделать одинаковой ширины.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br>3|1 2 3<br>6 5 4|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>6<br> <br> <br>| 1 2 3 4 5 6<br>12 11 10 9 8 7<br>13 14 15 16 17 18<br>24 23 22 21 20 19<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["a, b = int(input()), int(input())\n","\n","lenn = len(str(a * b))\n","\n","for i in range(1, a + 1):\n"," arr = []\n"," if i % 2 == 1:\n"," for j in range(1, b + 1):\n"," n = b * (i - 1) + j\n"," arr.append(\" \" * (lenn - len(str(n))) + str(n))\n"," else:\n"," for j in range(b, 0, -1):\n"," n = b * (i - 1) + j\n"," arr.append(\" \" * (lenn - len(str(n))) + str(n))\n"," print(*arr)"]},{"cell_type":"markdown","metadata":{},"source":["## **Числовая змейка 2.0**\n","Воспитательнице РІРЅРѕРІСЊ нужна программа, которая будет генерировать змейку РёР· чисел. Напишите программу, которая строит числовую змейку требуемого размера.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ — высота числового прямоугольника.<br>Р’Рѕ второй строке указано число $M$ — ширина числового прямоугольника.\n","### **Формат вывода**\n","Нужно вывести сформированную числовую змейку требуемого размера.<br>Чтобы прямоугольник был красивым, каждый его столбец следует сделать одинаковой ширины.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2<br>3|1 4 5<br>2 3 6|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>6<br> <br> <br>| 1 8 9 16 17 24<br> 2 7 10 15 18 23<br> 3 6 11 14 19 22<br> 4 5 12 13 20 21<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["a, b = int(input()), int(input())\n","\n","lenn = len(str(a * b))\n","\n","\n","for i in range(1, a + 1):\n"," arr = []\n"," for j in range(1, b + 1):\n"," if j % 2 == 1:\n"," n = a * (j - 1) + i\n"," arr.append(\" \" * (lenn - len(str(n))) + str(n))\n"," else:\n"," n = a * (j) - (i - 1)\n"," arr.append(\" \" * (lenn - len(str(n))) + str(n))\n"," print(*arr)"]},{"cell_type":"markdown","metadata":{},"source":["## **Редизайн таблицы умножения**\n","Согласитесь, что предыдущие таблицы умножения выглядят РЅРµ очень красиво. Давайте зададим для всех столбцов одинаковую ширину, Р° значения РІ ячейках выровним РїРѕ центру.<br>Р РґР°, заказчик РїРѕРїСЂРѕСЃРёР» ещё добавить РІ таблицу рамки между ячейками.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записан требуемый размер таблицы. Р’Рѕ второй строке — ширина столбцов.\n","### **Формат вывода**\n","Таблица умножения заданного размера Рё РІРёРґР°.\n","\n","\n",""]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","ln = int(input())\n","\n","a = []\n","for i in range(1, n + 1):\n"," if (ln - len(str(i))) % 2 == 0:\n"," a.append(\" \" * ((ln - len(str(i))) // 2) + str(i) + \" \" * ((ln - len(str(i))) // 2) + \"|\")\n"," if (ln - len(str(i))) % 2 == 1:\n"," a.append(\" \" * ((ln - len(str(i))) // 2) + str(i) + \" \" * ((ln - len(str(i))) // 2 + 1) + \"|\")\n","a[-1] = a[-1][:-1]\n","print(*a, sep=\"\")\n","\n","for i in range(2, n + 1):\n"," a = []\n"," print(\"-\" * ((ln * n) + (n - 1)))\n"," for j in range(1, n + 1):\n"," if (ln - len(str(i * j))) % 2 == 0:\n"," a.append(\" \" * ((ln - len(str(i * j))) // 2) + str(i * j) + \" \" * ((ln - len(str(i * j))) // 2) + \"|\")\n"," if (ln - len(str(i * j))) % 2 == 1:\n"," a.append(\" \" * ((ln - len(str(i * j))) // 2) + str(i * j) + \" \" * ((ln - len(str(i * j))) // 2 + 1) + \"|\")\n"," a[-1] = a[-1][:-1]\n"," print(*a, sep=\"\") "]},{"cell_type":"markdown","metadata":{},"source":["## **Рђ СЂРѕР·Р° упала РЅР° лапу РђР·РѕСЂР° 3.0**\n","Вернёмся Рє палиндромам. Напишите программу, которая определяет количество палиндромов РІ переданном СЃРїРёСЃРєРµ.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ Р’Рѕ всех последующих $N$ строках указано РїРѕ РѕРґРЅРѕРјСѓ числу.\n","### **Формат вывода**\n","Требуется вывести общее количество палиндромов среди введённых чисел (РєСЂРѕРјРµ числа $N$).\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br>1<br>2<br>3<br>4<br>5|5<br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>123<br>454<br>321|1<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["c = 0\n","for _ in range(int(input())):\n"," s = input()\n"," if s == s[::-1]:\n"," c += 1\n","\n","print(c)"]},{"cell_type":"markdown","metadata":{},"source":["## **Новогоднее настроение 2.0**\n","Коллеги математика РІРЅРѕРІСЊ хотят порадовать его Рё сделать математические ёлки, которые украсят кабинет учёного.<br>Помогите РёРј, написав программу, которая РїРѕ введённому числу строит математическую ёлку.\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅРѕ натуральное число — количество чисел РІ математической ёлке.\n","### **Формат вывода**\n","Требуемая РЅРѕРІРѕРіРѕРґРЅСЏ ёлка.\n","### **Примечание**\n","РќРµ забывайте РїСЂРѕ существование f-строк.<br><br>Р’ данный момент визуализация примеров работает РЅРµ корректно.<br>Ответ РЅР° первый тест должен выглядеть так:<br>\n"," 1 <br> 2 3 <br> 4 5 6 <br> 7 8 9 10 <br>11 12 13 14\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|14<br> <br> <br> <br> <br>| 1 <br> 2 3 <br> 4 5 6 <br> 7 8 9 10 <br>11 12 13 14<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|6<br> <br> <br>| 1 <br> 2 3 <br>4 5 6<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","a, b = 1, 1\n","arr = []\n","\n","while True:\n"," t = []\n"," f = False\n"," for _ in range(b):\n"," t.append(str(a))\n","\n"," if a == n:\n"," f = True\n"," break\n","\n"," a += 1\n"," arr.append(t)\n"," if f:\n"," break\n","\n"," b += 1\n","\n","ln = len(\" \".join(arr[-1]))\n","\n","for t in arr:\n"," print(f'{\" \".join(t):^{ln}}')"]},{"cell_type":"markdown","metadata":{},"source":["## **Числовой квадрат**\n","Рљ сожалению, Рё змейки детям надоели, поэтому воспитательнице нужна новая программа. Напишите программу, которая строит числовой квадрат требуемого размера.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано число $N$ — высота Рё ширина числового квадрата.\n","### **Формат вывода**\n","Требуется вывести сформированный числовой квадрат требуемого размера.<br>Чтобы квадрат был красивым, каждый его столбец — одинаковой ширины.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br> <br> <br>|1 1 1<br>1 2 1<br>1 1 1<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br> <br> <br> <br> <br>|1 1 1 1 1<br>1 2 2 2 1<br>1 2 3 2 1<br>1 2 2 2 1<br>1 1 1 1 1<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","\n","matrix = [[None] * n for _ in range(n)]\n","ln = len(str(n - n // 2))\n","\n","for i in range(n):\n"," for j in range(n):\n","\n"," if i >= n // 2:\n"," a = n - i\n"," else:\n"," a = i + 1\n","\n"," if j >= n // 2:\n"," b = n - j\n"," else:\n"," b = j + 1\n"," \n"," matrix[i][j] = \" \" * (ln - len(f\"{min(a, b)}\")) + f\"{min(a, b)}\"\n","\n","for a in matrix:\n"," print(*a)"]},{"cell_type":"markdown","metadata":{},"source":["## **Математическая выгода**\n","Математик Виталий Евгеньевич задумался над РІРѕРїСЂРѕСЃРѕРј выгоды систем счисления. РћРЅ решил, что выгодной системой счисления будет являться та, РІ которой число имеет наибольшую СЃСѓРјРјСѓ цифр. Напишите программу, которая РїРѕ введённому числу определяет основание системы счисления СЃ максимальной выгодой.\n","### **Формат РІРІРѕРґР°**\n","РћРґРЅРѕ натурально число.\n","### **Формат вывода**\n","РћРґРЅРѕ натуральное число РёР· диапазона [2;10] — основание системы счисления СЃ максимальной выгодой.<br>Если таких оснований несколько, выбирается наименьшее.\n","### **Примечание**\n","Подробнее Рѕ системах счисления можно почитать здесь\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|12|7|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|52|9|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","m = 0\n","m_b = 0\n","\n","for b in range(2, 11):\n"," s = \"\"\n"," num = n\n"," while num:\n"," s += str(num % b)\n"," num //= b\n","\n"," if (res := sum([int(i) for i in s])) > m:\n"," m = res\n"," m_b = b\n","\n","print(m_b)"]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.11.1"}},"nbformat":4,"nbformat_minor":2}
diff --git a/2.4/3.py b/2.4/3.py
deleted file mode 100644
index f432b4c81d78ef29a71d1aa34f610ffd3051d066..0000000000000000000000000000000000000000
--- a/2.4/3.py
+++ /dev/null
@@ -1,23 +0,0 @@
-n = int(input())
-a = 1
-b = 1
-arr = []
-
-while True:
- f = False
- for _ in range(1, b + 1):
- arr.append(a)
- if a == n:
- print(*arr)
- f = True
- break
- a += 1
-
- if f:
- break
-
- print(*arr)
-
- arr = []
- b += 1
-
\ No newline at end of file
diff --git a/2.4/4.py b/2.4/4.py
deleted file mode 100644
index 860c92cf3ef2bc58d134247667be36f6b458e49a..0000000000000000000000000000000000000000
--- a/2.4/4.py
+++ /dev/null
@@ -1 +0,0 @@
-print(sum([sum([int(i) for i in input()]) for _ in range(int(input()))]))
\ No newline at end of file
diff --git a/2.4/5.py b/2.4/5.py
deleted file mode 100644
index f0b26291f1b2e52a51f4406047711ab32ee9ea0c..0000000000000000000000000000000000000000
--- a/2.4/5.py
+++ /dev/null
@@ -1,14 +0,0 @@
-c = 0
-
-for _ in range(int(input())):
- s = input()
- arr = []
-
- while s != "Р’РЎРЃ":
- arr.append(s)
- s = input()
-
- if "зайка" in arr:
- c += 1
-
-print(c)
\ No newline at end of file
diff --git a/2.4/6.py b/2.4/6.py
deleted file mode 100644
index 94aa27b410e4a6cbbdeb02ee76721bb50049aca3..0000000000000000000000000000000000000000
--- a/2.4/6.py
+++ /dev/null
@@ -1,14 +0,0 @@
-arr = []
-for _ in range(int(input())):
- arr.append(int(input()))
- if len(arr) <= 1:
- continue
- a, b = sorted(arr)
-
- while a != b:
- b, a = a, b - a
- a, b = sorted([a, b])
-
- arr = [a]
-
-print(arr[0])
\ No newline at end of file
diff --git a/2.4/7.py b/2.4/7.py
deleted file mode 100644
index cb6c8f0f6c0bf8b7e923ecb80b519b7a141d0eae..0000000000000000000000000000000000000000
--- a/2.4/7.py
+++ /dev/null
@@ -1,4 +0,0 @@
-for i in range(int(input())):
- for j in range(3 + i, 0, -1):
- print(f"До старта {j} секунд(ы)")
- print(f"Старт {i + 1}!!!")
\ No newline at end of file
diff --git a/2.4/8.py b/2.4/8.py
deleted file mode 100644
index f87ba4a3286330af74c4b0856b4b910f643b8cd7..0000000000000000000000000000000000000000
--- a/2.4/8.py
+++ /dev/null
@@ -1,6 +0,0 @@
-arrs, arrn = [], []
-for _ in range(int(input())):
- arrs.append(input())
- arrn.append(sum([int(i) for i in input()]))
-
-print(arrs[len(arrs) - 1 - (arrn[::-1].index(max(arrn)))])
\ No newline at end of file
diff --git a/2.4/9.py b/2.4/9.py
deleted file mode 100644
index 8bfaace6e9735fcf86c3639d4e17d0288e5f4e7b..0000000000000000000000000000000000000000
--- a/2.4/9.py
+++ /dev/null
@@ -1,6 +0,0 @@
-arr = []
-
-for _ in range(int(input())):
- arr.append(str(max([int(i) for i in input()])))
-
-print("".join(arr))
\ No newline at end of file
diff --git a/3.1/1.py b/3.1/1.py
deleted file mode 100644
index ab375d241247a3e6fac49f069891328aff2d633a..0000000000000000000000000000000000000000
--- a/3.1/1.py
+++ /dev/null
@@ -1,16 +0,0 @@
-f = True
-for i in range(int(input())):
- s = input().lower()[0]
- for sym in "абв":
- if sym == s:
- f = True
- break
- else:
- f = False
- if not f:
- break
-
-if f:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/3.1/10.py b/3.1/10.py
deleted file mode 100644
index 0f6aa92e59ef9e5e0584bd93edfe90bf0154b1fd..0000000000000000000000000000000000000000
--- a/3.1/10.py
+++ /dev/null
@@ -1,26 +0,0 @@
-string = ""
-s = input()
-while s != "Р¤РРќРРЁ":
- string += s
- s = input()
-
-string = string.lower().replace(" ", "")
-
-d = {}
-
-for i in string:
- if i in d:
- d[i] += 1
- else:
- d[i] = 1
-
-maxl, s = 0, "СЏ"
-for i in d.keys():
- if d[i] > maxl:
- maxl = d[i]
- s = i
- elif d[i] == maxl:
- if ord(i) < ord(s):
- s = i
-
-print(s)
\ No newline at end of file
diff --git a/3.1/11.py b/3.1/11.py
deleted file mode 100644
index fe6ded3f1033ca8850d37c5b7bf872974b17c85a..0000000000000000000000000000000000000000
--- a/3.1/11.py
+++ /dev/null
@@ -1,7 +0,0 @@
-arr = [input() for _ in range(int(input()))]
-
-research = input()
-
-for s in arr:
- if research.lower() in s.lower():
- print(s)
\ No newline at end of file
diff --git a/3.1/12.py b/3.1/12.py
deleted file mode 100644
index 5bfc46827aef5df1b64effed6d21b30da4c3e35a..0000000000000000000000000000000000000000
--- a/3.1/12.py
+++ /dev/null
@@ -1,5 +0,0 @@
-arr = ["Манная", "Гречневая", "Пшённая", "Овсяная", "Рисовая"]
-
-n = int(input())
-for i in range(n):
- print(arr[i % 5])
\ No newline at end of file
diff --git a/3.1/13.py b/3.1/13.py
deleted file mode 100644
index 26ff0a0537e7b8e0648a41b539dbbd79f9ff5406..0000000000000000000000000000000000000000
--- a/3.1/13.py
+++ /dev/null
@@ -1,6 +0,0 @@
-arr = [int(input()) for _ in range(int(input()))]
-
-p = int(input())
-
-for i in arr:
- print(i**p)
\ No newline at end of file
diff --git a/3.1/14.py b/3.1/14.py
deleted file mode 100644
index 483d8c6332231c2e39d182b2c3b6e4fa8f1bb3ec..0000000000000000000000000000000000000000
--- a/3.1/14.py
+++ /dev/null
@@ -1,4 +0,0 @@
-arr = [int(i) for i in input().split()]
-p = int(input())
-for i in arr:
- print(i ** p, end=" ")
\ No newline at end of file
diff --git a/3.1/15.py b/3.1/15.py
deleted file mode 100644
index 8c6c92a2f6795a9e1968a6d79de3db7c3a52d015..0000000000000000000000000000000000000000
--- a/3.1/15.py
+++ /dev/null
@@ -1,13 +0,0 @@
-arr = [int(i) for i in input().split()]
-
-nod = 0
-for i in range(len(arr) - 1):
- a, b = arr[i], arr[i + 1]
- while a != b:
- if a > b:
- a -= b
- else:
- b -= a
- arr[i + 1] = a
-
-print(arr[-1])
\ No newline at end of file
diff --git a/3.1/16.py b/3.1/16.py
deleted file mode 100644
index 9f69d911ef2e0816247d6974c3361fe0e047cac9..0000000000000000000000000000000000000000
--- a/3.1/16.py
+++ /dev/null
@@ -1,14 +0,0 @@
-length = int(input()) - 3
-
-arr = [input() for _ in range(int(input()))]
-
-for elem in arr:
- if len(elem) < length:
- print(elem)
- length -= len(elem)
- elif len(elem) == length:
- print(f"{elem}...")
- break
- else:
- print(f"{elem[:length]}...")
- break
\ No newline at end of file
diff --git a/3.1/17.py b/3.1/17.py
deleted file mode 100644
index 8e0b61b5b2e0c3e4e93c849613289067d712e482..0000000000000000000000000000000000000000
--- a/3.1/17.py
+++ /dev/null
@@ -1,6 +0,0 @@
-s = input().lower().replace(" ", "")
-
-if s == s[::-1]:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/3.1/18.py b/3.1/18.py
deleted file mode 100644
index 2afc7443c5eb6714841770226f4e2c3274a98109..0000000000000000000000000000000000000000
--- a/3.1/18.py
+++ /dev/null
@@ -1,11 +0,0 @@
-s = input()
-sym = s[0]
-c = 1
-for i in s[1:]:
- if sym == i:
- c += 1
- else:
- print(sym, c)
- sym = i
- c = 1
-print(sym, c)
\ No newline at end of file
diff --git a/3.1/19.py b/3.1/19.py
deleted file mode 100644
index c86310e38930333865365c6d3d45af441460c73e..0000000000000000000000000000000000000000
--- a/3.1/19.py
+++ /dev/null
@@ -1,10 +0,0 @@
-arr = input().split()
-stek = []
-for elem in arr:
- if elem in "*-+":
- res = eval(f"{stek.pop(-2)} {elem} {stek.pop(-1)}")
- stek.append(res)
- else:
- stek.append(int(elem))
-
-print(stek[0])
\ No newline at end of file
diff --git a/3.1/2.py b/3.1/2.py
deleted file mode 100644
index d5f58f0a9092ad2bd168e85cc037062ced06a1e3..0000000000000000000000000000000000000000
--- a/3.1/2.py
+++ /dev/null
@@ -1,3 +0,0 @@
-s = input()
-for i in s:
- print(i)
\ No newline at end of file
diff --git a/3.1/20.py b/3.1/20.py
deleted file mode 100644
index 2497a5ce45e4f9f29ad7dff0076dc0905b22db50..0000000000000000000000000000000000000000
--- a/3.1/20.py
+++ /dev/null
@@ -1,34 +0,0 @@
-arr = input().split()
-stek = []
-for elem in arr:
- if elem in "*-+":
- res = eval(f"{stek.pop(-2)} {elem} {stek.pop(-1)}")
- stek.append(res)
-
- elif elem == "/":
- res = eval(f"{stek.pop(-2)} // {stek.pop(-1)}")
- stek.append(res)
-
- elif elem == "~":
- res = stek.pop(-1) * (-1)
- stek.append(res)
-
- elif elem == "#":
- stek.append(stek[-1])
-
- elif elem == "!":
- res = stek.pop(-1)
- prod = 1
- while res:
- prod *= res
- res -= 1
- stek.append(prod)
-
- elif elem == "@":
- a, b, c = stek.pop(-3), stek.pop(-2), stek.pop(-1)
- stek += [b, c, a]
-
- else:
- stek.append(int(elem))
-
-print(stek[0])
\ No newline at end of file
diff --git a/3.1/3.py b/3.1/3.py
deleted file mode 100644
index 4d179b4235d3206a00bf44bdfaa213ea899d1525..0000000000000000000000000000000000000000
--- a/3.1/3.py
+++ /dev/null
@@ -1,12 +0,0 @@
-length, n = int(input()), int(input())
-
-arr = []
-
-for _ in range(n):
- arr.append(input())
-
-for s in arr:
- if len(s) > length:
- print(f"{s[:(length - 3)]}...")
- else:
- print(s)
\ No newline at end of file
diff --git a/3.1/31.ipynb b/3.1/31.ipynb
deleted file mode 100644
index 58f2b7632ad340d210007e1ad6c605537fd60737..0000000000000000000000000000000000000000
--- a/3.1/31.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells":[{"cell_type":"markdown","metadata":{},"source":["## **РђР·Р±СѓРєР°**\n","Знакомые нам воспитанники детского сада наконец-то начали учить Р±СѓРєРІС‹.<br>Воспитатель предложил ребятам назвать слова, которые начинаются СЃ Рђ, Р‘ или Р’. Напишите программу, которая проверяет, что первая Р±СѓРєРІР° РІРѕ всех словах — Рђ, Р‘ или Р’.\n","### **Формат РІРІРѕРґР°**\n","Вводится натуральное число $N$ — количество слов, названных детьми.<br>Р’ каждой РёР· последующих $N$ строк записано РїРѕ РѕРґРЅРѕРјСѓ слову строчными буквам.\n","### **Формат вывода**\n","YES — если РІСЃРµ слова начинаются СЃ нужной Р±СѓРєРІС‹.<br>NO — если хотя Р±С‹ РѕРґРЅРѕ слово начинается РЅРµ СЃ нужной Р±СѓРєРІС‹.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>арбуз<br>барабан<br>РІРѕСЂРѕРЅР°|YES<br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>аист<br>вареник<br>кузнечик<br>алыча|NO<br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["f = True\n","for i in range(int(input())):\n"," s = input().lower()[0]\n"," for sym in \"абв\":\n"," if sym == s:\n"," f = True\n"," break\n"," else:\n"," f = False\n"," if not f:\n"," break\n","\n","if f:\n"," print(\"YES\")\n","else:\n"," print(\"NO\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Кручу-верчу**\n","Очень часто РІ текстовых редакторах требуется траспонировать (повернуть) текст.<br>Рљ сожалению, РІ Python такая функция РїРѕ-умолчанию отсутствует. Давайте создадим программу, которая преобразует введённую стоку РёР· горизонтальной записи РІ вертикальную.\n","### **Формат РІРІРѕРґР°**\n","РћРґРЅР° строка.\n","### **Формат вывода**\n","Вертикальное представление введённой строки.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Привет<br> <br> <br> <br> <br> <br>|Рџ<br>СЂ<br>Рё<br>РІ<br>Рµ<br>С‚<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Питон<br> <br> <br> <br> <br>|Рџ<br>Рё<br>С‚<br>Рѕ<br>РЅ<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input()\n","for i in s:\n"," print(i)"]},{"cell_type":"markdown","metadata":{},"source":["## **РђРЅРѕРЅСЃ новости**\n","Местная новостная компания заказала сайт. Его неотъемлемая часть — новостная лента.<br>Чтобы пользователи могли быстрее анализировать статьи, нужно сократить заголовки. Напишите программу, которая сокращает длинные заголовки РґРѕ требуемой длины Рё завершает РёС… многоточием ... РїСЂРё необходимости.\n","### **Формат РІРІРѕРґР°**\n","Вводится натуральное число $L$ — необходимая длина заголовка.<br>Вводится натуральное число $N$ — количество заголовков, которые требуется сократить.<br>Р’ каждой РёР· последующих $N$ строк записано РїРѕ РѕРґРЅРѕРјСѓ заголовку.\n","### **Формат вывода**\n","Сокращённые заголовки.\n","### **Примечание**\n","Многоточие учитывается РїСЂРё подсчёте длины заголовка.\n","### **Пример**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|25<br>3<br>Начался саммит РїРѕ глобальному потеплению<br>Завтра Новый РіРѕРґ!<br>Python Рё Java РєРѕРЅРєСѓСЂРёСЂСѓСЋС‚ Р·Р° звание самого популярного языка программирования|Начался саммит РїРѕ глоб...<br>Завтра Новый РіРѕРґ!<br>Python Рё Java РєРѕРЅРєСѓСЂРёСЂ...<br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["length, n = int(input()), int(input())\n","\n","arr = []\n","\n","for _ in range(n):\n"," arr.append(input())\n","\n","for s in arr:\n"," if len(s) > length:\n"," print(f\"{s[:(length - 3)]}...\")\n"," else:\n"," print(s)"]},{"cell_type":"markdown","metadata":{},"source":["## **Очистка данных**\n","Местный провайдер собирает большое количество логов, однако зачастую файлы СЃ отчётами РїСЂРёС…РѕРґСЏС‚ РІ негодность.<br>Самые частые проблемы — ошибки РІРёРґР° ## Рё @@@.<br>Напишите программу, которая избавляется РѕС‚:<br>\n","* Двух символов # РІ начале информационных сообщений;\n","* Строк, заканчивающихся тремя символами @.\n","\n","\n","### **Формат РІРІРѕРґР°**\n","Вводятся строки отчёта. Признаком завершения РІРІРѕРґР° считается пустая строка.\n","### **Формат вывода**\n","Очищенные данные.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Hello, world<br>Hello, @@@<br>##Goodbye<br>|Hello, world<br>Goodbye<br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|First Message<br>##Second Message<br>@@@Third Message##<br>##Fourth Message@@@<br>|First Message<br>Second Message<br>@@@Third Message##<br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = []\n","s = input()\n","while s:\n"," arr.append(s)\n"," s = input()\n","\n","for s in arr:\n"," if s[-3:] == \"@@@\":\n"," continue\n"," elif s[:2] == \"##\":\n"," print(s[2:])\n"," else:\n"," print(s)"]},{"cell_type":"markdown","metadata":{},"source":["## **Рђ СЂРѕР·Р° упала РЅР° лапу РђР·РѕСЂР° 4.0**\n","Вернёмся Рє палиндромам — числам, словам Рё предложениям, которые читаются одинаково РІ РѕР±Р° направления.<br>Напишите программу, которая определяет, относится ли введённая строка Рє палиндромам.\n","### **Формат РІРІРѕРґР°**\n","Вводится строка.\n","### **Формат вывода**\n","Требуется вывести YES — если введенная строка является палиндромом, иначе – NO.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|мама|NO|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|анна|YES|\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input()\n","if s == s[::-1]:\n"," print(\"YES\")\n","else:\n"," print(\"NO\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Зайка — 6**\n","Очередное путешествие родителей СЃ детьми, очередная РёРіСЂР° СЃ РїРѕРёСЃРєРѕРј зверушек Р·Р° РѕРєРЅРѕРј.<br>Давайте поиграем Рё найдём заек.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано натуральное число $N$ — количество выделенных придорожных местностей.<br>Р’ каждой РёР· $N$ последующих строк записано описание придорожной местности.\n","### **Формат вывода**\n","Количество заек.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>березка елочка зайка волк березка<br>СЃРѕСЃРЅР° зайка СЃРѕСЃРЅР° елочка зайка медведь<br>СЃРѕСЃРЅР° СЃРѕСЃРЅР° СЃРѕСЃРЅР° белочка СЃРѕСЃРЅР° белочка|3<br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>зайка березка<br>березка зайка<br>березка елочка березка<br>елочка елочка елочка|2<br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = []\n","for _ in range(int(input())):\n"," arr += input().split()\n","\n","c = 0\n","for s in arr:\n"," if s == \"зайка\":\n"," c += 1\n","\n","print(c) "]},{"cell_type":"markdown","metadata":{},"source":["## **Рђ Рё Р‘ сидели РЅР° трубе**\n","Сложение чисел весьма простая задача.<br>Рљ сожалению, пользователи РЅРµ всегда РІРІРѕРґСЏС‚ данные так, как нам СѓРґРѕР±РЅРѕ.\n","### **Формат РІРІРѕРґР°**\n","Два целых числа, разделённые пробелом.\n","### **Формат вывода**\n","РћРґРЅРѕ целое число — СЃСѓРјРјР° переданных чисел.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2 2|4|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|-3 5|2|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["a, b = [int(i) for i in input().split()]\n","print(a + b)"]},{"cell_type":"markdown","metadata":{},"source":["## **Зайка — 7**\n","Р’РЅРѕРІСЊ поищем заек Р·Р° РѕРєРЅРѕРј поезда.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано натуральное число $N$ — количество выделенных придорожных местностей.<br>Р’ каждой РёР· $N$ последующих строк записано описание придорожной местности.\n","### **Формат вывода**\n","Для каждой строки нужно найти положение первого зайки.<br>Если РІ строке нет заек, то РѕР± этом нужно непременно сообщить.\n","### **Примечание**\n","Для символов РІ строках используйте нумерацию СЃ 1.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>березка елочка зайка волк березка<br>СЃРѕСЃРЅР° зайка СЃРѕСЃРЅР° елочка зайка медведь<br>СЃРѕСЃРЅР° СЃРѕСЃРЅР° СЃРѕСЃРЅР° белочка СЃРѕСЃРЅР° белочка<br>|16<br>7<br>Заек нет =(<br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>зайка березка<br>березка зайка<br>березка елочка березка<br>елочка елочка елочка<br>|1<br>9<br>Заек нет =(<br>Заек нет =(<br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = []\n","for _ in range(int(input())):\n"," arr.append(input())\n","\n","c = 0\n","for elem in arr:\n"," pos = 0\n"," for i in range(len(elem) - 4):\n"," if elem[i: i + 5] == \"зайка\":\n"," pos = i + 1\n"," break\n"," if pos:\n"," print(pos)\n"," else:\n"," print(\"Заек нет =(\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Без комментариев**\n","РњС‹ надеемся, РІС‹ пишите комментарии Рє своему РєРѕРґСѓ. Если так, то интерпретатор удаляет РёС… перед тем, как выполнить РєРѕРґ. Напишите программу, которая выполняет данную функцию Р·Р° интерпретатор.\n","### **Формат РІРІРѕРґР°**\n","Вводятся строки программы.<br>Признаком остановки является пустая строка.\n","### **Формат вывода**\n","Каждую строку нужно очистить РѕС‚ комментариев.<br>Рђ если комментарий — РІСЃСЏ строка, то выводить её РЅРµ надо.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|# РњРѕСЏ первая супер-пупер программа<br>print(\"What is your name?\") # Как тебя Р·РѕРІСѓС‚?<br>name = input() # Сохраняем РёРјСЏ<br>print(f\"Hello, {name}!\") # Здороваемся# Конец моей супер-пупер программы<br>|print(\"What is your name?\")<br>name = input()<br>print(f\"Hello, {name}!\")<br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|# РњРѕР№ первый цикл<br>for i in range(10): # Считаем РґРѕ 10<br> print(i) # выводим число<br>|for i in range(10):<br> print(i)<br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input()\n","arr = []\n","while s:\n"," arr.append(s)\n"," s = input()\n","\n","for s in arr:\n"," res = \"\"\n"," for i in range(len(s)):\n"," res = s\n"," if s[i] == \"#\":\n"," res = s[:i]\n"," break\n"," if res:\n"," print(res)"]},{"cell_type":"markdown","metadata":{},"source":["## **Частотный анализ РЅР° минималках**\n","Частотный анализ — подсчёт, какие символы чаще всего встречаются РІ тексте. Рто важнейший инструмент взлома РјРЅРѕРіРёС… классических шифров — РѕС‚ шифра Цезаря Рё РґРѕ шифровальной машины В«Рнигма». Выполним простой частотный анализ: выясним, какой СЃРёРјРІРѕР» встречается РІ тексте чаще всего.\n","### **Формат РІРІРѕРґР°**\n","Вводятся строки, РїРѕРєР° РЅРµ будет введена строка «ФРРќРРЁВ».\n","### **Формат вывода**\n","Выводится РѕРґРёРЅ СЃРёРјРІРѕР» РІ нижнем регистре — наиболее часто встречающийся.<br><br>Примечания<br>Пробелы РІ анализе РЅРµ участвуют.<br>Если РІ результате анализа получено несколько ответов, следует вывести первый РїРѕ алфавиту.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Баобаб<br>Белка<br>Бобы<br>Р¤РРќРРЁ|Р±<br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Финики Фокачча Зайка<br>Филин Фосфор Светофор<br>Фехтовальщик Форма<br>Р¤РРќРРЁ|С„<br> <br> <br> <br>|\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["string = \"\"\n","s = input()\n","while s != \"Р¤РРќРРЁ\":\n"," string += s\n"," s = input()\n","\n","string = string.lower().replace(\" \", \"\")\n","\n","d = {}\n","\n","for i in string:\n"," if i in d:\n"," d[i] += 1\n"," else:\n"," d[i] = 1\n","\n","maxl, s = 0, \"СЏ\"\n","for i in d.keys():\n"," if d[i] > maxl:\n"," maxl = d[i] \n"," s = i\n"," elif d[i] == maxl:\n"," if ord(i) < ord(s):\n"," s = i\n","\n","print(s)"]},{"cell_type":"markdown","metadata":{},"source":["## **Найдётся РІСЃС‘**\n","РџРѕРёСЃРє информации — РѕРґРЅР° РёР· основных нужд РІ современном РјРёСЂРµ.<br>Создайте программу, которая реализует маленький компонент РїРѕРёСЃРєРѕРІРѕР№ системы.\n","### **Формат РІРІРѕРґР°**\n","Вводится натуральное число $N$ — количество страниц, среди которых требуется произвести РїРѕРёСЃРє.<br>Р’ каждой РёР· последующих $N$ строк записаны заголовки страниц.<br>Р’ последней строке записан поисковый запрос.\n","### **Формат вывода**\n","Вывести РІСЃРµ заголовки страниц, РІ которых присутствует поисковый запрос (регистр РЅРµ имеет значения).<br>РџРѕСЂСЏРґРѕРє заголовков должен сохраниться.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>Яндекс выпустил задачник РїРѕ программированию<br>РќР° соревнованиях РїРѕ программированию победил любитель питона<br>Как заказать Яндекс.Такси?!<br>яндекс<br>|Яндекс выпустил задачник РїРѕ программированию<br>Как заказать Яндекс.Такси?!<br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|8<br>сериал шерлок смотреть онлайн<br>учебник питона<br>мемы<br>социальная сеть<br>упражнения РїРѕ питону<br>кормовые мыши для питонов<br>ответы егэ скачать бесплатно<br>компьютерные мыши<br>питон<br>|учебник питона<br>упражнения РїРѕ питону<br>кормовые мыши для питонов<br> <br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = [input() for _ in range(int(input()))]\n","\n","research = input()\n","\n","for s in arr:\n"," if research.lower() in s.lower():\n"," print(s)"]},{"cell_type":"markdown","metadata":{},"source":["## **Меню питания**\n","Р’ детском саду ежедневно подают РЅРѕРІСѓСЋ кашу РЅР° завтрак.<br>Каши чередуются РІ следующем РїРѕСЂСЏРґРєРµ:<br>\n","* Манная;\n","* Гречневая;\n","* Пшённая;\n","* Овсяная;\n","* Рисовая.\n","\n","Напишите программу, которая строит расписание каш РЅР° ближайшие РґРЅРё.\n","### **Формат РІРІРѕРґР°**\n","Вводится натуральное число $N$ — количество дней.\n","### **Формат вывода**\n","Вывести СЃРїРёСЃРѕРє каш РІ РїРѕСЂСЏРґРєРµ подачи.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br> <br> <br>|Манная<br>Гречневая<br>Пшённая<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|12<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|Манная<br>Гречневая<br>Пшённая<br>Овсяная<br>Рисовая<br>Манная<br>Гречневая<br>Пшённая<br>Овсяная<br>Рисовая<br>Манная<br>Гречневая<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = [\"Манная\", \"Гречневая\", \"Пшённая\", \"Овсяная\", \"Рисовая\"]\n","\n","n = int(input())\n","for i in range(n):\n"," print(arr[i % 5])"]},{"cell_type":"markdown","metadata":{},"source":["## **Массовое возведение РІ степень**\n","Часто возникают трудности, РєРѕРіРґР° нужно выполнить множество однообразных операций. Р’ таких случаях люди желают упростить себе работу. Напишите программу, которая РІРѕР·РІРѕРґРёС‚ РІ заданную степень РІСЃРµ числа, что передали пользователи.\n","### **Формат РІРІРѕРґР°**\n","Вводится натуральное число $N$ — количество чисел.<br>Р’ каждой РёР· последующих $N$ строк записано РїРѕ РѕРґРЅРѕРјСѓ числу.<br>Р’ последней строке записано натуральное число $P$ — степень, РІ которую требуется возвести числа.\n","### **Формат вывода**\n","Последовательность чисел, являющихся ответом.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>2<br>3<br>4<br>3<br>|8<br>27<br>64<br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br>222222<br>22222<br>2222<br>222<br>22<br>2<br>|49382617284<br>493817284<br>4937284<br>49284<br>484<br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = [int(input()) for _ in range(int(input()))]\n","\n","p = int(input())\n","\n","for i in arr:\n"," print(i**p)"]},{"cell_type":"markdown","metadata":{},"source":["## **Массовое возведение РІ степень 2.0**\n","Продолжим упрощать себе работу, РјРёРЅСѓСЏ множество одинаковых операций.<br>Создадим РЅРѕРІСѓСЋ программу, которая РІРѕР·РІРѕРґРёС‚ РІ заданную степень РІСЃРµ числа, переданные пользователем.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записана последовательность натуральных чисел, разделённых пробелами.<br>Р’Рѕ второй строке записано натуральное число $P$ — степень, РІ которую требуется возвести числа.\n","### **Формат вывода**\n","Последовательность чисел, являющихся ответом.<br>Числа вывести РІ РѕРґРЅСѓ строку через пробел.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2 3 4<br>3|8 27 64<br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|222222 22222 2222 222 22<br>2|49382617284 493817284 4937284 49284 484<br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = [int(i) for i in input().split()]\n","p = int(input())\n","for i in arr:\n"," print(i ** p, end=\" \")"]},{"cell_type":"markdown","metadata":{},"source":["## **РќРћР” 3.0**\n","Местному РќРР РІ очередной раз нужно находить наибольший общий делитель (РќРћР”) нескольких чисел.<br>Руководство института вернулось СЃ этой задачей Рє нам.\n","### **Формат РІРІРѕРґР°**\n","Р’ единственной строке записывается последовательность натуральных чисел, разделённых пробелами.\n","### **Формат вывода**\n","Требуется вывести РѕРґРЅРѕ натуральное число — РќРћР” всех данных чисел.\n","### **Примечание**\n","Самый распространенный СЃРїРѕСЃРѕР± РїРѕРёСЃРєР° РќРћР” — Алгоритм Рвклида.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|12 42|6|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|102 39 768|3|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = [int(i) for i in input().split()]\n","\n","nod = 0\n","for i in range(len(arr) - 1):\n"," a, b = arr[i], arr[i + 1]\n"," while a != b:\n"," if a > b:\n"," a -= b\n"," else:\n"," b -= a\n"," arr[i + 1] = a\n","\n","print(arr[-1])"]},{"cell_type":"markdown","metadata":{},"source":["## **РђРЅРѕРЅСЃ новости 2.0**\n","Попробуем ещё раз сократить заголовки для статей РІ ленте новостного сайта. Давайте сделаем программу, которая сокращает длинный заголовок РґРѕ требуемой длины Рё завершает его многоточием ..., если это требуется.\n","### **Формат РІРІРѕРґР°**\n","Вводится натуральное число $L$ — необходимая длина заголовка.<br>Вводится натуральное число $N$ — количество строк РІ заголовке новости.<br>Р’ каждой РёР· последующих $N$ строк записано РїРѕ РѕРґРЅРѕР№ строке заголовка.\n","### **Формат вывода**\n","Сокращённый заголовок.\n","### **Примечание**\n","Многоточие учитывается РїСЂРё подсчёте длины заголовка.<br>РЎРёРјРІРѕР» перевода строки РїСЂРё подсчёте длины РЅРµ учитывается.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|144<br>5<br>Рнтузиаст написал программу для управления громкостью СЃ помощью жестов, чтоб РЅРµ вставать СЃ дивана<br>Благодаря ей РѕРЅ может регулировать громкость,<br>показывая расстояние между большим Рё указательным пальцами.<br>Для этого ему понадобилась веб-камера, знания Python Рё<br>библиотека для работы СЃ компьютерным зрением.|Рнтузиаст написал программу для управления громкостью СЃ помощью жестов, чтоб РЅРµ вставать СЃ дивана<br>Благодаря ей РѕРЅ может регулировать громкость...<br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|121<br>5<br>Рнтузиаст написал программу для управления громкостью СЃ помощью жестов, чтоб РЅРµ вставать СЃ дивана<br>Благодаря ей РѕРЅ может регулировать громкость,<br>показывая расстояние между большим Рё указательным пальцами.<br>Для этого ему понадобилась веб-камера, знания Python Рё<br>библиотека для работы СЃ компьютерным зрением.|Рнтузиаст написал программу для управления громкостью СЃ помощью жестов, чтоб РЅРµ вставать СЃ дивана<br>Благодаря ей РѕРЅ может...<br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["length = int(input()) - 3\n","\n","arr = [input() for _ in range(int(input()))]\n","\n","for elem in arr:\n"," if len(elem) < length:\n"," print(elem)\n"," length -= len(elem)\n"," elif len(elem) == length:\n"," print(f\"{elem}...\")\n"," break\n"," else:\n"," print(f\"{elem[:length]}...\")\n"," break"]},{"cell_type":"markdown","metadata":{},"source":["## **Рђ СЂРѕР·Р° упала РЅР° лапу РђР·РѕСЂР° 5.0**\n","Р СЃРЅРѕРІР° напишем программу, которая определяет, палиндромом перед нами или нет.\n","### **Формат РІРІРѕРґР°**\n","Вводится строка.\n","### **Формат вывода**\n","Если введённая строка относится Рє палиндрому, то вывести YES, Р° иначе — NO.\n","### **Примечание**\n","РџСЂРё проверке РЅРµ обращайте внимания РЅР° регистр Рё пробелы.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Рђ СЂРѕР·Р° упала РЅР° лапу РђР·РѕСЂР°|YES|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Мама мыла раму|NO|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input().lower().replace(\" \", \"\")\n","\n","if s == s[::-1]:\n"," print(\"YES\")\n","else:\n"," print(\"NO\")"]},{"cell_type":"markdown","metadata":{},"source":["## **RLE**\n","RLE означает “run-length encoding”. Рто СЃРїРѕСЃРѕР± сокращённой записи последовательности чего СѓРіРѕРґРЅРѕ (РІ случае этой задачи — цифр). РџСЂРё нём для РїРѕРґСЂСЏРґ идущей РіСЂСѓРїРїС‹ одинаковых цифр (run) записываются сама эта цифра Рё длина этой РіСЂСѓРїРїС‹ (run length). Таким образом, 99999 превратится РІ 9 5 («девять пять раз») Рё так далее. RLE широко используется РІ самых разных областях. Напишите программу, которая кодирует строку цифр РІ RLE.\n","### **Формат РІРІРѕРґР°**\n","Строка цифр длиной РЅРµ меньше 1.\n","### **Формат вывода**\n","Пары: сама цифра Рё количество повторений цифры РїРѕРґСЂСЏРґ РІРѕ введённой строке, как описано РІ условии Рё показано РІ примере.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|010000100001111111110111110000000000000011111111<br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|0 1<br>1 1<br>0 4<br>1 1<br>0 4<br>1 9<br>0 1<br>1 5<br>0 14<br>1 8<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|0110000000100001000<br> <br> <br> <br> <br> <br> <br>|0 1<br>1 2<br>0 7<br>1 1<br>0 4<br>1 1<br>0 3<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input()\n","sym = s[0]\n","c = 1\n","for i in s[1:]:\n"," if sym == i:\n"," c += 1\n"," else:\n"," print(sym, c)\n"," sym = i\n"," c = 1\n","print(sym, c)"]},{"cell_type":"markdown","metadata":{},"source":["## **Польский калькулятор**\n","Напишите программу, которая РїСЂРѕРёР·РІРѕРґРёС‚ вычисление выражения, записанного РІ обратной польской нотации (РћРџРќ).<br><br>Р’ РћРџРќ нет РЅРё СЃРєРѕР±РѕРє, РЅРё приоритета операторов («умножение раньше сложения»).<br><br>Чтобы прочитать выражение, записанное РІ таком формате, нужно просматривать выражение строго последовательно. Вводимые значения последовательно добавляются РІ стек. РљРѕРіРґР° встречается СЃРёРјРІРѕР» операции, то РёР· стека извлекаются последние положенные туда значения, СЃ РЅРёРјРё проделывается эта операция Рё результат возвращается РІ стек.<br><br>Если для операции важен РїРѕСЂСЏРґРѕРє значений, СЃ которыми РѕРЅР° производится, то первым идёт число, лежавшее РІ стеке глубже. Р’ частности, если операция — вычитание, то РёР· предпоследнего числа РІ стеке вычитается последнее, Р° РЅРµ наоборот.<br><br>Рзначально стек пустой, РІ результате полного вычисления выражения РІ нём должно остаться РѕРґРЅРѕ значение — результат вычислений.<br><br>Первый пример следует читать так: РІ стек последовательно добавляются значения 7 2 3, Р° затем встречаем знак операции *. РўРѕРіРґР° значения 2 Рё 3 извлекаются, перемножаются, результат 6 кладётся обратно РІ стек. Следующий знак извлекает РёР· стека РґРІР° оставшихся РІ нём значения 7 Рё 6, вычитает РѕРґРЅРѕ РёР· РґСЂСѓРіРѕРіРѕ Рё кладёт результат СЃРЅРѕРІР° РІ стек. Выражение закончилось, РІ стеке РѕРґРЅРѕ число — 1, это Рё есть результат вычисления.\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅР° строка, содержащая разделённые пробелами целые числа Рё знаки операций +, -, *, которые вместе составляют корректное выражение РІ обратной польской нотации.\n","### **Формат вывода**\n","Выводится РѕРґРЅРѕ целое число — результат вычисления выражения.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|7 2 3 * -|1|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|10 15 - 7 *|-35|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = input().split()\n","stek = []\n","for elem in arr:\n"," if elem in \"*-+\":\n"," res = eval(f\"{stek.pop(-2)} {elem} {stek.pop(-1)}\")\n"," stek.append(res) \n"," else:\n"," stek.append(int(elem))\n","\n","print(stek[0])"]},{"cell_type":"markdown","metadata":{},"source":["## **Польский калькулятор — 2**\n","Потренируемся РІ РћРџРќ дальше. Операции, которые выполняются СЃ РѕРґРЅРёРј значением, называются унарными, СЃ РґРІСѓРјСЏ — бинарными, СЃ тремя — тернарными. Давайте улучшим наш калькулятор, добавив поддержку следующих операций:<br>\n","\n","\n","* бинарные:<br>- (вычитание),<br>* (умножение),<br>/ (деление нацело; для отрицательных чисел работает РїРѕ тем же правилам, что Рё РІ Python);\n","\n","* унарные:<br>! (факториал),<br># (клонирование — вернуть РІ стек значение дважды);\n","\n","* тернарные:<br>@ (возвращает РІ стек те же три значения, РЅРѕ РІ РёРЅРѕРј РїРѕСЂСЏРґРєРµ: второе, третье, первое).\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅР° строка, содержащая разделённые пробелами целые числа Рё знаки операций. Вместе РѕРЅРё составляют корректное выражение РІ обратной польской нотации, РЅРµ содержащее деления РЅР° ноль Рё взятия факториала РѕС‚ отрицательного числа.\n","### **Формат вывода**\n","Выводится РѕРґРЅРѕ целое число — результат вычисления выражения.\n","### **Примечание**\n","Р’ первом примере стек РїРѕ мере прочтения строки выглядит так:\n","* 7 1\n","* 7 1 10\n","* 7 1 10 100\n","* 7 1 10 100 100\n","* 7 1 10 10000\n","* 7 10 10000 1\n","* 7 10 9999\n","* 7 10009\n","* 10016\n","* -10016\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|7 1 10 100 # * @ - + + ~|-10016|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|10 15 - 7 *|-35|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = input().split()\n","stek = []\n","for elem in arr:\n"," if elem in \"*-+\":\n"," res = eval(f\"{stek.pop(-2)} {elem} {stek.pop(-1)}\")\n"," stek.append(res)\n"," \n"," elif elem == \"/\":\n"," res = eval(f\"{stek.pop(-2)} // {stek.pop(-1)}\")\n"," stek.append(res)\n"," \n"," elif elem == \"~\":\n"," res = stek.pop(-1) * (-1)\n"," stek.append(res)\n"," \n"," elif elem == \"#\":\n"," stek.append(stek[-1])\n"," \n"," elif elem == \"!\":\n"," res = stek.pop(-1)\n"," prod = 1\n"," while res:\n"," prod *= res\n"," res -= 1\n"," stek.append(prod)\n"," \n"," elif elem == \"@\":\n"," a, b, c = stek.pop(-3), stek.pop(-2), stek.pop(-1)\n"," stek += [b, c, a] \n"," \n"," else:\n"," stek.append(int(elem))\n","\n","print(stek[0])"]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.11.1"}},"nbformat":4,"nbformat_minor":2}
diff --git a/3.1/4.py b/3.1/4.py
deleted file mode 100644
index 707d8a343f2179c62d80413803e622d41d5c7fd6..0000000000000000000000000000000000000000
--- a/3.1/4.py
+++ /dev/null
@@ -1,13 +0,0 @@
-arr = []
-s = input()
-while s:
- arr.append(s)
- s = input()
-
-for s in arr:
- if s[-3:] == "@@@":
- continue
- elif s[:2] == "##":
- print(s[2:])
- else:
- print(s)
\ No newline at end of file
diff --git a/3.1/5.py b/3.1/5.py
deleted file mode 100644
index b26d5fbd88c25bf39ad3c1b329fb254834db49dd..0000000000000000000000000000000000000000
--- a/3.1/5.py
+++ /dev/null
@@ -1,5 +0,0 @@
-s = input()
-if s == s[::-1]:
- print("YES")
-else:
- print("NO")
\ No newline at end of file
diff --git a/3.1/6.py b/3.1/6.py
deleted file mode 100644
index 8fe7f055837df9beab9733ba90c62e83afdfaa80..0000000000000000000000000000000000000000
--- a/3.1/6.py
+++ /dev/null
@@ -1,10 +0,0 @@
-arr = []
-for _ in range(int(input())):
- arr += input().split()
-
-c = 0
-for s in arr:
- if s == "зайка":
- c += 1
-
-print(c)
\ No newline at end of file
diff --git a/3.1/7.py b/3.1/7.py
deleted file mode 100644
index 4818ea2cd9f58b6a415a857e1681ce8c15b0e255..0000000000000000000000000000000000000000
--- a/3.1/7.py
+++ /dev/null
@@ -1,2 +0,0 @@
-a, b = [int(i) for i in input().split()]
-print(a + b)
\ No newline at end of file
diff --git a/3.1/8.py b/3.1/8.py
deleted file mode 100644
index adfa6353f504ff63226477abe82ecec44d2bb99f..0000000000000000000000000000000000000000
--- a/3.1/8.py
+++ /dev/null
@@ -1,15 +0,0 @@
-arr = []
-for _ in range(int(input())):
- arr.append(input())
-
-c = 0
-for elem in arr:
- pos = 0
- for i in range(len(elem) - 4):
- if elem[i: i + 5] == "зайка":
- pos = i + 1
- break
- if pos:
- print(pos)
- else:
- print("Заек нет =(")
\ No newline at end of file
diff --git a/3.1/9.py b/3.1/9.py
deleted file mode 100644
index 1e4f185db5717fc5e564dc417de092b844c5d7a9..0000000000000000000000000000000000000000
--- a/3.1/9.py
+++ /dev/null
@@ -1,15 +0,0 @@
-s = input()
-arr = []
-while s:
- arr.append(s)
- s = input()
-
-for s in arr:
- res = ""
- for i in range(len(s)):
- res = s
- if s[i] == "#":
- res = s[:i]
- break
- if res:
- print(res)
\ No newline at end of file
diff --git a/3.2/1.py b/3.2/1.py
deleted file mode 100644
index 65bc083fba799ff6dffd81b2bfe1c5840a4ee13c..0000000000000000000000000000000000000000
--- a/3.2/1.py
+++ /dev/null
@@ -1,2 +0,0 @@
-s = set(input())
-print(*s, sep="")
\ No newline at end of file
diff --git a/3.2/10.py b/3.2/10.py
deleted file mode 100644
index e575c53e12808701ac548ad5f97a34d35e587b1d..0000000000000000000000000000000000000000
--- a/3.2/10.py
+++ /dev/null
@@ -1,76 +0,0 @@
-d = {
- 'Рђ': 'A',
- 'Р°': 'a',
- 'Р‘': 'B',
- 'Р±': 'b',
- 'Р’': 'V',
- 'РІ': 'v',
- 'Р“': 'G',
- 'Рі': 'g',
- 'Р”': 'D',
- 'Рґ': 'd',
- 'Р•': 'E',
- 'Рµ': 'e',
- 'РЃ': 'E',
- 'С‘': 'e',
- 'Р–': 'Zh',
- 'Р¶': 'zh',
- 'Р—': 'Z',
- 'Р·': 'z',
- 'Р': 'I',
- 'Рё': 'i',
- 'Р™': 'I',
- 'Р№': 'i',
- 'Рљ': 'K',
- 'Рє': 'k',
- 'Р›': 'L',
- 'Р»': 'l',
- 'Рњ': 'M',
- 'Рј': 'm',
- 'Рќ': 'N',
- 'РЅ': 'n',
- 'Рћ': 'O',
- 'Рѕ': 'o',
- 'Рџ': 'P',
- 'Рї': 'p',
- 'Р ': 'R',
- 'СЂ': 'r',
- 'РЎ': 'S',
- 'СЃ': 's',
- 'Рў': 'T',
- 'С‚': 't',
- 'РЈ': 'U',
- 'Сѓ': 'u',
- 'Р¤': 'F',
- 'С„': 'f',
- 'РҐ': 'Kh',
- 'С…': 'kh',
- 'Р¦': 'Tc',
- 'С†': 'tc',
- 'Р§': 'Ch',
- 'С‡': 'ch',
- 'РЁ': 'Sh',
- 'С€': 'sh',
- 'Р©': 'Shch',
- 'С‰': 'shch',
- 'Р«': 'Y',
- 'С‹': 'y',
- 'Р': 'E',
- 'СЌ': 'e',
- 'Р®': 'Iu',
- 'СЋ': 'iu',
- 'РЇ': 'Ia',
- 'СЏ': 'ia'
-}
-
-s = input()
-new_s = ""
-for i in s:
- if i in d.keys():
- new_s += d[i]
- elif i.lower() in ["СЊ", "СЉ"]:
- continue
- else:
- new_s += i
-
-print(new_s)
\ No newline at end of file
diff --git a/3.2/11.py b/3.2/11.py
deleted file mode 100644
index 21ce6541730d2bd3ab9288be75bfaf5812749134..0000000000000000000000000000000000000000
--- a/3.2/11.py
+++ /dev/null
@@ -1,11 +0,0 @@
-d = {}
-for _ in range(int(input())):
- f = input()
- d[f] = 1 + d.get(f, 0)
-
-c = 0
-for f in d.keys():
- if d[f] - 1:
- c += d[f]
-
-print(c)
\ No newline at end of file
diff --git a/3.2/12.py b/3.2/12.py
deleted file mode 100644
index 6a5c8194ff551429be7e94a6a72a2cdc242dac32..0000000000000000000000000000000000000000
--- a/3.2/12.py
+++ /dev/null
@@ -1,13 +0,0 @@
-d = {}
-for _ in range(int(input())):
- f = input()
- d[f] = 1 + d.get(f, 0)
-
-c = 0
-for f in sorted(d.keys()):
- if d[f] - 1:
- print(f, "-", d[f])
- c += 1
-
-if not c:
- print("Однофамильцев нет")
\ No newline at end of file
diff --git a/3.2/13.py b/3.2/13.py
deleted file mode 100644
index 8687e84d4cbb374b00054bcd207e0df4c002ca4a..0000000000000000000000000000000000000000
--- a/3.2/13.py
+++ /dev/null
@@ -1,12 +0,0 @@
-s = {input() for _ in range(int(input()))}
-
-for _ in range(int(input())):
- for _ in range(int(input())):
- f = input()
- if f in s:
- s.remove(f)
-
-if s:
- print(*sorted(list(s)), sep="\n")
-else:
- print("Готовить нечего")
\ No newline at end of file
diff --git a/3.2/14.py b/3.2/14.py
deleted file mode 100644
index 346fe6fabd16c247f9753fdfc2511e93ef41da67..0000000000000000000000000000000000000000
--- a/3.2/14.py
+++ /dev/null
@@ -1,22 +0,0 @@
-n = int(input())
-food_set = set()
-for _ in range(n):
- food_set.add(input())
-
-res = []
-d = {}
-m = int(input())
-for i in range(m):
- dish = input()
- d[dish] = set()
- for j in range(int(input())):
- d[dish] = d[dish] | ({input()})
-
-for i in d.keys():
- if d[i] | food_set == food_set:
- res.append(i)
-
-if res:
- print(*sorted(res), sep="\n")
-else:
- print("Готовить нечего")
\ No newline at end of file
diff --git a/3.2/15.py b/3.2/15.py
deleted file mode 100644
index 839ab3cfbd350ae1eda88045847956c5b9930d7f..0000000000000000000000000000000000000000
--- a/3.2/15.py
+++ /dev/null
@@ -1,8 +0,0 @@
-digits = [int(i) for i in input().split()]
-dig_dicts = []
-for dig in digits:
- b = bin(dig)[2:]
- dig_dicts.append({"digits": len(b), "units": b.count("1"), "zeros": b.count("0")})
-
-
-print(dig_dicts)
diff --git a/3.2/16.py b/3.2/16.py
deleted file mode 100644
index 7d01521424b4e9e57e3b342e96860e547a022d66..0000000000000000000000000000000000000000
--- a/3.2/16.py
+++ /dev/null
@@ -1,15 +0,0 @@
-s = input()
-res = set()
-while s:
- arr = s.split()
- for i in range(len(arr)):
- if "зайка" == arr[i]:
- if i > 0:
- res.add(arr[i - 1])
- if i < len(arr) - 1:
- res.add(arr[i + 1])
-
-
- s = input()
-
-print(*list(res), sep="\n")
\ No newline at end of file
diff --git a/3.2/17.py b/3.2/17.py
deleted file mode 100644
index 52e671784f1e60677db72015428d2ec1e0da31f4..0000000000000000000000000000000000000000
--- a/3.2/17.py
+++ /dev/null
@@ -1,25 +0,0 @@
-s = input().split()
-people = set()
-connects = {}
-while s:
- people.add(s[0])
- people.add(s[1])
-
- connects[s[0]] = connects.get(s[0], []) + [s[1]]
- connects[s[1]] = connects.get(s[1], []) + [s[0]]
- s = input().split()
-
-for pers in sorted(list(people)):
- con = [[pers, second] for second in connects[pers]]
- con_new = []
- for elem in con:
- if elem[-1] in connects.keys():
- for friend in connects[elem[-1]]:
- if friend != pers and friend not in connects[elem[0]]:
- con_new.append(elem + [friend])
- con = con_new
- print(f"{pers}:", end=" ")
- res = set()
- for elem in con:
- res.add(elem[-1])
- print(*sorted(list(res)), sep=", ")
\ No newline at end of file
diff --git a/3.2/18.py b/3.2/18.py
deleted file mode 100644
index 904aec3c1c20ae906e72208dc763193a62fa8171..0000000000000000000000000000000000000000
--- a/3.2/18.py
+++ /dev/null
@@ -1,13 +0,0 @@
-coords = set()
-connects = {}
-for _ in range(int(input())):
- new_coord = tuple(input().split())
- coords.add(new_coord)
-
-for coord in coords:
- for new_coord in coords:
- if new_coord[0][:-1] == coord[0][:-1] and new_coord[1][:-1] == coord[1][:-1]:
- connects[coord] = connects.get(coord, 0) + 1
-
-
-print(max(connects.values()))
\ No newline at end of file
diff --git a/3.2/19.py b/3.2/19.py
deleted file mode 100644
index 3ff217449ab8e077d98dc9f439b4fd5aa8b0f85b..0000000000000000000000000000000000000000
--- a/3.2/19.py
+++ /dev/null
@@ -1,14 +0,0 @@
-arr = []
-for _ in range(int(input())):
- toys = input().split(", ")
- toys = toys[0].split(": ") + toys[1:]
- arr.append(set(toys[1:]))
-
-res = []
-for i in range(len(arr)):
- temp = set()
- for elem in arr[:i] + arr[i + 1:]:
- temp = temp | elem
- res += list(arr[i] - temp)
-
-print(*sorted(res), sep="\n")
\ No newline at end of file
diff --git a/3.2/2.py b/3.2/2.py
deleted file mode 100644
index 1412ef44a7d142704764ab75c07e1d21a1b03b6d..0000000000000000000000000000000000000000
--- a/3.2/2.py
+++ /dev/null
@@ -1,2 +0,0 @@
-s = set(input()) & set(input())
-print(*s, sep="")
\ No newline at end of file
diff --git a/3.2/20.py b/3.2/20.py
deleted file mode 100644
index 702f3fe42900bc8aba113b7e9cc8dbd958388240..0000000000000000000000000000000000000000
--- a/3.2/20.py
+++ /dev/null
@@ -1,19 +0,0 @@
-def find_nums(a, b):
- while b != 0:
- a, b = b, a % b
- return a == 1
-
-d = {}
-arr = sorted(list(set([int(i) for i in input().split("; ")])))
-
-for i in range(len(arr)):
- res = []
- for num in arr[:i] + arr[i + 1:]:
- if find_nums(num, arr[i]):
- res.append(num)
- if res:
- d[arr[i]] = res
-
-for k in d.keys():
- print(f"{k} -", end=" ")
- print(*d[k], sep=", ")
diff --git a/3.2/3.py b/3.2/3.py
deleted file mode 100644
index d83c1cf46dcd3d9acba4b082f54fda940b0430c6..0000000000000000000000000000000000000000
--- a/3.2/3.py
+++ /dev/null
@@ -1,6 +0,0 @@
-s = set()
-for _ in range(int(input())):
- for i in input().split():
- s.add(i)
-
-print(*s, sep="\n")
\ No newline at end of file
diff --git a/3.2/32.ipynb b/3.2/32.ipynb
deleted file mode 100644
index fb1d4cd3ca4a7605b7da45d0d97d37f500f98518..0000000000000000000000000000000000000000
--- a/3.2/32.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells":[{"cell_type":"markdown","metadata":{},"source":["## **Символическая выжимка**\n","Р’Рѕ РјРЅРѕРіРёС… промышленных задачах требуется понимать, РёР· каких символов состоят данные. Напишите программу, чтобы РїРѕ введённой строке РѕРЅР° определяла, РёР· каких символов та состоит.\n","### **Формат РІРІРѕРґР°**\n","Вводится РѕРґРЅР° строка.\n","### **Формат вывода**\n","Требуется вывести РІСЃРµ символы этой строки без повторений.<br>РџРѕСЂСЏРґРѕРє вывода РЅРµ имеет значения.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|змееед|Р·РґРјРµ|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|велосипед|исолвдеп|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = set(input())\n","print(*s, sep=\"\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Символическая разница**\n","Рђ ещё РІ промышленных задачах часто требуется находить общее среди данных, полученных РёР· раных источников. Напишите программу, которая РїРѕ РґРІСѓРј строкам определяет РёС… общие символы.\n","### **Формат РІРІРѕРґР°**\n","Вводится РґРІРµ строки.\n","### **Формат вывода**\n","Требуется вывести РІСЃРµ символы этой строки без повторений.<br>РџРѕСЂСЏРґРѕРє вывода РЅРµ имеет значения.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|змееед<br>велосипед|ед<br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|мама<br>папа|Р°<br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = set(input()) & set(input())\n","print(*s, sep=\"\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Зайка — 8**\n","Продолжаем считать заек Р·Р° РѕРєРЅРѕРј поезда.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке записано натуральное число $N$ — количество выделенных придорожных местностей.<br>Р’ каждой РёР· $N$ последующих строк записано описание придорожной местности.\n","### **Формат вывода**\n","Вывести РІСЃРµ найденные объекты РІ придорожных местностях.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>березка елочка зайка волк березка<br>СЃРѕСЃРЅР° зайка СЃРѕСЃРЅР° елочка зайка медведь<br>СЃРѕСЃРЅР° СЃРѕСЃРЅР° СЃРѕСЃРЅР° белочка СЃРѕСЃРЅР° белочка<br> <br> <br> <br>|СЃРѕСЃРЅР°<br>березка<br>волк<br>елочка<br>медведь<br>белочка<br>зайка<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>зайка березка<br>березка зайка<br>березка елочка березка<br>елочка елочка елочка|березка<br>елочка<br>зайка<br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = set()\n","for _ in range(int(input())):\n"," for i in input().split():\n"," s.add(i)\n","\n","print(*s, sep=\"\\n\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Кашееды**\n","Каждый воспитанник детского сада любит либо манную, либо РѕРІСЃСЏРЅСѓСЋ, либо РѕР±Рµ каши.<br>Давайте создадим программу, которая позволит воспитателю быстро выяснить, сколько детей любят РѕР±Рµ каши.\n","### **Формат РІРІРѕРґР°**\n","Р’ первых РґРІСѓС… строках указывается количество детей, любящих манную Рё РѕРІСЃСЏРЅСѓСЋ каши ($N$ Рё $M$).<br>Затем РёРґСѓС‚ $N$ строк — фамилии детей, которые любят манную кашу, Рё $M$ строк СЃ фамилиями детей, любящих РѕРІСЃСЏРЅСѓСЋ кашу.<br>Гарантируется, что РІ РіСЂСѓРїРїРµ нет однофамильцев.\n","### **Формат вывода**\n","Количество учеников, которые любят РѕР±Рµ каши.<br>Если таких РЅРµ окажется, РІ строке вывода нужно написать «Таких нет».\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>2<br>Васильев<br>Петров<br>Васечкин<br>Рванов<br>Михайлов|Таких нет<br> <br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>3<br>Рванов<br>Петров<br>Васечкин<br>Рванов<br>Петров<br>Васечкин|3<br> <br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n, m = int(input()), int(input())\n","s = {input() for _ in range(n + m)}\n","\n","\n","sum = 2 * len(s) - m - n\n","if sum:\n"," print(sum)\n","else:\n"," print(\"Таких нет\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Кашееды — 2**\n","Рзменим задачу Рё напишем программу, которая поможет быстро выяснить, сколько детей любят только РѕРґРЅСѓ кашу.\n","### **Формат РІРІРѕРґР°**\n","Р’ первых РґРІСѓС… строках указывается количество детей, любящих манную Рё РѕРІСЃСЏРЅСѓСЋ каши ($N$ Рё $M$).<br>Затем РёРґСѓС‚ $N$+$M$ строк — перемешанные фамилии детей.<br>Гарантируется, что РІ РіСЂСѓРїРїРµ нет однофамильцев.\n","### **Формат вывода**\n","Количество учеников, которые любят только РѕРґРЅСѓ кашу.<br>Если таких РЅРµ окажется, РІ строке вывода нужно написать «Таких нет».\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>2<br>Васильев<br>Петров<br>Васечкин<br>Рванов<br>Михайлов|5<br> <br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>3<br>Рванов<br>Петров<br>Васечкин<br>Рванов<br>Петров<br>Васечкин|Таких нет<br> <br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n, m = int(input()), int(input())\n","s = {input() for _ in range(n + m)}\n","\n","\n","sum = 2 * len(s) - m - n\n","if sum:\n"," print(sum)\n","else:\n"," print(\"Таких нет\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Кашееды — 3**\n","Вернёмся Рє условию, РєРѕРіРґР° каждый воспитанник детского сада любит либо манную, либо РѕРІСЃСЏРЅСѓСЋ, либо РѕР±Рµ эти каши.<br>Напишите программу, которая позволит воспитателю узнать, какие дети любят только РѕРґРЅСѓ кашу.\n","### **Формат РІРІРѕРґР°**\n","Р’ первых РґРІСѓС… строках указывается количество детей, любящих манную Рё РѕРІСЃСЏРЅСѓСЋ каши ($N$ Рё $M$).<br>Затем РёРґСѓС‚ $N$+$M$ строк — перемешанные фамилии детей.<br>Гарантируется, что РІ РіСЂСѓРїРїРµ нет однофамильцев.\n","### **Формат вывода**\n","Р’ алфавитном РїРѕСЂСЏРґРєРµ фамилии учеников, которые любят только РѕРґРЅСѓ кашу.<br>Если таких РЅРµ окажется, РІ строке вывода нужно написать «Таких нет».\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>2<br>Васильев<br>Петров<br>Васечкин<br>Рванов<br>Михайлов|Васечкин<br>Васильев<br>Рванов<br>Михайлов<br>Петров<br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>3<br>Рванов<br>Петров<br>Васечкин<br>Рванов<br>Петров<br>Васечкин|Таких нет<br> <br> <br> <br> <br> <br> <br> <br>|\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["\n","n, m = int(input()), int(input())\n","s = set()\n","for _ in range(n + m):\n"," i = input()\n"," if i in s:\n"," s.remove(i)\n"," else:\n"," s.add(i)\n","\n","if s:\n"," s = sorted(list(s))\n"," print(*s, sep=\"\\n\")\n","else:\n"," print(\"Таких нет\")"]},{"cell_type":"markdown","metadata":{},"source":["## **РђР·Р±СѓРєР° РњРѕСЂР·Рµ**\n","Вам дан английский текст. Закодируйте его СЃ помощью азбуки РњРѕСЂР·Рµ Каждая Р±СѓРєРІР° заменяется РЅР° последовательность точек Рё тире. Р’ качестве тире используйте обычный дефис: -, Р° РІ качестве точки — точку .. Например, Р±СѓРєРІР° g превратится РІ трёхсимвольную строку --.. Между закодированными буквами ставится СЂРѕРІРЅРѕ РѕРґРёРЅ пробел. Например, слово Help превратится РІ .... . .-.. .--.. Обратите внимание, что строчные Рё заглавные Р±СѓРєРІС‹ кодируются одинаково.\n","### **Формат РІРІРѕРґР°**\n","Весь текст записан РІ единственной строке. Текст состоит РёР· английских Р±СѓРєРІ Рё пробелов, РґСЂСѓРіРёС… символов РІ тексте нет. Р’ тексте РЅРµ может быть РґРІСѓС… или более пробелов РїРѕРґСЂСЏРґ.\n","### **Формат вывода**\n","Выведите каждое слово РёСЃС…РѕРґРЅРѕРіРѕ текста, закодированное азбукой РњРѕСЂР·Рµ, РЅР° отдельной строке.<br>Количество строк РІ ответе должно совпадать СЃ количеством слов РІ РёСЃС…РѕРґРЅРѕРј тексте.\n","### **Примечание**\n","РћРґРёРЅ РёР· вариантов словаря СЃ РђР·Р±СѓРєРѕР№ РњРѕСЂР·Рµ:<br>\n"," 'A': '.-', 'B': '-...', 'C': '-.-.',<br> 'D': '-..', 'E': '.', 'F': '..-.',<br> 'G': '--.', 'H': '....', 'I': '..',<br> 'J': '.---', 'K': '-.-', 'L': '.-..',<br> 'M': '--', 'N': '-.', 'O': '---',<br> 'P': '.--.', 'Q': '--.-', 'R': '.-.',<br> 'S': '...', 'T': '-', 'U': '..-',<br> 'V': '...-', 'W': '.--', 'X': '-..-',<br> 'Y': '-.--', 'Z': '--..',<br> '0': '-----', '1': '.----', '2': '..---',<br> '3': '...--', '4': '....-', '5': '.....',<br> '6': '-....', '7': '--...', '8': '---..',<br> '9': '----.'\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Hello world<br> <br>|.... . .-.. .-.. ---<br>.-- --- .-. .-.. -..<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Help me SOS<br> <br> <br>|.... . .-.. .--.<br>-- .<br>... --- ...<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["morz = {\n"," 'A': '.-', 'B': '-...', 'C': '-.-.',\n"," 'D': '-..', 'E': '.', 'F': '..-.',\n"," 'G': '--.', 'H': '....', 'I': '..',\n"," 'J': '.---', 'K': '-.-', 'L': '.-..',\n"," 'M': '--', 'N': '-.', 'O': '---',\n"," 'P': '.--.', 'Q': '--.-', 'R': '.-.',\n"," 'S': '...', 'T': '-', 'U': '..-',\n"," 'V': '...-', 'W': '.--', 'X': '-..-',\n"," 'Y': '-.--', 'Z': '--..',\n"," '0': '-----', '1': '.----', '2': '..---',\n"," '3': '...--', '4': '....-', '5': '.....',\n"," '6': '-....', '7': '--...', '8': '---..',\n"," '9': '----.'\n","}\n","\n","arr = []\n","for s in input().split():\n"," word = []\n"," for i in s:\n"," word.append(morz[i.upper()])\n"," arr.append(\" \".join(word))\n","\n","print(*arr, sep=\"\\n\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Кашееды — 4**\n","Каждый воспитанник детского сада любит РѕРґРЅСѓ или несколько каш.<br>Поможем воспитателю составить СЃРїРёСЃРѕРє детей, которые любят конкретную кашу.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке задаётся количество детей РІ РіСЂСѓРїРїРµ ($N$). Р’ следующих $N$ строках записана фамилия ребенка Рё СЃРїРёСЃРѕРє его любимых каш. Р’ последней строке записана каша, информацию Рѕ которой хочет получить воспитатель.\n","### **Формат вывода**\n","Фамилии учеников, которые любят заданную кашу, РІ алфавитном РїРѕСЂСЏРґРєРµ.<br>Если таких РЅРµ окажется, РІ строке вывода нужно написать «Таких нет».\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br>Васильев манная<br>Петров манная<br>Васечкин манная<br>Рванов овсяная<br>Михайлов овсяная<br>манная|Васечкин<br>Васильев<br>Петров<br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>Рванов манная овсяная<br>Петров манная овсяная<br>Васечкин манная овсяная<br>гречневая|Таких нет<br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["d = {}\n","\n","for _ in range(int(input())):\n"," data = input().split()\n"," for i in data[1:]:\n"," if i in d.keys():\n"," d[i].append(data[0])\n"," else:\n"," d[i] = [data[0]]\n","\n","m = input()\n","\n","if m in d.keys():\n"," arr = d[m]\n"," print(*sorted(arr), sep=\"\\n\")\n","else:\n"," print(\"Таких нет\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Зайка — 9**\n","Поможем детям подсчитать, сколько Р·Р° РѕРєРЅРѕРј поезда встречается животных Рё деревьев каждого РІРёРґР°.\n","### **Формат РІРІРѕРґР°**\n","Р’ каждой строке записано описание придорожной местности.<br>Конец РІРІРѕРґР° обозначается пустой строкой.\n","### **Формат вывода**\n","РЎРїРёСЃРѕРє увиденного Рё РёС… количество.<br>РџРѕСЂСЏРґРѕРє вывода РЅРµ имеет значения.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|березка елочка зайка волк березка<br>СЃРѕСЃРЅР° зайка СЃРѕСЃРЅР° елочка зайка медведь<br>СЃРѕСЃРЅР° СЃРѕСЃРЅР° СЃРѕСЃРЅР° белочка СЃРѕСЃРЅР° белочка<br> <br> <br> <br> <br> <br>|<br>березка 2<br>елочка 2<br>зайка 3<br>волк 1<br>СЃРѕСЃРЅР° 6<br>медведь 1<br>белочка 2<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|зайка березка<br>березка зайка<br>березка елочка березка<br>елочка елочка елочка<br>|зайка 2<br>березка 4<br>елочка 4<br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["d = {}\n","\n","s = input()\n","while s:\n"," for i in s.split():\n"," if i in d.keys():\n"," d[i] += 1\n"," else:\n"," d[i] = 1\n"," \n"," s = input()\n","\n","for m in d.keys():\n"," print(m, d[m])"]},{"cell_type":"markdown","metadata":{},"source":["## **Транслитерация**\n","Для международных документов СЂСѓСЃСЃРєРёР№ текст преобразуется СЃ использованием латинского алфавита.<br>ГОСТ Р 52535.1-2006 задаёт правила транслитерации идентификационных карт.<br>Ниже приведена таблица замен:<br>\n","Рђ — A<br>Р‘ — B<br>Р’ — V<br>Р“ — G<br>Р” — D<br>Р• — E<br>РЃ — E<br>Р– — ZH<br>Р— — Z<br>Р— I<br>Р™ — I<br>Рљ — K<br>Р› — L<br>Рњ — M<br>Рќ — N<br>Рћ — O<br>Рџ — P<br>Р— R<br>РЎ — S<br>Рў — T<br>РЈ — U<br>Р¤ — F<br>РҐ — KH<br>Р¦ — TC<br>Р§ — CH<br>РЁ — SH<br>Р© — SHCH<br>Р« — Y<br>Р— E<br>Р® — IU<br>РЇ — IA<br>Давайте транслитерируем СЂСѓСЃСЃРєРёР№ текст.<br><br>Букву «ё» транслитерируйте как В«eВ», «й» как «и», Р° «ъ» Рё «ь» (Рё РёС… заглавные версии «Ъ» Рё «Ь») должны исчезнуть РёР· текста. Строчные Р±СѓРєРІС‹ заменяются РЅР° строчные, заглавные заменяются РЅР° заглавные. Если заглавная Р±СѓРєРІР° превращается РїСЂРё транслитерации РІ несколько Р±СѓРєРІ, то заглавной должна остаться только первая РёР· РЅРёС… (например, «Ц» в†’ В«TcВ»). Р’СЃРµ некириллические символы должны остаться РЅР° месте.\n","### **Формат РІРІРѕРґР°**\n","Р’ единственной строке задан СЂСѓСЃСЃРєРёР№ текст. Текст может состоять РёР· любых символов. Вам необходимо транслитерировать только СЂСѓСЃСЃРєРёРµ Р±СѓРєРІС‹, Р° остальные оставить РЅР° месте. Гарантируется, что нет слов, состоящих только РёР· Р±СѓРєРІ «ъ» Рё «ь».\n","### **Формат вывода**\n","Выведите РѕРґРЅСѓ строку — транслитерированный текст.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Привет, РјРёСЂ!|Privet, mir!|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|РЇ РїРѕРјРЅСЋ чудное мгновенье: Передо РјРЅРѕР№ явилась ты, Как мимолетное виденье, Как гений чистой красоты.|Ia pomniu chudnoe mgnovene: Peredo mnoi iavilas ty, Kak mimoletnoe videne, Kak genii chistoi krasoty.|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["d = {\n"," 'Рђ': 'A',\n"," 'Р°': 'a',\n"," 'Р‘': 'B',\n"," 'Р±': 'b',\n"," 'Р’': 'V',\n"," 'РІ': 'v',\n"," 'Р“': 'G',\n"," 'Рі': 'g',\n"," 'Р”': 'D',\n"," 'Рґ': 'd',\n"," 'Р•': 'E',\n"," 'Рµ': 'e',\n"," 'РЃ': 'E',\n"," 'С‘': 'e',\n"," 'Р–': 'Zh',\n"," 'Р¶': 'zh',\n"," 'Р—': 'Z',\n"," 'Р·': 'z',\n"," 'Р': 'I',\n"," 'Рё': 'i',\n"," 'Р™': 'I',\n"," 'Р№': 'i',\n"," 'Рљ': 'K',\n"," 'Рє': 'k',\n"," 'Р›': 'L',\n"," 'Р»': 'l',\n"," 'Рњ': 'M',\n"," 'Рј': 'm',\n"," 'Рќ': 'N',\n"," 'РЅ': 'n',\n"," 'Рћ': 'O',\n"," 'Рѕ': 'o',\n"," 'Рџ': 'P',\n"," 'Рї': 'p',\n"," 'Р ': 'R',\n"," 'СЂ': 'r',\n"," 'РЎ': 'S',\n"," 'СЃ': 's',\n"," 'Рў': 'T',\n"," 'С‚': 't',\n"," 'РЈ': 'U',\n"," 'Сѓ': 'u',\n"," 'Р¤': 'F',\n"," 'С„': 'f',\n"," 'РҐ': 'Kh',\n"," 'С…': 'kh',\n"," 'Р¦': 'Tc',\n"," 'С†': 'tc',\n"," 'Р§': 'Ch',\n"," 'С‡': 'ch',\n"," 'РЁ': 'Sh',\n"," 'С€': 'sh',\n"," 'Р©': 'Shch',\n"," 'С‰': 'shch',\n"," 'Р«': 'Y',\n"," 'С‹': 'y',\n"," 'Р': 'E',\n"," 'СЌ': 'e',\n"," 'Р®': 'Iu',\n"," 'СЋ': 'iu',\n"," 'РЇ': 'Ia',\n"," 'СЏ': 'ia'\n","}\n","\n","s = input()\n","new_s = \"\"\n","for i in s: \n"," if i in d.keys():\n"," new_s += d[i]\n"," elif i.lower() in [\"СЊ\", \"СЉ\"]:\n"," continue\n"," else:\n"," new_s += i\n","\n","print(new_s)"]},{"cell_type":"markdown","metadata":{},"source":["## **Однофамильцы**\n","Начальник кадровой службы хочет выяснить, сколько мужчин-однофамильцев работает РІ организации. РЈ него есть СЃРїРёСЃРѕРє фамилий, Рё РЅР° основании этого СЃРїРёСЃРєР° нужно вычислить количество фамилий, которые совпадают СЃ РґСЂСѓРіРёРјРё.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке указывается количество мужчин — сотрудников организации ($N$).<br>Затем РёРґСѓС‚ $N$ строк СЃ фамилиями этих сотрудников РІ произвольном РїРѕСЂСЏРґРєРµ.\n","### **Формат вывода**\n","Количество однофамильцев РІ организации.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|6<br>Рванов<br>Петров<br>РЎРёРґРѕСЂРѕРІ<br>Петров<br>Рванов<br>Петров|5<br> <br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>Рванов<br>Петров<br>РЎРёРґРѕСЂРѕРІ|0<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["d = {}\n","for _ in range(int(input())):\n"," f = input()\n"," d[f] = 1 + d.get(f, 0)\n","\n","c = 0\n","for f in d.keys():\n"," if d[f] - 1:\n"," c += d[f]\n","\n","print(c)"]},{"cell_type":"markdown","metadata":{},"source":["## **Однофамильцы — 2**\n","Р’РЅРѕРІСЊ поможем сотруднику РёР· отдела кадров выяснить, сколько мужчин-однофамильцев работает РІ организации, РЅРѕ уже немного СЃ иными условиями.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке указывается количество мужчин — сотрудников организации ($N$).<br>Затем РёРґСѓС‚ $N$ строк СЃ фамилиями этих сотрудников РІ произвольном РїРѕСЂСЏРґРєРµ.\n","### **Формат вывода**\n","РЎРїРёСЃРѕРє однофамильцев РІ организации СЃ указанием РёС… количества РІ алфавитном РїРѕСЂСЏРґРєРµ.<br>Если таковых нет — вывести «Однофамильцев нет».\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|6<br>Рванов<br>Петров<br>РЎРёРґРѕСЂРѕРІ<br>Петров<br>Рванов<br>Петров|Рванов - 2<br>Петров - 3<br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>Рванов<br>Петров<br>РЎРёРґРѕСЂРѕРІ|Однофамильцев нет<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["d = {}\n","for _ in range(int(input())):\n"," f = input()\n"," d[f] = 1 + d.get(f, 0)\n","\n","c = 0\n","for f in sorted(d.keys()):\n"," if d[f] - 1:\n"," print(f, \"-\", d[f])\n"," c += 1\n","\n","if not c:\n"," print(\"Однофамильцев нет\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Дайте чего-РЅРёР±СѓРґСЊ новенького!**\n","Главный повар детского сада хочет приготовить РІ праздничный день блюда, которые РЅРё разу РЅРµ готовил РЅР° этой неделе.<br>Р’ его распоряжении есть СЃРїРёСЃРѕРє блюд:<br>\n","* которые можно приготовить РІ столовой сегодня;\n","* которые были приготовлены РІ каждый РёР· дней недели.\n","\n","\n","### **Формат РІРІРѕРґР°**\n","Число блюд ($N$), которые можно приготовить РІ столовой.<br>$N$ строк СЃ названиями блюд. Число дней ($M$), Рѕ которых имеется информация.<br>$M$ блоков строк для каждого РёР· СЃРїРёСЃРєРѕРІ. Р’ первой строке каждого блока записано число блюд РІ заданный день, затем перечисляются эти блюда.\n","### **Формат вывода**\n","РЎРїРёСЃРѕРє блюд, которые ещё РЅРµ готовились РЅР° этой неделе РІ алфавитном РїРѕСЂСЏРґРєРµ.<br>Если РІСЃРµ возможные блюда уже были приготовлены, следует вывести «Готовить нечего».\n","### **Пример**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5<br>РћРІСЃСЏРЅРєР°<br>Р РёСЃ<br>РЎСѓРї<br>Манная каша<br>Рыба<br>2<br>3<br>Р РёСЃ<br>РЎСѓРї<br>Рыба<br>2<br>Р РёСЃ<br>Рыба|Манная каша<br>РћРІСЃСЏРЅРєР°<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = {input() for _ in range(int(input()))}\n","\n","for _ in range(int(input())):\n"," for _ in range(int(input())):\n"," f = input()\n"," if f in s:\n"," s.remove(f)\n","\n","if s:\n"," print(*sorted(list(s)), sep=\"\\n\")\n","else:\n"," print(\"Готовить нечего\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Рто будет шедевр!**\n","Главный повар детского сада хочет быстрее выбирать блюда для готовки.<br>Р’ его распоряжении есть СЃРїРёСЃРѕРє продуктов, Р° также набор блюд.<br><br>Напишите программу, СЃРїРѕСЃРѕР±РЅСѓСЋ быстро определить блюда, которые можно приготовить.\n","### **Формат РІРІРѕРґР°**\n","Число продуктов ($N$), которые имеются РІ наличии.<br>$N$ строк СЃ названиями продуктов.<br>Число рецептов ($M$), Рѕ которых имеется информация.<br>$M$ блоков строк для каждого РёР· рецептов.<br>Р’ первой строке каждого блока записано название блюда.<br>Р’Рѕ второй — число ингредиентов.<br>Затем перечисляются сами ингредиенты, требуемые для приготовления блюда.\n","### **Формат вывода**\n","РЎРїРёСЃРѕРє блюд, которые можно приготовить РІ алфавитном РїРѕСЂСЏРґРєРµ.<br>Если РЅРё РѕРґРЅРѕ РёР· блюд нельзя приготовить, следует вывести «Готовить нечего».\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|4<br>Яблоки<br>Хлеб<br>Варенье<br>Картошка<br>3<br>Тосты<br>2<br>Хлеб<br>Варенье<br>Яблочный РЎРѕРє<br>1<br>Яблоки<br>Яичница<br>1<br>Яйца|Тосты<br>Яблочный РЎРѕРє<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|1<br>хлеб<br>1<br>бутерброд<br>2<br>масло<br>хлеб|Готовить нечего<br> <br> <br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["n = int(input())\n","food_set = set()\n","for _ in range(n):\n"," food_set.add(input())\n","\n","res = []\n","d = {}\n","m = int(input())\n","for i in range(m):\n"," dish = input()\n"," d[dish] = set()\n"," for j in range(int(input())):\n"," d[dish] = d[dish] | ({input()})\n","\n","for i in d.keys():\n"," if d[i] | food_set == food_set:\n"," res.append(i)\n","\n","if res:\n"," print(*sorted(res), sep=\"\\n\")\n","else:\n"," print(\"Готовить нечего\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Двоичная статистика!**\n","РЈ программистов особые отношения СЃ двоичной системой счисления.<br>Продолжим тренировки РІ статистической обработке данных Рё проанализируем данные числа.<br>Напишите программу, которая для переданных чисел вычисляет:<br>\n","* количество разрядов;\n","* количество единиц;\n","* количество нулей.\n","\n","\n","### **Формат РІРІРѕРґР°**\n","Вводится последовательность чисел, записанных через пробел.\n","### **Формат вывода**\n","Вывести СЃРїРёСЃРѕРє словарей СЃ требуемой статистикой.\n","### **Примечание**\n","Вывод РІ примерах отформатирован только для визуальной наглядности.<br>Р’СЃРµ пробельные символы РїСЂРё проверке игнорируются.<br>РџРѕСЂСЏРґРѕРє словарей обязан совпадать СЃ РїРѕСЂСЏРґРєРѕРј переданных чисел.<br>РџРѕСЂСЏРґРѕРє ключей РІ словаре РЅРµ имеет значения.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|5 8 12<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|[<br> {<br> \"digits\": 3,<br> \"units\": 2,<br> \"zeros\": 1<br> },<br> {<br> \"digits\": 4,<br> \"units\": 1,<br> \"zeros\": 3<br> },<br> {<br> \"digits\": 4,<br> \"units\": 2,<br> \"zeros\": 2<br> }<br>]<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|13 2 7<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|[<br> {<br> \"digits\": 4,<br> \"units\": 3,<br> \"zeros\": 1<br> },<br> {<br> \"digits\": 2,<br> \"units\": 1,<br> \"zeros\": 1<br> },<br> {<br> \"digits\": 3,<br> \"units\": 3,<br> \"zeros\": 0<br> }<br>]<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["digits = [int(i) for i in input().split()]\n","dig_dicts = []\n","for dig in digits:\n"," b = bin(dig)[2:]\n"," dig_dicts.append({\"digits\": len(b), \"units\": b.count(\"1\"), \"zeros\": b.count(\"0\")})\n","\n","\n","print(dig_dicts)\n"]},{"cell_type":"markdown","metadata":{},"source":["## **Зайка — 10**\n","Поможем детям разобраться, что именно РѕРЅРё увидели СЂСЏРґРѕРј СЃ зайками.\n","### **Формат РІРІРѕРґР°**\n","Р’ каждой строке записано описание придорожной местности.<br>Конец РІРІРѕРґР° обозначается пустой строкой.\n","### **Формат вывода**\n","Определите СЃРїРёСЃРѕРє увиденного СЂСЏРґРѕРј СЃ зайками без повторений.<br>РџРѕСЂСЏРґРѕРє вывода РЅРµ имеет значения.\n","### **Примечание**\n","Считается, что объект находится СЂСЏРґРѕРј, если РѕРЅ записан справа или слева РѕС‚ требуемого.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|березка елочка зайка волк березка<br>СЃРѕСЃРЅР° зайка СЃРѕСЃРЅР° елочка зайка медведь<br>СЃРѕСЃРЅР° СЃРѕСЃРЅР° СЃРѕСЃРЅР° белочка СЃРѕСЃРЅР° белочка<br> <br>|волк<br>елочка<br>медведь<br>СЃРѕСЃРЅР°|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|зайка березка<br>березка зайка<br>березка елочка березка<br>елочка елочка елочка<br> <br>|березка<br> <br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input()\n","res = set()\n","while s:\n"," arr = s.split()\n"," for i in range(len(arr)):\n"," if \"зайка\" == arr[i]:\n"," if i > 0:\n"," res.add(arr[i - 1])\n"," if i < len(arr) - 1:\n"," res.add(arr[i + 1])\n","\n","\n"," s = input()\n","\n","print(*list(res), sep=\"\\n\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Друзья друзей**\n","Теория шести рукопожатий — социологическая теория, согласно которой любые РґРІР° человека РЅР° Земле разделены РЅРµ более, чем пятью СѓСЂРѕРІРЅСЏРјРё общих знакомых (Рё, соответственно, шестью СѓСЂРѕРІРЅСЏРјРё связей). Формальная математическая формулировка теории: диаметр графа знакомств РЅРµ превышает 6. РњС‹ РЅРµ станем так сильно углубляться РІ дружественные СЃРІСЏР·Рё Рё РїРѕРєР° нам хватит только РґРІСѓС… уровней. Напишите программу, которая РїРѕ СЃРїРёСЃРєСѓ дружественных пар для каждого человека определяет СЃРїРёСЃРѕРє «друзей 2-РіРѕ СѓСЂРѕРІРЅСЏВ».\n","### **Формат РІРІРѕРґР°**\n","Р’ каждой строке записывается РґРІР° имени.<br>Окончанием РІРІРѕРґР° служит пустая строка.\n","### **Формат вывода**\n","Выведите СЃРїРёСЃРѕРє всех людей Рё РёС… «друзей 2-РіРѕ СѓСЂРѕРІРЅСЏВ» РІ формате «Человек: Друг1, Друг2, ...В».<br>РЎРїРёСЃРѕРє людей Рё друзей РІ каждой строке требуется вывести РІ алфавитном РїРѕСЂСЏРґРєРµ без повторений.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Рванов Петров<br>Рванов Сергеев<br>Васильев Петров<br>Сергеев Яковлев<br>Петров Кириллов<br>Петров Яковлев<br> <br>|Васильев: Рванов, Кириллов, Яковлев<br>Рванов: Васильев, Кириллов, Яковлев<br>Кириллов: Васильев, Рванов, Яковлев<br>Петров: Сергеев<br>Сергеев: Петров<br>Яковлев: Васильев, Рванов, Кириллов<br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|Николай Фёдор<br>Николай Женя<br>Фёдор Женя<br>Фёдор Рлья<br>Рлья Фёдор<br> <br>|Женя: Рлья<br>Рлья: Женя, Николай<br>Николай: Рлья<br>Фёдор: <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["s = input().split()\n","people = set()\n","connects = {}\n","while s:\n"," people.add(s[0])\n"," people.add(s[1])\n","\n"," connects[s[0]] = connects.get(s[0], []) + [s[1]]\n"," connects[s[1]] = connects.get(s[1], []) + [s[0]]\n"," s = input().split()\n","\n","for pers in sorted(list(people)):\n"," con = [[pers, second] for second in connects[pers]]\n"," con_new = []\n"," for elem in con:\n"," if elem[-1] in connects.keys():\n"," for friend in connects[elem[-1]]:\n"," if friend != pers and friend not in connects[elem[0]]:\n"," con_new.append(elem + [friend])\n"," con = con_new\n"," print(f\"{pers}:\", end=\" \")\n"," res = set()\n"," for elem in con:\n"," res.add(elem[-1])\n"," print(*sorted(list(res)), sep=\", \")"]},{"cell_type":"markdown","metadata":{},"source":["## **Карта СЃРѕРєСЂРѕРІРёС‰**\n","РќР° пиратской карте отмечено N точек, РІ которых зарыты сокровища. Каждая точка задана координатами ($x_i$, $y_i$). Координаты указаны РІ километрах. Команда Капитана РљСЂСЋРєР° хочет составить маршрут, чтобы собрать как можно больше кладов. Однако есть ограничение: для любых РґРІСѓС… соседних точек маршрута ($x_i$, $y_i$) Рё ($x_j$, $y_j$) координаты $x_i$ Рё $x_j$ РјРѕРіСѓС‚ различаться только последней цифрой, как Рё координаты $y_i$ Рё $y_j$ тоже РјРѕРіСѓС‚ различаться только последней цифрой. Например, после точки (15, 10) РѕРЅРё РјРѕРіСѓС‚ отправиться РІ точку (18, 16), Р° РІРѕС‚ РёР· точки (14, 68) РІ точку (19, 71) пройти уже РЅРµ получится, ведь 68 Рё 71 различаются РЅРµ только последней цифрой. РР· точки (5, 12) РІ точку (13, 14) попасть тоже нельзя, так как числа 5 Рё 13 отличаются РІ разряде десятков. РџРѕ заданным координатам определите, какое максимальное количество точек сможет добавить РІ СЃРІРѕР№ маршрут Капитан РљСЂСЋРє.\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке указано число $N$ ($1≤N≤10^5$) — количество точек, отмеченных РЅР° карте СЃРѕРєСЂРѕРІРёС‰. Р’ следующих N строках содержатся пары координат: $x_i$ Рё $y_i$ — координаты $i$-РѕР№ точки. Координаты — целые числа РЅРµ меньше нуля Рё РЅРµ больше $10^9$. Гарантируется, что совпадающих точек РІ СЃРїРёСЃРєРµ нет.\n","### **Формат вывода**\n","Выведите РѕРґРЅРѕ число — максимальное количество точек, которое Капитан РљСЂСЋРє сможет посетить РїРѕ маршруту, построенному РїРѕ описанным правилам.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|9<br>10 18<br>17 15<br>25 21<br>0 21<br>1 16<br>25 29<br>24 24<br>8 26<br>10 20|3<br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>12 113<br>114 15<br>16 117|2<br> <br> <br> <br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["coords = set()\n","connects = {}\n","for _ in range(int(input())):\n"," new_coord = tuple(input().split())\n"," coords.add(new_coord)\n","\n","for coord in coords:\n"," for new_coord in coords:\n"," if new_coord[0][:-1] == coord[0][:-1] and new_coord[1][:-1] == coord[1][:-1]:\n"," connects[coord] = connects.get(coord, 0) + 1\n","\n","\n","print(max(connects.values()))"]},{"cell_type":"markdown","metadata":{},"source":["## **Частная собственность**\n","Ребята РїСЂРёРЅРѕСЃСЏС‚ игрушки РІ детский сад Рё играют РІСЃРµ вместе.<br>Сегодня РѕРЅРё решили выяснить, игрушки какого типа принадлежат только РѕРґРЅРѕРјСѓ РёР· детей. Напишите программу, которая РїРѕ СЃРїРёСЃРєСѓ детей Рё РёС… игрушек определит «частную собственность».\n","### **Формат РІРІРѕРґР°**\n","Р’ первой строке задается количество детей РІ РіСЂСѓРїРїРµ ($N$).<br>Р’ каждой РёР· следующих $N$ строк записано РёРјСЏ ребенка Рё его игрушки РІ формате:\n","### **Формат вывода**\n","РЎРїРёСЃРѕРє игрушек, которые есть только Сѓ РѕРґРЅРѕРіРѕ РёР· детей РІ алфавитном РїРѕСЂСЏРґРєРµ.\n","### **Пример**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|3<br>РђРЅСЏ: кукла, машинка, кукла, РґРѕРјРёРє<br>Боря: машинка, зайчик<br>Р’РѕРІР°: РєСѓР±РёРєРё, машинка|РґРѕРјРёРє<br>зайчик<br>РєСѓР±РёРєРё<br>кукла|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["arr = []\n","for _ in range(int(input())):\n"," toys = input().split(\", \")\n"," toys = toys[0].split(\": \") + toys[1:]\n"," arr.append(set(toys[1:]))\n","\n","res = []\n","for i in range(len(arr)):\n"," temp = set()\n"," for elem in arr[:i] + arr[i + 1:]:\n"," temp = temp | elem\n"," res += list(arr[i] - temp)\n","\n","print(*sorted(res), sep=\"\\n\")"]},{"cell_type":"markdown","metadata":{},"source":["## **Простая задача 4.0**\n","Напомним, что взаимно простыми называются числа, которые РЅРµ имеют общих делителей РєСЂРѕРјРµ 1. Напишите программу, которая для каждого переданного числа находит СЃРїРёСЃРѕРє его взаимно простых.\n","### **Формат РІРІРѕРґР°**\n","Задана последовательность чисел записанных через точку СЃ запятой (;) Рё пробел.\n","### **Формат вывода**\n","РЎРїРёСЃРѕРє чисел СЃ указанием взаимно простых ему среди переданных.<br>Р’СЃРµ числа должны быть выведены РІ РїРѕСЂСЏРґРєРµ возрастания без повторений.<br>Строки следует отформатировать РїРѕ правилу:<br>Если для числа РЅРµ было найдено РЅРё РѕРґРЅРѕРіРѕ взаимно простого, то Рё выводить его РЅРµ требуется.\n","### **Пример 1**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|2 - 3, 5, 7, 9, 11, 13, 15, 17, 19<br>3 - 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20<br>4 - 3, 5, 7, 9, 11, 13, 15, 17, 19<br>5 - 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19<br>6 - 5, 7, 11, 13, 17, 19<br>7 - 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20<br>8 - 3, 5, 7, 9, 11, 13, 15, 17, 19<br>9 - 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20<br>10 - 3, 7, 9, 11, 13, 17, 19<br>11 - 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20<br>12 - 5, 7, 11, 13, 17, 19<br>13 - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20<br>14 - 3, 5, 9, 11, 13, 15, 17, 19<br>15 - 2, 4, 7, 8, 11, 13, 14, 16, 17, 19<br>16 - 3, 5, 7, 9, 11, 13, 15, 17, 19<br>17 - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20<br>18 - 5, 7, 11, 13, 17, 19<br>19 - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20<br>20 - 3, 7, 9, 11, 13, 17, 19<br>|\n","### **Пример 2**\n","|Р’РІРѕРґ |Вывод|\n","|-----|-----|\n","|7; 2; 2; 12; 14; 7; 2; 49<br> <br> <br> <br>|2 - 7, 49<br>7 - 2, 12<br>12 - 7, 49<br>49 - 2, 12<br>|"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["def find_nums(a, b):\n"," while b != 0:\n"," a, b = b, a % b\n"," return a == 1\n","\n","d = {}\n","arr = sorted(list(set([int(i) for i in input().split(\"; \")])))\n","\n","for i in range(len(arr)):\n"," res = []\n"," for num in arr[:i] + arr[i + 1:]:\n"," if find_nums(num, arr[i]):\n"," res.append(num)\n"," if res:\n"," d[arr[i]] = res\n","\n","for k in d.keys():\n"," print(f\"{k} -\", end=\" \")\n"," print(*d[k], sep=\", \")"]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.11.1"}},"nbformat":4,"nbformat_minor":2}
diff --git a/3.2/4.py b/3.2/4.py
deleted file mode 100644
index 9008f7ce7e07ab38b365773fba7daccfad6907da..0000000000000000000000000000000000000000
--- a/3.2/4.py
+++ /dev/null
@@ -1,9 +0,0 @@
-n, m = int(input()), int(input())
-s = {input() for _ in range(n + m)}
-
-
-sum = 2 * len(s) - m - n
-if sum:
- print(sum)
-else:
- print("Таких нет")
\ No newline at end of file
diff --git a/3.2/5.py b/3.2/5.py
deleted file mode 100644
index 9008f7ce7e07ab38b365773fba7daccfad6907da..0000000000000000000000000000000000000000
--- a/3.2/5.py
+++ /dev/null
@@ -1,9 +0,0 @@
-n, m = int(input()), int(input())
-s = {input() for _ in range(n + m)}
-
-
-sum = 2 * len(s) - m - n
-if sum:
- print(sum)
-else:
- print("Таких нет")
\ No newline at end of file
diff --git a/3.2/6.py b/3.2/6.py
deleted file mode 100644
index d22382843bfc4a481d76c3ea54a0f58156158936..0000000000000000000000000000000000000000
--- a/3.2/6.py
+++ /dev/null
@@ -1,15 +0,0 @@
-
-n, m = int(input()), int(input())
-s = set()
-for _ in range(n + m):
- i = input()
- if i in s:
- s.remove(i)
- else:
- s.add(i)
-
-if s:
- s = sorted(list(s))
- print(*s, sep="\n")
-else:
- print("Таких нет")
\ No newline at end of file
diff --git a/3.2/7.py b/3.2/7.py
deleted file mode 100644
index e6dcbe90f7432581cad181e1e90f44257d4ac7ea..0000000000000000000000000000000000000000
--- a/3.2/7.py
+++ /dev/null
@@ -1,24 +0,0 @@
-morz = {
- 'A': '.-', 'B': '-...', 'C': '-.-.',
- 'D': '-..', 'E': '.', 'F': '..-.',
- 'G': '--.', 'H': '....', 'I': '..',
- 'J': '.---', 'K': '-.-', 'L': '.-..',
- 'M': '--', 'N': '-.', 'O': '---',
- 'P': '.--.', 'Q': '--.-', 'R': '.-.',
- 'S': '...', 'T': '-', 'U': '..-',
- 'V': '...-', 'W': '.--', 'X': '-..-',
- 'Y': '-.--', 'Z': '--..',
- '0': '-----', '1': '.----', '2': '..---',
- '3': '...--', '4': '....-', '5': '.....',
- '6': '-....', '7': '--...', '8': '---..',
- '9': '----.'
-}
-
-arr = []
-for s in input().split():
- word = []
- for i in s:
- word.append(morz[i.upper()])
- arr.append(" ".join(word))
-
-print(*arr, sep="\n")
\ No newline at end of file
diff --git a/3.2/8.py b/3.2/8.py
deleted file mode 100644
index b274c88c5da4eb9bfb3e63ae8ba4b0ac11797ee9..0000000000000000000000000000000000000000
--- a/3.2/8.py
+++ /dev/null
@@ -1,17 +0,0 @@
-d = {}
-
-for _ in range(int(input())):
- data = input().split()
- for i in data[1:]:
- if i in d.keys():
- d[i].append(data[0])
- else:
- d[i] = [data[0]]
-
-m = input()
-
-if m in d.keys():
- arr = d[m]
- print(*sorted(arr), sep="\n")
-else:
- print("Таких нет")
\ No newline at end of file
diff --git a/3.2/9.py b/3.2/9.py
deleted file mode 100644
index 52cf0cceca94ec6db48ff6bdaa33f9eb3c51dcc8..0000000000000000000000000000000000000000
--- a/3.2/9.py
+++ /dev/null
@@ -1,14 +0,0 @@
-d = {}
-
-s = input()
-while s:
- for i in s.split():
- if i in d.keys():
- d[i] += 1
- else:
- d[i] = 1
-
- s = input()
-
-for m in d.keys():
- print(m, d[m])
\ No newline at end of file
diff --git a/3.3/1.py b/3.3/1.py
deleted file mode 100644
index 1099fd17d2d79c20ab7af7d9e663ec3e37e49ebd..0000000000000000000000000000000000000000
--- a/3.3/1.py
+++ /dev/null
@@ -1 +0,0 @@
-[i ** 2 for i in range(a, b)]
\ No newline at end of file
diff --git a/3.3/10.py b/3.3/10.py
deleted file mode 100644
index 9697c86c44abbbb5a38b5c91f848e376b1cc6054..0000000000000000000000000000000000000000
--- a/3.3/10.py
+++ /dev/null
@@ -1 +0,0 @@
-"".join(["".join([rle[i][0] for j in range(rle[i][1])]) for i in range(len(rle))])
\ No newline at end of file
diff --git a/3.3/2.py b/3.3/2.py
deleted file mode 100644
index 185924224312f3479010231d117c2c462007c517..0000000000000000000000000000000000000000
--- a/3.3/2.py
+++ /dev/null
@@ -1 +0,0 @@
-[[(i + 1) * (j + 1) for j in range(n)] for i in range(n)]
\ No newline at end of file
diff --git a/3.3/3.py b/3.3/3.py
deleted file mode 100644
index 5691608c120f248d2d23e3ec5ce127d0545de26d..0000000000000000000000000000000000000000
--- a/3.3/3.py
+++ /dev/null
@@ -1 +0,0 @@
-[len(s) for s in sentence.split()]
\ No newline at end of file
diff --git a/3.3/33.ipynb b/3.3/33.ipynb
deleted file mode 100644
index bde909db6c721b89ef3fdee227c8a4de5bdd3fad..0000000000000000000000000000000000000000
--- a/3.3/33.ipynb
+++ /dev/null
@@ -1,287 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Список квадратов**\n",
- "Большинство задач этой главы ориентированы на отработку навыков по построению списочных выражений.<br><br>Вашему решению будет предоставлены две переменные a и b. Напишите списочное выражения для получения квадратов чисел из диапазона [a,b].\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме списочного выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|a = 1<br>b = 5<br>|[1, 4, 9, 16, 25]<br> <br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|a = -5<br>b = 5<br>|[25, 16, 9, 4, 1, 0, 1, 4, 9, 16, 25]<br> <br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "[i ** 2 for i in range(a, b)]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Таблица умножения 2.0**\n",
- "Вашему решению будет предоставлена единственная переменная n — необходимый размер таблицы умножения.<br><br>Напишите списочное выражения для генерации таблицы умножения.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме списочного выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|n = 3<br>|[[1, 2, 3], [2, 4, 6], [3, 6, 9]]<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|n = 4<br>|[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "[[(i + 1) * (j + 1) for j in range(n)] for i in range(n)]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Длины всех слов**\n",
- "Вашему решению будет предоставлена строка sentence слов, разделённых пробелами.<br><br>Напишите списочное выражения для генерации списка длин слов.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме списочного выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|sentence = 'Мама мыла раму'<br>|[4, 4, 4]<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|sentence = 'Ехали медведи на велосипеде'<br>|[5, 7, 2, 10]<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "[len(s) for s in sentence.split()]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Множество нечетных чисел**\n",
- "Вашему решению будет предоставлен список numbers, содержащий натуральные числа.<br><br>Напишите выражение для генерации множества всех нечётных чисел среди переданных.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = [1, 2, 3, 4, 5]<br>|{1, 3, 5}<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = [1, 2, 3, 2, 1, 2, 3, 2, 1, 2]<br>|{1, 3}<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "{i for i in numbers}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Множество всех полных квадратов**\n",
- "Полным квадратом назовём натуральное число, которое является квадратом другого натурального числа. Например: 1, 25, 144.<br><br>Вашему решению будет предоставлен список numbers, содержащий натуральные числа.<br><br>Разработайте выражение для генерации множества всех чисел, которые выступают полными квадратами.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = [1, 2, 3, 4, 5]<br>|{1, 4}<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = [number for number in range(16, 100, 4)]<br>|{16, 64, 36}<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "{n for n in numbers if n ** 0.5 % 1 == 0}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Буквенная статистика**\n",
- "Вашему решению будет предоставлена строка text.<br><br>Напишите выражение для генерации словаря, который содержит информацию о частоте употребления букв в заданной строке.<br><br>При анализе не учитывайте регистр, а ключами словаря сделайте использованные в строке буквы в нижнем регистре.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|text = 'Мама мыла раму!'<br>|{'а': 4, 'л': 1, 'м': 4, 'р': 1, 'у': 1, 'ы': 1}<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|text = '''Ехали медведи<br>На велосипеде.<br><br>А за ними кот<br>Задом наперёд.'''<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|{ 'а': 6,<br> 'в': 2,<br> 'д': 5,<br> 'е': 7,<br> 'з': 2,<br> 'и': 5,<br> 'к': 1,<br> 'л': 2,<br> 'м': 3,<br> 'н': 3,<br> 'о': 3,<br> 'п': 2,<br> 'р': 1,<br> 'с': 1,<br> 'т': 1,<br> 'х': 1,<br> 'ё': 1}<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "{let: text.lower().count(let) for let in set(text.lower()) if let.isaplha()}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Делители**\n",
- "Вашему решению будет предоставлено множество numbers.<br><br>Продумайте выражение для генерации словаря содержащего информацию о делителях каждого из заданных чисел.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = {1, 2, 3, 4, 5}<br>|{1: [1], 2: [1, 2], 3: [1, 3], 4: [1, 2, 4], 5: [1, 5]}<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = {15, 49, 36}<br>|{15: [1, 3, 5, 15], 36: [1, 2, 3, 4, 6, 9, 12, 18, 36], 49: [1, 7, 49]}<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "{n: [d for d in range(1, n + 1) if n % d == 0] for n in numbers}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Аббревиатура**\n",
- "Вашему решению предоставлена строка string.<br><br>Напишите выражение для генерации строки, представляющей собой аббревиатуру заданной.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|string = 'Российская Федерация'<br>|'РФ'<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|string = 'открытое акционерное общество'<br>|'ОАО'<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "\"\".join([w[0] for w in string.split()]).upper()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **Преобразование в строку**\n",
- "Вашему решению предоставлен список натуральных чисел numbers.<br><br>Напишите выражение для генерации строки, представляющей собой отсортированный список чисел, записанных через дефис, окружённый пробелами, без повторений.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = [3, 1, 2, 3, 2, 2, 1]<br>|'1 - 2 - 3'<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|numbers = [1, 1, 3, 1, 10, 2, 4, 6, 7, 1, 2, 7]<br>|'1 - 2 - 3 - 4 - 6 - 7 - 10'<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "\" - \".join([str(i) for i in sorted(list(set(numbers)))])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## **RLE наоборот**\n",
- "Вашему решению будет предоставлен список кортежей rle с символами и количеством их повторений.<br><br>Напишите выражение для генерации строки, из которой был получен данный список.\n",
- "### **Примечание**\n",
- "В решении не должно быть ничего, кроме выражения.\n",
- "### **Пример 1**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|rle = [('a', 2), ('b', 3), ('c', 1)]<br>|'aabbbc'<br>|\n",
- "### **Пример 2**\n",
- "|Ввод |Вывод|\n",
- "|-----|-----|\n",
- "|rle = [('1', 1), ('0', 2), ('5', 1), ('0', 2)]<br>|'100500'<br>|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "\"\".join([\"\".join([rle[i][0] for j in range(rle[i][1])]) for i in range(len(rle))])"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "name": "python",
- "version": "3.11.1"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/3.3/4.py b/3.3/4.py
deleted file mode 100644
index 96bb92e3b44d802636fc143522f3632e24a479cd..0000000000000000000000000000000000000000
--- a/3.3/4.py
+++ /dev/null
@@ -1 +0,0 @@
-{i for i in numbers}
\ No newline at end of file
diff --git a/3.3/5.py b/3.3/5.py
deleted file mode 100644
index 929f0f090cf03b6819490629f2f4e160f38848c7..0000000000000000000000000000000000000000
--- a/3.3/5.py
+++ /dev/null
@@ -1 +0,0 @@
-{n for n in numbers if n ** 0.5 % 1 == 0}
\ No newline at end of file
diff --git a/3.3/6.py b/3.3/6.py
deleted file mode 100644
index b62bf9a22c683dbcf381b864eaf031b4d361bfa9..0000000000000000000000000000000000000000
--- a/3.3/6.py
+++ /dev/null
@@ -1 +0,0 @@
-{let: text.lower().count(let) for let in set(text.lower()) if let.isaplha()}
\ No newline at end of file
diff --git a/3.3/7.py b/3.3/7.py
deleted file mode 100644
index 538a106e1197f0b3312eaf52b5ef7c0aa6e31a25..0000000000000000000000000000000000000000
--- a/3.3/7.py
+++ /dev/null
@@ -1 +0,0 @@
-{n: [d for d in range(1, n + 1) if n % d == 0] for n in numbers}
\ No newline at end of file
diff --git a/3.3/8.py b/3.3/8.py
deleted file mode 100644
index 8d64dee68c7f4a5a982986bd57e09376d1d1aa70..0000000000000000000000000000000000000000
--- a/3.3/8.py
+++ /dev/null
@@ -1 +0,0 @@
-"".join([w[0] for w in string.split()]).upper()
\ No newline at end of file
diff --git a/3.3/9.py b/3.3/9.py
deleted file mode 100644
index 495df77f98be4c86b8274a5ae1571d4a6959934d..0000000000000000000000000000000000000000
--- a/3.3/9.py
+++ /dev/null
@@ -1 +0,0 @@
-" - ".join([str(i) for i in sorted(list(set(numbers)))])
\ No newline at end of file
diff --git a/3.4/1.py b/3.4/1.py
deleted file mode 100644
index d821d832d26fff71e64bde34f501032417894bc9..0000000000000000000000000000000000000000
--- a/3.4/1.py
+++ /dev/null
@@ -1,2 +0,0 @@
-for index, value in enumerate(input().split(), 1):
- print(f"{index}. {value}")
\ No newline at end of file
diff --git a/3.4/10.py b/3.4/10.py
deleted file mode 100644
index ab9b80b8118fd6ad1dc44176582cdc84b7c03e6b..0000000000000000000000000000000000000000
--- a/3.4/10.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from itertools import product
-
-n = int(input())
-
-print("Рђ Р‘ Р’")
-
-for a, b in product([i for i in range(1, n - 1)], repeat=2):
- if a + b < n:
- print(a, b, n - (a + b))
\ No newline at end of file
diff --git a/3.4/11.py b/3.4/11.py
deleted file mode 100644
index a826f309bf9d5b5666d1bbcb0ac60202a86d5950..0000000000000000000000000000000000000000
--- a/3.4/11.py
+++ /dev/null
@@ -1,9 +0,0 @@
-n, m = int(input()), int(input())
-
-numLength = len(str(n * m))
-
-for i in range(1, (n * m) + 1):
- if i % m == 0 and i:
- print(f"{' ' * (numLength - len(str(i)))}{i}")
- else:
- print(f"{' ' * (numLength - len(str(i)))}{i}", end=" ")
\ No newline at end of file
diff --git a/3.4/12.py b/3.4/12.py
deleted file mode 100644
index c307e1890aad5151d47345b5ea31ba0ad1250746..0000000000000000000000000000000000000000
--- a/3.4/12.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from itertools import chain
-
-food = sorted(list(chain.from_iterable([input().split(", ") for _ in range(int(input()))])))
-
-for index, fd in enumerate(food, 1):
- print(f"{index}. {fd}")
\ No newline at end of file
diff --git a/3.4/13.py b/3.4/13.py
deleted file mode 100644
index ad091f4ce0efb59f7af9a6e2d0293db9d34413ee..0000000000000000000000000000000000000000
--- a/3.4/13.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from itertools import permutations
-
-for names in permutations(sorted([input() for _ in range(int(input()))])):
- print(", ".join(names))
\ No newline at end of file
diff --git a/3.4/14.py b/3.4/14.py
deleted file mode 100644
index 7a8e366e16109a28e5073082572bff7e39204a79..0000000000000000000000000000000000000000
--- a/3.4/14.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from itertools import permutations
-
-for names in permutations(sorted([input() for _ in range(int(input()))]), r=3):
- print(", ".join(names))
\ No newline at end of file
diff --git a/3.4/15.py b/3.4/15.py
deleted file mode 100644
index 06be22b2ca242b6e7f6d76e772433997fe7d3276..0000000000000000000000000000000000000000
--- a/3.4/15.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from itertools import permutations, chain
-
-for a, b, c in permutations(sorted(list(chain.from_iterable([input().split(", ") for _ in range(int(input()))]))), r=3):
- print(a, b, c)
\ No newline at end of file
diff --git a/3.4/16.py b/3.4/16.py
deleted file mode 100644
index 107f10cf62195a107565c06c549de511325027c3..0000000000000000000000000000000000000000
--- a/3.4/16.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from itertools import product
-tr = {"буби": "бубен", "пики": "пик", "трефы": "треф", "черви": "червей"}
-card_type, card_num = tr[input()], input()
-
-types = ("бубен", "пик", "треф", "червей")
-nums = ("10", "2", "3", "4", "5", "6", "7", "8", "9", "валет", "дама", "король", "туз")
-count = 0
-for elem in product(nums, types, repeat=3):
- f = True
- a, b, c = f"{elem[0]} {elem[1]}", f"{elem[2]} {elem[3]}", f"{elem[4]} {elem[5]}"
- if a == b or b == c or a == c:
- f = False
- if f and card_type in elem and card_num not in elem:
- print(a, b, c, sep=", ")
- count += 1
- if count == 10:
- break
\ No newline at end of file
diff --git a/3.4/17.py b/3.4/17.py
deleted file mode 100644
index 13e2bf8555f3283ab6ffae92391464ee49bdea53..0000000000000000000000000000000000000000
--- a/3.4/17.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from itertools import product
-tr = {"буби": "бубен", "пики": "пик", "трефы": "треф", "черви": "червей"}
-types = ("бубен", "пик", "треф", "червей")
-nums = ("10", "2", "3", "4", "5", "6", "7", "8", "9", "валет", "дама", "король", "туз")
-
-card_type, card_num = tr[input()], input()
-combtorem = input()
-
-prevcomb = ""
-f = False
-# arr = []
-for elem in product(nums, types, repeat=3):
- a, b, c = f"{elem[0]} {elem[1]}", f"{elem[2]} {elem[3]}", f"{elem[4]} {elem[5]}"
- if a == b or b == c or a == c:
- continue
- if card_type not in elem or card_num in elem:
- continue
-
- comb = ", ".join([a, b, c])
-
- # if len(arr) >= 10:
- # arr = arr[1:]
- # arr.append(comb)
-
- if prevcomb == combtorem:
- f = True
-
- if f and comb.split()[-2] == combtorem.split()[-2]:
- print(comb)
- break
-
- prevcomb = comb
\ No newline at end of file
diff --git a/3.4/18.py b/3.4/18.py
deleted file mode 100644
index 25ef2c4cf3988de1db25b5909131f835835ccb72..0000000000000000000000000000000000000000
--- a/3.4/18.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from itertools import product
-
-state = input()
-print("a b c f")
-for elem in product((0, 1), repeat=3):
- a, b, c = elem[0], elem[1], elem[2]
- print(a, b, c, int(eval(state)))
\ No newline at end of file
diff --git a/3.4/19.py b/3.4/19.py
deleted file mode 100644
index f7801a636be0fe552aaced2e7f67aa21126f76b9..0000000000000000000000000000000000000000
--- a/3.4/19.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from itertools import product
-alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-state = input()
-arr = []
-for let in alph:
- if let in state:
- arr.append(let)
-
-print(*arr, "F")
-
-for elem in product((0, 1), repeat=len(arr)):
- m = []
- buff = arr
- c = 0
- for let in alph:
- if let in buff:
- m.append(elem[c])
- buff = buff[1:]
- c += 1
- else:
- m.append(0)
-
- dict = {alph[i].lower(): m[i] for i in range(len(alph))}
- print(*elem, int(eval(state.lower(), {}, dict)))
\ No newline at end of file
diff --git a/3.4/2.py b/3.4/2.py
deleted file mode 100644
index 75747698010cba2e38963a79c02873b8fc40ab2b..0000000000000000000000000000000000000000
--- a/3.4/2.py
+++ /dev/null
@@ -1 +0,0 @@
-[print(f"{pair[0]} - {pair[1]}") for pair in zip(input().split(", "), input().split(", "))]
\ No newline at end of file
diff --git a/3.4/20.py b/3.4/20.py
deleted file mode 100644
index a4cb0a21952f21d99f5c1bb9f9f5961255e57c78..0000000000000000000000000000000000000000
--- a/3.4/20.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from itertools import product
-
-
-def make_brackets(eq):
-
- opers = ["<=", "!=", "or", "and"][::-1]
- for op in opers:
- if op in eq:
- parts = eq.split(op)
- else:
- continue
- for i in range(len(parts) - 1):
- if parts[i][-2] in alph:
- parts[i] = parts[i][:-2] + "(" + parts[i][-2:]
- else:
- c = 1
- for j in range(len(parts[i]) - 3, -1, -1):
- if parts[i][j] == ")":
- c += 1
- elif parts[i][j] == "(":
- c -= 1
- if not c:
- if j >= 4:
- if parts[i][j - 4:j] == "not ":
- parts[i] = parts[i][:j - 4] + "(" + parts[i][j - 4:]
- else:
- parts[i] = parts[i][:j] + "(" + parts[i][j:]
- break
-
- if parts[i + 1][1] in alph:
- parts[i + 1] = parts[i + 1][:2] + ")" + parts[i + 1][2:]
-
- else:
- if parts[i + 1][1] == "(":
- c = 1
- for j in range(2, len(parts[i + 1])):
- if parts[i + 1][j] == "(":
- c += 1
- elif parts[i + 1][j] == ")":
- c -= 1
- if not c:
- parts[i + 1] = parts[i + 1][:j] + ")" + parts[i + 1][j:]
- break
-
- elif parts[i + 1][1] == "n":
- if parts[i + 1][5] == "(":
- for j in range(6, len(parts[i + 1])):
- if parts[i + 1][j] == "(":
- c += 1
- elif parts[i + 1][j] == ")":
- c -= 1
- if not c:
- parts[i + 1] = parts[i + 1][:j] + ")" + parts[i + 1][j:]
- break
- else:
- parts[i + 1] = parts[i + 1][:6] + ")" + parts[i + 1][6:]
-
- eq = op.join(parts)
- return eq
-
-
-alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-state = input().replace("->", "<=").replace("^", "!=").replace("~", "==")
-arr = []
-
-for let in alph:
- if let in state:
- arr.append(let)
-
-print(*arr, "F")
-
-for elem in product((0, 1), repeat=len(arr)):
- m = []
- buff = arr
- c = 0
- for let in alph:
- if let in buff:
- m.append(elem[c])
- buff = buff[1:]
- c += 1
- else:
- m.append(0)
-
- dict = {alph[i].lower(): m[i] for i in range(len(alph))}
- print(*elem, int(eval(make_brackets(state).lower(), {}, dict)))
\ No newline at end of file
diff --git a/3.4/3.py b/3.4/3.py
deleted file mode 100644
index fc6df8d639f363e86934552074e9f3c56b7559ca..0000000000000000000000000000000000000000
--- a/3.4/3.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from itertools import count
-st, en, sp = [float(i) for i in input().split()]
-
-for value in count(st, sp):
- if value <= en:
- print(round(value, 2))
- else:
- break
\ No newline at end of file
diff --git a/3.4/34.ipynb b/3.4/34.ipynb
deleted file mode 100644
index 9face7c563db00978eac1b4bdcf95919ea37b058..0000000000000000000000000000000000000000
--- a/3.4/34.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["## **\u0410\u0432\u0442\u043e\u043c\u0430\u0442\u0438\u0437\u0430\u0446\u0438\u044f \u0441\u043f\u0438\u0441\u043a\u0430**", "\u041c\u043d\u043e\u0433\u0438\u043c \u0432\u0435\u0441\u044c\u043c\u0430 \u0447\u0430\u0441\u0442\u043e \u043f\u0440\u0438\u0445\u043e\u0434\u0438\u0442\u0441\u044f \u0432\u0435\u0441\u0442\u0438 \u0441\u043f\u0438\u0441\u043a\u0438 \u043f\u0440\u043e\u0434\u0443\u043a\u0442\u043e\u0432, \u0434\u0435\u043b \u0438 \u0442\u0430\u043a \u0434\u0430\u043b\u0435\u0435.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0435\u043e\u0431\u0440\u0430\u0437\u0443\u0435\u0442 \u0432\u0432\u0435\u0434\u0451\u043d\u043d\u0443\u044e \u0441\u0442\u0440\u043e\u043a\u0443 \u0432 \u043d\u0443\u043c\u0435\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0441\u043f\u0438\u0441\u043e\u043a.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043e\u0434\u043d\u0430 \u0441\u0442\u0440\u043e\u043a\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u0432\u044b\u0432\u0435\u0441\u0442\u0438 \u043d\u0443\u043c\u0435\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0441\u043f\u0438\u0441\u043e\u043a, \u0441\u043e\u0441\u0442\u0430\u0432\u043b\u0435\u043d\u043d\u044b\u0439 \u0438\u0437 \u0435\u0451 \u0441\u043b\u043e\u0432.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u043a\u0430\u0440\u0442\u0438\u043d\u0430 \u043a\u043e\u0440\u0437\u0438\u043d\u0430 \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br> <br> <br>|1. \u043a\u0430\u0440\u0442\u0438\u043d\u0430<br>2. \u043a\u043e\u0440\u0437\u0438\u043d\u0430<br>3. \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0410\u043d\u044f \u0411\u043e\u0440\u044f \u0412\u043e\u0432\u0430<br> <br> <br>|1. \u0410\u043d\u044f<br>2. \u0411\u043e\u0440\u044f<br>3. \u0412\u043e\u0432\u0430<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["for index, value in enumerate(input().split(), 1):", " print(f\"{index}. {value}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u0431\u043e\u0440\u044b \u043d\u0430 \u043f\u0440\u043e\u0433\u0443\u043b\u043a\u0443**", "\u0412\u043e\u0441\u043f\u0438\u0442\u0430\u0442\u0435\u043b\u044c \u0432 \u0434\u0435\u0442\u0441\u043a\u043e\u043c \u0441\u0430\u0434\u0443 \u0443\u0441\u0442\u0430\u043b \u0442\u0440\u0430\u0442\u0438\u0442\u044c \u0432\u0440\u0435\u043c\u044f, \u0447\u0442\u043e\u0431\u044b \u043f\u043e\u0441\u0442\u0440\u043e\u0438\u0442\u044c \u0434\u0435\u0442\u0435\u0439 \u043f\u043e \u043f\u0430\u0440\u0430\u043c.<br><br>\u041e\u043d \u0434\u043e\u0433\u043e\u0432\u043e\u0440\u0438\u043b\u0441\u044f \u0441 \u0434\u0435\u0442\u044c\u043c\u0438, \u0447\u0442\u043e\u0431\u044b \u0442\u0435 \u0434\u0435\u043b\u0438\u043b\u0438\u0441\u044c \u043d\u0430 \u0434\u0432\u0435, \u043f\u043e \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u043e\u0441\u0442\u0438 \u0440\u0430\u0432\u043d\u044b\u0435, \u0433\u0440\u0443\u043f\u043f\u044b.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u043e \u0441\u043f\u0438\u0441\u043a\u0443 \u0434\u0432\u0443\u0445 \u0448\u0435\u0440\u0435\u043d\u0433 \u0441\u043e\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442 \u043f\u0430\u0440\u044b \u0434\u0435\u0442\u0435\u0439.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u0434\u0432\u0435 \u0441\u0442\u0440\u043e\u043a\u0438 \u0441 \u0438\u043c\u0435\u043d\u0430\u043c\u0438 \u0434\u0435\u0442\u0435\u0439, \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043d\u044b\u043c\u0438 \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0438 \u043f\u0440\u043e\u0431\u0435\u043b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u0432\u044b\u0432\u0435\u0441\u0442\u0438 \u0441\u043f\u0438\u0441\u043e\u043a \u043f\u0430\u0440, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u043c\u043e\u0436\u043d\u043e \u0441\u043e\u0441\u0442\u0430\u0432\u0438\u0442\u044c, \u0435\u0441\u043b\u0438 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e \u0431\u0440\u0430\u0442\u044c \u0438\u0437 \u043a\u0430\u0436\u0434\u043e\u0439 \u0448\u0435\u0440\u0435\u043d\u0433\u0438 \u043f\u043e \u043e\u0434\u043d\u043e\u043c\u0443 \u0440\u0435\u0431\u0451\u043d\u043a\u0443.<br>\u0418\u043c\u0435\u043d\u0430 \u0432 \u043f\u0430\u0440\u0430\u0445 \u0432\u044b\u0432\u043e\u0434\u0438\u0442\u044c \u0447\u0435\u0440\u0435\u0437 \u0434\u0435\u0444\u0438\u0441 \u043e\u043a\u0440\u0443\u0436\u0451\u043d\u043d\u044b\u0439 \u043f\u0440\u043e\u0431\u0435\u043b\u0430\u043c\u0438.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412 \u043e\u0434\u043d\u043e\u0439 \u0438\u0437 \u0433\u0440\u0443\u043f\u043f \u043c\u043e\u0436\u0435\u0442 \u0431\u044b\u0442\u044c \u043d\u0430 \u043e\u0434\u043d\u043e\u0433\u043e \u0440\u0435\u0431\u0435\u043d\u043a\u0430 \u0431\u043e\u043b\u044c\u0448\u0435, \u0447\u0435\u043c \u0432 \u0434\u0440\u0443\u0433\u043e\u0439.<br>\u042d\u0442\u043e\u0442 \u0440\u0435\u0431\u0451\u043d\u043e\u043a \u043f\u0440\u0438 \u0444\u043e\u0440\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u0438 \u043f\u0430\u0440 \u043d\u0435 \u0443\u0447\u0438\u0442\u044b\u0432\u0430\u0435\u0442\u0441\u044f \u0438 \u0438\u0434\u0451\u0442 \u0432 \u043f\u0430\u0440\u0435 \u0441 \u0432\u043e\u0441\u043f\u0438\u0442\u0430\u0442\u0435\u043b\u0435\u043c.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0413\u0435\u043d\u0430<br>|\u0410\u043d\u044f - \u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430 - \u0414\u0438\u043c\u0430<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["[print(f\"{pair[0]} - {pair[1]}\") for pair in zip(input().split(\", \"), input().split(\", \"))]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0420\u0430\u0446\u0438\u043e\u043d\u0430\u043b\u044c\u043d\u0430\u044f \u0441\u0447\u0438\u0442\u0430\u043b\u043e\u0447\u043a\u0430**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u0438\u0442 \u0441\u0447\u0451\u0442 \u043f\u043e \u0437\u0430\u0434\u0430\u043d\u043d\u044b\u043c \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u0430\u043c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043e\u0434\u043d\u0443 \u0441\u0442\u0440\u043e\u043a\u0443 \u0447\u0435\u0440\u0435\u0437 \u043f\u0440\u043e\u0431\u0435\u043b \u0432\u0432\u043e\u0434\u044f\u0442\u0441\u044f 3 \u0440\u0430\u0446\u0438\u043e\u043d\u0430\u043b\u044c\u043d\u044b\u0445 \u0447\u0438\u0441\u043b\u0430 \u2014 \u043d\u0430\u0447\u0430\u043b\u043e \u0441\u0447\u0435\u0442\u0430, \u043a\u043e\u043d\u0435\u0446 \u0438 \u0448\u0430\u0433.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u044c \u0447\u0438\u0441\u0435\u043b \u0441 \u0437\u0430\u0434\u0430\u043d\u043d\u044b\u043c\u0438 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u0430\u043c\u0438.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3.2 6.4 0.8<br> <br> <br> <br> <br>|3.20<br>4.00<br>4.80<br>5.60<br>6.40<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3.14 10 1.57<br> <br> <br> <br> <br>|3.14<br>4.71<br>6.28<br>7.85<br>9.42<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import count", "st, en, sp = [float(i) for i in input().split()]", "", "for value in count(st, sp):", " if value <= en:", " print(round(value, 2))", " else:", " break"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043b\u043e\u0432\u0430\u0440\u043d\u0430\u044f \u0451\u043b\u043a\u0430**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0435\u043e\u0431\u0440\u0430\u0437\u0443\u0435\u0442 \u0441\u0442\u0440\u043e\u043a\u0443 \u0441\u043b\u043e\u0432 \u0432 \u0451\u043b\u043a\u0443 \u043a\u0430\u043a \u043f\u043e\u043a\u0430\u0437\u0430\u043d\u043e \u0432 \u043f\u0440\u0438\u043c\u0435\u0440\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043e\u0434\u043d\u0443 \u0441\u0442\u0440\u043e\u043a\u0443 \u0447\u0435\u0440\u0435\u0437 \u043f\u0440\u043e\u0431\u0435\u043b \u0432\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0441\u043b\u043e\u0432\u0430 \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d\u043d\u044b\u0435 \u043f\u0440\u043e\u0431\u0435\u043b\u043e\u043c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0441\u0442\u0440\u043e\u043a. \u0412 \u043a\u0430\u0436\u0434\u043e\u0439 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0435\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u043d\u0430 \u043e\u0434\u043d\u043e \u0441\u043b\u043e\u0432\u043e \u0431\u043e\u043b\u044c\u0448\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "accumulate \u00ab\u0441\u043a\u043b\u0430\u0434\u044b\u0432\u0430\u0435\u0442\u00bb \u043d\u0435 \u0442\u043e\u043b\u044c\u043a\u043e \u0447\u0438\u0441\u043b\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u043c\u0430\u043c\u0430 \u043c\u044b\u043b\u0430 \u0440\u0430\u043c\u0443<br> <br> <br>|\u043c\u0430\u043c\u0430<br>\u043c\u0430\u043c\u0430 \u043c\u044b\u043b\u0430<br>\u043c\u0430\u043c\u0430 \u043c\u044b\u043b\u0430 \u0440\u0430\u043c\u0443<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u043a\u0430\u0440\u0442\u0438\u043d\u0430 \u043a\u043e\u0440\u0437\u0438\u043d\u0430 \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br> <br> <br>|\u043a\u0430\u0440\u0442\u0438\u043d\u0430<br>\u043a\u0430\u0440\u0442\u0438\u043d\u0430 \u043a\u043e\u0440\u0437\u0438\u043d\u0430<br>\u043a\u0430\u0440\u0442\u0438\u043d\u0430 \u043a\u043e\u0440\u0437\u0438\u043d\u0430 \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import accumulate", "", "for string in accumulate([[i] for i in input().split()]):", " print(\" \".join(string))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043f\u0438\u0441\u043e\u043a \u043f\u043e\u043a\u0443\u043f\u043e\u043a**", "\u041f\u043e\u0445\u043e\u0434 \u0432 \u043c\u0430\u0433\u0430\u0437\u0438\u043d \u0447\u0430\u0441\u0442\u043e \u0432\u044b\u0437\u044b\u0432\u0430\u0435\u0442 \u043f\u0440\u043e\u0431\u043b\u0435\u043c\u044b. \u0415\u0441\u043b\u0438 \u043d\u0435 \u043f\u043e\u0434\u0433\u043e\u0442\u043e\u0432\u0438\u0442\u044c \u0441\u043f\u0438\u0441\u043e\u043a, \u043c\u043e\u0436\u043d\u043e \u0443\u0439\u0442\u0438 \u0432 \u043c\u0430\u0433\u0430\u0437\u0438\u043d \u0437\u0430 \u0445\u043b\u0435\u0431\u043e\u043c, \u0430 \u0432\u0435\u0440\u043d\u0443\u0442\u044c\u0441\u044f \u0441 \u0434\u0435\u0441\u044f\u0442\u043a\u043e\u043c \u043f\u0430\u043a\u0435\u0442\u043e\u0432. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u043e\u0431\u0438\u0440\u0430\u0435\u0442 \u043f\u043e\u0436\u0435\u043b\u0430\u043d\u0438\u044f \u0441\u0435\u043c\u044c\u0438 (\u043c\u0430\u043c\u044b, \u043f\u0430\u043f\u044b \u0438 \u0434\u043e\u0447\u043a\u0438) \u0432 \u0435\u0434\u0438\u043d\u044b\u0439 \u0441\u043f\u0438\u0441\u043e\u043a.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u0442\u0440\u0451\u0445 \u0441\u0442\u0440\u043e\u043a\u0430\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u044b \u0436\u0435\u043b\u0430\u0435\u043c\u044b\u0435 \u043f\u0440\u043e\u0434\u0443\u043a\u0442\u044b (\u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0438 \u043f\u0440\u043e\u0431\u0435\u043b).", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u043f\u043e \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u0443 \u0441\u043f\u0438\u0441\u043e\u043a \u043f\u0440\u043e\u0434\u0443\u043a\u0442\u043e\u0432 \u0441 \u043d\u0443\u043c\u0435\u0440\u0430\u0446\u0438\u0435\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u041f\u043e\u043c\u043d\u0438\u0442\u0435, \u0447\u0442\u043e \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440\u044b \u043c\u043e\u0436\u043d\u043e \u043f\u0440\u0438\u043c\u0435\u043d\u044f\u0442\u044c \u043a \u0434\u0440\u0443\u0433\u0438\u043c \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440\u0430\u043c.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u043a\u0430\u0440\u0442\u0438\u043d\u0430, \u043a\u043e\u0440\u0437\u0438\u043d\u0430, \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br>\u043c\u044b\u043b\u043e, \u043c\u0430\u043d\u043a\u0430<br>\u043c\u043e\u043b\u043e\u043a\u043e, \u0445\u043b\u0435\u0431, \u0441\u044b\u0440<br> <br> <br> <br> <br> <br>|1. \u043a\u0430\u0440\u0442\u0438\u043d\u0430<br>2. \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br>3. \u043a\u043e\u0440\u0437\u0438\u043d\u0430<br>4. \u043c\u0430\u043d\u043a\u0430<br>5. \u043c\u043e\u043b\u043e\u043a\u043e<br>6. \u043c\u044b\u043b\u043e<br>7. \u0441\u044b\u0440<br>8. \u0445\u043b\u0435\u0431<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import chain", "", "for index, value in enumerate(sorted(chain.from_iterable([input().split(\", \") for _ in range(3)])), 1):", " print(f\"{index}. {value}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041a\u043e\u043b\u043e\u0434\u0430 \u043a\u0430\u0440\u0442**", "\u0421\u0433\u0435\u043d\u0435\u0440\u0438\u0440\u0443\u0439\u0442\u0435 \u0438 \u0432\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u043d\u0430 \u044d\u043a\u0440\u0430\u043d \u043a\u043e\u043b\u043e\u0434\u0443 \u0438\u0433\u0440\u0430\u043b\u044c\u043d\u044b\u0445 \u043a\u0430\u0440\u0442 \u0431\u0435\u0437 \u043e\u0434\u043d\u043e\u0439 \u0438\u0437 \u043c\u0430\u0441\u0442\u0435\u0439: \u0442\u0440\u0438 \u043c\u0430\u0441\u0442\u0438 \u043e\u0442 \u0434\u0432\u043e\u0439\u043a\u0438 \u0434\u043e \u0442\u0443\u0437\u0430. \u041c\u0430\u0441\u0442\u044c, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043e\u043b\u0436\u043d\u0430 \u0431\u044b\u0442\u044c \u0432\u044b\u0431\u0440\u043e\u0448\u0435\u043d\u0430, \u0432\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435\u043c. \u0418\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0439\u0442\u0435 \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440 product \u0434\u043b\u044f \u0442\u043e\u0433\u043e, \u0447\u0442\u043e\u0431\u044b \u0441\u043a\u043e\u043c\u0431\u0438\u043d\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u043c\u0430\u0441\u0442\u0438 \u0438 \u043d\u043e\u043c\u0438\u043d\u0430\u043b\u044b.<br><br>\u041d\u0430\u0437\u0432\u0430\u043d\u0438\u044f \u043a\u0430\u0440\u0442 \u0434\u043e\u043b\u0436\u043d\u044b \u0431\u044b\u0442\u044c \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435 \u00ab\u043d\u043e\u043c\u0438\u043d\u0430\u043b \u043c\u0430\u0441\u0442\u044c\u00bb. \u041d\u0430\u043f\u0440\u0438\u043c\u0435\u0440: \u00ab2 \u043f\u0438\u043a\u00bb, \u00ab10 \u0442\u0440\u0435\u0444\u00bb, \u00ab\u0432\u0430\u043b\u0435\u0442 \u0431\u0443\u0431\u0435\u043d\u00bb, \u00ab\u0434\u0430\u043c\u0430 \u0447\u0435\u0440\u0432\u0435\u0439\u00bb.<br>\u041f\u043e\u0440\u044f\u0434\u043e\u043a \u043c\u0430\u0441\u0442\u0435\u0439 \u0438\u043c\u0435\u0435\u0442 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041d\u0430\u0437\u0432\u0430\u043d\u0438\u0435 \u043c\u0430\u0441\u0442\u0438, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043e\u043b\u0436\u043d\u0430 \u0431\u044b\u0442\u044c \u0432\u044b\u0431\u0440\u043e\u0448\u0435\u043d\u0430, \u043f\u0435\u0440\u0435\u0434\u0430\u0451\u0442\u0441\u044f \u0432 \u0442\u043e\u043c \u0436\u0435 \u043f\u0430\u0434\u0435\u0436\u0435, \u0432 \u043a\u043e\u0442\u043e\u0440\u043e\u043c \u043e\u043d\u0430 \u0432\u044b\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043d\u0430 \u044d\u043a\u0440\u0430\u043d: \u00ab\u043f\u0438\u043a\u00bb, \u00ab\u0442\u0440\u0435\u0444\u00bb, \u00ab\u0431\u0443\u0431\u0435\u043d\u00bb \u0438 \u00ab\u0447\u0435\u0440\u0432\u0435\u0439\u00bb.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0421\u043f\u0438\u0441\u043e\u043a \u043a\u0430\u0440\u0442 \u0432 \u043a\u043e\u043b\u043e\u0434\u0435 \u043f\u043e \u0443\u0432\u0435\u043b\u0438\u0447\u0435\u043d\u0438\u044e \u043d\u043e\u043c\u0438\u043d\u0430\u043b\u0430, \u0437\u0430\u0442\u0435\u043c \u043c\u0430\u0441\u0442\u0438 (\u043a\u0430\u043a \u0432 \u043f\u0440\u0435\u0444\u0435\u0440\u0430\u043d\u0441\u0435).", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0442\u0440\u0435\u0444<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|2 \u043f\u0438\u043a<br>2 \u0431\u0443\u0431\u0435\u043d<br>2 \u0447\u0435\u0440\u0432\u0435\u0439<br>3 \u043f\u0438\u043a<br>3 \u0431\u0443\u0431\u0435\u043d<br>3 \u0447\u0435\u0440\u0432\u0435\u0439<br>4 \u043f\u0438\u043a<br>4 \u0431\u0443\u0431\u0435\u043d<br>4 \u0447\u0435\u0440\u0432\u0435\u0439<br>5 \u043f\u0438\u043a<br>5 \u0431\u0443\u0431\u0435\u043d<br>5 \u0447\u0435\u0440\u0432\u0435\u0439<br>6 \u043f\u0438\u043a<br>6 \u0431\u0443\u0431\u0435\u043d<br>6 \u0447\u0435\u0440\u0432\u0435\u0439<br>7 \u043f\u0438\u043a<br>7 \u0431\u0443\u0431\u0435\u043d<br>7 \u0447\u0435\u0440\u0432\u0435\u0439<br>8 \u043f\u0438\u043a<br>8 \u0431\u0443\u0431\u0435\u043d<br>8 \u0447\u0435\u0440\u0432\u0435\u0439<br>9 \u043f\u0438\u043a<br>9 \u0431\u0443\u0431\u0435\u043d<br>9 \u0447\u0435\u0440\u0432\u0435\u0439<br>10 \u043f\u0438\u043a<br>10 \u0431\u0443\u0431\u0435\u043d<br>10 \u0447\u0435\u0440\u0432\u0435\u0439<br>\u0432\u0430\u043b\u0435\u0442 \u043f\u0438\u043a<br>\u0432\u0430\u043b\u0435\u0442 \u0431\u0443\u0431\u0435\u043d<br>\u0432\u0430\u043b\u0435\u0442 \u0447\u0435\u0440\u0432\u0435\u0439<br>\u0434\u0430\u043c\u0430 \u043f\u0438\u043a<br>\u0434\u0430\u043c\u0430 \u0431\u0443\u0431\u0435\u043d<br>\u0434\u0430\u043c\u0430 \u0447\u0435\u0440\u0432\u0435\u0439<br>\u043a\u043e\u0440\u043e\u043b\u044c \u043f\u0438\u043a<br>\u043a\u043e\u0440\u043e\u043b\u044c \u0431\u0443\u0431\u0435\u043d<br>\u043a\u043e\u0440\u043e\u043b\u044c \u0447\u0435\u0440\u0432\u0435\u0439<br>\u0442\u0443\u0437 \u043f\u0438\u043a<br>\u0442\u0443\u0437 \u0431\u0443\u0431\u0435\u043d<br>\u0442\u0443\u0437 \u0447\u0435\u0440\u0432\u0435\u0439<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "", "types = [\"\u043f\u0438\u043a\", \"\u0442\u0440\u0435\u0444\", \"\u0431\u0443\u0431\u0435\u043d\", \"\u0447\u0435\u0440\u0432\u0435\u0439\"]", "", "majors = [\"\u0432\u0430\u043b\u0435\u0442\", \"\u0434\u0430\u043c\u0430\", \"\u043a\u043e\u0440\u043e\u043b\u044c\", \"\u0442\u0443\u0437\"]", "m = types.index(input())", "", "for a, b in product([str(i) for i in range(2, 11)] + majors, types[:m] + types[m + 1:]):", " print(a, b)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0418\u0433\u0440\u043e\u0432\u0430\u044f \u0441\u0435\u0442\u043a\u0430**", "\u0420\u0435\u0431\u044f\u0442\u0430 \u0432 \u043a\u043b\u0430\u0441\u0441\u0435 \u0440\u0435\u0448\u0438\u043b\u0438 \u0443\u0441\u0442\u0440\u043e\u0438\u0442\u044c \u0447\u0435\u043c\u043f\u0438\u043e\u043d\u0430\u0442 \u043f\u043e \u0448\u0430\u0448\u043a\u0430\u043c. \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0443\u0447\u0435\u043d\u0438\u043a\u043e\u0432 \u043d\u0435 \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0441\u0442\u0435\u043f\u0435\u043d\u044c\u044e \u0434\u0432\u043e\u0439\u043a\u0438 \u0438 \u043f\u043e\u044d\u0442\u043e\u043c\u0443 \u043a\u043b\u0430\u0441\u0441\u0438\u0447\u0435\u0441\u043a\u0443\u044e \u0442\u0443\u0440\u043d\u0438\u0440\u043d\u0443\u044e \u0441\u0435\u0442\u043a\u0443 \u0441\u043e\u0437\u0434\u0430\u0442\u044c \u0441\u043b\u043e\u0436\u043d\u043e. \u0414\u043b\u044f \u0432\u044b\u044f\u0432\u043b\u0435\u043d\u0438\u044f \u0444\u0430\u0432\u043e\u0440\u0438\u0442\u043e\u0432 \u0440\u0435\u0431\u044f\u0442\u0430 \u0434\u043e\u0433\u043e\u0432\u043e\u0440\u0438\u043b\u0438\u0441\u044c \u0441\u044b\u0433\u0440\u0430\u0442\u044c \u043f\u043e \u043f\u0440\u0438\u043d\u0446\u0438\u043f\u0443 \u00ab\u043a\u0430\u0436\u0434\u044b\u0439 \u0441 \u043a\u0430\u0436\u0434\u044b\u043c\u00bb. \u041f\u0440\u043e\u0434\u0443\u043c\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u043e\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442 \u0441\u043f\u0438\u0441\u043e\u043a \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u044b\u0445 \u0438\u0433\u0440.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043e \u0447\u0438\u0441\u043b\u043e \u0443\u0447\u0435\u043d\u0438\u043a\u043e\u0432 ($N$).<br>\u0412 \u043a\u0430\u0436\u0434\u043e\u0439 \u0438\u0437 \u043f\u043e\u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 $N$ \u0441\u0442\u0440\u043e\u043a \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043e \u043e\u0434\u043d\u043e \u0438\u043c\u044f.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0421\u043f\u0438\u0441\u043e\u043a \u0438\u0433\u0440 \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435:<br>\u041f\u043e\u0440\u044f\u0434\u043e\u043a \u0438\u0433\u0440 \u043d\u0435 \u0438\u043c\u0435\u0435\u0442 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3<br>\u0410\u043d\u044f<br>\u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430<br>|\u0410\u043d\u044f - \u0411\u043e\u0440\u044f<br>\u0410\u043d\u044f - \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f - \u0412\u043e\u0432\u0430<br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import combinations", "", "people = [input() for _ in range(int(input()))]", "", "for a, b in combinations(people, 2):", " print(f\"{a} - {b}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041c\u0435\u043d\u044e \u043f\u0438\u0442\u0430\u043d\u0438\u044f 2.0**", "\u0412 \u0434\u0435\u0442\u0441\u043a\u043e\u043c \u0441\u0430\u0434\u0443 \u0435\u0436\u0435\u0434\u043d\u0435\u0432\u043d\u043e \u043f\u043e\u0434\u0430\u044e\u0442 \u043d\u043e\u0432\u0443\u044e \u043a\u0430\u0448\u0443 \u043d\u0430 \u0437\u0430\u0432\u0442\u0440\u0430\u043a.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u0442\u0440\u043e\u0438\u0442 \u0440\u0430\u0441\u043f\u0438\u0441\u0430\u043d\u0438\u0435 \u043a\u0430\u0448 \u043d\u0430 \u0431\u043b\u0438\u0436\u0430\u0439\u0448\u0438\u0435 \u0434\u043d\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e $M$ \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043a\u0430\u0448 \u0432 \u043c\u0435\u043d\u044e. \u0412 \u043a\u0430\u0436\u0434\u043e\u0439 \u0438\u0437 \u043f\u043e\u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 $M$ \u0441\u0442\u0440\u043e\u043a \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043e \u043e\u0434\u043d\u043e \u043d\u0430\u0437\u0432\u0430\u043d\u0438\u0435 \u043a\u0430\u0448\u0438. \u0412 \u043a\u043e\u043d\u0446\u0435 \u043f\u0435\u0440\u0435\u0434\u0430\u0435\u0442\u0441\u044f \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e $N$ \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0434\u043d\u0435\u0439.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0441\u0442\u0438 \u0441\u043f\u0438\u0441\u043e\u043a \u043a\u0430\u0448 \u0432 \u043f\u043e\u0440\u044f\u0434\u043a\u0435 \u043f\u043e\u0434\u0430\u0447\u0438.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0421\u043e\u0432\u0435\u0442\u0443\u0435\u043c \u0438\u0437\u0443\u0447\u0438\u0442\u044c \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u044e \u043d\u0430 \u0444\u0443\u043d\u043a\u0446\u0438\u044e itertools.islice, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0440\u0435\u0430\u043b\u0438\u0437\u0443\u0435\u0442 \u0441\u0440\u0435\u0437\u044b \u043d\u0430 \u043e\u0441\u043d\u043e\u0432\u0435 \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440\u043e\u0432.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|5<br>\u041c\u0430\u043d\u043d\u0430\u044f<br>\u0413\u0440\u0435\u0447\u043d\u0435\u0432\u0430\u044f<br>\u041f\u0448\u0451\u043d\u043d\u0430\u044f<br>\u041e\u0432\u0441\u044f\u043d\u0430\u044f<br>\u0420\u0438\u0441\u043e\u0432\u0430\u044f<br>3<br>|\u041c\u0430\u043d\u043d\u0430\u044f<br>\u0413\u0440\u0435\u0447\u043d\u0435\u0432\u0430\u044f<br>\u041f\u0448\u0451\u043d\u043d\u0430\u044f<br> <br> <br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|5<br>\u041c\u0430\u043d\u043d\u0430\u044f<br>\u0413\u0440\u0435\u0447\u043d\u0435\u0432\u0430\u044f<br>\u041f\u0448\u0451\u043d\u043d\u0430\u044f<br>\u041e\u0432\u0441\u044f\u043d\u0430\u044f<br>\u0420\u0438\u0441\u043e\u0432\u0430\u044f<br>12<br> <br> <br> <br> <br> <br>|\u041c\u0430\u043d\u043d\u0430\u044f<br>\u0413\u0440\u0435\u0447\u043d\u0435\u0432\u0430\u044f<br>\u041f\u0448\u0451\u043d\u043d\u0430\u044f<br>\u041e\u0432\u0441\u044f\u043d\u0430\u044f<br>\u0420\u0438\u0441\u043e\u0432\u0430\u044f<br>\u041c\u0430\u043d\u043d\u0430\u044f<br>\u0413\u0440\u0435\u0447\u043d\u0435\u0432\u0430\u044f<br>\u041f\u0448\u0451\u043d\u043d\u0430\u044f<br>\u041e\u0432\u0441\u044f\u043d\u0430\u044f<br>\u0420\u0438\u0441\u043e\u0432\u0430\u044f<br>\u041c\u0430\u043d\u043d\u0430\u044f<br>\u0413\u0440\u0435\u0447\u043d\u0435\u0432\u0430\u044f<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import cycle", "", "food = [input() for _ in range(int(input()))]", "", "daysc = int(input())", "", "count = 0", "for fd in cycle(food):", " if count < daysc:", " print(fd)", " count += 1", " else:", " break"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0443\u043c\u043d\u043e\u0436\u0435\u043d\u0438\u044f 3.0**", "\u041c\u0435\u0441\u0442\u043d\u0430\u044f \u0444\u0430\u0431\u0440\u0438\u043a\u0430 \u043a\u0430\u043d\u0446\u0435\u043b\u044f\u0440\u0441\u043a\u0438\u0445 \u0442\u043e\u0432\u0430\u0440\u043e\u0432 \u0437\u0430\u043a\u0430\u0437\u0430\u043b\u0430 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0433\u0435\u043d\u0435\u0440\u0438\u0440\u0443\u0435\u0442 \u0442\u0430\u0431\u043b\u0438\u0446\u044b \u0443\u043c\u043d\u043e\u0436\u0435\u043d\u0438\u044f.<br>\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u043f\u043e\u043c\u043e\u0436\u0435\u043c \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u0438\u0442\u0435\u043b\u044e.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043e\u0434\u043d\u043e \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e \u2014 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0439 \u0440\u0430\u0437\u043c\u0435\u0440 \u0442\u0430\u0431\u043b\u0438\u0446\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0443\u043c\u043d\u043e\u0436\u0435\u043d\u0438\u044f \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0440\u0430\u0437\u043c\u0435\u0440\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "itertools.product \u043e\u0442\u043b\u0438\u0447\u043d\u044b\u0439 \u0441\u043f\u043e\u0441\u043e\u0431, \u0447\u0442\u043e\u0431\u044b \u0438\u0437\u0431\u0430\u0432\u0438\u0442\u044c\u0441\u044f \u043e\u0442 \u0432\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0445 \u0446\u0438\u043a\u043b\u043e\u0432.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3<br> <br> <br>|1 2 3<br>2 4 6<br>3 6 9<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|5<br> <br> <br> <br> <br>|1 2 3 4 5<br>2 4 6 8 10<br>3 6 9 12 15<br>4 8 12 16 20<br>5 10 15 20 25<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "", "n = int(input())", "c = 0", "for a, b in product([i for i in range(1, n + 1)], [i for i in range(1, n + 1)]):", " if c % n == 0 and c:", " print()", " print(a * b, end=\" \")", " c += 1", "print()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041c\u044b \u0434\u0435\u043b\u0438\u043b\u0438 \u0430\u043f\u0435\u043b\u044c\u0441\u0438\u043d 2.0**", "\u0410\u043d\u044f, \u0411\u043e\u0440\u044f \u0438 \u0412\u043e\u0432\u0430 \u0440\u0435\u0448\u0438\u043b\u0438 \u0441\u044a\u0435\u0441\u0442\u044c \u0430\u043f\u0435\u043b\u044c\u0441\u0438\u043d.<br>\u041f\u043e\u0434\u0441\u043a\u0430\u0436\u0438\u0442\u0435 \u0440\u0435\u0431\u044f\u0442\u0430\u043c, \u043a\u0430\u043a \u0438\u043c \u0435\u0433\u043e \u0440\u0430\u0437\u0434\u0435\u043b\u0438\u0442\u044c.<br><br>\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u0432\u0441\u0435 \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u044b\u0435 \u0441\u043f\u043e\u0441\u043e\u0431\u044b \u0440\u0430\u0437\u0434\u0435\u043b\u043a\u0438 \u0430\u043f\u0435\u043b\u044c\u0441\u0438\u043d\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u0435\u0434\u0438\u043d\u0441\u0442\u0432\u0435\u043d\u043d\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043e \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0434\u043e\u043b\u0435\u043a \u0430\u043f\u0435\u043b\u044c\u0441\u0438\u043d\u0430 ($N$).", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u043e\u0432 \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d\u0438\u044f \u0430\u043f\u0435\u043b\u044c\u0441\u0438\u043d\u0430.<br><br>\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u044f<br>\u041a\u0430\u0436\u0434\u043e\u043c\u0443 \u0440\u0435\u0431\u0451\u043d\u043a\u0443 \u0434\u043e\u043b\u0436\u043d\u0430 \u0434\u043e\u0441\u0442\u0430\u0442\u044c\u0441\u044f \u0445\u043e\u0442\u044f \u0431\u044b \u043e\u0434\u043d\u0430 \u0434\u043e\u043b\u044c\u043a\u0430 \u0430\u043f\u0435\u043b\u044c\u0441\u0438\u043d\u0430.<br>\u041d\u0438 \u043e\u0434\u043d\u043e\u0439 \u0434\u043e\u043b\u044c\u043a\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u043e\u0441\u0442\u0430\u0442\u044c\u0441\u044f.<br>\u0412\u044b\u0432\u043e\u0434\u0438\u0442\u044c \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u044b \u0432 \u043f\u043e\u0440\u044f\u0434\u043a\u0435 \u0443\u0432\u0435\u043b\u0438\u0447\u0435\u043d\u0438\u044f \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u0430 \u0434\u043e\u043b\u0435\u043a \u0443 \u0410\u043d\u0438, \u0441\u043b\u0435\u0434\u043e\u043c \u0411\u043e\u0440\u0438 \u0438 \u0437\u0430\u0442\u0435\u043c \u0412\u043e\u0432\u044b.<br>\u0414\u043b\u044f \u0443\u0434\u043e\u0431\u0441\u0442\u0432\u0430 \u0441\u0432\u0435\u0434\u0438\u0442\u0435 \u0437\u0430\u0434\u0430\u0447\u0443 \u043a \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d\u0438\u044e \u0434\u043e\u043b\u0435\u043a \u043c\u0435\u0436\u0434\u0443 \u0434\u0432\u0443\u043c\u044f \u0440\u0435\u0431\u044f\u0442\u0430\u043c\u0438, \u0430 \u0442\u0440\u0435\u0442\u044c\u0435\u043c\u0443 \u043e\u0442\u0434\u0430\u0439\u0442\u0435 \u043e\u0441\u0442\u0430\u0442\u043a\u0438.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3<br> <br>|\u0410 \u0411 \u0412<br>1 1 1<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|5<br> <br> <br> <br> <br> <br> <br>|\u0410 \u0411 \u0412<br>1 1 3<br>1 2 2<br>1 3 1<br>2 1 2<br>2 2 1<br>3 1 1<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "", "n = int(input())", "", "print(\"\u0410 \u0411 \u0412\")", "", "for a, b in product([i for i in range(1, n - 1)], repeat=2):", " if a + b < n:", " print(a, b, n - (a + b))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0427\u0438\u0441\u043b\u043e\u0432\u043e\u0439 \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a 3.0**", "\u0420\u0435\u0431\u044f\u0442\u0430 \u0432 \u0434\u0435\u0442\u0441\u043a\u043e\u043c \u0441\u0430\u0434\u0443 \u0432\u043d\u043e\u0432\u044c \u0443\u0447\u0430\u0442\u0441\u044f \u0441\u0447\u0438\u0442\u0430\u0442\u044c, \u0438 \u0432\u043e\u0441\u043f\u0438\u0442\u0430\u0442\u0435\u043b\u044c\u043d\u0438\u0446\u0430 \u0440\u0435\u0448\u0438\u043b\u0430 \u0441\u0434\u0435\u043b\u0430\u0442\u044c \u0442\u0430\u043a, \u0447\u0442\u043e\u0431\u044b \u0438\u043c \u0431\u044b\u043b\u043e \u043f\u0440\u043e\u0449\u0435 \u043e\u0441\u0432\u043e\u0438\u0442\u044c \u043d\u043e\u0432\u044b\u0439 \u043d\u0430\u0432\u044b\u043a. \u0414\u043b\u044f \u044d\u0442\u043e\u0433\u043e \u043e\u043d\u0430 \u0445\u043e\u0447\u0435\u0442 \u043e\u0444\u043e\u0440\u043c\u0438\u0442\u044c \u0441\u043f\u0438\u0441\u043e\u043a \u0438\u0437\u0443\u0447\u0430\u0435\u043c\u044b\u0445 \u0447\u0438\u0441\u0435\u043b \u043e\u0441\u043e\u0431\u044b\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c.<br>\u0414\u0435\u0442\u0438 \u0441\u043f\u0440\u0430\u0432\u043b\u044f\u044e\u0442\u0441\u044f \u0432\u0435\u0441\u044c\u043c\u0430 \u0431\u044b\u0441\u0442\u0440\u043e, \u043f\u043e\u044d\u0442\u043e\u043c\u0443 \u0435\u0439 \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0430, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u043f\u043e\u0441\u043e\u0431\u043d\u0430 \u0441\u0442\u0440\u043e\u0438\u0442\u044c \u0447\u0438\u0441\u043b\u043e\u0432\u044b\u0435 \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a\u0438. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u0442\u0440\u043e\u0438\u0442 \u0447\u0438\u0441\u043b\u043e\u0432\u043e\u0439 \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u043e\u0433\u043e \u0440\u0430\u0437\u043c\u0435\u0440\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043e \u0447\u0438\u0441\u043b\u043e $N$ \u2014 \u0432\u044b\u0441\u043e\u0442\u0430 \u0447\u0438\u0441\u043b\u043e\u0432\u043e\u0433\u043e \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a\u0430.<br>\u0412\u043e \u0432\u0442\u043e\u0440\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0443\u043a\u0430\u0437\u0430\u043d\u043e \u0447\u0438\u0441\u043b\u043e $M$ \u2014 \u0448\u0438\u0440\u0438\u043d\u0430 \u0447\u0438\u0441\u043b\u043e\u0432\u043e\u0433\u043e \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041d\u0443\u0436\u043d\u043e \u0432\u044b\u0432\u0435\u0441\u0442\u0438 \u0441\u0444\u043e\u0440\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0447\u0438\u0441\u043b\u043e\u0432\u043e\u0439 \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u043e\u0433\u043e \u0440\u0430\u0437\u043c\u0435\u0440\u0430.<br>\u0427\u0442\u043e\u0431\u044b \u043f\u0440\u044f\u043c\u043e\u0443\u0433\u043e\u043b\u044c\u043d\u0438\u043a \u0431\u044b\u043b \u043a\u0440\u0430\u0441\u0438\u0432\u044b\u043c, \u043a\u0430\u0436\u0434\u044b\u0439 \u0435\u0433\u043e \u0441\u0442\u043e\u043b\u0431\u0435\u0446 \u0434\u043e\u043b\u0436\u0435\u043d \u0431\u044b\u0442\u044c \u043e\u0434\u0438\u043d\u0430\u043a\u043e\u0432\u043e\u0439 \u0448\u0438\u0440\u0438\u043d\u044b.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "itertools.product \u043f\u0440\u0435\u043a\u0440\u0430\u0441\u043d\u043e \u043f\u043e\u0434\u0445\u043e\u0434\u0438\u0442, \u0447\u0442\u043e\u0431\u044b \u0438\u0437\u0431\u0430\u0432\u0438\u0442\u044c\u0441\u044f \u043e\u0442 \u0432\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0445 \u0446\u0438\u043a\u043b\u043e\u0432.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|2<br>3<br>|1 2 3<br>4 5 6<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|4<br>6<br> <br> <br>| 1 2 3 4 5 6<br> 7 8 9 10 11 12<br>13 14 15 16 17 18<br>19 20 21 22 23 24<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n, m = int(input()), int(input())", "", "numLength = len(str(n * m))", "", "for i in range(1, (n * m) + 1):", " if i % m == 0 and i:", " print(f\"{' ' * (numLength - len(str(i)))}{i}\")", " else:", " print(f\"{' ' * (numLength - len(str(i)))}{i}\", end=\" \")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043f\u0438\u0441\u043e\u043a \u043f\u043e\u043a\u0443\u043f\u043e\u043a 2.0**", "\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u0432\u043d\u043e\u0432\u044c \u043f\u043e\u043c\u043e\u0436\u0435\u043c \u0447\u0435\u043b\u043e\u0432\u0435\u043a\u0443 \u0441 \u043f\u043e\u043a\u0443\u043f\u043a\u0430\u043c\u0438. \u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u043e\u0431\u0438\u0440\u0430\u0435\u0442 \u043f\u043e\u0436\u0435\u043b\u0430\u043d\u0438\u044f \u0441\u0435\u043c\u044c\u0438 \u0432 \u0435\u0434\u0438\u043d\u044b\u0439 \u0441\u043f\u0438\u0441\u043e\u043a.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u0434\u0430\u043d\u043e \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e $N$ \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0447\u043b\u0435\u043d\u043e\u0432 \u0441\u0435\u043c\u044c\u0438. \u0412 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 $N$ \u0441\u0442\u0440\u043e\u043a\u0430\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u044b \u0436\u0435\u043b\u0430\u0435\u043c\u044b\u0435 \u043f\u0440\u043e\u0434\u0443\u043a\u0442\u044b (\u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0438 \u043f\u0440\u043e\u0431\u0435\u043b).", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u043f\u043e \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u0443 \u0441\u043f\u0438\u0441\u043e\u043a \u043f\u0440\u043e\u0434\u0443\u043a\u0442\u043e\u0432 \u0441 \u043d\u0443\u043c\u0435\u0440\u0430\u0446\u0438\u0435\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u041f\u043e\u043c\u043d\u0438\u0442\u0435, \u0447\u0442\u043e \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440\u044b \u043c\u043e\u0436\u043d\u043e \u0445\u0440\u0430\u043d\u0438\u0442\u044c \u0432 \u0441\u043f\u0438\u0441\u043a\u0435, \u0430 \u0435\u0433\u043e \u043c\u043e\u0436\u043d\u043e \u0440\u0430\u0441\u043f\u0430\u043a\u043e\u0432\u0430\u0442\u044c \u0432 \u043b\u044e\u0431\u0443\u044e \u0444\u0443\u043d\u043a\u0446\u0438\u044e.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3<br>\u043a\u0430\u0440\u0442\u0438\u043d\u0430, \u043a\u043e\u0440\u0437\u0438\u043d\u0430, \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br>\u043c\u044b\u043b\u043e, \u043c\u0430\u043d\u043a\u0430<br>\u043c\u043e\u043b\u043e\u043a\u043e, \u0445\u043b\u0435\u0431, \u0441\u044b\u0440<br> <br> <br> <br> <br>|1. \u043a\u0430\u0440\u0442\u0438\u043d\u0430<br>2. \u043a\u0430\u0440\u0442\u043e\u043d\u043a\u0430<br>3. \u043a\u043e\u0440\u0437\u0438\u043d\u0430<br>4. \u043c\u0430\u043d\u043a\u0430<br>5. \u043c\u043e\u043b\u043e\u043a\u043e<br>6. \u043c\u044b\u043b\u043e<br>7. \u0441\u044b\u0440<br>8. \u0445\u043b\u0435\u0431<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|2<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435, \u0441\u0443\u0448\u043a\u0438<br>\u0447\u0430\u0439, \u043a\u043e\u0444\u0435<br> <br>|1. \u043a\u043e\u0444\u0435<br>2. \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>3. \u0441\u0443\u0448\u043a\u0438<br>4. \u0447\u0430\u0439<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import chain", "", "food = sorted(list(chain.from_iterable([input().split(\", \") for _ in range(int(input()))])))", "", "for index, fd in enumerate(food, 1):", " print(f\"{index}. {fd}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0420\u0430\u0441\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0430 \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432**", "\u0420\u0430\u0441\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0430 \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432 \u043d\u0430 \u0441\u0442\u0430\u0440\u0442\u0435 \u2014 \u0441\u043b\u043e\u0436\u043d\u0430\u044f \u0437\u0430\u0434\u0430\u0447\u0430. \u041e\u0434\u043d\u0430\u043a\u043e \u043f\u0440\u0438 \u043f\u043e\u043c\u043e\u0449\u0438 \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440\u043e\u0432 \u043e\u043d\u0430 \u0440\u0435\u0448\u0430\u0435\u0442\u0441\u044f \u0437\u0430 \u043f\u0430\u0440\u0443 \u0441\u0442\u0440\u043e\u043a. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u044b\u0445 \u0440\u0430\u0441\u0441\u0442\u0430\u043d\u043e\u0432\u043e\u043a \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432 \u043d\u0430 \u0441\u0442\u0430\u0440\u0442\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u0434\u0430\u043d\u043e \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e $N$ \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432. \u0412 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 $N$ \u0441\u0442\u0440\u043e\u043a\u0430\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u044b \u0438\u043c\u0435\u043d\u0430 \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u043f\u043e \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u0443 \u0441\u043f\u0438\u0441\u043e\u043a \u0440\u0430\u0441\u0441\u0442\u0430\u043d\u043e\u0432\u043e\u043a.<br>\u0418\u043c\u0435\u043d\u0430 \u0432 \u043a\u0430\u0436\u0434\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0432\u044b\u0432\u043e\u0434\u0438\u0442\u044c \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0438 \u043f\u0440\u043e\u0431\u0435\u043b.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3<br>\u0410\u043d\u044f<br>\u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430<br> <br> <br>|\u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f<br>\u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f<br>\u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|4<br>\u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f<br>\u0414\u0438\u043c\u0430<br>\u0411\u043e\u0440\u044f<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|\u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430<br>\u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430<br>\u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f<br>\u0410\u043d\u044f, \u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f, \u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f<br>\u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430<br>\u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0414\u0438\u043c\u0430<br>\u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430, \u0410\u043d\u044f<br>\u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f<br>\u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430<br>\u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0414\u0438\u043c\u0430<br>\u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0410\u043d\u044f<br>\u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f<br>\u0414\u0438\u043c\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430<br>\u0414\u0438\u043c\u0430, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f<br>\u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f<br>\u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f<br>\u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import permutations", "", "for names in permutations(sorted([input() for _ in range(int(input()))])):", " print(\", \".join(names))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043f\u043e\u0440\u0442\u0438\u0432\u043d\u044b\u0435 \u0433\u0430\u0434\u0430\u043d\u0438\u044f**", "\u0425\u043e\u0440\u043e\u0448\u043e, \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u044b \u0440\u0430\u0441\u0441\u0442\u0430\u0432\u043b\u0435\u043d\u044b \u043d\u0430 \u0441\u0442\u0430\u0440\u0442\u0435. \u0412\u043e\u0442 \u0442\u043e\u043b\u044c\u043a\u043e \u0443\u0433\u0430\u0434\u0430\u0442\u044c \u0444\u0438\u043d\u0430\u043b\u0438\u0441\u0442\u043e\u0432 \u043f\u0440\u0430\u043a\u0442\u0438\u0447\u0435\u0441\u043a\u0438 \u043d\u0435\u0432\u043e\u0437\u043c\u043e\u0436\u043d\u043e. \u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u043d\u0430\u043f\u0438\u0448\u0435\u043c \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u044b\u0445 \u043f\u043e\u0431\u0435\u0434\u0438\u0442\u0435\u043b\u0435\u0439.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u0434\u0430\u043d\u043e \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e $N$ \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432. \u0412 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 $N$ \u0441\u0442\u0440\u043e\u043a\u0430\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u044b \u0438\u043c\u0435\u043d\u0430 \u0441\u043f\u043e\u0440\u0442\u0441\u043c\u0435\u043d\u043e\u0432.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u043f\u043e \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u0443 \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u043e\u0432.<br>\u0418\u043c\u0435\u043d\u0430 \u0432 \u043a\u0430\u0436\u0434\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0432\u044b\u0432\u043e\u0434\u0438\u0442\u044c \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0438 \u043f\u0440\u043e\u0431\u0435\u043b.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|3<br>\u0410\u043d\u044f<br>\u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430<br> <br> <br>|\u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f<br>\u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f<br>\u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|4<br>\u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f<br>\u0414\u0438\u043c\u0430<br>\u0411\u043e\u0440\u044f<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|\u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430<br>\u0410\u043d\u044f, \u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430<br>\u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f<br>\u0410\u043d\u044f, \u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430<br>\u0410\u043d\u044f, \u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f<br>\u0410\u043d\u044f, \u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0411\u043e\u0440\u044f, \u0410\u043d\u044f, \u0414\u0438\u043c\u0430<br>\u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f<br>\u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430<br>\u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0410\u043d\u044f<br>\u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430<br>\u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f<br>\u0412\u043e\u0432\u0430, \u0410\u043d\u044f, \u0414\u0438\u043c\u0430<br>\u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f<br>\u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f, \u0414\u0438\u043c\u0430<br>\u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430, \u0410\u043d\u044f<br>\u0412\u043e\u0432\u0430, \u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f<br>\u0414\u0438\u043c\u0430, \u0410\u043d\u044f, \u0411\u043e\u0440\u044f<br>\u0414\u0438\u043c\u0430, \u0410\u043d\u044f, \u0412\u043e\u0432\u0430<br>\u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f, \u0410\u043d\u044f<br>\u0414\u0438\u043c\u0430, \u0411\u043e\u0440\u044f, \u0412\u043e\u0432\u0430<br>\u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430, \u0410\u043d\u044f<br>\u0414\u0438\u043c\u0430, \u0412\u043e\u0432\u0430, \u0411\u043e\u0440\u044f<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import permutations", "", "for names in permutations(sorted([input() for _ in range(int(input()))]), r=3):", " print(\", \".join(names))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043f\u0438\u0441\u043e\u043a \u043f\u043e\u043a\u0443\u043f\u043e\u043a 3.0**", "\u0412 \u044d\u0442\u043e\u0442 \u0440\u0430\u0437 \u0441\u0435\u043c\u044c\u044f \u0434\u043e\u0433\u043e\u0432\u043e\u0440\u0438\u043b\u0430\u0441\u044c \u043e \u0442\u043e\u043c, \u0447\u0442\u043e \u0432 \u0446\u0435\u043b\u044f\u0445 \u044d\u043a\u043e\u043d\u043e\u043c\u0438\u0438 \u0431\u044e\u0434\u0436\u0435\u0442\u0430, \u043e\u043d\u0438 \u0431\u0443\u0434\u0443\u0442 \u0441\u043e\u0432\u0435\u0440\u0448\u0430\u0442\u044c \u0432 \u0434\u0435\u043d\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0442\u0440\u0438 \u043f\u043e\u043a\u0443\u043f\u043a\u0438. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0433\u043e\u0442\u043e\u0432\u0438\u0442 \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u044b \u0441\u043f\u0438\u0441\u043a\u043e\u0432 \u043f\u043e\u043a\u0443\u043f\u043e\u043a.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u0434\u0430\u043d\u043e \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e $N$ \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0447\u043b\u0435\u043d\u043e\u0432 \u0441\u0435\u043c\u044c\u0438. \u0412 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 $N$ \u0441\u0442\u0440\u043e\u043a\u0430\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u044b \u0436\u0435\u043b\u0430\u0435\u043c\u044b\u0435 \u043f\u0440\u043e\u0434\u0443\u043a\u0442\u044b (\u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0438 \u043f\u0440\u043e\u0431\u0435\u043b).", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u0430\u0440\u0438\u0430\u043d\u0442\u044b \u0441\u043f\u0438\u0441\u043a\u043e\u0432 \u043f\u043e\u043a\u0443\u043f\u043e\u043a \u0432 \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u043d\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|2<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435, \u0441\u0443\u0448\u043a\u0438<br>\u0447\u0430\u0439, \u043a\u043e\u0444\u0435<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|\u043a\u043e\u0444\u0435 \u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0441\u0443\u0448\u043a\u0438<br>\u043a\u043e\u0444\u0435 \u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0447\u0430\u0439<br>\u043a\u043e\u0444\u0435 \u0441\u0443\u0448\u043a\u0438 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u043a\u043e\u0444\u0435 \u0441\u0443\u0448\u043a\u0438 \u0447\u0430\u0439<br>\u043a\u043e\u0444\u0435 \u0447\u0430\u0439 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u043a\u043e\u0444\u0435 \u0447\u0430\u0439 \u0441\u0443\u0448\u043a\u0438<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u043a\u043e\u0444\u0435 \u0441\u0443\u0448\u043a\u0438<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u043a\u043e\u0444\u0435 \u0447\u0430\u0439<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0441\u0443\u0448\u043a\u0438 \u043a\u043e\u0444\u0435<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0441\u0443\u0448\u043a\u0438 \u0447\u0430\u0439<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0447\u0430\u0439 \u043a\u043e\u0444\u0435<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0447\u0430\u0439 \u0441\u0443\u0448\u043a\u0438<br>\u0441\u0443\u0448\u043a\u0438 \u043a\u043e\u0444\u0435 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u0441\u0443\u0448\u043a\u0438 \u043a\u043e\u0444\u0435 \u0447\u0430\u0439<br>\u0441\u0443\u0448\u043a\u0438 \u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u043a\u043e\u0444\u0435<br>\u0441\u0443\u0448\u043a\u0438 \u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0447\u0430\u0439<br>\u0441\u0443\u0448\u043a\u0438 \u0447\u0430\u0439 \u043a\u043e\u0444\u0435<br>\u0441\u0443\u0448\u043a\u0438 \u0447\u0430\u0439 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u0447\u0430\u0439 \u043a\u043e\u0444\u0435 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u0447\u0430\u0439 \u043a\u043e\u0444\u0435 \u0441\u0443\u0448\u043a\u0438<br>\u0447\u0430\u0439 \u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u043a\u043e\u0444\u0435<br>\u0447\u0430\u0439 \u043f\u0435\u0447\u0435\u043d\u044c\u0435 \u0441\u0443\u0448\u043a\u0438<br>\u0447\u0430\u0439 \u0441\u0443\u0448\u043a\u0438 \u043a\u043e\u0444\u0435<br>\u0447\u0430\u0439 \u0441\u0443\u0448\u043a\u0438 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import permutations, chain", "", "for a, b, c in permutations(sorted(list(chain.from_iterable([input().split(\", \") for _ in range(int(input()))]))), r=3):", " print(a, b, c)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0420\u0430\u0441\u043a\u043b\u0430\u0434 \u0442\u0430\u043a\u043e\u0432...**", "\u0412\u0438\u0442\u0430\u043b\u0438\u0439 \u043b\u044e\u0431\u0438\u0442 \u0438\u0433\u0440\u0430\u0442\u044c \u0432 \u043a\u0430\u0440\u0442\u044b. \u041e\u043d \u0440\u0435\u0448\u0438\u043b \u0432\u044b\u044f\u0441\u043d\u0438\u0442\u044c, \u043a\u0430\u043a\u0438\u0435 \u0435\u0441\u0442\u044c \u0432\u0430\u0440\u0438\u0430\u0446\u0438\u0438 \u0432\u044b\u0442\u0430\u0449\u0438\u0442\u044c \u0438\u0437 \u043a\u043e\u043b\u043e\u0434\u044b \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0435 \u0442\u0440\u043e\u0439\u043a\u0438 \u043a\u0430\u0440\u0442. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u043e\u0432 \u0441\u043e\u0433\u043b\u0430\u0441\u043d\u043e \u0442\u0440\u0435\u0431\u043e\u0432\u0430\u043d\u0438\u044f\u043c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u0430 \u043c\u0430\u0441\u0442\u044c, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043e\u043b\u0436\u043d\u0430 \u043f\u0440\u0438\u0441\u0443\u0442\u0441\u0442\u0432\u043e\u0432\u0430\u0442\u044c \u0432 \u0442\u0440\u043e\u0439\u043a\u0435.<br>\u0412\u043e \u0432\u0442\u043e\u0440\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d \u0434\u043e\u0441\u0442\u043e\u0438\u043d\u0441\u0442\u0432\u043e, \u043a\u043e\u0442\u043e\u0440\u043e\u0433\u043e \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432 \u0442\u0440\u043e\u0439\u043a\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u043d\u0430 \u044d\u043a\u0440\u0430\u043d \u043f\u0435\u0440\u0432\u044b\u0435 10 \u043f\u043e\u043b\u0443\u0447\u0438\u0432\u0448\u0438\u0445\u0441\u044f \u0442\u0440\u043e\u0435\u043a.<br>\u041a\u0430\u0440\u0442\u044b \u0432 \u043a\u0430\u0436\u0434\u043e\u0439 \u043a\u043e\u043c\u0431\u0438\u043d\u0430\u0446\u0438\u0438 \u0434\u043e\u043b\u0436\u043d\u044b \u0431\u044b\u0442\u044c \u043e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u044b \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u0438 (\u043f\u043e \u0441\u0442\u0440\u043e\u043a\u0435 \u043d\u0430\u0437\u0432\u0430\u043d\u0438\u044f \u043a\u0430\u0440\u0442\u044b). \u041a\u0430\u0440\u0442\u044b \u043a\u043e\u043c\u0431\u0438\u043d\u0430\u0446\u0438\u0438 \u0432\u044b\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043f\u044f\u0442\u0443\u044e \u0441 \u043f\u0440\u043e\u0431\u0435\u043b\u043e\u043c \u043f\u043e\u0441\u043b\u0435 \u043d\u0435\u0451.<br>\u041a\u043e\u043c\u0431\u0438\u043d\u0430\u0446\u0438\u0438 \u043c\u0435\u0436\u0434\u0443 \u0441\u043e\u0431\u043e\u0439 \u0442\u0430\u043a\u0436\u0435 \u0434\u043e\u043b\u0436\u043d\u044b \u0431\u044b\u0442\u044c \u043e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u044b \u0432 \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435 \u043f\u043e \u0441\u0442\u0440\u043e\u043a\u0435, \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u044f\u044e\u0449\u0435\u0439 \u043a\u043e\u043c\u0431\u0438\u043d\u0430\u0446\u0438\u044e \u0446\u0435\u043b\u0438\u043a\u043e\u043c.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u041e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435: \u0432\u0430\u043b\u0435\u0442-\u0434\u0430\u043c\u0430-\u043a\u043e\u0440\u043e\u043b\u044c-\u0442\u0443\u0437 \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u0438 \u0443\u043f\u043e\u0440\u044f\u0434\u043e\u0447\u0435\u043d\u044b. \u041d\u043e \u00ab10 ...\u00bb \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u0438 \u043c\u043b\u0430\u0434\u0448\u0435, \u0447\u0435\u043c \u00ab2 ...\u00bb, \u0430 \u0431\u0443\u0431\u043d\u044b \u043c\u043b\u0430\u0434\u0448\u0435, \u0447\u0435\u043c \u043f\u0438\u043a\u0438.<br><br>\u041c\u0430\u0441\u0442\u0438 \u0432 \u0438\u043c\u0435\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u043c \u0438 \u0440\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u043c \u043f\u0430\u0434\u0435\u0436\u0430\u0445:<br>", "\u0418\u043c\u0435\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0439\t\u0420\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0439<br>\u0431\u0443\u0431\u0438\t\u0431\u0443\u0431\u0435\u043d<br>\u043f\u0438\u043a\u0438\t\u043f\u0438\u043a<br>\u0442\u0440\u0435\u0444\u044b\t\u0442\u0440\u0435\u0444<br>\u0447\u0435\u0440\u0432\u0438\t\u0447\u0435\u0440\u0432\u0435\u0439", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u043f\u0438\u043a\u0438<br>10<br> <br> <br> <br> <br> <br> <br> <br> <br>|2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 2 \u0442\u0440\u0435\u0444<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 2 \u0447\u0435\u0440\u0432\u0435\u0439<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 3 \u0431\u0443\u0431\u0435\u043d<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 3 \u043f\u0438\u043a<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 3 \u0442\u0440\u0435\u0444<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 3 \u0447\u0435\u0440\u0432\u0435\u0439<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 4 \u0431\u0443\u0431\u0435\u043d<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 4 \u043f\u0438\u043a<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 4 \u0442\u0440\u0435\u0444<br>2 \u0431\u0443\u0431\u0435\u043d, 2 \u043f\u0438\u043a, 4 \u0447\u0435\u0440\u0432\u0435\u0439<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0442\u0440\u0435\u0444\u044b<br>\u043a\u043e\u0440\u043e\u043b\u044c<br> <br> <br> <br> <br> <br> <br> <br> <br>|10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 10 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 2 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 3 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 4 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 5 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 6 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 7 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 8 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, 9 \u0442\u0440\u0435\u0444<br>10 \u0431\u0443\u0431\u0435\u043d, 10 \u043f\u0438\u043a, \u0432\u0430\u043b\u0435\u0442 \u0442\u0440\u0435\u0444<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "tr = {\"\u0431\u0443\u0431\u0438\": \"\u0431\u0443\u0431\u0435\u043d\", \"\u043f\u0438\u043a\u0438\": \"\u043f\u0438\u043a\", \"\u0442\u0440\u0435\u0444\u044b\": \"\u0442\u0440\u0435\u0444\", \"\u0447\u0435\u0440\u0432\u0438\": \"\u0447\u0435\u0440\u0432\u0435\u0439\"}", "card_type, card_num = tr[input()], input()", "", "types = (\"\u0431\u0443\u0431\u0435\u043d\", \"\u043f\u0438\u043a\", \"\u0442\u0440\u0435\u0444\", \"\u0447\u0435\u0440\u0432\u0435\u0439\")", "nums = (\"10\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"\u0432\u0430\u043b\u0435\u0442\", \"\u0434\u0430\u043c\u0430\", \"\u043a\u043e\u0440\u043e\u043b\u044c\", \"\u0442\u0443\u0437\")", "count = 0", "for elem in product(nums, types, repeat=3): ", " f = True", " a, b, c = f\"{elem[0]} {elem[1]}\", f\"{elem[2]} {elem[3]}\", f\"{elem[4]} {elem[5]}\"", " if a == b or b == c or a == c:", " f = False", " if f and card_type in elem and card_num not in elem:", " print(a, b, c, sep=\", \")", " count += 1", " if count == 10:", " break"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0410 \u0435\u0441\u0442\u044c \u0435\u0449\u0451 \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u044b?**", "\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u0432\u043d\u043e\u0432\u044c \u043f\u043e\u043c\u043e\u0436\u0435\u043c \u0412\u0438\u0442\u0430\u043b\u0438\u044e \u0432\u044b\u044f\u0441\u043d\u0438\u0442\u044c, \u043a\u0430\u043a\u0438\u0435 \u0432\u0430\u0440\u0438\u0430\u0446\u0438\u0438 \u0432\u044b\u0442\u0430\u0449\u0438\u0442\u044c \u0438\u0437 \u043a\u043e\u043b\u043e\u0434\u044b \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0435 \u0442\u0440\u043e\u0439\u043a\u0438 \u043a\u0430\u0440\u0442 \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u044b. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u0430\u0440\u0438\u0430\u043d\u0442\u043e\u0432 \u0441\u043e\u0433\u043b\u0430\u0441\u043d\u043e \u0442\u0440\u0435\u0431\u043e\u0432\u0430\u043d\u0438\u044f\u043c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u0430 \u043c\u0430\u0441\u0442\u044c, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043e\u043b\u0436\u043d\u0430 \u043f\u0440\u0438\u0441\u0443\u0442\u0441\u0442\u0432\u043e\u0432\u0430\u0442\u044c \u0432 \u0442\u0440\u043e\u0439\u043a\u0435. \u0412\u043e \u0432\u0442\u043e\u0440\u043e\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d \u0434\u043e\u0441\u0442\u043e\u0438\u043d\u0441\u0442\u0432\u043e, \u043a\u043e\u0442\u043e\u0440\u043e\u0433\u043e \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432 \u0442\u0440\u043e\u0439\u043a\u0435. \u0412 \u0442\u0440\u0435\u0442\u044c\u0435\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d \u043f\u0440\u0435\u0434\u044b\u0434\u0443\u0449\u0438\u0439 \u0432\u0430\u0440\u0438\u0430\u043d\u0442 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u0439 \u0412\u0438\u0442\u0430\u043b\u0438\u0435\u043c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0439 \u0432\u0430\u0440\u0438\u0430\u043d\u0442 \u0440\u0430\u0441\u043a\u043b\u0430\u0434\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u041e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435: \u0432\u0430\u043b\u0435\u0442-\u0434\u0430\u043c\u0430-\u043a\u043e\u0440\u043e\u043b\u044c-\u0442\u0443\u0437 \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u0438 \u0443\u043f\u043e\u0440\u044f\u0434\u043e\u0447\u0435\u043d\u044b. \u041d\u043e \u00ab10 ...\u00bb \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u0438 \u043c\u043b\u0430\u0434\u0448\u0435, \u0447\u0435\u043c \u00ab2 ...\u00bb, \u0430 \u0431\u0443\u0431\u043d\u044b \u043c\u043b\u0430\u0434\u0448\u0435, \u0447\u0435\u043c \u043f\u0438\u043a\u0438.<br><br>\u041c\u0430\u0441\u0442\u0438 \u0432 \u0438\u043c\u0435\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u043c \u0438 \u0440\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u043c \u043f\u0430\u0434\u0435\u0436\u0430\u0445:<br>", "\u0418\u043c\u0435\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0439\t\u0420\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0439<br>\u0431\u0443\u0431\u0438\t\u0431\u0443\u0431\u0435\u043d<br>\u043f\u0438\u043a\u0438\t\u043f\u0438\u043a<br>\u0442\u0440\u0435\u0444\u044b\t\u0442\u0440\u0435\u0444<br>\u0447\u0435\u0440\u0432\u0438\t\u0447\u0435\u0440\u0432\u0435\u0439", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u043f\u0438\u043a\u0438<br>10<br>9 \u043f\u0438\u043a, \u043a\u043e\u0440\u043e\u043b\u044c \u0442\u0440\u0435\u0444, \u0442\u0443\u0437 \u0447\u0435\u0440\u0432\u0435\u0439<br>|9 \u043f\u0438\u043a, \u043a\u043e\u0440\u043e\u043b\u044c \u0447\u0435\u0440\u0432\u0435\u0439, \u0442\u0443\u0437 \u0431\u0443\u0431\u0435\u043d<br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0442\u0440\u0435\u0444\u044b<br>\u043a\u043e\u0440\u043e\u043b\u044c<br>2 \u0447\u0435\u0440\u0432\u0435\u0439, \u0442\u0443\u0437 \u043f\u0438\u043a, \u0442\u0443\u0437 \u0442\u0440\u0435\u0444<br>|2 \u0447\u0435\u0440\u0432\u0435\u0439, \u0442\u0443\u0437 \u0442\u0440\u0435\u0444, \u0442\u0443\u0437 \u0447\u0435\u0440\u0432\u0435\u0439<br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "tr = {\"\u0431\u0443\u0431\u0438\": \"\u0431\u0443\u0431\u0435\u043d\", \"\u043f\u0438\u043a\u0438\": \"\u043f\u0438\u043a\", \"\u0442\u0440\u0435\u0444\u044b\": \"\u0442\u0440\u0435\u0444\", \"\u0447\u0435\u0440\u0432\u0438\": \"\u0447\u0435\u0440\u0432\u0435\u0439\"}", "types = (\"\u0431\u0443\u0431\u0435\u043d\", \"\u043f\u0438\u043a\", \"\u0442\u0440\u0435\u0444\", \"\u0447\u0435\u0440\u0432\u0435\u0439\")", "nums = (\"10\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"\u0432\u0430\u043b\u0435\u0442\", \"\u0434\u0430\u043c\u0430\", \"\u043a\u043e\u0440\u043e\u043b\u044c\", \"\u0442\u0443\u0437\")", "", "card_type, card_num = tr[input()], input()", "combtorem = input()", "", "prevcomb = \"\"", "f = False", "# arr = []", "for elem in product(nums, types, repeat=3): ", " a, b, c = f\"{elem[0]} {elem[1]}\", f\"{elem[2]} {elem[3]}\", f\"{elem[4]} {elem[5]}\"", " if a == b or b == c or a == c:", " continue", " if card_type not in elem or card_num in elem:", " continue", " ", " comb = \", \".join([a, b, c])", " ", " # if len(arr) >= 10:", " # arr = arr[1:]", " # arr.append(comb)", "", " if prevcomb == combtorem:", " f = True", "", " if f and comb.split()[-2] == combtorem.split()[-2]:", " print(comb)", " break", "", " prevcomb = comb"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438**", "\u0412\u0441\u044f \u0441\u043e\u0432\u0440\u0435\u043c\u0435\u043d\u043d\u0430\u044f \u044d\u043b\u0435\u043a\u0442\u0440\u043e\u043d\u043d\u043e-\u0432\u044b\u0447\u0438\u0441\u043b\u0438\u0442\u0435\u043b\u044c\u043d\u0430\u044f \u0442\u0435\u0445\u043d\u0438\u043a\u0430 \u0441\u0442\u0440\u043e\u0438\u0442\u0441\u044f \u043d\u0430 \u0411\u0443\u043b\u0435\u0432\u043e\u0439 \u0430\u043b\u0433\u0435\u0431\u0440\u0435, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043e\u043f\u0435\u0440\u0438\u0440\u0443\u0435\u0442 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u044c\u044e \u0438 \u043b\u043e\u0436\u043d\u043e\u0441\u0442\u044c\u044e \u0432\u044b\u0441\u043a\u0430\u0437\u044b\u0432\u0430\u043d\u0438\u0439. \u041b\u044e\u0431\u043e\u0439 \u044f\u0437\u044b\u043a \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u0438\u0435 \u043e\u043f\u0435\u0440\u0430\u0446\u0438\u0438 (\u0432 Python \u044d\u0442\u043e and, or, not).<br><br>\u0427\u0430\u0449\u0435 \u0432\u0441\u0435\u0433\u043e \u0434\u043b\u044f \u0440\u0430\u0431\u043e\u0442\u044b \u0441\u043e \u0441\u043b\u043e\u0436\u043d\u044b\u043c\u0438 \u0432\u044b\u0441\u043a\u0430\u0437\u044b\u0432\u0430\u043d\u0438\u044f\u043c\u0438 \u043f\u0440\u0438\u0431\u0435\u0433\u0430\u044e\u0442 \u043a \u043c\u0435\u0442\u043e\u0434\u0443 \u043f\u043e\u0434 \u043d\u0430\u0437\u0432\u0430\u043d\u0438\u0435\u043c \u00ab\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438\u00bb.<br>\u0421\u0443\u0442\u044c \u043c\u0435\u0442\u043e\u0434\u0430 \u043f\u0440\u043e\u0441\u0442\u0430 \u2014 \u0440\u0430\u0441\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u044e\u0442\u0441\u044f \u0432\u0441\u0435 \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u044b\u0435 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f \u0432\u0445\u043e\u0434\u043d\u044b\u0445 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u044b\u0445 \u0438 \u0434\u043b\u044f \u043d\u0438\u0445 \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442\u0441\u044f \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442.<br><br>\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043b\u044f \u0432\u0432\u0435\u0434\u0451\u043d\u043d\u043e\u0433\u043e \u0441\u043b\u043e\u0436\u043d\u043e\u0433\u043e \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e \u0432\u044b\u0441\u043a\u0430\u0437\u044b\u0432\u0430\u043d\u0438\u044f \u0441\u0442\u0440\u043e\u0438\u0442 \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u0435 \u043e\u0442 \u0442\u0440\u0435\u0445 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u044b\u0445 (a, b, c) \u0432\u0430\u043b\u0438\u0434\u043d\u043e\u0435 \u0434\u043b\u044f \u044f\u0437\u044b\u043a\u0430 Python.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438 \u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u044f.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0414\u043b\u044f \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u044f Python \u043a\u043e\u0434\u0430, \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043d\u043e\u0433\u043e \u0432 \u0441\u0442\u0440\u043e\u043a\u0430\u0445, \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u044e\u0442 \u0434\u0432\u0435 \u0437\u0430\u043c\u0435\u0447\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0438: exec \u0438 eval.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|not a or b and c<br> <br> <br> <br> <br> <br> <br> <br> <br>|a b c f<br>0 0 0 1<br>0 0 1 1<br>0 1 0 1<br>0 1 1 1<br>1 0 0 0<br>1 0 1 0<br>1 1 0 0<br>1 1 1 1<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|a and not b and c<br> <br> <br> <br> <br> <br> <br> <br> <br>|a b c f<br>0 0 0 0<br>0 0 1 0<br>0 1 0 0<br>0 1 1 0<br>1 0 0 0<br>1 0 1 1<br>1 1 0 0<br>1 1 1 0<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "", "state = input()", "print(\"a b c f\")", "for elem in product((0, 1), repeat=3):", " a, b, c = elem[0], elem[1], elem[2]", " print(a, b, c, int(eval(state)))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438 2**", "\u041f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u043c \u0440\u0430\u0431\u043e\u0442\u0443 \u0441 \u0442\u0430\u0431\u043b\u0438\u0446\u0430\u043c\u0438 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438. \u041f\u0440\u043e\u0434\u0443\u043c\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043b\u044f \u0432\u0432\u0435\u0434\u0451\u043d\u043d\u043e\u0433\u043e \u0441\u043b\u043e\u0436\u043d\u043e\u0433\u043e \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e \u0432\u044b\u0441\u043a\u0430\u0437\u044b\u0432\u0430\u043d\u0438\u044f \u0441\u0442\u0440\u043e\u0438\u0442 \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u0435 \u043e\u0442 \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u0438\u0445 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u044b\u0445 \u0432\u0430\u043b\u0438\u0434\u043d\u043e\u0435 \u0434\u043b\u044f \u044f\u0437\u044b\u043a\u0430 Python.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438 \u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u044f.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412 \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u0438 \u0432\u0441\u0435 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u044b\u0435 \u0437\u0430\u0434\u0430\u043d\u044b \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u044b\u043c\u0438 \u043b\u0430\u0442\u0438\u043d\u0441\u043a\u0438\u043c\u0438 \u0431\u0443\u043a\u0432\u0430\u043c\u0438.<br>\u041e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u043d\u0430 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b __globals \u0438 __locals \u0443 \u0444\u0443\u043d\u043a\u0446\u0438\u0438 eval.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|not A or B and C<br> <br> <br> <br> <br> <br> <br> <br> <br>|A B C F<br>0 0 0 1<br>0 0 1 1<br>0 1 0 1<br>0 1 1 1<br>1 0 0 0<br>1 0 1 0<br>1 1 0 0<br>1 1 1 1<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|A and not B and A<br> <br> <br> <br> <br>|A B F<br>0 0 0<br>0 1 0<br>1 0 1<br>1 1 0<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "alph = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"", "state = input()", "arr = []", "for let in alph:", " if let in state:", " arr.append(let)", "", "print(*arr, \"F\")", "", "for elem in product((0, 1), repeat=len(arr)):", " m = []", " buff = arr", " c = 0", " for let in alph:", " if let in buff:", " m.append(elem[c])", " buff = buff[1:]", " c += 1 ", " else:", " m.append(0)", "", " dict = {alph[i].lower(): m[i] for i in range(len(alph))}", " print(*elem, int(eval(state.lower(), {}, dict)))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0422\u0430\u0431\u043b\u0438\u0446\u044b \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438 3**", "\u041f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u043c \u0440\u0430\u0431\u043e\u0442\u0443 \u0441 \u0442\u0430\u0431\u043b\u0438\u0446\u0430\u043c\u0438 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438.<br>\u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u043d\u0435\u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0438\u0437 \u043e\u043f\u0435\u0440\u0430\u0446\u0438\u0439 \u0411\u0443\u043b\u0435\u0432\u043e\u0439 \u0430\u043b\u0433\u0435\u0431\u0440\u044b \u043d\u0435 \u0440\u0435\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u043d\u044b \u0432 Python.<br>\u0421\u0430\u043c\u044b\u0435 \u0447\u0430\u0441\u0442\u044b\u0435 \u043d\u0435 \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u044b\u0435 \u043e\u043f\u0435\u0440\u0430\u0446\u0438\u0438 \u044d\u0442\u043e: \u0438\u043c\u043f\u043b\u0438\u043a\u0430\u0446\u0438\u044f, \u0441\u0442\u0440\u043e\u0433\u0430\u044f \u0434\u0438\u0437\u044a\u044e\u043d\u043a\u0446\u0438\u044f \u0438 \u044d\u043a\u0432\u0438\u0432\u0430\u043b\u0435\u043d\u0442\u043d\u043e\u0441\u0442\u044c.<br><br>\u041e\u0431\u043e\u0437\u043d\u0430\u0447\u0438\u043c \u0438\u0445 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c:<br>", "* \u0438\u043c\u043f\u043b\u0438\u043a\u0430\u0446\u0438\u044f \u2014 ->;", "* \u0441\u0442\u0440\u043e\u0433\u0430\u044f \u0434\u0438\u0437\u044a\u044e\u043d\u043a\u0446\u0438\u044f \u2014 ^;", "* \u044d\u043a\u0432\u0438\u0432\u0430\u043b\u0435\u043d\u0442\u043d\u043e\u0441\u0442\u044c \u2014 ~.", "", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043b\u044f \u0432\u0432\u0435\u0434\u0451\u043d\u043d\u043e\u0433\u043e \u0441\u043b\u043e\u0436\u043d\u043e\u0433\u043e \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e \u0432\u044b\u0441\u043a\u0430\u0437\u044b\u0432\u0430\u043d\u0438\u044f \u0441\u0442\u0440\u043e\u0438\u0442 \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u0435 \u043e\u0442 \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u0438\u0445 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u044b\u0445.<br><br>\u0412\u043e\u0437\u043c\u043e\u0436\u043d\u043e\u0435 \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u043d\u0438\u0435 \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u044f:<br>", "* \u0417\u0430\u0433\u043b\u0430\u0432\u043d\u0430\u044f \u043b\u0430\u0442\u0438\u043d\u0441\u043a\u0430\u044f \u0431\u0443\u043a\u0432\u0430 \u2014 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u0430\u044f;", "* not \u2014 \u043e\u0442\u0440\u0438\u0446\u0430\u043d\u0438\u0435;", "* and \u2014 \u043a\u043e\u043d\u044a\u044e\u043d\u043a\u0446\u0438\u044f;", "* or \u2014 \u0434\u0438\u0437\u044a\u044e\u043d\u043a\u0446\u0438\u044f;", "* ^ \u2014 \u0441\u0442\u0440\u043e\u0433\u0430\u044f \u0434\u0438\u0437\u044a\u044e\u043d\u043a\u0446\u0438\u044f;", "* -> \u2014 \u0438\u043c\u043f\u043b\u0438\u043a\u0430\u0446\u0438\u044f;", "* ~ \u2014 \u044d\u043a\u0432\u0438\u0432\u0430\u043b\u0435\u043d\u0442\u043d\u043e\u0441\u0442\u044c;", "* () \u2014 \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u0438\u0435 \u0441\u043a\u043e\u0431\u043a\u0438.", "", "", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0438 \u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u044f.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u041f\u0440\u0435\u0436\u0434\u0435, \u0447\u0435\u043c \u0440\u0435\u0430\u043b\u0438\u0437\u043e\u0432\u044b\u0432\u0430\u0442\u044c \u043d\u043e\u0432\u044b\u0435 \u043e\u043f\u0435\u0440\u0430\u0446\u0438\u0438, \u043e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u043d\u0430 \u0438\u0445 \u043f\u0440\u0438\u043e\u0440\u0438\u0442\u0435\u0442.<br>\u0420\u0435\u043a\u043e\u043c\u0435\u043d\u0434\u0443\u0435\u043c \u0432\u043e\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c\u0441\u044f \u0437\u043d\u0430\u043d\u0438\u044f\u043c\u0438 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u043c\u0438 \u043f\u0440\u0438 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u0437\u0430\u0434\u0430\u0447\u0438 \u00ab\u041f\u043e\u043b\u044c\u0441\u043a\u0438\u0439 \u043a\u0430\u043b\u044c\u043a\u0443\u043b\u044f\u0442\u043e\u0440\u00bb.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|A -> B ~ C<br> <br> <br> <br> <br> <br> <br> <br> <br>|A B C F<br>0 0 0 0<br>0 0 1 1<br>0 1 0 0<br>0 1 1 1<br>1 0 0 1<br>1 0 1 0<br>1 1 0 0<br>1 1 1 1<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|A or C ~ not (A -> B) or C<br> <br> <br> <br> <br> <br> <br> <br> <br>|A B C F<br>0 0 0 1<br>0 0 1 1<br>0 1 0 1<br>0 1 1 1<br>1 0 0 1<br>1 0 1 1<br>1 1 0 0<br>1 1 1 1<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from itertools import product", "", "", "def make_brackets(eq):", "", " opers = [\"<=\", \"!=\", \"or\", \"and\"][::-1]", " for op in opers:", " if op in eq:", " parts = eq.split(op)", " else:", " continue", " for i in range(len(parts) - 1):", " if parts[i][-2] in alph:", " parts[i] = parts[i][:-2] + \"(\" + parts[i][-2:]", " else:", " c = 1", " for j in range(len(parts[i]) - 3, -1, -1):", " if parts[i][j] == \")\":", " c += 1", " elif parts[i][j] == \"(\":", " c -= 1", " if not c:", " if j >= 4:", " if parts[i][j - 4:j] == \"not \":", " parts[i] = parts[i][:j - 4] + \"(\" + parts[i][j - 4:] ", " else:", " parts[i] = parts[i][:j] + \"(\" + parts[i][j:]", " break", " ", " if parts[i + 1][1] in alph:", " parts[i + 1] = parts[i + 1][:2] + \")\" + parts[i + 1][2:]", " ", " else:", " if parts[i + 1][1] == \"(\":", " c = 1", " for j in range(2, len(parts[i + 1])):", " if parts[i + 1][j] == \"(\":", " c += 1", " elif parts[i + 1][j] == \")\":", " c -= 1", " if not c:", " parts[i + 1] = parts[i + 1][:j] + \")\" + parts[i + 1][j:]", " break", " ", " elif parts[i + 1][1] == \"n\":", " if parts[i + 1][5] == \"(\":", " for j in range(6, len(parts[i + 1])):", " if parts[i + 1][j] == \"(\":", " c += 1", " elif parts[i + 1][j] == \")\":", " c -= 1", " if not c:", " parts[i + 1] = parts[i + 1][:j] + \")\" + parts[i + 1][j:]", " break", " else:", " parts[i + 1] = parts[i + 1][:6] + \")\" + parts[i + 1][6:]", " ", " eq = op.join(parts)", " return eq", "", "", "alph = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"", "state = input().replace(\"->\", \"<=\").replace(\"^\", \"!=\").replace(\"~\", \"==\")", "arr = []", "", "for let in alph:", " if let in state:", " arr.append(let)", "", "print(*arr, \"F\")", "", "for elem in product((0, 1), repeat=len(arr)):", " m = []", " buff = arr", " c = 0", " for let in alph:", " if let in buff:", " m.append(elem[c])", " buff = buff[1:]", " c += 1 ", " else:", " m.append(0)", "", " dict = {alph[i].lower(): m[i] for i in range(len(alph))}", " print(*elem, int(eval(make_brackets(state).lower(), {}, dict)))"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"name": "python", "version": "3.11.1"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/3.4/4.py b/3.4/4.py
deleted file mode 100644
index 3386992a859d5b52eb87354701342e2de3a78903..0000000000000000000000000000000000000000
--- a/3.4/4.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from itertools import accumulate
-
-for string in accumulate([[i] for i in input().split()]):
- print(" ".join(string))
\ No newline at end of file
diff --git a/3.4/5.py b/3.4/5.py
deleted file mode 100644
index 27a5bfad5d0ef5ac0bbb48f7c260d56db3aa38ca..0000000000000000000000000000000000000000
--- a/3.4/5.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from itertools import chain
-
-for index, value in enumerate(sorted(chain.from_iterable([input().split(", ") for _ in range(3)])), 1):
- print(f"{index}. {value}")
\ No newline at end of file
diff --git a/3.4/6.py b/3.4/6.py
deleted file mode 100644
index bd0721ac9ec274b4c4ed2de778d35f7b9700cbde..0000000000000000000000000000000000000000
--- a/3.4/6.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from itertools import product
-
-types = ["пик", "треф", "бубен", "червей"]
-
-majors = ["валет", "дама", "король", "туз"]
-m = types.index(input())
-
-for a, b in product([str(i) for i in range(2, 11)] + majors, types[:m] + types[m + 1:]):
- print(a, b)
\ No newline at end of file
diff --git a/3.4/7.py b/3.4/7.py
deleted file mode 100644
index 4d6dd7648de52e778e8be328ba2625cdea43fb4a..0000000000000000000000000000000000000000
--- a/3.4/7.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from itertools import combinations
-
-people = [input() for _ in range(int(input()))]
-
-for a, b in combinations(people, 2):
- print(f"{a} - {b}")
\ No newline at end of file
diff --git a/3.4/8.py b/3.4/8.py
deleted file mode 100644
index 0b68a779bf283728bb43925b2df824386cba6253..0000000000000000000000000000000000000000
--- a/3.4/8.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from itertools import cycle
-
-food = [input() for _ in range(int(input()))]
-
-daysc = int(input())
-
-count = 0
-for fd in cycle(food):
- if count < daysc:
- print(fd)
- count += 1
- else:
- break
\ No newline at end of file
diff --git a/3.4/9.py b/3.4/9.py
deleted file mode 100644
index f79cdddf602299bdc96eed25c67694eabb9d8a05..0000000000000000000000000000000000000000
--- a/3.4/9.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from itertools import product
-
-n = int(input())
-c = 0
-for a, b in product([i for i in range(1, n + 1)], [i for i in range(1, n + 1)]):
- if c % n == 0 and c:
- print()
- print(a * b, end=" ")
- c += 1
-print()
\ No newline at end of file
diff --git a/3.5/1.py b/3.5/1.py
deleted file mode 100644
index 22bffdc8aed5eb2596c8f3c28e53e6cffff6b2cc..0000000000000000000000000000000000000000
--- a/3.5/1.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from sys import stdin
-
-arr = []
-for line in stdin:
- arr += [int(i) for i in line.rstrip("\n").split()]
-
-print(sum(arr))
\ No newline at end of file
diff --git a/3.5/10.py b/3.5/10.py
deleted file mode 100644
index 19c91c055b6ebe3ef29b18ed6b7b80f182a42ed3..0000000000000000000000000000000000000000
--- a/3.5/10.py
+++ /dev/null
@@ -1,12 +0,0 @@
-file_name, n = input(), int(input())
-c = 0
-with open(file_name, "r", encoding="utf-8") as file:
- for line in file:
- c += 1
-
-with open(file_name, "r", encoding="utf-8") as file:
- line_number = 0
- for line in file:
- line_number += 1
- if line_number > c - n:
- print(line, end="")
\ No newline at end of file
diff --git a/3.5/11.py b/3.5/11.py
deleted file mode 100644
index 0ef1b8802501aaad4418b0b0123842ff6a8730d7..0000000000000000000000000000000000000000
--- a/3.5/11.py
+++ /dev/null
@@ -1,20 +0,0 @@
-import json
-
-in_file, js_file = input(), input()
-res = {"count": 0, "positive_count": 0, "min": float("inf"),
- "max": float("-inf"), "sum": 0, "average": 0}
-
-with open(in_file, "r", encoding="utf-8")as inp:
- for line in inp:
- for num in [int(i) for i in line.split()]:
- res["count"] += 1
- if num > 0:
- res["positive_count"] += 1
- res["min"] = min(res["min"], num)
- res["max"] = max(res["max"], num)
- res["sum"] += num
-
-res["average"] = round((res["sum"] / res["count"]), 2)
-
-with open(js_file, "w", encoding="UTF-8") as js:
- json.dump(res, js, ensure_ascii=False, indent=2)
\ No newline at end of file
diff --git a/3.5/12.py b/3.5/12.py
deleted file mode 100644
index c22f5537cbb856372d85b3c4aa99db4a7d99446d..0000000000000000000000000000000000000000
--- a/3.5/12.py
+++ /dev/null
@@ -1,34 +0,0 @@
-def count_even_cif(num):
- c = 0
- for i in num:
- if int(i) % 2 == 0:
- c += 1
-
- return c
-
-
-finputname, fevenname, foddname, feqname = [input() for _ in range(4)]
-
-even, odd, eq = [], [], []
-evenfile = open(fevenname, "w", encoding="utf-8")
-oddfile = open(foddname, "w", encoding="utf-8")
-eqfile = open(feqname, "w", encoding="utf-8")
-with open(finputname, "r", encoding="utf-8")as inputfile:
- for line in inputfile:
- for num in line.rstrip("\n").split():
- ev = count_even_cif(num)
- if len(num) - ev > ev:
- odd.append(num)
- elif len(num) == 2 * ev:
- eq.append(num)
- else:
- even.append(num)
-
- evenfile.write(" ".join(even) + "\n")
- oddfile.write(" ".join(odd) + "\n")
- eqfile.write(" ".join(eq) + "\n")
- even, odd, eq = [], [], []
-
-evenfile.close()
-oddfile.close()
-eqfile.close()
\ No newline at end of file
diff --git a/3.5/13.py b/3.5/13.py
deleted file mode 100644
index f58259c0cdb35833758cc2c9c9794d230dfd9737..0000000000000000000000000000000000000000
--- a/3.5/13.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from sys import stdin
-import json
-
-file_name = input()
-d = {}
-
-for line in stdin:
- key, val = line.rstrip().split(" == ")
- d[key] = val
-
-with open(file_name, "r", encoding="UTF-8") as js:
- data = json.load(js)
- for key, val in d.items():
- data[key] = val
-
-with open(file_name, "w", encoding="UTF-8") as js:
- json.dump(data, js, ensure_ascii=False, indent=2)
\ No newline at end of file
diff --git a/3.5/14.py b/3.5/14.py
deleted file mode 100644
index 9c2e728ac056fffdf95a56d4c19e91333cbbd375..0000000000000000000000000000000000000000
--- a/3.5/14.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import json
-
-
-jsusersname, jsupdatesname = input(), input()
-
-
-data = []
-with open(jsusersname, "r", encoding="UTF-8") as js:
- data = json.load(js)
-
-newdata = {}
-for d in data:
- newdata[d["name"]] = {}
- for key, val in d.items():
- if key == "name":
- continue
- newdata[d["name"]][key] = val
-
-with open(jsupdatesname, "r", encoding="UTF-8") as js:
- data = json.load(js)
-
-for d in data:
- name = d["name"]
- for key, newval in d.items():
- if key == "name":
- continue
- if key in newdata[name]:
- val = newdata[name][key]
- newdata[name][key] = sorted([val, newval], reverse=True)[0]
- else:
- newdata[name][key] = newval
-
-with open(jsusersname, "w", encoding="UTF-8") as js:
- json.dump(newdata, js, ensure_ascii=False, indent=2)
\ No newline at end of file
diff --git a/3.5/15.py b/3.5/15.py
deleted file mode 100644
index 662a52394f55d35abbcb55cbe48acfff9ae991c2..0000000000000000000000000000000000000000
--- a/3.5/15.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import json
-from sys import stdin
-
-
-name = "scoring.json"
-
-data = []
-with open(name, "r", encoding="utf-8") as js:
- data = json.load(js)
-
-testcnt = 0
-for elem in data:
- testcnt += len(elem["tests"])
-
-c = 0
-packc = 0
-pointsum = 0
-
-d = data[packc]
-points = d["points"]
-tests = d["tests"]
-for line in stdin:
- answer = line.rstrip("\n")
- if c < len(tests):
- if tests[c]["pattern"] == answer:
- pointsum += int(points / len(tests))
- c += 1
- else:
- packc += 1
- d = data[packc]
- points = d["points"]
- tests = d["tests"]
- c = 0
- if c < len(tests):
- if tests[c]["pattern"] == answer:
- pointsum += int(points / len(tests))
- c += 1
-
-print(pointsum)
\ No newline at end of file
diff --git a/3.5/16.py b/3.5/16.py
deleted file mode 100644
index 9bc112d616026581e92e0adce1a58bc5b5933a18..0000000000000000000000000000000000000000
--- a/3.5/16.py
+++ /dev/null
@@ -1,48 +0,0 @@
-from sys import stdin
-
-
-search_task = input().lower().split()
-
-filenames = [line.rstrip("\n") for line in stdin]
-is_something = False
-
-for fname in filenames:
-
- active_searches = []
- ind = 0
- f = False
- with open(fname, "r", encoding="utf-8") as file:
- for line in file:
- for word in line.replace(" ", " ").rstrip("\n").lower().split():
- if not word:
- continue
- if word == search_task[0]:
- active_searches.append([word])
- continue
- if active_searches:
- for i in range(len(active_searches) - 1, -1, -1):
- if len(active_searches[i]) == len(search_task):
- f = True
- break
- elif search_task[len(active_searches[i])] == word:
- active_searches[i].append(word)
- else:
- del active_searches[i]
-
- if f:
- break
-
- if active_searches:
- for i in range(len(active_searches) - 1, -1, -1):
- if len(active_searches[i]) == len(search_task):
- f = True
- break
-
- if f:
- break
- if f:
- print(fname)
- is_something = True
-
-if not is_something:
- print("404. Not Found")
\ No newline at end of file
diff --git a/3.5/17.py b/3.5/17.py
deleted file mode 100644
index 9099976ff7e1c4c8b8dbe95ef31eaa2a25219358..0000000000000000000000000000000000000000
--- a/3.5/17.py
+++ /dev/null
@@ -1,18 +0,0 @@
-fname = "secret.txt"
-
-with open(fname, "r", encoding="utf-8") as file:
- for line in file:
- string = line.rstrip("\n")
- res = ''
-
- for char in string:
- b = bin(ord(char))[2:]
- if len(b) % 8 != 0:
- bytenum = len(b) // 8 + 1
- b = "0" * (8 * bytenum - len(b)) + b
- if len(b) <= 8:
- res += chr(int(b, 2))
- else:
- res += chr(int(b[8:], 2))
-
- print(res)
\ No newline at end of file
diff --git a/3.5/18.py b/3.5/18.py
deleted file mode 100644
index 11cd6d9b4f798bddfd6d08484c493e1a34f8313b..0000000000000000000000000000000000000000
--- a/3.5/18.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import os
-
-types = ["Б", "КБ", "МБ", "ГБ"]
-fname = input()
-bytessum = 0
-type = 0
-bytessum = os.stat(fname).st_size
-
-while bytessum >= 1024:
- if bytessum == 3:
- break
- type += 1
- bytessum = bytessum // 1024 + (bytessum % 1024 > 0)
-
-print(f"{bytessum}{types[type]}")
diff --git a/3.5/19.py b/3.5/19.py
deleted file mode 100644
index 3e5743cb8fb85ab200c1a1e204a43bcc96ada550..0000000000000000000000000000000000000000
--- a/3.5/19.py
+++ /dev/null
@@ -1,34 +0,0 @@
-inpname = "public.txt"
-outname = "private.txt"
-
-change = int(input())
-
-with open(inpname, "r", encoding="utf-8") as inpfile:
- with open(outname, "w", encoding="utf-8") as outfile:
- for line in inpfile:
- s = ''
- for c in line:
- code = ord(c)
- if 65 <= code <= 90:
- code += change
- if code > 90:
- while code > 90:
- code = code - 26
- elif code < 65:
- while code < 65:
- code = 26 + code
- c = chr(code)
- elif 97 <= code <= 122:
- code += change
- if code > 122:
- while code > 122:
- code = code - 26
- elif code < 97:
- while code < 97:
- code = 26 + code
- c = chr(code)
-
- s += c
- outfile.write(s)
-
-
diff --git a/3.5/2.py b/3.5/2.py
deleted file mode 100644
index 1a583e0b661f5a959d2b014751a2bbe4341d4e87..0000000000000000000000000000000000000000
--- a/3.5/2.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from sys import stdin
-
-high_arr = []
-for line in stdin:
- high = [int(i) for i in line.rstrip("\n").split()[1:]]
- high_arr.append(high[1] - high[0])
-
-print(round(sum(high_arr) / len(high_arr)))
\ No newline at end of file
diff --git a/3.5/20.py b/3.5/20.py
deleted file mode 100644
index c305993b11d4e63ff03196b015148b5d1a742c9c..0000000000000000000000000000000000000000
--- a/3.5/20.py
+++ /dev/null
@@ -1,9 +0,0 @@
-fname = "numbers.num"
-
-snum = 0
-with open(fname, "rb") as file:
- while (byte := file.read(2)):
- snum += int.from_bytes(byte)
-
-snum = snum % 2**16
-print(snum)
\ No newline at end of file
diff --git a/3.5/3.py b/3.5/3.py
deleted file mode 100644
index 1b6810c57ad753d249c5b44ddcbf8e643720127c..0000000000000000000000000000000000000000
--- a/3.5/3.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from sys import stdin
-
-code = []
-for line in stdin:
- if line.find("#") != 0:
- print(line[: line.find("#")])
\ No newline at end of file
diff --git a/3.5/35.ipynb b/3.5/35.ipynb
deleted file mode 100644
index 6a647e28a26ca2fe537ae2cb3ca812190938bc66..0000000000000000000000000000000000000000
--- a/3.5/35.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["## **A+B+...**", "\u041d\u0430\u043a\u043e\u043d\u0435\u0446-\u0442\u043e \u043c\u044b \u043c\u043e\u0436\u0435\u043c \u043e\u0431\u0440\u0430\u0431\u0430\u0442\u044b\u0432\u0430\u0442\u044c \u0434\u0430\u043d\u043d\u044b\u0435, \u043d\u0435 \u0438\u043c\u0435\u044f \u043d\u0438 \u043c\u0430\u043b\u0435\u0439\u0448\u0435\u0433\u043e \u043f\u043e\u043d\u044f\u0442\u0438\u044f \u043e\u0431 \u0438\u0445 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u0435.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043d\u0430\u0445\u043e\u0434\u0438\u0442 \u0441\u0443\u043c\u043c\u0443 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b \u0432\u0432\u0435\u0434\u0451\u043d\u043d\u044b\u0445 \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435\u043c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0441\u0442\u0440\u043e\u043a\u0438 \u0447\u0438\u0441\u0435\u043b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0434\u043d\u043e \u0447\u0438\u0441\u043b\u043e \u2014 \u0441\u0443\u043c\u043c\u0430 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b \u0432 \u043f\u043e\u0442\u043e\u043a\u0435 \u0432\u0432\u043e\u0434\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|1 2<br>3 4 5<br>6<br>7 8 9 10<br>|55<br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "", "arr = []", "for line in stdin:", " arr += [int(i) for i in line.rstrip(\"\\n\").split()]", "", "print(sum(arr))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u0440\u0435\u0434\u043d\u0438\u0439 \u0440\u043e\u0441\u0442**", "\u0423\u0447\u0438\u0442\u0435\u043b\u044c \u0444\u0438\u0437\u043a\u0443\u043b\u044c\u0442\u0443\u0440\u044b \u0437\u0430\u0434\u0430\u043b\u0441\u044f \u0432\u043e\u043f\u0440\u043e\u0441\u043e\u043c, \u043d\u0430 \u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0432 \u0441\u0440\u0435\u0434\u043d\u0435\u043c \u0435\u0433\u043e \u043f\u043e\u0434\u043e\u043f\u0435\u0447\u043d\u044b\u0435 \u0432\u044b\u0440\u043e\u0441\u043b\u0438 \u0437\u0430 \u043f\u0440\u043e\u0448\u0435\u0434\u0448\u0438\u0439 \u043c\u0435\u0441\u044f\u0446.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u044f\u0435\u0442, \u043d\u0430 \u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0438\u0437\u043c\u0435\u043d\u0438\u043b\u0441\u044f \u0441\u0440\u0435\u0434\u043d\u0438\u0439 \u0440\u043e\u0441\u0442 \u0443\u0447\u0435\u043d\u0438\u043a\u043e\u0432 \u0432 \u043a\u043b\u0430\u0441\u0441\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043e \u0434\u0435\u0442\u044f\u0445 \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435:", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0434\u043d\u043e \u0447\u0438\u0441\u043b\u043e \u2014 \u043e\u0442\u0432\u0435\u0442 \u043d\u0430 \u0432\u043e\u043f\u0440\u043e\u0441 \u0437\u0430\u0434\u0430\u0447\u0438.<br>\u041e\u0442\u0432\u0435\u0442 \u043e\u043a\u0440\u0443\u0433\u043b\u0438\u0442\u0435 \u0434\u043e \u0446\u0435\u043b\u044b\u0445. \u041d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, \u0444\u0443\u043d\u043a\u0446\u0438\u0435\u0439 round.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0410\u043d\u044f 160 162<br>\u0411\u043e\u0440\u044f 165 172<br>\u0412\u043e\u0432\u0430 165 165<br>|3<br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0410\u043d\u044f 161 165<br>\u0411\u043e\u0440\u044f 167 172<br>\u0412\u043e\u0432\u0430 165 166<br>\u0414\u0438\u043c\u0430 173 178<br>|4<br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "", "high_arr = []", "for line in stdin:", " high = [int(i) for i in line.rstrip(\"\\n\").split()[1:]]", " high_arr.append(high[1] - high[0])", "", "print(round(sum(high_arr) / len(high_arr)))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0411\u0435\u0437 \u043a\u043e\u043c\u043c\u0435\u043d\u0442\u0430\u0440\u0438\u0435\u0432 2.0**", "\u041a\u0430\u043a \u0432\u044b \u043f\u043e\u043c\u043d\u0438\u0442\u0435, \u043a\u043e\u0433\u0434\u0430 \u0432\u044b \u043a\u043e\u043c\u043c\u0435\u043d\u0442\u0438\u0440\u0443\u0435\u0442\u0435 \u0441\u0432\u043e\u0439 \u043a\u043e\u0434, \u043f\u0435\u0440\u0435\u0434 \u0435\u0433\u043e \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435\u043c \u0438\u043d\u0442\u0435\u0440\u043f\u0440\u0435\u0442\u0430\u0442\u043e\u0440 \u0443\u0434\u0430\u043b\u044f\u0435\u0442 \u043a\u043e\u043c\u043c\u0435\u043d\u0442\u0430\u0440\u0438\u0438.<br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u043f\u043e\u043b\u043d\u044f\u0435\u0442 \u0434\u0430\u043d\u043d\u0443\u044e \u0444\u0443\u043d\u043a\u0446\u0438\u044e \u0437\u0430 \u0438\u043d\u0442\u0435\u0440\u043f\u0440\u0435\u0442\u0430\u0442\u043e\u0440.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0441\u0442\u0440\u043e\u043a\u0438 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041a\u0430\u0436\u0434\u0443\u044e \u0441\u0442\u0440\u043e\u043a\u0443 \u043d\u0443\u0436\u043d\u043e \u043e\u0447\u0438\u0441\u0442\u0438\u0442\u044c \u043e\u0442 \u043a\u043e\u043c\u043c\u0435\u043d\u0442\u0430\u0440\u0438\u0435\u0432.<br>\u0410 \u0435\u0441\u043b\u0438 \u043a\u043e\u043c\u043c\u0435\u043d\u0442\u0430\u0440\u0438\u0439 \u2014 \u0432\u0441\u044f \u0441\u0442\u0440\u043e\u043a\u0430, \u0442\u043e \u0432\u044b\u0432\u043e\u0434\u0438\u0442\u044c \u0435\u0451 \u043d\u0435 \u043d\u0443\u0436\u043d\u043e.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041c\u043e\u044f \u043f\u0435\u0440\u0432\u0430\u044f \u0441\u0443\u043f\u0435\u0440-\u043f\u0443\u043f\u0435\u0440 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0430<br>print(\"What is your name?\") # \u041a\u0430\u043a \u0442\u0435\u0431\u044f \u0437\u043e\u0432\u0443\u0442?<br>name = input() # \u0421\u043e\u0445\u0440\u0430\u043d\u044f\u0435\u043c \u0438\u043c\u044f<br>print(f\"Hello, {name}!\") # \u0417\u0434\u043e\u0440\u043e\u0432\u0430\u0435\u043c\u0441\u044f# \u041a\u043e\u043d\u0435\u0446 \u043c\u043e\u0435\u0439 \u0441\u0443\u043f\u0435\u0440-\u043f\u0443\u043f\u0435\u0440 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b<br>|print(\"What is your name?\")<br>name = input()<br>print(f\"Hello, {name}!\")<br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041c\u043e\u0439 \u043f\u0435\u0440\u0432\u044b\u0439 \u0446\u0438\u043a\u043b<br>for i in range(10): # \u0421\u0447\u0438\u0442\u0430\u0435\u043c \u0434\u043e 10<br> print(i) # \u0432\u044b\u0432\u043e\u0434\u0438\u043c \u0447\u0438\u0441\u043b\u043e<br>|for i in range(10):<br> print(i)<br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "", "code = []", "for line in stdin:", " if line.find(\"#\") != 0:", " print(line[: line.find(\"#\")])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041d\u0430\u0439\u0434\u0451\u0442\u0441\u044f \u0432\u0441\u0451 2.0**", "\u041f\u043e\u0438\u0441\u043a \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438 \u2014 \u0432\u0430\u0436\u043d\u0430\u044f \u0447\u0430\u0441\u0442\u044c \u0441\u043e\u0432\u0440\u0435\u043c\u0435\u043d\u043d\u043e\u0439 \u0436\u0438\u0437\u043d\u0438. \u0421\u043e\u0437\u0434\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0440\u0435\u0430\u043b\u0438\u0437\u0443\u0435\u0442 \u043c\u0430\u043b\u0435\u043d\u044c\u043a\u0438\u0439 \u043a\u043e\u043c\u043f\u043e\u043d\u0435\u043d\u0442 \u043f\u043e\u0438\u0441\u043a\u043e\u0432\u043e\u0439 \u0441\u0438\u0441\u0442\u0435\u043c\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0437\u0430\u0433\u043e\u043b\u043e\u0432\u043a\u0438 \u0441\u0442\u0440\u0430\u043d\u0438\u0446.<br>\u0412 \u043f\u043e\u0441\u043b\u0435\u0434\u043d\u0435\u0439 \u0441\u0442\u0440\u043e\u043a\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d \u043f\u043e\u0438\u0441\u043a\u043e\u0432\u044b\u0439 \u0437\u0430\u043f\u0440\u043e\u0441.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0441\u0442\u0438 \u0432\u0441\u0435 \u0437\u0430\u0433\u043e\u043b\u043e\u0432\u043a\u0438 \u0441\u0442\u0440\u0430\u043d\u0438\u0446, \u0432 \u043a\u043e\u0442\u043e\u0440\u044b\u0445 \u043f\u0440\u0438\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043f\u043e\u0438\u0441\u043a\u043e\u0432\u044b\u0439 \u0437\u0430\u043f\u0440\u043e\u0441 (\u0440\u0435\u0433\u0438\u0441\u0442\u0440 \u043d\u0435 \u0438\u043c\u0435\u0435\u0442 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f).<br>\u041f\u043e\u0440\u044f\u0434\u043e\u043a \u0437\u0430\u0433\u043e\u043b\u043e\u0432\u043a\u043e\u0432 \u0434\u043e\u043b\u0436\u0435\u043d \u0441\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c\u0441\u044f.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u042f\u043d\u0434\u0435\u043a\u0441 \u0432\u044b\u043f\u0443\u0441\u0442\u0438\u043b \u0437\u0430\u0434\u0430\u0447\u043d\u0438\u043a \u043f\u043e \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044e<br>\u041d\u0430 \u0441\u043e\u0440\u0435\u0432\u043d\u043e\u0432\u0430\u043d\u0438\u044f\u0445 \u043f\u043e \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044e \u043f\u043e\u0431\u0435\u0434\u0438\u043b \u043b\u044e\u0431\u0438\u0442\u0435\u043b\u044c \u043f\u0438\u0442\u043e\u043d\u0430<br>\u041a\u0430\u043a \u0437\u0430\u043a\u0430\u0437\u0430\u0442\u044c \u042f\u043d\u0434\u0435\u043a\u0441.\u0422\u0430\u043a\u0441\u0438?!<br>\u044f\u043d\u0434\u0435\u043a\u0441<br>|\u042f\u043d\u0434\u0435\u043a\u0441 \u0432\u044b\u043f\u0443\u0441\u0442\u0438\u043b \u0437\u0430\u0434\u0430\u0447\u043d\u0438\u043a \u043f\u043e \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044e<br>\u041a\u0430\u043a \u0437\u0430\u043a\u0430\u0437\u0430\u0442\u044c \u042f\u043d\u0434\u0435\u043a\u0441.\u0422\u0430\u043a\u0441\u0438?!<br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0441\u0435\u0440\u0438\u0430\u043b \u0448\u0435\u0440\u043b\u043e\u043a \u0441\u043c\u043e\u0442\u0440\u0435\u0442\u044c \u043e\u043d\u043b\u0430\u0439\u043d<br>\u0443\u0447\u0435\u0431\u043d\u0438\u043a \u043f\u0438\u0442\u043e\u043d\u0430<br>\u043c\u0435\u043c\u044b<br>\u0441\u043e\u0446\u0438\u0430\u043b\u044c\u043d\u0430\u044f \u0441\u0435\u0442\u044c<br>\u0443\u043f\u0440\u0430\u0436\u043d\u0435\u043d\u0438\u044f \u043f\u043e \u043f\u0438\u0442\u043e\u043d\u0443<br>\u043a\u043e\u0440\u043c\u043e\u0432\u044b\u0435 \u043c\u044b\u0448\u0438 \u0434\u043b\u044f \u043f\u0438\u0442\u043e\u043d\u043e\u0432<br>\u043e\u0442\u0432\u0435\u0442\u044b \u0435\u0433\u044d \u0441\u043a\u0430\u0447\u0430\u0442\u044c \u0431\u0435\u0441\u043f\u043b\u0430\u0442\u043d\u043e<br>\u043a\u043e\u043c\u043f\u044c\u044e\u0442\u0435\u0440\u043d\u044b\u0435 \u043c\u044b\u0448\u0438<br>\u043f\u0438\u0442\u043e\u043d<br>|\u0443\u0447\u0435\u0431\u043d\u0438\u043a \u043f\u0438\u0442\u043e\u043d\u0430<br>\u0443\u043f\u0440\u0430\u0436\u043d\u0435\u043d\u0438\u044f \u043f\u043e \u043f\u0438\u0442\u043e\u043d\u0443<br>\u043a\u043e\u0440\u043c\u043e\u0432\u044b\u0435 \u043c\u044b\u0448\u0438 \u0434\u043b\u044f \u043f\u0438\u0442\u043e\u043d\u043e\u0432<br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "", "sentences = []", "for line in stdin:", " sentences.append(line.rstrip(\"\\n\"))", "", "search = sentences.pop(-1)", "res = []", "", "for sen in sentences:", " if search.lower() in sen.lower():", " res.append(sen)", "", "print(*res, sep=\"\\n\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0410 \u0440\u043e\u0437\u0430 \u0443\u043f\u0430\u043b\u0430 \u043d\u0430 \u043b\u0430\u043f\u0443 \u0410\u0437\u043e\u0440\u0430 6.0**", "\u041c\u044b \u0443\u0436\u0435 \u043f\u0438\u0441\u0430\u043b\u0438 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u044f\u043b\u0438, \u0430 \u043f\u0430\u043b\u0438\u043d\u0434\u0440\u043e\u043c \u043f\u0435\u0440\u0435\u0434 \u043d\u0430\u043c\u0438 \u0438\u043b\u0438 \u043d\u0435\u0442.<br>\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u0442\u0435\u043f\u0435\u0440\u044c \u043d\u0430\u0439\u0434\u0451\u043c \u0432\u0441\u0435 \u0441\u043b\u043e\u0432\u0430-\u043f\u0430\u043b\u0438\u043d\u0434\u0440\u043e\u043c\u044b \u0441\u0440\u0435\u0434\u0438 \u0432\u0432\u0435\u0434\u0451\u043d\u043d\u044b\u0445 \u0441\u0442\u0440\u043e\u043a.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0441\u043b\u043e\u0432\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0421\u043f\u0438\u0441\u043e\u043a \u0441\u043b\u043e\u0432-\u043f\u0430\u043b\u0438\u043d\u0434\u0440\u043e\u043c\u043e\u0432 \u0432 \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u043d\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435 \u0431\u0435\u0437 \u043f\u043e\u0432\u0442\u043e\u0440\u0435\u043d\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u041f\u0440\u0438 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0435 \u0441\u043b\u043e\u0432 \u043d\u0435 \u043e\u0431\u0440\u0430\u0449\u0430\u0439\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u043d\u0430 \u0440\u0435\u0433\u0438\u0441\u0442\u0440.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u0410\u043d\u043d\u0430 \u0411\u043e\u0440\u044f \u0412\u043e\u0432\u0430<br>\u042f \u043f\u043e\u0441\u043b\u0435\u0434\u043d\u044f\u044f \u0431\u0443\u043a\u0432\u0430 \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u0430<br>\u0414\u0435\u0434 \u0441\u0442\u0440\u043e\u0438\u0442 \u0448\u0430\u043b\u0430\u0448<br>\u0428\u0430\u043b\u0430\u0448 \u0431\u044b\u043b \u0445\u043e\u0440\u043e\u0448<br>\u0414\u0435\u0434 \u0441\u043b\u044b\u0448\u0438\u0442 \u0442\u043e\u043f\u043e\u0442<br>\u0410\u0440\u0430 \u0437\u0430\u043b\u0435\u0442\u0435\u043b \u0432 \u0448\u0430\u043b\u0430\u0448<br> <br> <br>|\u0410\u043d\u043d\u0430<br>\u0410\u0440\u0430<br>\u0414\u0435\u0434<br>\u0428\u0430\u043b\u0430\u0448<br>\u042f<br>\u0432<br>\u0442\u043e\u043f\u043e\u0442<br>\u0448\u0430\u043b\u0430\u0448<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "", "res = set()", "for line in stdin:", " for word in line.rstrip(\"\\n\").split():", " if word.lower() == word[::-1].lower():", " res.add(word)", "", "print(*sorted(list(res)), sep=\"\\n\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0422\u0440\u0430\u043d\u0441\u043b\u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f 2.0**", "\u0414\u043b\u044f \u043c\u0435\u0436\u0434\u0443\u043d\u0430\u0440\u043e\u0434\u043d\u044b\u0445 \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u043e\u0432 \u0440\u0443\u0441\u0441\u043a\u0438\u0439 \u0442\u0435\u043a\u0441\u0442 \u043f\u0440\u0435\u043e\u0431\u0440\u0430\u0437\u0443\u0435\u0442\u0441\u044f \u0441 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u043d\u0438\u0435\u043c \u043b\u0430\u0442\u0438\u043d\u0441\u043a\u043e\u0433\u043e \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u0430. \u0413\u041e\u0421\u0422 \u0420 52535.1-2006 \u0437\u0430\u0434\u0430\u0451\u0442 \u043f\u0440\u0430\u0432\u0438\u043b\u0430 \u0442\u0440\u0430\u043d\u0441\u043b\u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0438 \u0438\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0445 \u043a\u0430\u0440\u0442.<br>\u041d\u0438\u0436\u0435 \u043f\u0440\u0438\u0432\u0435\u0434\u0435\u043d\u0430 \u0442\u0430\u0431\u043b\u0438\u0446\u0430 \u0437\u0430\u043c\u0435\u043d:<br>", "\u0410 \u2014 A<br>\u0411 \u2014 B<br>\u0412 \u2014 V<br>\u0413 \u2014 G<br>\u0414 \u2014 D<br>\u0415 \u2014 E<br>\u0401 \u2014 E<br>\u0416 \u2014 ZH<br>\u0417 \u2014 Z<br>\u0418 \u2014 I<br>\u0419 \u2014 I<br>\u041a \u2014 K<br>\u041b \u2014 L<br>\u041c \u2014 M<br>\u041d \u2014 N<br>\u041e \u2014 O<br>\u041f \u2014 P<br>\u0420 \u2014 R<br>\u0421 \u2014 S<br>\u0422 \u2014 T<br>\u0423 \u2014 U<br>\u0424 \u2014 F<br>\u0425 \u2014 KH<br>\u0426 \u2014 TC<br>\u0427 \u2014 CH<br>\u0428 \u2014 SH<br>\u0429 \u2014 SHCH<br>\u042b \u2014 Y<br>\u042d \u2014 E<br>\u042e \u2014 IU<br>\u042f \u2014 IA<br>\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u0442\u0440\u0430\u043d\u0441\u043b\u0438\u0442\u0435\u0440\u0438\u0440\u0443\u0435\u043c \u0440\u0443\u0441\u0441\u043a\u0438\u0439 \u0442\u0435\u043a\u0441\u0442.<br>\u0411\u0443\u043a\u0432\u0443 \u00ab\u0451\u00bb \u0442\u0440\u0430\u043d\u0441\u043b\u0438\u0442\u0435\u0440\u0438\u0440\u0443\u0439\u0442\u0435 \u043a\u0430\u043a \u00abe\u00bb, \u00ab\u0439\u00bb \u043a\u0430\u043a \u00ab\u0438\u00bb, \u0430 \u00ab\u044a\u00bb \u0438 \u00ab\u044c\u00bb (\u0438 \u0438\u0445 \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u044b\u0435 \u0432\u0435\u0440\u0441\u0438\u0438 \u00ab\u042a\u00bb \u0438 \u00ab\u042c\u00bb) \u0434\u043e\u043b\u0436\u043d\u044b \u0438\u0441\u0447\u0435\u0437\u043d\u0443\u0442\u044c \u0438\u0437 \u0442\u0435\u043a\u0441\u0442\u0430. \u0421\u0442\u0440\u043e\u0447\u043d\u044b\u0435 \u0431\u0443\u043a\u0432\u044b \u0437\u0430\u043c\u0435\u043d\u044f\u044e\u0442\u0441\u044f \u043d\u0430 \u0441\u0442\u0440\u043e\u0447\u043d\u044b\u0435, \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u044b\u0435 \u0437\u0430\u043c\u0435\u043d\u044f\u044e\u0442\u0441\u044f \u043d\u0430 \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u044b\u0435. \u0415\u0441\u043b\u0438 \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u0430\u044f \u0431\u0443\u043a\u0432\u0430 \u043f\u0440\u0435\u0432\u0440\u0430\u0449\u0430\u0435\u0442\u0441\u044f \u043f\u0440\u0438 \u0442\u0440\u0430\u043d\u0441\u043b\u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0438 \u0432 \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0431\u0443\u043a\u0432, \u0442\u043e \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u043e\u0439 \u0434\u043e\u043b\u0436\u043d\u0430 \u043e\u0441\u0442\u0430\u0442\u044c\u0441\u044f \u0442\u043e\u043b\u044c\u043a\u043e \u043f\u0435\u0440\u0432\u0430\u044f \u0438\u0437 \u043d\u0438\u0445 (\u043d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, \u00ab\u0426\u00bb \u2192 \u00abTc\u00bb). \u0412\u0441\u0435 \u043d\u0435\u043a\u0438\u0440\u0438\u043b\u043b\u0438\u0447\u0435\u0441\u043a\u0438\u0435 \u0441\u0438\u043c\u0432\u043e\u043b\u044b \u0434\u043e\u043b\u0436\u043d\u044b \u043e\u0441\u0442\u0430\u0442\u044c\u0441\u044f \u043d\u0430 \u043c\u0435\u0441\u0442\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u043e\u0434\u043d\u043e\u0439 \u043f\u0430\u043f\u043a\u0435 \u0441 \u0432\u0430\u0448\u0435\u0439 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u043e\u0439 \u043b\u0435\u0436\u0438\u0442 \u0444\u0430\u0439\u043b cyrillic.txt. \u0412 \u043d\u0451\u043c, \u0432 \u0447\u0438\u0441\u043b\u0435 \u043f\u0440\u043e\u0447\u0438\u0445, \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442\u0441\u044f \u043d\u0435\u043a\u043e\u0442\u043e\u0440\u043e\u0435 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043a\u0438\u0440\u0438\u043b\u043b\u0438\u0447\u0435\u0441\u043a\u0438\u0445 \u0441\u0438\u043c\u0432\u043e\u043b\u043e\u0432.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412 \u0444\u0430\u0439\u043b transliteration.txt \u0437\u0430\u043f\u0438\u0441\u0430\u0442\u044c \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442 \u0442\u0440\u0430\u043d\u0441\u043b\u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0438 \u0438\u0441\u0445\u043e\u0434\u043d\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u041f\u0440\u0438\u0432\u0435\u0442, \u043c\u0438\u0440!<br>|Privet, mir!<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u042f \u043f\u043e\u043c\u043d\u044e \u0447\u0443\u0434\u043d\u043e\u0435 \u043c\u0433\u043d\u043e\u0432\u0435\u043d\u044c\u0435: \u041f\u0435\u0440\u0435\u0434\u043e \u043c\u043d\u043e\u0439 \u044f\u0432\u0438\u043b\u0430\u0441\u044c \u0442\u044b, \u041a\u0430\u043a \u043c\u0438\u043c\u043e\u043b\u0435\u0442\u043d\u043e\u0435 \u0432\u0438\u0434\u0435\u043d\u044c\u0435, \u041a\u0430\u043a \u0433\u0435\u043d\u0438\u0439 \u0447\u0438\u0441\u0442\u043e\u0439 \u043a\u0440\u0430\u0441\u043e\u0442\u044b.<br>|Ia pomniu chudnoe mgnovene: Peredo mnoi iavilas ty, Kak mimoletnoe videne, Kak genii chistoi krasoty.<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["d = {", " '\u0410': 'A',", " '\u0430': 'a',", " '\u0411': 'B',", " '\u0431': 'b',", " '\u0412': 'V',", " '\u0432': 'v',", " '\u0413': 'G',", " '\u0433': 'g',", " '\u0414': 'D',", " '\u0434': 'd',", " '\u0415': 'E',", " '\u0435': 'e',", " '\u0401': 'E',", " '\u0451': 'e',", " '\u0416': 'Zh',", " '\u0436': 'zh',", " '\u0417': 'Z',", " '\u0437': 'z',", " '\u0418': 'I',", " '\u0438': 'i',", " '\u0419': 'I',", " '\u0439': 'i',", " '\u041a': 'K',", " '\u043a': 'k',", " '\u041b': 'L',", " '\u043b': 'l',", " '\u041c': 'M',", " '\u043c': 'm',", " '\u041d': 'N',", " '\u043d': 'n',", " '\u041e': 'O',", " '\u043e': 'o',", " '\u041f': 'P',", " '\u043f': 'p',", " '\u0420': 'R',", " '\u0440': 'r',", " '\u0421': 'S',", " '\u0441': 's',", " '\u0422': 'T',", " '\u0442': 't',", " '\u0423': 'U',", " '\u0443': 'u',", " '\u0424': 'F',", " '\u0444': 'f',", " '\u0425': 'Kh',", " '\u0445': 'kh',", " '\u0426': 'Tc',", " '\u0446': 'tc',", " '\u0427': 'Ch',", " '\u0447': 'ch',", " '\u0428': 'Sh',", " '\u0448': 'sh',", " '\u0429': 'Shch',", " '\u0449': 'shch',", " '\u042b': 'Y',", " '\u044b': 'y',", " '\u042d': 'E',", " '\u044d': 'e',", " '\u042e': 'Iu',", " '\u044e': 'iu',", " '\u042f': 'Ia',", " '\u044f': 'ia'", "}", "string = \"\"", "with open(\"cyrillic.txt\", \"r\", encoding=\"utf-8\") as input_file:", " with open(\"transliteration.txt\", \"w\", encoding=\"utf-8\") as output_file:", " for line in input_file:", " string = line", " new_string = \"\"", " for i in string: ", " if i in d.keys():", " new_string += d[i]", " elif i.lower() in [\"\u044c\", \"\u044a\"]:", " continue", " else:", " new_string += i", " output_file.write(new_string)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0430\u0439\u043b\u043e\u0432\u0430\u044f \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043a\u0430**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043b\u044f \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430 \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b:<br>", "* \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b;", "* \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043f\u043e\u043b\u043e\u0436\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b;", "* \u043c\u0438\u043d\u0438\u043c\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e;", "* \u043c\u0430\u043a\u0441\u0438\u043c\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e;", "* \u0441\u0443\u043c\u043c\u0430 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b;", "* \u0441\u0440\u0435\u0434\u043d\u0435\u0435 \u0430\u0440\u0438\u0444\u043c\u0435\u0442\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b \u0441 \u0442\u043e\u0447\u043d\u043e\u0441\u0442\u044c\u044e \u0434\u043e \u0434\u0432\u0443\u0445 \u0437\u043d\u0430\u043a\u043e\u0432 \u043f\u043e\u0441\u043b\u0435 \u0437\u0430\u043f\u044f\u0442\u043e\u0439.", "", "", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0438\u043c\u044f \u0444\u0430\u0439\u043b\u0430.<br>\u0424\u0430\u0439\u043b \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u043b\u044c\u043d\u043e\u0435 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0447\u0438\u0441\u0435\u043b, \u0440\u0430\u0437\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0445 \u043f\u0440\u043e\u0431\u0435\u043b\u0430\u043c\u0438 \u0438 \u0441\u0438\u043c\u0432\u043e\u043b\u0430\u043c\u0438 \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u0430 \u0441\u0442\u0440\u043e\u043a\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043a\u0443 \u0432 \u0443\u043a\u0430\u0437\u0430\u043d\u043d\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>numbers.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 numbers.txt<br>1 2 3 4 5<br>-5 -4 -3 -2 -1<br>10 20<br>20 10<br>|14<br>9<br>-5<br>20<br>60<br>4.29<br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["file_name = input()", "", "data = []", "with open(file_name, \"r\", encoding=\"utf-8\") as file:", " for line in file:", " data += [int(i) for i in line.rstrip(\"\\n\").split()]", "", "print(len(data))", "print(len([i for i in data if i > 0]))", "print(min(data))", "print(max(data))", "print(sum(data))", "print(round(sum(data) / len(data), 2))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0430\u0439\u043b\u043e\u0432\u0430\u044f \u0440\u0430\u0437\u043d\u0438\u0446\u0430**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u044f\u0435\u0442, \u043a\u0430\u043a\u0438\u0435 \u0441\u043b\u043e\u0432\u0430 \u0435\u0441\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0432 \u043e\u0434\u043d\u043e\u043c \u0438\u0437 \u0444\u0430\u0439\u043b\u043e\u0432.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0442\u0440\u0438 \u0438\u043c\u0435\u043d\u0438 \u0444\u0430\u0439\u043b\u043e\u0432.<br>\u041a\u0430\u0436\u0434\u044b\u0439 \u0438\u0437 \u0432\u0445\u043e\u0434\u043d\u044b\u0445 \u0444\u0430\u0439\u043b\u043e\u0432 \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u043b\u044c\u043d\u043e\u0435 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0441\u043b\u043e\u0432, \u0440\u0430\u0437\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0445 \u043f\u0440\u043e\u0431\u0435\u043b\u0430\u043c\u0438 \u0438 \u0441\u0438\u043c\u0432\u043e\u043b\u0430\u043c\u0438 \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u0430 \u0441\u0442\u0440\u043e\u043a\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412 \u0442\u0440\u0435\u0442\u0438\u0439 \u0444\u0430\u0439\u043b \u0432\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0432 \u0430\u043b\u0444\u0430\u0432\u0438\u0442\u043d\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435 \u0431\u0435\u0437 \u043f\u043e\u0432\u0442\u043e\u0440\u0435\u043d\u0438\u0439 \u0441\u043f\u0438\u0441\u043e\u043a \u0441\u043b\u043e\u0432, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0435\u0441\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0432 \u043e\u0434\u043d\u043e\u043c \u0438\u0437 \u0444\u0430\u0439\u043b\u043e\u0432.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>first.txt<br>second.txt<br>answer.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 first.txt<br>\u043a\u043e\u0444\u0435 \u043c\u043e\u043b\u043e\u043a\u043e<br>\u0447\u0430\u0439 \u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u0432\u0435\u043b\u043e\u0441\u0438\u043f\u0435\u0434<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 second.txt<br>\u043a\u043e\u0444\u0435 \u0432\u0435\u043b\u043e\u0441\u0438\u043f\u0435\u0434<br>\u043f\u0440\u044f\u043d\u0438\u043a \u0436\u0432\u0430\u0447\u043a\u0430 \u0432\u0435\u0441\u043b\u043e<br><br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 answer.txt<br>\u0432\u0435\u0441\u043b\u043e<br>\u0436\u0432\u0430\u0447\u043a\u0430<br>\u043c\u043e\u043b\u043e\u043a\u043e<br>\u043f\u0435\u0447\u0435\u043d\u044c\u0435<br>\u043f\u0440\u044f\u043d\u0438\u043a<br>\u0447\u0430\u0439<br> <br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["file1_name, file2_name = input(), input()", "fileres_name = input()", "set1, set2 = set(), set()", "", "with open(file1_name, \"r\", encoding=\"utf-8\") as file1:", " for line in file1:", " for word in line.rstrip(\"\\n\").split():", " set1.add(word)", "", "with open(file2_name, \"r\", encoding=\"utf-8\") as file2:", " for line in file2:", " for word in line.rstrip(\"\\n\").split():", " set2.add(word)", "", "res = sorted(list(set1 ^ set2))", "", "with open(fileres_name, \"w+\", encoding=\"utf-8\") as fileres:", " for elem in res:", " fileres.write(f\"{elem}\\n\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0430\u0439\u043b\u043e\u0432\u0430\u044f \u0447\u0438\u0441\u0442\u043a\u0430**", "Python \u0432 \u043f\u0435\u0440\u0432\u0443\u044e \u043e\u0447\u0435\u0440\u0435\u0434\u044c \u0441\u043a\u0440\u0438\u043f\u0442\u043e\u0432\u044b\u0439 \u044f\u0437\u044b\u043a. \u0422\u0430\u043a\u0438\u0435 \u044f\u0437\u044b\u043a\u0438 \u0447\u0430\u0441\u0442\u043e \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u044e\u0442\u0441\u044f \u0434\u043b\u044f \u0441\u043e\u0437\u0434\u0430\u043d\u0438\u044f \u043a\u043e\u043d\u0441\u043e\u043b\u044c\u043d\u044b\u0445 \u0443\u0442\u0438\u043b\u0438\u0442.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0441\u0442\u0443\u044e \u0443\u0442\u0438\u043b\u0438\u0442\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043e\u0447\u0438\u0449\u0430\u0435\u0442 \u0437\u0430\u0434\u0430\u043d\u043d\u044b\u0439 \u0444\u0430\u0439\u043b \u043e\u0442:<br>", "* \u043f\u043e\u0432\u0442\u043e\u0440\u044f\u044e\u0449\u0438\u0445\u0441\u044f \u043f\u0440\u043e\u0431\u0435\u043b\u043e\u0432;", "* \u043f\u043e\u0432\u0442\u043e\u0440\u044f\u044e\u0449\u0438\u0445\u0441\u044f \u0441\u0438\u043c\u0432\u043e\u043b\u043e\u0432 \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u0430 \u0441\u0442\u0440\u043e\u043a\u0438;", "* \u0442\u0430\u0431\u0443\u043b\u044f\u0446\u0438\u0439,", "* \u0438\u0437\u043b\u0438\u0448\u043d\u0438\u0445 \u043f\u0440\u043e\u0431\u0435\u043b\u043e\u0432 \u0432 \u043d\u0430\u0447\u0430\u043b\u0435 \u0438 \u043a\u043e\u043d\u0446\u0435 \u0441\u0442\u0440\u043e\u043a.", "", "", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0434\u0432\u0430 \u0438\u043c\u0435\u043d\u0438 \u0444\u0430\u0439\u043b\u043e\u0432.<br>\u0412\u0445\u043e\u0434\u043d\u043e\u0439 \u0444\u0430\u0439\u043b \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043d\u0435\u0444\u043e\u0440\u043c\u0430\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0442\u0435\u043a\u0441\u0442 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u043b\u044c\u043d\u043e\u0439 \u0434\u043b\u0438\u043d\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u043e \u0432\u0442\u043e\u0440\u043e\u0439 \u0444\u0430\u0439\u043b \u0432\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u043e\u0447\u0438\u0449\u0435\u043d\u043d\u044b\u0439 \u0442\u0435\u043a\u0441\u0442.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>first.txt<br>second.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 first.txt<br> \u043e\u0447\u0435\u043d\u044c \t\t \u043f\u043b\u043e\u0445\u043e \u0444\u043e\u0440\u043c\u0430\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0442\u0435\u043a\u0441\u0442<br><br><br>\u043d\u0443\t\t\u043d\u0443\t<br>\u043f\u0440\u044f\u043c\u043e<br><br>\u043e\u0447\u0435\u043d\u044c-\u043e\u0447\u0435\u043d\u044c<br><br>\t<br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 second.txt<br>\u043e\u0447\u0435\u043d\u044c \u043f\u043b\u043e\u0445\u043e \u0444\u043e\u0440\u043c\u0430\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0442\u0435\u043a\u0441\u0442<br>\u043d\u0443\u043d\u0443<br>\u043f\u0440\u044f\u043c\u043e<br>\u043e\u0447\u0435\u043d\u044c-\u043e\u0447\u0435\u043d\u044c<br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["first_file_name, second_file_name = input(), input()", "", "with open(first_file_name, \"r\", encoding=\"utf-8\") as first_file:", " with open(second_file_name, \"w\", encoding=\"utf-8\") as second_file:", " for line in first_file:", " string = line.rstrip(\"\\n\")", " if not string:", " continue", " if \"\\t\" in string:", " while \"\\t\" in string:", " ind = string.index(\"\\t\")", " string = string[:ind] + string[ind + 1:]", " words = string.split()", " string = \" \".join(words)", " second_file.write(string + \"\\n\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0425\u0432\u043e\u0441\u0442**", "\u0412 \u0441\u0435\u043c\u0435\u0439\u0441\u0442\u0432\u0435 \u043e\u043f\u0435\u0440\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0445 \u0441\u0438\u0441\u0442\u0435\u043c Linux \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442 \u043e\u0434\u043d\u0430 \u043f\u0440\u0435\u043a\u0440\u0430\u0441\u043d\u0430\u044f \u043a\u043e\u043d\u0441\u043e\u043b\u044c\u043d\u0430\u044f \u0443\u0442\u0438\u043b\u0438\u0442\u0430 \u2014 tail. \u041e\u043d\u0430 \u043f\u0440\u0435\u0434\u043d\u0430\u0437\u043d\u0430\u0447\u0435\u043d\u0430 \u0434\u043b\u044f \u0441\u043b\u0443\u0447\u0430\u0435\u0432, \u043a\u043e\u0433\u0434\u0430 \u043d\u0430\u043c \u043d\u0435 \u043d\u0443\u0436\u043d\u043e \u0447\u0438\u0442\u0430\u0442\u044c \u0432\u0435\u0441\u044c \u0444\u0430\u0439\u043b, \u0430 \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043f\u0440\u043e\u0441\u043c\u043e\u0442\u0440\u0435\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u043f\u043e\u0441\u043b\u0435\u0434\u043d\u0438\u0445 \u0441\u0442\u0440\u043e\u043a.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0430\u043d\u0430\u043b\u043e\u0433 \u044d\u0442\u043e\u0439 \u0443\u0442\u0438\u043b\u0438\u0442\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0438\u043c\u044f \u0444\u0430\u0439\u043b\u0430 ( <br>F<br> F), \u0430 \u0437\u0430\u0442\u0435\u043c \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0441\u0442\u0440\u043e\u043a ( <br>N<br> N), \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u043e\u043d \u0445\u043e\u0447\u0435\u0442 \u0443\u0432\u0438\u0434\u0435\u0442\u044c.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 <br>N<br> N \u043f\u043e\u0441\u043b\u0435\u0434\u043d\u0438\u0445 \u0441\u0442\u0440\u043e\u043a \u0444\u0430\u0439\u043b\u0430 <br>F<br> F.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>some_file.txt<br>2<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 some_file.txt<br>1 \u0441\u0442\u0440\u043e\u043a\u0430<br>2 \u0441\u0442\u0440\u043e\u043a\u0430<br>3 \u0441\u0442\u0440\u043e\u043a\u0430<br>4 \u0441\u0442\u0440\u043e\u043a\u0430<br>5 \u0441\u0442\u0440\u043e\u043a\u0430<br>|4 \u0441\u0442\u0440\u043e\u043a\u0430<br>5 \u0441\u0442\u0440\u043e\u043a\u0430<br> <br> <br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["file_name, n = input(), int(input())", "c = 0", "with open(file_name, \"r\", encoding=\"utf-8\") as file:", " for line in file:", " c += 1", "", "with open(file_name, \"r\", encoding=\"utf-8\") as file:", " line_number = 0", " for line in file:", " line_number += 1", " if line_number > c - n:", " print(line, end=\"\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0430\u0439\u043b\u043e\u0432\u0430\u044f \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043a\u0430 2.0**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0434\u043b\u044f \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430 \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b:<br>", "* \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b;", "* \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043f\u043e\u043b\u043e\u0436\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b;", "* \u043c\u0438\u043d\u0438\u043c\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e;", "* \u043c\u0430\u043a\u0441\u0438\u043c\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e;", "* \u0441\u0443\u043c\u043c\u0430 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b;", "* \u0441\u0440\u0435\u0434\u043d\u0435\u0435 \u0430\u0440\u0438\u0444\u043c\u0435\u0442\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b \u0441 \u0442\u043e\u0447\u043d\u043e\u0441\u0442\u044c\u044e \u0434\u043e \u0434\u0432\u0443\u0445 \u0437\u043d\u0430\u043a\u043e\u0432 \u043f\u043e\u0441\u043b\u0435 \u0437\u0430\u043f\u044f\u0442\u043e\u0439.", "", "", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0434\u0432\u0430 \u0438\u043c\u0435\u043d\u0438 \u0444\u0430\u0439\u043b\u0430.<br>\u041f\u0435\u0440\u0432\u044b\u0439 \u0444\u0430\u0439\u043b \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u043b\u044c\u043d\u043e\u0435 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0447\u0438\u0441\u0435\u043b, \u0440\u0430\u0437\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0445 \u043f\u0440\u043e\u0431\u0435\u043b\u0430\u043c\u0438 \u0438 \u0441\u0438\u043c\u0432\u043e\u043b\u0430\u043c\u0438 \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u0430 \u0441\u0442\u0440\u043e\u043a\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043a\u0443 \u0432\u043e \u0432\u0442\u043e\u0440\u043e\u0439 \u0444\u0430\u0439\u043b \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435 JSON.<br><br>\u041a\u043b\u044e\u0447\u0438 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0439 \u0437\u0430\u0434\u0430\u0439\u0442\u0435 \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0435\u043d\u043d\u043e:<br>", "* count \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b;", "* positive_count \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043f\u043e\u043b\u043e\u0436\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b;", "* min \u2014 \u043c\u0438\u043d\u0438\u043c\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e;", "* max \u2014 \u043c\u0430\u043a\u0441\u0438\u043c\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e;", "* sum \u2014 \u0441\u0443\u043c\u043c\u0430 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b;", "* average \u2014 \u0441\u0440\u0435\u0434\u043d\u0435\u0435 \u0430\u0440\u0438\u0444\u043c\u0435\u0442\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b \u0441 \u0442\u043e\u0447\u043d\u043e\u0441\u0442\u044c\u044e \u0434\u043e \u0434\u0432\u0443\u0445 \u0437\u043d\u0430\u043a\u043e\u0432 \u043f\u043e\u0441\u043b\u0435 \u0437\u0430\u043f\u044f\u0442\u043e\u0439.", "", "", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>numbers.txt<br>statistics.json<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 numbers.txt<br>1 2 3 4 5<br>-5 -4 -3 -2 -1<br>10 20<br>20 10<br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 statistics.json<br>{<br> \"count\": 14,<br> \"positive_count\": 9,<br> \"min\": -5,<br> \"max\": 20,<br> \"sum\": 60,<br> \"average\": 4.29<br>}<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json", "", "in_file, js_file = input(), input()", "res = {\"count\": 0, \"positive_count\": 0, \"min\": float(\"inf\"),", " \"max\": float(\"-inf\"), \"sum\": 0, \"average\": 0}", "", "with open(in_file, \"r\", encoding=\"utf-8\")as inp:", " for line in inp:", " for num in [int(i) for i in line.split()]:", " res[\"count\"] += 1", " if num > 0:", " res[\"positive_count\"] += 1", " res[\"min\"] = min(res[\"min\"], num)", " res[\"max\"] = max(res[\"max\"], num)", " res[\"sum\"] += num", "", "res[\"average\"] = round((res[\"sum\"] / res[\"count\"]), 2)", "", "with open(js_file, \"w\", encoding=\"UTF-8\") as js:", " json.dump(res, js, ensure_ascii=False, indent=2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0420\u0430\u0437\u0434\u0435\u043b\u044f\u0439 \u0438 \u0432\u043b\u0430\u0441\u0442\u0432\u0443\u0439**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0443\u0442\u0438\u043b\u0438\u0442\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0440\u0430\u0437\u0434\u0435\u043b\u044f\u0435\u0442 \u0447\u0438\u0441\u043b\u0430, \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043d\u044b\u0435 \u0432 \u0444\u0430\u0439\u043b\u0435, \u043d\u0430 \u0442\u0440\u0438 \u0433\u0440\u0443\u043f\u043f\u044b:<br>", "* \u0447\u0438\u0441\u043b\u0430 \u0441 \u043f\u0440\u0435\u043e\u0431\u043b\u0430\u0434\u0430\u044e\u0449\u0438\u043c \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e\u043c \u0447\u0451\u0442\u043d\u044b\u0445 \u0446\u0438\u0444\u0440;", "* \u0447\u0438\u0441\u043b\u0430 \u0441 \u043f\u0440\u0435\u043e\u0431\u043b\u0430\u0434\u0430\u044e\u0449\u0438\u043c \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e\u043c \u043d\u0435\u0447\u0451\u0442\u043d\u044b\u0445 \u0446\u0438\u0444\u0440;", "* \u0447\u0438\u0441\u043b\u0430 \u0441 \u043e\u0434\u0438\u043d\u0430\u043a\u043e\u0432\u044b\u043c \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e\u043c \u0447\u0451\u0442\u043d\u044b\u0445 \u0438 \u043d\u0435\u0447\u0451\u0442\u043d\u044b\u0445 \u0446\u0438\u0444\u0440.", "", "", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0447\u0435\u0442\u044b\u0440\u0435 \u0438\u043c\u0435\u043d\u0438 \u0444\u0430\u0439\u043b\u0430.<br>\u041f\u0435\u0440\u0432\u044b\u0439 \u0444\u0430\u0439\u043b \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u043b\u044c\u043d\u043e\u0435 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0447\u0438\u0441\u0435\u043b, \u0440\u0430\u0437\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0445 \u043f\u0440\u043e\u0431\u0435\u043b\u0430\u043c\u0438 \u0438 \u0441\u0438\u043c\u0432\u043e\u043b\u0430\u043c\u0438 \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u0430 \u0441\u0442\u0440\u043e\u043a\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412 \u0442\u0440\u0438 \u0434\u0440\u0443\u0433\u0438\u0435 \u0444\u0430\u0439\u043b\u0430 \u0432\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0447\u0438\u0441\u043b\u0430, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u043f\u043e\u0434\u0445\u043e\u0434\u044f\u0442 \u043f\u043e\u0434 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u043e\u0435 \u0443\u0441\u043b\u043e\u0432\u0438\u0435.<br>\u0421\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u0435 \u043f\u043e\u043b\u043e\u0436\u0435\u043d\u0438\u0435 \u0447\u0438\u0441\u0435\u043b \u0432 \u0441\u0442\u0440\u043e\u043a\u0430\u0445.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>numbers.txt<br>even.txt<br>odd.txt<br>eq.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 numbers.txt<br>650975472 591084323 629700 1504180 577023<br>8460612246 42161437 29409368 58531725 5725268 2198001838<br>796451 69358 7195510 975628465 9756641<br>44200289 126541 979391 93479581 291170 28987042 86139603<br> <br> <br> <br> <br> <br> <br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 even.txt<br>629700 1504180<br>8460612246 29409368 5725268 2198001838<br>975628465<br>44200289 28987042<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 odd.txt<br>650975472 591084323 577023<br>58531725<br>796451 69358 7195510 9756641<br>979391 93479581 291170<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 eq.txt<br><br>42161437<br><br>126541 86139603<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def count_even_cif(num):", " c = 0", " for i in num:", " if int(i) % 2 == 0:", " c += 1", "", " return c", "", "", "finputname, fevenname, foddname, feqname = [input() for _ in range(4)]", "", "even, odd, eq = [], [], []", "evenfile = open(fevenname, \"w\", encoding=\"utf-8\")", "oddfile = open(foddname, \"w\", encoding=\"utf-8\")", "eqfile = open(feqname, \"w\", encoding=\"utf-8\")", "with open(finputname, \"r\", encoding=\"utf-8\")as inputfile:", " for line in inputfile:", " for num in line.rstrip(\"\\n\").split():", " ev = count_even_cif(num)", " if len(num) - ev > ev:", " odd.append(num)", " elif len(num) == 2 * ev:", " eq.append(num)", " else:", " even.append(num) ", "", " evenfile.write(\" \".join(even) + \"\\n\")", " oddfile.write(\" \".join(odd) + \"\\n\")", " eqfile.write(\" \".join(eq) + \"\\n\")", " even, odd, eq = [], [], []", " ", "evenfile.close()", "oddfile.close()", "eqfile.close()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041e\u0431\u043d\u043e\u0432\u043b\u0435\u043d\u0438\u0435 \u0434\u0430\u043d\u043d\u044b\u0445**", "\u0427\u0430\u0441\u0442\u043e \u043f\u0440\u0438\u0445\u043e\u0434\u0438\u0442\u0441\u044f \u043e\u0431\u043d\u043e\u0432\u043b\u044f\u0442\u044c \u0434\u0430\u043d\u043d\u044b\u0435.<br><br>\u0421\u043e\u0437\u0434\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043e\u0431\u043d\u043e\u0432\u043b\u044f\u0435\u0442 JSON \u0444\u0430\u0439\u043b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0438\u043c\u044f \u0444\u0430\u0439\u043b\u0430.<br>\u0417\u0430\u0442\u0435\u043c \u0432\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0441\u0442\u0440\u043e\u043a\u0438 \u0432\u0438\u0434\u0430 \u043a\u043b\u044e\u0447 == \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412 \u0437\u0430\u0434\u0430\u043d\u043d\u044b\u0439 \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435\u043c \u0444\u0430\u0439\u043b \u0441\u043b\u0435\u0434\u0443\u0435\u0442 \u0437\u0430\u043f\u0438\u0441\u0430\u0442\u044c \u043e\u0431\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u044b\u0439 JSON.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>data.json<br>one == \u043e\u0434\u0438\u043d<br>two == \u0434\u0432\u0430<br>three == \u0442\u0440\u0438<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 data.json<br>{<br> \"one\": 1,<br> \"three\": 2<br>}<br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 data.json<br>{<br> \"one\": \"\u043e\u0434\u0438\u043d\",<br> \"three\": \"\u0442\u0440\u0438\",<br> \"two\": \"\u0434\u0432\u0430\"<br>}<br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "import json", "", "file_name = input()", "d = {}", "", "for line in stdin:", " key, val = line.rstrip().split(\" == \")", " d[key] = val", "", "with open(file_name, \"r\", encoding=\"UTF-8\") as js:", " data = json.load(js)", " for key, val in d.items():", " data[key] = val", "", "with open(file_name, \"w\", encoding=\"UTF-8\") as js:", " json.dump(data, js, ensure_ascii=False, indent=2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043b\u0438\u044f\u043d\u0438\u0435 \u0434\u0430\u043d\u043d\u044b\u0445**", "\u041e\u0434\u043d\u0430 \u043c\u0435\u0441\u0442\u043d\u0430\u044f \u043a\u043e\u043c\u043f\u0430\u043d\u0438\u044f \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u0438\u0442 \u043e\u0431\u043d\u043e\u0432\u043b\u0435\u043d\u0438\u0435 \u0434\u0430\u043d\u043d\u044b\u0445 \u043e \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044f\u0445 \u0438 \u0437\u0430\u043e\u0434\u043d\u043e \u0440\u0435\u0448\u0438\u043b\u0438 \u0440\u0435\u043e\u0440\u0433\u0430\u043d\u0438\u0437\u043e\u0432\u0430\u0442\u044c \u0441\u0438\u0441\u0442\u0435\u043c\u0443 \u0445\u0440\u0430\u043d\u0435\u043d\u0438\u044f.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043e\u0431\u043d\u043e\u0432\u043b\u044f\u0435\u0442 \u0434\u0430\u043d\u043d\u044b\u0435 \u043e \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044f\u0445, \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043d\u044b\u0445 \u0432 JSON \u0444\u0430\u0439\u043b\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c \u0432\u0432\u043e\u0434\u0438\u0442 \u0434\u0432\u0430 \u0438\u043c\u0435\u043d\u0438 \u0444\u0430\u0439\u043b\u0430.<br>\u0412 \u043f\u0435\u0440\u0432\u043e\u043c \u0445\u0440\u0430\u043d\u0438\u0442\u0441\u044f JSON \u043c\u0430\u0441\u0441\u0438\u0432 \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435\u0439.<br>\u0412\u043e \u0432\u0442\u043e\u0440\u043e\u043c \u2014 \u043c\u0430\u0441\u0441\u0438\u0432 \u043d\u043e\u0432\u044b\u0445 \u0434\u0430\u043d\u043d\u044b\u0445.<br><br>\u0418\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043e \u043a\u0430\u0436\u0434\u043e\u043c \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435 \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442\u0441\u044f JSON \u043e\u0431\u044a\u0435\u043a\u0442\u043e\u043c, \u0432 \u043a\u043e\u0442\u043e\u0440\u043e\u043c \u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u043e \u043f\u0440\u0438\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043f\u043e\u043b\u0435 name, \u043e\u043f\u0438\u0441\u044b\u0432\u0430\u044e\u0449\u0435\u0435 \u0438\u043c\u044f \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044f. \u041e\u0441\u0442\u0430\u043b\u044c\u043d\u044b\u0435 \u043f\u043e\u043b\u044f \u044f\u0432\u043b\u044f\u044e\u0442\u0441\u044f \u0434\u043e\u043f\u043e\u043b\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u043c\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412 \u043f\u0435\u0440\u0432\u044b\u0439 \u0444\u0430\u0439\u043b \u0437\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044e \u043e \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044f\u0445 \u0432 \u0432\u0438\u0434\u0435 JSON \u043e\u0431\u044a\u0435\u043a\u0442\u0430, \u043a\u043b\u044e\u0447\u0430\u043c\u0438 \u043a\u043e\u0442\u043e\u0440\u043e\u0433\u043e \u0432\u044b\u0441\u0442\u0443\u043f\u0430\u044e\u0442 \u0438\u043c\u0435\u043d\u0430 \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435\u0439, \u0430 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f\u043c\u0438 \u2014 \u043e\u0431\u044a\u0435\u043a\u0442\u044b \u0441 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0435\u0439 \u043e \u043d\u0438\u0445.<br><br>\u0415\u0441\u043b\u0438 \u043a\u0430\u043a\u0430\u044f-\u043b\u0438\u0431\u043e \u0434\u043e\u043f\u043e\u043b\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u0430\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043e \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u0435 \u0438\u0437\u043c\u0435\u043d\u044f\u0435\u0442\u0441\u044f, \u0442\u043e \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u0441\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c \u043b\u0435\u043a\u0441\u0438\u043a\u043e\u0433\u0440\u0430\u0444\u0438\u0447\u0435\u0441\u043a\u0438 \u0431\u043e\u043b\u044c\u0448\u0435\u0435 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>users.json<br>updates.json<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 users.json<br>[<br> {<br> \"name\": \"Ann\",<br> \"address\": \"Flower st.\"<br> },<br> {<br> \"name\": \"Bob\",<br> \"address\": \"Summer st.\",<br> \"phone\": \"+7 (123) 456-78-90\"<br> }<br>]<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 updates.json<br>[<br> {<br> \"name\": \"Ann\",<br> \"address\": \"Awesome st.\",<br> \"phone\": \"+7 (098) 765-43-21\"<br> },<br> {<br> \"name\": \"Bob\",<br> \"address\": \"Winter st.\"<br> }<br>]<br><br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 users.json<br>{<br> \"Ann\": {<br> \"address\": \"Flower st.\",<br> \"phone\": \"+7 (098) 765-43-21\"<br> },<br> \"Bob\": {<br> \"address\": \"Winter st.\",<br> \"phone\": \"+7 (123) 456-78-90\"<br> }<br>}<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json", "", "", "jsusersname, jsupdatesname = input(), input()", "", "", "data = []", "with open(jsusersname, \"r\", encoding=\"UTF-8\") as js:", " data = json.load(js)", "", "newdata = {}", "for d in data:", " newdata[d[\"name\"]] = {}", " for key, val in d.items():", " if key == \"name\":", " continue", " newdata[d[\"name\"]][key] = val", "", "with open(jsupdatesname, \"r\", encoding=\"UTF-8\") as js:", " data = json.load(js)", "", "for d in data:", " name = d[\"name\"]", " for key, newval in d.items():", " if key == \"name\":", " continue", " if key in newdata[name]:", " val = newdata[name][key]", " newdata[name][key] = sorted([val, newval], reverse=True)[0]", " else:", " newdata[name][key] = newval", "", "with open(jsusersname, \"w\", encoding=\"UTF-8\") as js:", " json.dump(newdata, js, ensure_ascii=False, indent=2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041f\u043e\u0441\u0442\u0430\u0432\u044c \u0441\u0435\u0431\u044f \u043d\u0430 \u043c\u043e\u0451 \u043c\u0435\u0441\u0442\u043e**", "\u0412\u044b \u0443\u0436\u0435 \u0434\u043e\u043b\u0433\u043e\u0435 \u0432\u0440\u0435\u043c\u044f \u0440\u0435\u0448\u0430\u0435\u0442\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0432 \u042f\u043d\u0434\u0435\u043a\u0441.\u041a\u043e\u043d\u0442\u0435\u0441\u0442\u0435.<br>\u0421\u0435\u0433\u043e\u0434\u043d\u044f \u043f\u0440\u0438\u0448\u043b\u043e \u0432\u0440\u0435\u043c\u044f \u043f\u043e\u0447\u0443\u0432\u0441\u0442\u0432\u043e\u0432\u0430\u0442\u044c \u0441\u0435\u0431\u044f \u043d\u0430 \u0435\u0433\u043e \u043c\u0435\u0441\u0442\u0435.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043d\u0435\u0431\u043e\u043b\u044c\u0448\u043e\u0439 \u043a\u0443\u0441\u043e\u0447\u0435\u043a \u0442\u0435\u0441\u0442\u0438\u0440\u0443\u044e\u0449\u0435\u0439 \u0441\u0438\u0441\u0442\u0435\u043c\u044b.<br><br>\u0412\u0430\u0448\u0435\u043c\u0443 \u0440\u0435\u0448\u0435\u043d\u0438\u044e \u0434\u043e\u0441\u0442\u0443\u043f\u0435\u043d \u0444\u0430\u0439\u043b scoring.json, \u0432 \u043a\u043e\u0442\u043e\u0440\u043e\u043c \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442\u0441\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043e \u0441\u0438\u0441\u0442\u0435\u043c\u0435 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0438.<br><br>\u041e\u0441\u043d\u043e\u0432\u043e\u0439 \u0441\u0438\u0441\u0442\u0435\u043c\u044b \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0441\u043f\u0438\u0441\u043e\u043a \u0433\u0440\u0443\u043f\u043f \u0442\u0435\u0441\u0442\u043e\u0432.<br>\u041a\u0430\u0436\u0434\u0430\u044f \u0433\u0440\u0443\u043f\u043f\u0430 \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442 \u0441\u043e\u0431\u043e\u0439 \u043e\u0431\u044a\u0435\u043a\u0442 \u0441 \u043f\u043e\u043b\u044f\u043c\u0438:<br>", "* points \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043e\u0447\u043a\u043e\u0432, \u043a\u043e\u0442\u043e\u0440\u043e\u0435 \u043c\u043e\u0436\u043d\u043e \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u0437\u0430 \u043f\u0440\u043e\u0445\u043e\u0436\u0434\u0435\u043d\u0438\u0435 \u0434\u0430\u043d\u043d\u043e\u0439 \u0433\u0440\u0443\u043f\u043f\u044b;", "* tests \u2014 \u0441\u043f\u0438\u0441\u043e\u043a \u043e\u0431\u044a\u0435\u043a\u0442\u043e\u0432 \u0441 \u043e\u043f\u0438\u0441\u0430\u043d\u0438\u0435\u043c \u043a\u043e\u043d\u043a\u0440\u0435\u0442\u043d\u043e\u0433\u043e \u0442\u0435\u0441\u0442\u0430.", "", "\u041e\u0431\u044a\u0435\u043a\u0442 \u043e\u043f\u0438\u0441\u044b\u0432\u0430\u044e\u0449\u0438\u0439 \u0442\u0435\u0441\u0442 \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043f\u043e\u043b\u044f:<br>", "* input \u2014 \u0441\u0442\u0440\u043e\u043a\u0430 \u0432\u0445\u043e\u0434\u043d\u044b\u0445 \u0434\u0430\u043d\u043d\u044b\u0445 \u0442\u0435\u0441\u0442\u0430;", "* pattern \u2014 \u0441\u0442\u0440\u043e\u043a\u0430 \u043e\u0436\u0438\u0434\u0430\u0435\u043c\u044b\u0445 \u0432 \u043a\u0430\u0447\u0435\u0441\u0442\u0432\u0435 \u043e\u0442\u0432\u0435\u0442\u0430.", "", "\u0412 \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u044b\u0439 \u043f\u043e\u0442\u043e\u043a \u0432\u0432\u043e\u0434\u0430 \u0432\u0430\u0448\u0435\u0433\u043e \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u043f\u0435\u0440\u0435\u0434\u0430\u044e\u0442\u0441\u044f \u043e\u0442\u0432\u0435\u0442\u044b, \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u0435 \u043e\u0442 \u0442\u0435\u0441\u0442\u0438\u0440\u0443\u0435\u043c\u043e\u0439 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u044b\u0439 \u043f\u043e\u0442\u043e\u043a \u0432\u0432\u043e\u0434\u0430 \u043f\u0435\u0440\u0435\u0434\u0430\u044e\u0442\u0441\u044f \u0441\u0442\u0440\u043e\u043a\u0438 \u2014 \u043e\u0442\u0432\u0435\u0442\u044b \u0442\u0435\u0441\u0442\u0438\u0440\u0443\u0435\u043c\u043e\u0439 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b \u043d\u0430 \u043a\u0430\u0436\u0434\u044b\u0439 \u0442\u0435\u0441\u0442. \u0412 \u0444\u0430\u0439\u043b\u0435 scoring.json \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442\u0441\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043e \u0442\u0435\u0441\u0442\u0430\u0445 \u0437\u0430\u0434\u0430\u0447\u0438.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0434\u043d\u043e \u0447\u0438\u0441\u043b\u043e \u2014 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u0445 \u0442\u0435\u0441\u0442\u0438\u0440\u0443\u0435\u043c\u043e\u0439 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u043e\u0439 \u0431\u0430\u043b\u043b\u043e\u0432.<br>\u0415\u0441\u043b\u0438 \u0433\u0440\u0443\u043f\u043f\u0430 \u0442\u0435\u0441\u0442\u043e\u0432 \u043d\u0435 \u0431\u044b\u043b\u0430 \u043f\u0440\u043e\u0439\u0434\u0435\u043d\u0430 \u043f\u043e\u043b\u043d\u043e\u0441\u0442\u044c\u044e, \u0442\u043e \u0437\u0430 \u0434\u0430\u043d\u043d\u0443\u044e \u0433\u0440\u0443\u043f\u043f\u0443 \u0441\u0442\u0430\u0432\u0438\u0442\u0441\u044f \u043f\u0440\u043e\u043f\u043e\u0440\u0446\u0438\u043e\u043d\u0430\u043b\u044c\u043d\u044b\u0439 \u0431\u0430\u043b\u043b.<br>\u0413\u0430\u0440\u0430\u043d\u0442\u0438\u0440\u0443\u0435\u0442\u0441\u044f, \u0447\u0442\u043e \u0431\u0430\u043b\u043b\u044b \u0437\u0430 \u0433\u0440\u0443\u043f\u043f\u0443 \u043a\u0440\u0430\u0442\u043d\u044b \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u0443 \u0442\u0435\u0441\u0442\u043e\u0432 \u0432 \u043d\u0435\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>4<br>12<br>3<br>100<br>0<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 scoring.json<br>[<br> {<br> \"points\": 10,<br> \"tests\": [<br> {<br> \"input\": \"2 2\",<br> \"pattern\": \"4\"<br> },<br> {<br> \"input\": \"4 3\",<br> \"pattern\": \"7\"<br> }<br> ]<br> },<br> {<br> \"points\": 30,<br> \"tests\": [<br> {<br> \"input\": \"2 1\",<br> \"pattern\": \"3\"<br> },<br> {<br> \"input\": \"25 4\",<br> \"pattern\": \"29\"<br> },<br> {<br> \"input\": \"3 -3\",<br> \"pattern\": \"0\"<br> }<br> ]<br> }<br>]<br>|25<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json", "from sys import stdin", "", "", "name = \"scoring.json\"", "", "data = []", "with open(name, \"r\", encoding=\"utf-8\") as js:", " data = json.load(js)", "", "testcnt = 0", "for elem in data:", " testcnt += len(elem[\"tests\"])", "", "c = 0", "packc = 0", "pointsum = 0", "", "d = data[packc]", "points = d[\"points\"]", "tests = d[\"tests\"]", "for line in stdin:", " answer = line.rstrip(\"\\n\")", " if c < len(tests):", " if tests[c][\"pattern\"] == answer:", " pointsum += int(points / len(tests))", " c += 1", " else:", " packc += 1", " d = data[packc]", " points = d[\"points\"]", " tests = d[\"tests\"]", " c = 0", " if c < len(tests):", " if tests[c][\"pattern\"] == answer:", " pointsum += int(points / len(tests))", " c += 1", "", "print(pointsum)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041d\u0430\u0439\u0434\u0451\u0442\u0441\u044f \u0432\u0441\u0451 3.0**", "\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u0432\u043d\u043e\u0432\u044c \u043d\u0430\u043f\u0438\u0448\u0435\u043c \u043d\u0435\u0431\u043e\u043b\u044c\u0448\u043e\u0439 \u043a\u043e\u043c\u043f\u043e\u043d\u0435\u043d\u0442 \u043f\u043e\u0438\u0441\u043a\u043e\u0432\u043e\u0439 \u0441\u0438\u0441\u0442\u0435\u043c\u044b.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0421\u043d\u0430\u0447\u0430\u043b\u0430 \u0432\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043f\u043e\u0438\u0441\u043a\u043e\u0432\u044b\u0439 \u0437\u0430\u043f\u0440\u043e\u0441.<br>\u0417\u0430\u0442\u0435\u043c \u0432\u0432\u043e\u0434\u044f\u0442\u0441\u044f \u0438\u043c\u0435\u043d\u0430 \u0444\u0430\u0439\u043b\u043e\u0432, \u0441\u0440\u0435\u0434\u0438 \u043a\u043e\u0442\u043e\u0440\u044b\u0445 \u0441\u043b\u0435\u0434\u0443\u0435\u0442 \u043f\u0440\u043e\u0438\u0437\u0432\u0435\u0441\u0442\u0438 \u043f\u043e\u0438\u0441\u043a.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0432\u0441\u0435 \u0438\u043c\u0435\u043d\u0430 \u0444\u0430\u0439\u043b\u043e\u0432, \u0432 \u043a\u043e\u0442\u043e\u0440\u044b\u0445 \u0435\u0441\u0442\u044c \u043f\u043e\u0438\u0441\u043a\u043e\u0432\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430 \u0431\u0435\u0437 \u0443\u0447\u0435\u0442\u0430 \u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430 \u0438 \u043f\u043e\u0432\u0442\u043e\u0440\u044f\u044e\u0449\u0438\u0445\u0441\u044f \u043f\u0440\u043e\u0431\u0435\u043b\u044c\u043d\u044b\u0445 \u0441\u0438\u043c\u0432\u043e\u043b\u043e\u0432.<br>\u0415\u0441\u043b\u0438 \u043d\u0438 \u0432 \u043e\u0434\u043d\u043e\u043c \u0444\u0430\u0439\u043b\u0435 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043d\u0435 \u0431\u044b\u043b\u0430 \u043d\u0430\u0439\u0434\u0435\u043d\u0430, \u0432\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \"404. Not Found\".", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0421\u0438\u0441\u0442\u0435\u043c\u0430 \u043f\u043e\u0438\u0441\u043a\u0430 \u0434\u043e\u043b\u0436\u043d\u0430 \u043e\u0431\u0440\u0430\u0431\u0430\u0442\u044b\u0432\u0430\u0442\u044c \u0441\u0442\u0440\u043e\u043a\u0438 \"a b\", \"a b\" \u0438 \"a\\nb\" \u043a\u0430\u043a \u043e\u0434\u0438\u043d\u0430\u043a\u043e\u0432\u044b\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>\u041c\u0430\u043c\u0430 \u043c\u044b\u043b\u0430 \u0420\u0410\u041c\u0423<br>first.txt<br>second.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 first.txt<br>\u0412 \u044d\u0442\u043e\u043c \u0444\u0430\u0439\u043b\u0435 \u0433\u043e\u0432\u043e\u0440\u0438\u0442\u0441\u044f \u043e \u0442\u043e\u043c \u0447\u0442\u043e \u041c\u0410\u041c\u0410 <br><br>\u043c\u044b\u043b\u0410<br>\u0420\u0430\u043c\u0443<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 second.txt<br>\u0410 \u0432 \u044d\u0442\u043e\u043c \u043d\u0435 \u0433\u043e\u0432\u043e\u0440\u0438\u0442\u0441\u044f<br><br>|first.txt<br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434:<br>Python<br>only_one_file.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 only_one_file.txt<br>\u0422\u0443\u0442 \u043d\u0435\u0442 \u043d\u0438\u043a\u0430\u043a\u0438\u0445 \u0437\u043c\u0435\u0439<br><br>|404. Not Found<br> <br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from sys import stdin", "", "", "search_task = input().lower().split()", "", "filenames = [line.rstrip(\"\\n\") for line in stdin]", "is_something = False", "", "for fname in filenames:", "", " active_searches = []", " ind = 0", " f = False", " with open(fname, \"r\", encoding=\"utf-8\") as file:", " for line in file:", " for word in line.replace(\" \", \" \").rstrip(\"\\n\").lower().split():", " if not word:", " continue", " if word == search_task[0]:", " active_searches.append([word])", " continue", " if active_searches:", " for i in range(len(active_searches) - 1, -1, -1):", " if len(active_searches[i]) == len(search_task):", " f = True", " break ", " elif search_task[len(active_searches[i])] == word:", " active_searches[i].append(word)", " else:", " del active_searches[i]", "", " if f:", " break", " ", " if active_searches:", " for i in range(len(active_searches) - 1, -1, -1):", " if len(active_searches[i]) == len(search_task):", " f = True", " break", " ", " if f:", " break", " if f:", " print(fname)", " is_something = True", "", "if not is_something:", " print(\"404. Not Found\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041f\u0440\u044f\u0442\u043a\u0438**", "\u0421\u0442\u0435\u0433\u0430\u043d\u043e\u0433\u0440\u0430\u0444\u0438\u044f \u2014 \u0441\u043f\u043e\u0441\u043e\u0431 \u043f\u0435\u0440\u0435\u0434\u0430\u0447\u0438 \u0438\u043b\u0438 \u0445\u0440\u0430\u043d\u0435\u043d\u0438\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438 \u0441 \u0443\u0447\u0451\u0442\u043e\u043c \u0441\u043e\u0445\u0440\u0430\u043d\u0435\u043d\u0438\u044f \u0432 \u0442\u0430\u0439\u043d\u0435 \u0441\u0430\u043c\u043e\u0433\u043e \u0444\u0430\u043a\u0442\u0430 \u0442\u0430\u043a\u043e\u0439 \u043f\u0435\u0440\u0435\u0434\u0430\u0447\u0438 (\u0445\u0440\u0430\u043d\u0435\u043d\u0438\u044f).<br><br>\u0412 \u043e\u0442\u043b\u0438\u0447\u0438\u0435 \u043e\u0442 \u043a\u0440\u0438\u043f\u0442\u043e\u0433\u0440\u0430\u0444\u0438\u0438, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0441\u043a\u0440\u044b\u0432\u0430\u0435\u0442 \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0442\u0430\u0439\u043d\u043e\u0433\u043e \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u044f, \u0441\u0442\u0435\u0433\u0430\u043d\u043e\u0433\u0440\u0430\u0444\u0438\u044f \u0441\u043a\u0440\u044b\u0432\u0430\u0435\u0442 \u0441\u0430\u043c \u0444\u0430\u043a\u0442 \u0435\u0433\u043e \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u043e\u0432\u0430\u043d\u0438\u044f. \u041a\u0430\u043a \u043f\u0440\u0430\u0432\u0438\u043b\u043e, \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 \u0431\u0443\u0434\u0435\u0442 \u0432\u044b\u0433\u043b\u044f\u0434\u0435\u0442\u044c \u043a\u0430\u043a \u0447\u0442\u043e-\u043b\u0438\u0431\u043e \u0438\u043d\u043e\u0435, \u043d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, \u043a\u0430\u043a \u0438\u0437\u043e\u0431\u0440\u0430\u0436\u0435\u043d\u0438\u0435, \u0441\u0442\u0430\u0442\u044c\u044f, \u0441\u043f\u0438\u0441\u043e\u043a \u043f\u043e\u043a\u0443\u043f\u043e\u043a, \u043f\u0438\u0441\u044c\u043c\u043e \u0438\u043b\u0438 \u0441\u0443\u0434\u043e\u043a\u0443. \u0421\u0442\u0435\u0433\u0430\u043d\u043e\u0433\u0440\u0430\u0444\u0438\u044e \u043e\u0431\u044b\u0447\u043d\u043e \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u044e\u0442 \u0441\u043e\u0432\u043c\u0435\u0441\u0442\u043d\u043e \u0441 \u043c\u0435\u0442\u043e\u0434\u0430\u043c\u0438 \u043a\u0440\u0438\u043f\u0442\u043e\u0433\u0440\u0430\u0444\u0438\u0438, \u0442\u0430\u043a\u0438\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c, \u0434\u043e\u043f\u043e\u043b\u043d\u044f\u044f \u0435\u0451.<br><br>\u041d\u0430\u043c \u0431\u044b\u043b \u0434\u0430\u043d \u0444\u0430\u0439\u043b \u0441\u043e \u0441\u043a\u0440\u044b\u0442\u044b\u043c \u0442\u0435\u043a\u0441\u0442\u043e\u043c. \u0418 \u0431\u044b\u043b\u043e \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u043e, \u0447\u0442\u043e \u0434\u043b\u044f \u0432\u044b\u0434\u0435\u043b\u0435\u043d\u0438\u044f \u043f\u043e\u043b\u0435\u0437\u043d\u043e\u0439 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438, \u043d\u0443\u0436\u043d\u043e \u0438\u0437 \u043a\u0430\u0436\u0434\u043e\u0433\u043e \u043a\u043e\u0434\u0430 \u0441\u0438\u043c\u0432\u043e\u043b\u0430 \u0432 \u0442\u0435\u043a\u0441\u0442\u0435 \u00ab\u0432\u044b\u0434\u0435\u0440\u043d\u0443\u0442\u044c\u00bb \u043c\u043b\u0430\u0434\u0448\u0438\u0439 \u0431\u0430\u0439\u0442. \u042d\u0442\u043e \u0438 \u0431\u0443\u0434\u0435\u0442 \u043a\u043e\u0434 \u0441\u0438\u043c\u0432\u043e\u043b\u0430 \u043f\u043e\u043b\u0435\u0437\u043d\u043e\u0439 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438.<br>\u041e\u0434\u043d\u0430\u043a\u043e \u0435\u0441\u0442\u044c \u043e\u0434\u043d\u043e \u00ab\u043d\u043e\u00bb. \u0415\u0441\u043b\u0438 \u043a\u043e\u0434 \u0441\u0438\u043c\u0432\u043e\u043b\u0430 \u043c\u0435\u043d\u044c\u0448\u0435 128 \u2014 \u044d\u0442\u043e \u0438 \u0435\u0441\u0442\u044c \u043f\u043e\u043b\u0435\u0437\u043d\u0430\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f.<br><br>\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0438\u0437 \u0442\u0435\u043a\u0441\u0442\u043e\u0432\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430 \u0432\u044b\u0434\u0435\u043b\u044f\u0435\u0442 \u043f\u043e\u043b\u0435\u0437\u043d\u0443\u044e \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044e.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u0444\u0430\u0439\u043b\u0435 secret.txt \u0445\u0440\u0430\u043d\u0438\u0442\u0441\u044f \u0442\u0435\u043a\u0441\u0442.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u0441\u043f\u0440\u044f\u0442\u0430\u043d\u043d\u043e\u0435 \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0414\u043b\u044f \u043c\u0430\u043d\u0438\u043f\u0443\u043b\u044f\u0446\u0438\u0438 \u043a\u043e\u0434\u0430\u043c\u0438 \u0441\u0438\u043c\u0432\u043e\u043b\u043e\u0432 \u0438\u0437\u0443\u0447\u0438\u0442\u0435 \u0440\u0430\u0431\u043e\u0442\u0443 \u0444\u0443\u043d\u043a\u0446\u0438\u0439 chr \u0438 ord.", "### **\u041f\u0440\u0438\u043c\u0435\u0440**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|\u1948\u0b65\u166c\u1c6c\u176f, \u1b77\u176f\u0b72\u0a6c\u0e64!<br>|Hello, world!<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["fname = \"secret.txt\"", "", "with open(fname, \"r\", encoding=\"utf-8\") as file:", " for line in file:", " string = line.rstrip(\"\\n\")", " res = ''", "", " for char in string:", " b = bin(ord(char))[2:]", " if len(b) % 8 != 0:", " bytenum = len(b) // 8 + 1", " b = \"0\" * (8 * bytenum - len(b)) + b", " if len(b) <= 8:", " res += chr(int(b, 2))", " else:", " res += chr(int(b[8:], 2))", "", " print(res)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043a\u043e\u043b\u044c\u043a\u043e \u0432\u0435\u0448\u0430\u0442\u044c \u0432 \u0431\u0430\u0439\u0442\u0430\u0445?**", "\u0420\u0430\u0437\u043c\u0435\u0440 \u2014 \u0432\u0430\u0436\u043d\u0430\u044f \u0445\u0430\u0440\u0430\u043a\u0442\u0435\u0440\u0438\u0441\u0442\u0438\u043a\u0430 \u043b\u044e\u0431\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430. \u0412 \u043d\u0430\u0448\u0435\u0439 \u0441\u0442\u0440\u0430\u043d\u0438\u0446\u0435 \u0441\u043e\u0433\u043b\u0430\u0441\u043d\u043e \u0413\u041e\u0421\u0422 8.417-2002 \u043e\u0431\u044a\u0451\u043c \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438 \u0438\u0437\u043c\u0435\u0440\u044f\u0435\u0442\u0441\u044f \u0432 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 \u0435\u0434\u0438\u043d\u0438\u0446\u0430\u0445:<br>", "\u0431\u0438\u0442 (\u0431)<br>\u0411\u0430\u0439\u0442 (\u0411) = 8 \u0431\u0438\u0442<br>\u041a\u0438\u043b\u043e\u0431\u0430\u0439\u0442 (\u041a\u0411) = 1024 \u0411<br>\u041c\u0435\u0433\u0430\u0431\u0430\u0439\u0442 (\u041c\u0411) = 1024 \u041a\u0411<br>\u0413\u0438\u0433\u0430\u0431\u0430\u0439\u0442 (\u0413\u0411) = 1024 \u041c\u0411<br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u043e\u0431\u044a\u0451\u043c \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u043e\u0434\u043d\u043e \u0438\u043c\u044f \u0444\u0430\u0439\u043b\u0430.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412\u044b\u0432\u0435\u0434\u0438\u0442\u0435 \u043e\u0431\u044a\u0451\u043c \u0444\u0430\u0439\u043b\u0430 \u0432 \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0438\u0445 \u0435\u0434\u0438\u043d\u0438\u0446\u0430\u0445 \u0438\u0437\u043c\u0435\u0440\u0435\u043d\u0438\u044f.<br>\u041f\u0440\u0438 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u0438\u0438 \u0434\u0440\u043e\u0431\u043d\u043e\u0433\u043e \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f, \u043f\u0440\u043e\u0438\u0437\u0432\u0435\u0434\u0438\u0442\u0435 \u043e\u043a\u0440\u0443\u0433\u043b\u0435\u043d\u0438\u0435 \u0432\u0432\u0435\u0440\u0445.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0414\u043b\u044f \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u0434\u0430\u043d\u043d\u043e\u0439 \u0437\u0430\u0434\u0430\u0447\u0438 \u0432\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u043f\u043e\u0439\u0442\u0438 \u0434\u0432\u0443\u043c\u044f \u043f\u0443\u0442\u044f\u043c\u0438:<br>", "* \u0438\u0437\u0443\u0447\u0438\u0442\u0435 \u0447\u0442\u0435\u043d\u0438\u0435 \u0444\u0430\u0439\u043b\u043e\u0432 \u0432 \u043f\u043e\u0431\u0430\u0439\u0442\u043d\u043e\u043c \u0440\u0435\u0436\u0438\u043c\u0435;", "* \u0438\u0437\u0443\u0447\u0438\u0442\u0435 \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u0443\u044e \u0431\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0443 os.", "", "", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434<br>file.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 file.txt<br>\u042d\u0442\u043e\u0442 \u0444\u0430\u0439\u043b \u0432\u0435\u0441\u0438\u0442 \u0431\u043e\u043b\u044c\u0448\u0435 \u0447\u0435\u043c \u043a\u0430\u0436\u0435\u0442\u0441\u044f ))<br>|67\u0411<br> <br> <br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434<br>another_file.txt<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 another_file.txt<br>\u0425\u043e\u0442\u0435\u043b\u043e\u0441\u044c \u0431\u044b \u0441\u0434\u0435\u043b\u0430\u0442\u044c \u043f\u0440\u0438\u043c\u0435\u0440 \u0441 \u0444\u0430\u0439\u043b\u043e\u043c \u0431\u043e\u043b\u044c\u0448\u0435 1\u041a\u0411<br>\u041d\u0435 \u043f\u0435\u0440\u0435\u0436\u0438\u0432\u0430\u0439\u0442\u0435, \u0442\u0430\u043a\u043e\u0439 \u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u043e \u0431\u0443\u0434\u0435\u0442 \u0432 \u0441\u043a\u0440\u044b\u0442\u044b\u0445 \u0442\u0435\u0441\u0442\u0430\u0445 ))<br>|193\u0411<br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import os", "", "types = [\"\u0411\", \"\u041a\u0411\", \"\u041c\u0411\", \"\u0413\u0411\"]", "fname = input()", "bytessum = 0", "type = 0", "bytessum = os.stat(fname).st_size", " ", "while bytessum >= 1024:", " if bytessum == 3:", " break", " type += 1", " bytessum = bytessum // 1024 + (bytessum % 1024 > 0)", "", "print(f\"{bytessum}{types[type]}\")", ""]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u042d\u0442\u043e \u0431\u0443\u0434\u0435\u0442 \u043d\u0430\u0448 \u0441\u0435\u043a\u0440\u0435\u0442**", "\u0428\u0438\u0444\u0440 \u0426\u0435\u0437\u0430\u0440\u044f, \u0442\u0430\u043a\u0436\u0435 \u0438\u0437\u0432\u0435\u0441\u0442\u043d\u044b\u0439 \u043a\u0430\u043a \u0448\u0438\u0444\u0440 \u0441\u0434\u0432\u0438\u0433\u0430, \u043a\u043e\u0434 \u0426\u0435\u0437\u0430\u0440\u044f \u2014 \u043e\u0434\u0438\u043d \u0438\u0437 \u0441\u0430\u043c\u044b\u0445 \u043f\u0440\u043e\u0441\u0442\u044b\u0445 \u0438 \u043d\u0430\u0438\u0431\u043e\u043b\u0435\u0435 \u0448\u0438\u0440\u043e\u043a\u043e \u0438\u0437\u0432\u0435\u0441\u0442\u043d\u044b\u0445 \u043c\u0435\u0442\u043e\u0434\u043e\u0432 \u0448\u0438\u0444\u0440\u043e\u0432\u0430\u043d\u0438\u044f. \u041e\u043d \u043d\u0430\u0437\u0432\u0430\u043d \u0432 \u0447\u0435\u0441\u0442\u044c \u0440\u0438\u043c\u0441\u043a\u043e\u0433\u043e \u043f\u043e\u043b\u043a\u043e\u0432\u043e\u0434\u0446\u0430 \u0413\u0430\u044f \u042e\u043b\u0438\u044f \u0426\u0435\u0437\u0430\u0440\u044f, \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0432\u0448\u0435\u0433\u043e \u0435\u0433\u043e \u0434\u043b\u044f \u0441\u0435\u043a\u0440\u0435\u0442\u043d\u043e\u0439 \u043f\u0435\u0440\u0435\u043f\u0438\u0441\u043a\u0438 \u0441\u043e \u0441\u0432\u043e\u0438\u043c\u0438 \u0433\u0435\u043d\u0435\u0440\u0430\u043b\u0430\u043c\u0438.<br><br>\u0414\u0430\u0432\u0430\u0439\u0442\u0435 \u0440\u0435\u0430\u043b\u0438\u0437\u0443\u0435\u043c \u044d\u0442\u0443 \u0441\u0438\u0441\u0442\u0435\u043c\u0443 \u0448\u0438\u0444\u0440\u043e\u0432\u0430\u043d\u0438\u044f. \u041e\u0434\u043d\u0430\u043a\u043e \u0434\u043b\u044f \u043f\u0440\u043e\u0441\u0442\u043e\u0442\u044b \u043c\u044b \u0431\u0443\u0434\u0435\u043c \u0441\u0434\u0432\u0438\u0433\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u043b\u0430\u0442\u0438\u043d\u0441\u043a\u0438\u0435 \u0441\u0438\u043c\u0432\u043e\u043b\u044b \u043f\u043e \u043a\u0440\u0443\u0433\u0443.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412\u0432\u043e\u0434\u0438\u0442\u0441\u044f \u0440\u0430\u0437\u043c\u0435\u0440 \u0441\u0434\u0432\u0438\u0433\u0430 \u0434\u043b\u044f \u0448\u0438\u0444\u0440\u043e\u0432\u0430\u043d\u0438\u044f.<br><br>\u0412 \u0444\u0430\u0439\u043b\u0435 public.txt \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442\u0441\u044f \u0442\u0435\u043a\u0441\u0442 \u043d\u0430 \u0430\u043d\u0433\u043b\u0438\u0439\u0441\u043a\u043e\u043c \u044f\u0437\u044b\u043a\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0412 \u0444\u0430\u0439\u043b private.txt \u0437\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0437\u0430\u0448\u0438\u0444\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0439 \u0442\u0435\u043a\u0441\u0442.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434<br>3<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 public.txt<br>Hello, world!<br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 private.txt<br>Khoor, zruog!<br> <br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|# \u041f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u0441\u043a\u0438\u0439 \u0432\u0432\u043e\u0434<br>-10<br><br># \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 public.txt<br>English alphabet: ABCDEFG...XYZ<br>|# \u0421\u043e\u0434\u0435\u0440\u0436\u0438\u043c\u043e\u0435 \u0444\u0430\u0439\u043b\u0430 private.txt<br>Udwbyix qbfxqruj: QRSTUVW...NOP<br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["inpname = \"public.txt\"", "outname = \"private.txt\"", "", "change = int(input())", "", "with open(inpname, \"r\", encoding=\"utf-8\") as inpfile:", " with open(outname, \"w\", encoding=\"utf-8\") as outfile:", " for line in inpfile:", " s = ''", " for c in line:", " code = ord(c)", " if 65 <= code <= 90:", " code += change", " if code > 90:", " while code > 90:", " code = code - 26", " elif code < 65:", " while code < 65:", " code = 26 + code", " c = chr(code)", " elif 97 <= code <= 122:", " code += change", " if code > 122:", " while code > 122:", " code = code - 26", " elif code < 97:", " while code < 97:", " code = 26 + code", " c = chr(code)", " ", " s += c", " outfile.write(s)", "", "", ""]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0430\u0439\u043b\u043e\u0432\u0430\u044f \u0441\u0443\u043c\u043c\u0430**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0443, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u0441\u0443\u043c\u043c\u0443 \u0432\u0441\u0435\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043d\u044b\u0445 \u0432 \u0444\u0430\u0439\u043b\u0435 \u0447\u0438\u0441\u0435\u043b \u0432 2-\u0431\u0430\u0439\u0442\u043d\u043e\u043c \u0434\u0438\u0430\u043f\u0430\u0437\u043e\u043d\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u0432\u043e\u0434\u0430**", "\u0412 \u0444\u0430\u0439\u043b\u0435 numbers.num \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u0441\u044f \u0447\u0438\u0441\u043b\u0430 \u0432 \u0443\u043a\u0430\u0437\u0430\u043d\u043d\u043e\u043c \u0444\u043e\u0440\u043c\u0430\u0442\u0435.", "### **\u0424\u043e\u0440\u043c\u0430\u0442 \u0432\u044b\u0432\u043e\u0434\u0430**", "\u041e\u0434\u043d\u043e \u0447\u0438\u0441\u043b\u043e \u2014 \u0441\u0443\u043c\u043c\u0430 \u0432\u0441\u0435\u0445 \u0447\u0438\u0441\u0435\u043b \u0432 \u0444\u0430\u0439\u043b\u0435 \u043d\u0430 2-\u0431\u0430\u0439\u0442\u043d\u043e\u043c \u0434\u0438\u0430\u043f\u0430\u0437\u043e\u043d\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0414\u043b\u044f \u043f\u0440\u043e\u0441\u0442\u043e\u0442\u044b \u0444\u0430\u0439\u043b\u044b \u0432 \u043f\u0440\u0438\u043c\u0435\u0440\u0430\u0445 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u044b \u0432 HEX \u0444\u043e\u0440\u043c\u0430\u0442\u0435. \u0412 \u044d\u0442\u043e\u043c \u0432\u0438\u0434\u0435 \u0444\u0430\u0439\u043b \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u043a\u0430\u043a \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u044c \u0447\u0435\u0442\u044b\u0440\u0435\u0445\u0437\u043d\u0430\u0447\u043d\u044b\u0445 \u0448\u0435\u0441\u0442\u043d\u0430\u0434\u0446\u0430\u0442\u0435\u0440\u0438\u0447\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b.<br><br>\u0412 \u043f\u0435\u0440\u0432\u043e\u043c \u043f\u0440\u0438\u043c\u0435\u0440\u0435 \u0437\u0430\u043f\u0438\u0441\u0430\u043d\u043e 5 \u0448\u0435\u0441\u0442\u043d\u0430\u0434\u0446\u0430\u0442\u0435\u0440\u0438\u0447\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b: 1, 2, 3, 4, 5. \u0418\u0445 \u0441\u0443\u043c\u043c\u0430 \u0440\u0430\u0432\u043d\u0430 15.<br>\u0412\u043e \u0432\u0442\u043e\u0440\u043e\u043c \u2014 255 \u0438 257. \u0418\u0445 \u0441\u0443\u043c\u043c\u0430 \u0440\u0430\u0432\u043d\u0430 512.<br><br>\u0424\u0430\u0439\u043b \u0438\u0437 \u043f\u0440\u0438\u043c\u0435\u0440\u043e\u0432 \u0432 \u0438\u0437\u043d\u0430\u0447\u0430\u043b\u044c\u043d\u043e\u043c \u0432\u0438\u0434\u0435 \u043c\u043e\u0436\u043d\u043e \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044c \u0437\u0434\u0435\u0441\u044c:<br>", "\u041f\u0435\u0440\u0432\u044b\u0439 \u043f\u0440\u0438\u043c\u0435\u0440<br>\u0412\u0442\u043e\u0440\u043e\u0439 \u043f\u0440\u0438\u043c\u0435\u0440<br>\u0415\u0441\u043b\u0438 \u0432\u044b \u0445\u043e\u0442\u0438\u0442\u0435 \u0438\u0437\u0443\u0447\u0438\u0442\u044c \u043f\u0440\u0438\u043d\u0446\u0438\u043f \u0445\u0440\u0430\u043d\u0435\u043d\u0438\u044f \u0446\u0435\u043b\u044b\u0445 \u0447\u0438\u0441\u0435\u043b \u0432 \u042d\u0412\u041c, \u0441\u043e\u0432\u0435\u0442\u0443\u0435\u043c \u043f\u043e\u0447\u0438\u0442\u0430\u0442\u044c \u043f\u0440\u043e \u043f\u0440\u044f\u043c\u043e\u0439, \u043e\u0431\u0440\u0430\u0442\u043d\u044b\u0439 \u0438 \u0434\u043e\u043f\u043e\u043b\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u044b\u0439 \u043a\u043e\u0434\u044b.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|0001 0002 0003 0004 0005<br>|15<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|00FF 0101<br>|512<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["fname = \"numbers.num\"", "", "snum = 0", "with open(fname, \"rb\") as file:", " while (byte := file.read(2)):", " snum += int.from_bytes(byte)", "", "snum = snum % 2**16", "print(snum)"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"name": "python", "version": "3.11.1"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/3.5/4.py b/3.5/4.py
deleted file mode 100644
index c286a45eae096247a9bf62c5755669eba4d73b3c..0000000000000000000000000000000000000000
--- a/3.5/4.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from sys import stdin
-
-sentences = []
-for line in stdin:
- sentences.append(line.rstrip("\n"))
-
-search = sentences.pop(-1)
-res = []
-
-for sen in sentences:
- if search.lower() in sen.lower():
- res.append(sen)
-
-print(*res, sep="\n")
\ No newline at end of file
diff --git a/3.5/5.py b/3.5/5.py
deleted file mode 100644
index ffb70edfc4fd78605adf1f1038d7f64de7555808..0000000000000000000000000000000000000000
--- a/3.5/5.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from sys import stdin
-
-res = set()
-for line in stdin:
- for word in line.rstrip("\n").split():
- if word.lower() == word[::-1].lower():
- res.add(word)
-
-print(*sorted(list(res)), sep="\n")
\ No newline at end of file
diff --git a/3.5/6.py b/3.5/6.py
deleted file mode 100644
index 8c1b1cd5d8b99b17a91eb76295eb46838d968282..0000000000000000000000000000000000000000
--- a/3.5/6.py
+++ /dev/null
@@ -1,78 +0,0 @@
-d = {
- 'Рђ': 'A',
- 'Р°': 'a',
- 'Р‘': 'B',
- 'Р±': 'b',
- 'Р’': 'V',
- 'РІ': 'v',
- 'Р“': 'G',
- 'Рі': 'g',
- 'Р”': 'D',
- 'Рґ': 'd',
- 'Р•': 'E',
- 'Рµ': 'e',
- 'РЃ': 'E',
- 'С‘': 'e',
- 'Р–': 'Zh',
- 'Р¶': 'zh',
- 'Р—': 'Z',
- 'Р·': 'z',
- 'Р': 'I',
- 'Рё': 'i',
- 'Р™': 'I',
- 'Р№': 'i',
- 'Рљ': 'K',
- 'Рє': 'k',
- 'Р›': 'L',
- 'Р»': 'l',
- 'Рњ': 'M',
- 'Рј': 'm',
- 'Рќ': 'N',
- 'РЅ': 'n',
- 'Рћ': 'O',
- 'Рѕ': 'o',
- 'Рџ': 'P',
- 'Рї': 'p',
- 'Р ': 'R',
- 'СЂ': 'r',
- 'РЎ': 'S',
- 'СЃ': 's',
- 'Рў': 'T',
- 'С‚': 't',
- 'РЈ': 'U',
- 'Сѓ': 'u',
- 'Р¤': 'F',
- 'С„': 'f',
- 'РҐ': 'Kh',
- 'С…': 'kh',
- 'Р¦': 'Tc',
- 'С†': 'tc',
- 'Р§': 'Ch',
- 'С‡': 'ch',
- 'РЁ': 'Sh',
- 'С€': 'sh',
- 'Р©': 'Shch',
- 'С‰': 'shch',
- 'Р«': 'Y',
- 'С‹': 'y',
- 'Р': 'E',
- 'СЌ': 'e',
- 'Р®': 'Iu',
- 'СЋ': 'iu',
- 'РЇ': 'Ia',
- 'СЏ': 'ia'
-}
-string = ""
-with open("cyrillic.txt", "r", encoding="utf-8") as input_file:
- with open("transliteration.txt", "w", encoding="utf-8") as output_file:
- for line in input_file:
- string = line
- new_string = ""
- for i in string:
- if i in d.keys():
- new_string += d[i]
- elif i.lower() in ["СЊ", "СЉ"]:
- continue
- else:
- new_string += i
- output_file.write(new_string)
\ No newline at end of file
diff --git a/3.5/7.py b/3.5/7.py
deleted file mode 100644
index f8108322776e43920b91450668df8c5363b72f82..0000000000000000000000000000000000000000
--- a/3.5/7.py
+++ /dev/null
@@ -1,13 +0,0 @@
-file_name = input()
-
-data = []
-with open(file_name, "r", encoding="utf-8") as file:
- for line in file:
- data += [int(i) for i in line.rstrip("\n").split()]
-
-print(len(data))
-print(len([i for i in data if i > 0]))
-print(min(data))
-print(max(data))
-print(sum(data))
-print(round(sum(data) / len(data), 2))
\ No newline at end of file
diff --git a/3.5/8.py b/3.5/8.py
deleted file mode 100644
index 35901ea93502af6d3af7ed3c03501c8d52686ee1..0000000000000000000000000000000000000000
--- a/3.5/8.py
+++ /dev/null
@@ -1,19 +0,0 @@
-file1_name, file2_name = input(), input()
-fileres_name = input()
-set1, set2 = set(), set()
-
-with open(file1_name, "r", encoding="utf-8") as file1:
- for line in file1:
- for word in line.rstrip("\n").split():
- set1.add(word)
-
-with open(file2_name, "r", encoding="utf-8") as file2:
- for line in file2:
- for word in line.rstrip("\n").split():
- set2.add(word)
-
-res = sorted(list(set1 ^ set2))
-
-with open(fileres_name, "w+", encoding="utf-8") as fileres:
- for elem in res:
- fileres.write(f"{elem}\n")
\ No newline at end of file
diff --git a/3.5/9.py b/3.5/9.py
deleted file mode 100644
index 7c29a10250ba59abd59f6665f0dafae6b55933bf..0000000000000000000000000000000000000000
--- a/3.5/9.py
+++ /dev/null
@@ -1,15 +0,0 @@
-first_file_name, second_file_name = input(), input()
-
-with open(first_file_name, "r", encoding="utf-8") as first_file:
- with open(second_file_name, "w", encoding="utf-8") as second_file:
- for line in first_file:
- string = line.rstrip("\n")
- if not string:
- continue
- if "\t" in string:
- while "\t" in string:
- ind = string.index("\t")
- string = string[:ind] + string[ind + 1:]
- words = string.split()
- string = " ".join(words)
- second_file.write(string + "\n")
\ No newline at end of file
diff --git a/3.6/1.py b/3.6/1.py
deleted file mode 100644
index 3257f180c12bf01ff9f22787a9edc1e09197d36c..0000000000000000000000000000000000000000
--- a/3.6/1.py
+++ /dev/null
@@ -1,13 +0,0 @@
-n = int(input())
-strings = []
-for _ in range(n):
- buff = input().split("&")
- strings.append([int(buff[0]), int(buff[1]), "&".join(buff[2:])])
-
-for elem in strings:
- s = ""
- a, b, string = elem
- for i in range(a, len(string), 2):
- s += string[i]
- s = s[:b]
- print(s)
\ No newline at end of file
diff --git a/3.6/2.py b/3.6/2.py
deleted file mode 100644
index d1bd26ed9cd151927cc2e7cbe17f3baa6b2b19b1..0000000000000000000000000000000000000000
--- a/3.6/2.py
+++ /dev/null
@@ -1,18 +0,0 @@
-s = input()
-arr = []
-while s:
- arr += s.split()
- s = input()
-
-res = {}
-for word in arr:
- key = word[-1].upper()
- if key in res:
- if word.lower() not in res[key]:
- res[key].append(word.lower())
- else:
- res[key] = [word.lower()]
-
-for key in res.keys():
- print(f"{key} - ", end="")
- print(*sorted(res[key]), sep=", ")
diff --git a/3.6/3.py b/3.6/3.py
deleted file mode 100644
index c51110daf835588dbd4e26bb1373e1f827db42a1..0000000000000000000000000000000000000000
--- a/3.6/3.py
+++ /dev/null
@@ -1 +0,0 @@
-[num for num in numbers if num % 2 == 0] + [num for num in numbers if num % 2 == 1]
\ No newline at end of file
diff --git a/3.6/4.py b/3.6/4.py
deleted file mode 100644
index b9908c1ad72ec5db66d162f10b9fba4acebd9ea0..0000000000000000000000000000000000000000
--- a/3.6/4.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from itertools import product
-
-arr = []
-for _ in range(int(input())):
- arr.append(sorted(list(set(input().split(", ")))))
-
-for val in product(*arr):
- print("".join(val))
\ No newline at end of file
diff --git a/3.6/5.py b/3.6/5.py
deleted file mode 100644
index 27b1d0115fdbb9b42a9da00616ff9db2524e68e1..0000000000000000000000000000000000000000
--- a/3.6/5.py
+++ /dev/null
@@ -1,51 +0,0 @@
-import json
-from sys import stdin
-
-def make_siple_nums(maxnum):
- res = []
-
- for num in range(2, maxnum // 2 + 1):
- f = True
- for d in range(2, int(num ** 0.5 + 1)):
- if num % d == 0 and num != d:
- f = False
- break
- if f:
- res.append(num)
-
- f = True
- for d in range(2, int(maxnum ** 0.5 + 1)):
- if maxnum % d == 0 and maxnum != d:
- f = False
- break
- if f:
- res.append(maxnum)
-
- return res
-
-def process(arr):
- res = {}
- arr = set(arr)
-
- snums = make_siple_nums(max(arr) // 2 + 1)
- for krat in arr:
- for num in snums:
- if krat % num == 0:
- if num in res:
- res[num].append(krat)
- else:
- res[num] = [krat]
- if num in res:
- res[num] = sorted(res[num])
-
- with open('result.json', 'w', encoding="utf-8") as file:
- json.dump(res, file)
- file.close()
-
-
-
-
-arr = []
-for line in stdin:
- arr.append(int(line))
- process(arr)
diff --git a/3.6/tets.py b/3.6/tets.py
deleted file mode 100644
index 26654fd043ad26b008ff6efe025d90e8871b646e..0000000000000000000000000000000000000000
--- a/3.6/tets.py
+++ /dev/null
@@ -1,92 +0,0 @@
-alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-def unite_equation(operation_dict, opers):
- opers = opers[::-1]
- for i in range(len(opers)):
- if i == len(opers) - 1:
- for elemind in range(len(operation_dict[opers[i]][()])):
- operation_dict[opers[i]][()][elemind] = f"({operation_dict[opers[i]][()][elemind]})"
- eq = opers[i].join(operation_dict[opers[i]][()])
-
-
- u_dict = operation_dict.pop(opers[i])
- for key in u_dict.keys():
- buff = u_dict[key]
- for elemind in range(len(buff)):
- buff[elemind] = f"({buff[elemind]})"
-
- for j in range(i + 1, len(opers)):
- if key[:-1] in operation_dict[opers[j]].keys():
- operation_dict[opers[j]][key[:-1]][key[-1]] = opers[i].join(buff)
-
-
-
- return eq
-
-def make_brackets(eq):
- opers = [" == ", " <= ", " != ", " or ", " and "]
- ind = -1
- buff = []
- for i in range(len(opers)):
- if opers[i] in eq:
- buff.append(opers[i])
- opers = buff
- del buff
-
-# A <= B == C == D != E <= F
-# [A <= B, C, D != E <= F]
-# {==: {(): [A <= B, C, D != E <= F]}, <=: {(0): [A, B], (2): [D != E, F]}, !=: {(2, 0)): D != E}}
-# B or C
-
- if opers:
- base_op = opers[0]
- parts = eq.split(base_op)
- f_p = False
- for p in parts:
- for op in opers:
- if op in p:
- f_p = True
- break
- if f_p:
- break
-
- if f_p:
- operation_dict = {base_op: {(): parts}}
-
-
- for i in range(1, len(opers)):
- if i - 1:
- prev_d = operation_dict[opers[i - 1]]
- new_d = {}
-
- for key in prev_d.keys():
- for p_i in range(len(prev_d[key])):
- if opers[i] in prev_d[key][p_i]:
- new_d[key + (p_i, )] = prev_d[key][p_i].split(opers[i])
-
- if new_d:
- operation_dict[opers[i]] = new_d
- else:
- break #end
-
- else:
-
- for p_i in range(len(parts)):
- if opers[i] in parts[p_i]:
- if opers[i] in operation_dict:
- operation_dict[opers[i]][(p_i, )] = parts[p_i].split(opers[i])
- else:
- operation_dict[opers[i]] = {(p_i, ): parts[p_i].split(opers[i])}
-
- eq = unite_equation(operation_dict, opers)
-
- else:
- for i in range(len(parts)):
- parts[i] = f"({parts[i]})"
-
- eq = base_op.join(parts)
-
- return eq
-
-
-print(make_brackets("A or C ~ not (A -> B) or C".replace("->", "<=").replace("^", "!=").replace("~", "==")))
\ No newline at end of file
diff --git a/4.1/1.py b/4.1/1.py
deleted file mode 100644
index 592a6d63d95c73b63df243510febebaf38dd3ff0..0000000000000000000000000000000000000000
--- a/4.1/1.py
+++ /dev/null
@@ -1,2 +0,0 @@
-def print_hello(name):
- print(f"Hello, {name}!")
\ No newline at end of file
diff --git a/4.1/10.py b/4.1/10.py
deleted file mode 100644
index 8c14d6a41caaf17f28ce8ea98b1dcbd971b4903c..0000000000000000000000000000000000000000
--- a/4.1/10.py
+++ /dev/null
@@ -1,18 +0,0 @@
-def merge(nums1, nums2):
- res = []
- nums1, nums2 = map(list, [nums1, nums2])
- while nums1 or nums2:
- if not nums1:
- res.append(nums2[0])
- del nums2[0]
- elif not nums2:
- res.append(nums1[0])
- del nums1[0]
- else:
- if nums1[0] < nums2[0]:
- res.append(nums1[0])
- del nums1[0]
- else:
- res.append(nums2[0])
- del nums2[0]
- return tuple(res)
\ No newline at end of file
diff --git a/4.1/2.py b/4.1/2.py
deleted file mode 100644
index 92a94adac3cb2a6d290fcb287bcc3ab0f2eaa014..0000000000000000000000000000000000000000
--- a/4.1/2.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def gcd(a, b):
- while a != b:
- if a > b:
- a -= b
- else:
- b -= a
- return a
\ No newline at end of file
diff --git a/4.1/3.py b/4.1/3.py
deleted file mode 100644
index d5905b9f6fcae2e58b0ad9b1b810d15692b5aeb3..0000000000000000000000000000000000000000
--- a/4.1/3.py
+++ /dev/null
@@ -1,5 +0,0 @@
-def number_length(num):
- res = len(str(num))
- if num < 0:
- res -= 1
- return res
\ No newline at end of file
diff --git a/4.1/4.py b/4.1/4.py
deleted file mode 100644
index 718a66731ab5365c23f8a21793d22e082021a7bd..0000000000000000000000000000000000000000
--- a/4.1/4.py
+++ /dev/null
@@ -1,19 +0,0 @@
-def month(num, lang):
- mths = (
- ("January", "Январь"),
- ("February", "Февраль"),
- ("March", "Март"),
- ("April", "Апрель"),
- ("May", "Май"),
- ("June", "РСЋРЅСЊ"),
- ("July", "Рюль"),
- ("August", "РђРІРіСѓСЃС‚"),
- ("September", "Сентябрь"),
- ("October", "Октябрь"),
- ("November", "РќРѕСЏР±СЂСЊ"),
- ("December", "Декабрь")
- )
- if lang == "en":
- return mths[num - 1][0]
- else:
- return mths[num - 1][1]
\ No newline at end of file
diff --git a/4.1/41.ipynb b/4.1/41.ipynb
deleted file mode 100644
index 0601032295169300ec544a8d09cbb02563287841..0000000000000000000000000000000000000000
--- a/4.1/41.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0443\u043d\u043a\u0446\u0438\u043e\u043d\u0430\u043b\u044c\u043d\u043e\u0435 \u043f\u0440\u0438\u0432\u0435\u0442\u0441\u0442\u0432\u0438\u0435**", "\u0411\u043e\u043b\u044c\u0448\u0438\u043d\u0441\u0442\u0432\u043e \u0437\u0430\u0434\u0430\u0447 \u044d\u0442\u043e\u0439 \u0433\u043b\u0430\u0432\u044b \u043e\u0440\u0438\u0435\u043d\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043e \u043d\u0430 \u043e\u0442\u0440\u0430\u0431\u043e\u0442\u043a\u0443 \u043d\u0430\u0432\u044b\u043a\u043e\u0432 \u043f\u043e \u0440\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u043a\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.<br><br>\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0431\u0443\u0434\u0435\u0442 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c\u0441\u044f \u043a\u0430\u043a \u0431\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0430.<br><br>\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e print_hello, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u0438\u043c\u044f \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044f \u0438 \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u043f\u0440\u0438\u0432\u0435\u0442\u0441\u0442\u0432\u0438\u0435 \u0432 \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u044b\u0439 \u043f\u043e\u0442\u043e\u043a \u0432\u044b\u0432\u043e\u0434\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|name = \"world\"<br>print_hello(name)<br>|Hello, world!<br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|string = \"Yandex\"<br>print_hello(string)<br>|Hello, Yandex!<br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def print_hello(name):", " print(f\"Hello, {name}!\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0424\u0443\u043d\u043a\u0446\u0438\u043e\u043d\u0430\u043b\u044c\u043d\u044b\u0439 \u041d\u041e\u0414**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e gcd, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u0434\u0432\u0430 \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u044b\u0445 \u0447\u0438\u0441\u043b\u0430 \u0438 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0438\u0445 \u043d\u0430\u0438\u0431\u043e\u043b\u044c\u0448\u0438\u0439 \u043e\u0431\u0449\u0438\u0439 \u0434\u0435\u043b\u0438\u0442\u0435\u043b\u044c.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = gcd(12, 45)<br>|result = 3<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = gcd(144, 96)<br>|result = 48<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def gcd(a, b):", " while a != b:", " if a > b:", " a -= b", " else:", " b -= a", " return a"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0414\u043b\u0438\u043d\u0430 \u0447\u0438\u0441\u043b\u0430**", "\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e number_length, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u043e\u0434\u043d\u043e \u0446\u0435\u043b\u043e\u0435 \u0447\u0438\u0441\u043b\u043e \u0438 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0435\u0433\u043e \u0434\u043b\u0438\u043d\u0443 \u0431\u0435\u0437 \u0443\u0447\u0451\u0442\u0430 \u0437\u043d\u0430\u043a\u0430.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = number_length(12345)<br>|result = 5<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = number_length(-100500)<br>|result = 6<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def number_length(num):", " res = len(str(num))", " if num < 0:", " res -= 1", " return res"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0418\u043c\u044f of the month**", "\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e month, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u043d\u043e\u043c\u0435\u0440 \u043c\u0435\u0441\u044f\u0446\u0430 \u0438 \u043e\u0431\u043e\u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435 \u044f\u0437\u044b\u043a\u0430 (\"ru\", \"en\") \u0438 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043d\u0430\u0437\u0432\u0430\u043d\u0438\u0435 \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u0433\u043e \u043c\u0435\u0441\u044f\u0446\u0430 \u0432 \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u043c \u044f\u0437\u044b\u043a\u0435 \u0441 \u0437\u0430\u0433\u043b\u0430\u0432\u043d\u043e\u0439 \u0431\u0443\u043a\u0432\u044b.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = month(1, \"en\")<br>|result = 'January'<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = month(7, \"ru\")<br>|result = '\u0418\u044e\u043b\u044c'<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def month(num, lang):", " mths = (", " (\"January\", \"\u042f\u043d\u0432\u0430\u0440\u044c\"),", " (\"February\", \"\u0424\u0435\u0432\u0440\u0430\u043b\u044c\"),", " (\"March\", \"\u041c\u0430\u0440\u0442\"),", " (\"April\", \"\u0410\u043f\u0440\u0435\u043b\u044c\"),", " (\"May\", \"\u041c\u0430\u0439\"),", " (\"June\", \"\u0418\u044e\u043d\u044c\"),", " (\"July\", \"\u0418\u044e\u043b\u044c\"),", " (\"August\", \"\u0410\u0432\u0433\u0443\u0441\u0442\"),", " (\"September\", \"\u0421\u0435\u043d\u0442\u044f\u0431\u0440\u044c\"),", " (\"October\", \"\u041e\u043a\u0442\u044f\u0431\u0440\u044c\"),", " (\"November\", \"\u041d\u043e\u044f\u0431\u0440\u044c\"),", " (\"December\", \"\u0414\u0435\u043a\u0430\u0431\u0440\u044c\")", " )", " if lang == \"en\":", " return mths[num - 1][0]", " else:", " return mths[num - 1][1]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0427\u0438\u0441\u043b\u043e\u0432\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430**", "\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e split_numbers, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u0441\u0442\u0440\u043e\u043a\u0443 \u0446\u0435\u043b\u044b\u0445 \u0447\u0438\u0441\u0435\u043b, \u0440\u0430\u0437\u0434\u0435\u043b\u0451\u043d\u043d\u044b\u0445 \u043f\u0440\u043e\u0431\u0435\u043b\u0430\u043c\u0438, \u0438 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043a\u043e\u0440\u0442\u0435\u0436 \u0438\u0437 \u044d\u0442\u0438\u0445 \u0447\u0438\u0441\u0435\u043b.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.<br><br>\u0412\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u0441\u043f\u0440\u043e\u0441\u0438\u0442\u044c: \u043f\u043e\u0447\u0435\u043c\u0443 \u043a\u043e\u0440\u0442\u0435\u0436, \u0430 \u043d\u0435 \u0441\u043f\u0438\u0441\u043e\u043a. \u0412\u0441\u0451 \u0434\u0435\u043b\u043e \u0432 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438. \u041a\u043e\u0440\u0442\u0435\u0436\u0438 \u043d\u0435\u0438\u0437\u043c\u0435\u043d\u044f\u0435\u043c\u044b\u0435 \u043a\u043e\u043b\u043b\u0435\u043a\u0446\u0438\u0438 \u0438 \u0438\u0445 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u0435\u0435 \u043f\u0435\u0440\u0435\u0434\u0430\u0432\u0430\u0442\u044c \u0432 \u0444\u0443\u043d\u043a\u0446\u0438\u044e \u0438\u043b\u0438 \u0438\u0437 \u043d\u0435\u0451.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = split_numbers(\"1 2 3 4 5\")<br>|result = (1, 2, 3, 4, 5)<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = split_numbers(\"1 -2 3 -4 5\")<br>|result = (1, -2, 3, -4, 5)<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def split_numbers(string):", " return tuple(map(int, string.split()))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041c\u043e\u0434\u0435\u0440\u043d\u0438\u0437\u0430\u0446\u0438\u044f \u0441\u0438\u0441\u0442\u0435\u043c\u044b \u0432\u044b\u0432\u043e\u0434\u0430**", "\u0420\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0430\u0439\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e modern_print, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u0441\u0442\u0440\u043e\u043a\u0443 \u0438 \u0432\u044b\u0432\u043e\u0434\u0438\u0442 \u0435\u0451, \u0435\u0441\u043b\u0438 \u043e\u043d\u0430 \u043d\u0435 \u0431\u044b\u043b\u0430 \u0432\u044b\u0432\u0435\u0434\u0435\u043d\u0430 \u0440\u0430\u043d\u0435\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|modern_print(\"Hello!\")<br>modern_print(\"Hello!\")<br>modern_print(\"How do you do?\")<br>modern_print(\"Hello!\")<br>|Hello!<br>How do you do?<br> <br> <br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|modern_print(\"\u0410\u043b\u043e!\")<br>modern_print(\"\u0410\u043b\u043e!\")<br>modern_print(\"\u042f \u0442\u0435\u0431\u044f \u043d\u0435 \u0441\u043b\u044b\u0448\u0443\")<br>modern_print(\"\u0410\u043b\u043e!\")<br>modern_print(\"\u0410\u043b\u043e!\")<br>modern_print(\"\u041f\u043e\u0437\u0432\u043e\u043d\u0438 \u043a\u043e\u0433\u0434\u0430 \u0441\u043c\u043e\u0436\u0435\u0448\u044c\")<br>modern_print(\"\u041f\u043e\u0437\u0432\u043e\u043d\u0438 \u043a\u043e\u0433\u0434\u0430 \u0441\u043c\u043e\u0436\u0435\u0448\u044c\")<br>modern_print(\"\u042f \u0442\u0435\u0431\u044f \u043d\u0435 \u0441\u043b\u044b\u0448\u0443\")<br>|\u0410\u043b\u043e!<br>\u042f \u0442\u0435\u0431\u044f \u043d\u0435 \u0441\u043b\u044b\u0448\u0443<br>\u041f\u043e\u0437\u0432\u043e\u043d\u0438 \u043a\u043e\u0433\u0434\u0430 \u0441\u043c\u043e\u0436\u0435\u0448\u044c<br> <br> <br> <br> <br> <br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def modern_print(string, messages=set()):", " if string not in messages:", " print(string)", " messages.add(string)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0428\u0430\u0445\u043c\u0430\u0442\u043d\u044b\u0439 \u00ab\u043e\u0431\u0435\u0434\u00bb**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e can_eat, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u043f\u043e\u043b\u043e\u0436\u0435\u043d\u0438\u0435 \u043a\u043e\u043d\u044f \u0438 \u0434\u0440\u0443\u0433\u043e\u0439 \u0444\u0438\u0433\u0443\u0440\u044b \u0432 \u0432\u0438\u0434\u0435 \u043a\u043e\u0440\u0442\u0435\u0436\u0435\u0439 \u0438\u0437 \u0434\u0432\u0443\u0445 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442, \u0430 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0431\u0443\u043b\u0435\u0432\u043e \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435: True \u0435\u0441\u043b\u0438 \u043a\u043e\u043d\u044c \u0441\u044a\u0435\u0434\u0430\u0435\u0442 \u0444\u0438\u0433\u0443\u0440\u0443 \u0438 False \u0438\u043d\u0430\u0447\u0435.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = can_eat((2, 1), (4, 2))<br>|result = True<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = can_eat((5, 5), (6, 6))<br>|result = False<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def can_eat(h, f):", " return (abs(h[0] - f[0]) == 1 and abs(h[1] - f[1]) == 2) or \\", " (abs(h[0] - f[0]) == 2 and abs(h[1] - f[1]) == 1)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0410 \u0440\u043e\u0437\u0430 \u0443\u043f\u0430\u043b\u0430 \u043d\u0430 \u043b\u0430\u043f\u0443 \u0410\u0437\u043e\u0440\u0430 7.0**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e is_palindrome, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e, \u0441\u0442\u0440\u043e\u043a\u0443, \u043a\u043e\u0440\u0442\u0435\u0436 \u0438\u043b\u0438 \u0441\u043f\u0438\u0441\u043e\u043a, \u0430 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043b\u043e\u0433\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435: True \u2014 \u0435\u0441\u043b\u0438 \u043f\u0435\u0440\u0435\u0434\u0430\u043d \u043f\u0430\u043b\u0438\u043d\u0434\u0440\u043e\u043c, \u0430 \u0432 \u043f\u0440\u043e\u0442\u0438\u0432\u043d\u043e\u043c \u0441\u043b\u0443\u0447\u0430\u0435 \u2014 False.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.<br><br>\u0414\u043b\u044f \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u0438\u044f \u0442\u0438\u043f\u0430 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u0430 \u043c\u043e\u0436\u043d\u043e \u0432\u043e\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c\u0441\u044f \u0444\u0443\u043d\u043a\u0446\u0438\u0435\u0439 type \u0438\u043b\u0438 \u0431\u043e\u043b\u0435\u0435 \u043f\u0440\u043e\u0434\u0432\u0438\u043d\u0443\u0442\u043e\u0439 isinstance.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = is_palindrome(123)<br>|result = False<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = is_palindrome([1, 2, 1, 2, 1])<br>|result = True<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def is_palindrome(data):", " if type(data) is int:", " data = str(data)", " return (data == data[::-1])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u041f\u0440\u043e\u0441\u0442\u0430\u044f \u0437\u0430\u0434\u0430\u0447\u0430 5.0**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e is_prime, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u043d\u0430\u0442\u0443\u0440\u0430\u043b\u044c\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e, \u0430 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0431\u0443\u043b\u0435\u0432\u043e \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435: True \u2014 \u0435\u0441\u043b\u0438 \u043f\u0435\u0440\u0435\u0434\u0430\u043d\u043d\u043e\u0435 \u0447\u0438\u0441\u043b\u043e \u043f\u0440\u043e\u0441\u0442\u043e\u0435, \u0430 \u0438\u043d\u0430\u0447\u0435 \u2014 False.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = is_prime(1001459)<br>|result = True<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = is_prime(79701)<br>|result = False<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def is_prime(num):", " f = True", " for i in range(2, int(num ** 0.5) + 1):", " if (num % i == 0):", " f = False", " break", " return f"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## **\u0421\u043b\u0438\u044f\u043d\u0438\u0435**", "\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u044e merge, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u0434\u0432\u0430 \u043e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0445 \u043f\u043e \u0432\u043e\u0437\u0440\u0430\u0441\u0442\u0430\u043d\u0438\u044e \u043a\u043e\u0440\u0442\u0435\u0436\u0430 \u0446\u0435\u043b\u044b\u0445 \u0447\u0438\u0441\u0435\u043b, \u0430 \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043e\u0434\u0438\u043d \u0438\u0437 \u0432\u0441\u0435\u0445 \u043f\u0435\u0440\u0435\u0434\u0430\u043d\u043d\u044b\u0445 \u0447\u0438\u0441\u0435\u043b.", "### **\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435**", "\u0412\u0430\u0448\u0435 \u0440\u0435\u0448\u0435\u043d\u0438\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u0444\u0443\u043d\u043a\u0446\u0438\u0438.<br>\u0412 \u0440\u0435\u0448\u0435\u043d\u0438\u0438 \u043d\u0435 \u0434\u043e\u043b\u0436\u043d\u043e \u0431\u044b\u0442\u044c \u0432\u044b\u0437\u043e\u0432\u043e\u0432 \u0442\u0440\u0435\u0431\u0443\u0435\u043c\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439.<br>\u0412 \u044d\u0442\u043e\u0439 \u0437\u0430\u0434\u0430\u0447\u0435 \u043e\u0442\u043a\u043b\u044e\u0447\u0435\u043d\u044b \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u044b\u0435 \u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u043a\u0438", "### **\u041f\u0440\u0438\u043c\u0435\u0440 1**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = merge((1, 2), (3, 4, 5))<br>|result = (1, 2, 3, 4, 5)<br>|", "### **\u041f\u0440\u0438\u043c\u0435\u0440 2**", "|\u0412\u0432\u043e\u0434 |\u0412\u044b\u0432\u043e\u0434|", "|-----|-----|", "|result = merge((7, 12), (1, 9, 50))<br>|result = (1, 7, 9, 12, 50)<br>|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def merge(nums1, nums2):", " res = []", " nums1, nums2 = map(list, [nums1, nums2])", " while nums1 or nums2:", " if not nums1:", " res.append(nums2[0])", " del nums2[0]", " elif not nums2:", " res.append(nums1[0])", " del nums1[0]", " else:", " if nums1[0] < nums2[0]:", " res.append(nums1[0])", " del nums1[0]", " else:", " res.append(nums2[0])", " del nums2[0]", " return tuple(res)"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"name": "python", "version": "3.11.1"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/4.1/5.py b/4.1/5.py
deleted file mode 100644
index b61df10236527640cc847588dd3ac9a6fff4e4a7..0000000000000000000000000000000000000000
--- a/4.1/5.py
+++ /dev/null
@@ -1,2 +0,0 @@
-def split_numbers(string):
- return tuple(map(int, string.split()))
\ No newline at end of file
diff --git a/4.1/6.py b/4.1/6.py
deleted file mode 100644
index e0370e04f59d23d97a4b386d3e2d37d82eb2d07e..0000000000000000000000000000000000000000
--- a/4.1/6.py
+++ /dev/null
@@ -1,4 +0,0 @@
-def modern_print(string, messages=set()):
- if string not in messages:
- print(string)
- messages.add(string)
\ No newline at end of file
diff --git a/4.1/7.py b/4.1/7.py
deleted file mode 100644
index 355d2acbaf05526e0f5c13fe430a93032ffec021..0000000000000000000000000000000000000000
--- a/4.1/7.py
+++ /dev/null
@@ -1,3 +0,0 @@
-def can_eat(h, f):
- return (abs(h[0] - f[0]) == 1 and abs(h[1] - f[1]) == 2) or \
- (abs(h[0] - f[0]) == 2 and abs(h[1] - f[1]) == 1)
\ No newline at end of file
diff --git a/4.1/8.py b/4.1/8.py
deleted file mode 100644
index c9dca5be28075adecaa438e3b89760481358e11f..0000000000000000000000000000000000000000
--- a/4.1/8.py
+++ /dev/null
@@ -1,4 +0,0 @@
-def is_palindrome(data):
- if type(data) is int:
- data = str(data)
- return (data == data[::-1])
\ No newline at end of file
diff --git a/4.1/9.py b/4.1/9.py
deleted file mode 100644
index 808fab9332668e587168ba727ec367d5b56294bc..0000000000000000000000000000000000000000
--- a/4.1/9.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def is_prime(num):
- f = True
- for i in range(2, int(num ** 0.5) + 1):
- if (num % i == 0):
- f = False
- break
- return f
\ No newline at end of file
diff --git a/4.2/1.py b/4.2/1.py
deleted file mode 100644
index a1c8913d8d061b90d29914427631b0eec183182c..0000000000000000000000000000000000000000
--- a/4.2/1.py
+++ /dev/null
@@ -1,2 +0,0 @@
-def make_list(length, value=0):
- return [value] * length
\ No newline at end of file
diff --git a/4.2/10.py b/4.2/10.py
deleted file mode 100644
index 9d2c8b4d41a77da4a993f71b20b4d27cf7810cbd..0000000000000000000000000000000000000000
--- a/4.2/10.py
+++ /dev/null
@@ -1,14 +0,0 @@
-def secret_replace(text, **replaces):
- counter = {k: 0 for k in replaces.keys()}
- while True:
- f = False
- for k in replaces.keys():
- if k in text:
- text = text.replace(k, replaces[k][counter[k]], 1)
- if counter[k] >= len(replaces[k]) - 1:
- counter[k] = -1
- counter[k] += 1
- f = True
- if not f:
- break
- return text
\ No newline at end of file
diff --git a/4.2/2.py b/4.2/2.py
deleted file mode 100644
index 6e08d9bb221a5964a48f860fc24681dd9b08aade..0000000000000000000000000000000000000000
--- a/4.2/2.py
+++ /dev/null
@@ -1,5 +0,0 @@
-def make_matrix(size, value=0):
- if type(size) is int:
- return [[value] * size for _ in range(size)]
- else:
- return [[value] * size[0] for _ in range(size[1])]
\ No newline at end of file
diff --git a/4.2/3.py b/4.2/3.py
deleted file mode 100644
index 46056814a7b2bf7f710c32899a9ad71b6f4578f3..0000000000000000000000000000000000000000
--- a/4.2/3.py
+++ /dev/null
@@ -1,12 +0,0 @@
-def gcd(*nums):
- nums = list(nums)
- for i in range(len(nums) - 1):
- a, b = nums[i], nums[i + 1]
- while a != b:
- if a > b:
- a -= b
- else:
- b -= a
- nums[i + 1] = a
-
- return nums[-1]
\ No newline at end of file
diff --git a/4.2/4.py b/4.2/4.py
deleted file mode 100644
index 355c44325ce7ce0d277fa58fcfafdb3b4419943c..0000000000000000000000000000000000000000
--- a/4.2/4.py
+++ /dev/null
@@ -1,19 +0,0 @@
-def month(num, lang="ru"):
- mths = (
- ("January", "Январь"),
- ("February", "Февраль"),
- ("March", "Март"),
- ("April", "Апрель"),
- ("May", "Май"),
- ("June", "РСЋРЅСЊ"),
- ("July", "Рюль"),
- ("August", "РђРІРіСѓСЃС‚"),
- ("September", "Сентябрь"),
- ("October", "Октябрь"),
- ("November", "РќРѕСЏР±СЂСЊ"),
- ("December", "Декабрь")
- )
- if lang == "en":
- return mths[num - 1][0]
- else:
- return mths[num - 1][1]
\ No newline at end of file
diff --git a/4.2/5.py b/4.2/5.py
deleted file mode 100644
index 1a005a21192a64e927c1d5aae981a594c8ff3964..0000000000000000000000000000000000000000
--- a/4.2/5.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def to_string(*nums, sep=" ", end="\n"):
- res = ''
- for i in range(len(nums)):
- res += str(nums[i])
- if i != len(nums) - 1:
- res += sep
- return res + end
\ No newline at end of file
diff --git a/4.2/6.py b/4.2/6.py
deleted file mode 100644
index 4ff82503f98015e2c0d49070b86b514979ffd9db..0000000000000000000000000000000000000000
--- a/4.2/6.py
+++ /dev/null
@@ -1,24 +0,0 @@
-def order(*names):
- global in_stock
- res = ""
- message = "К сожалению, не можем предложить Вам напиток"
- d = {
- "Рспрессо": {"coffee": 1},
- "Капучино": {"coffee": 1, "milk": 3},
- "Макиато": {"coffee": 2, "milk": 1},
- "Кофе по-венски": {"coffee": 1, "cream": 2},
- "Латте Макиато": {"coffee": 1, "milk": 2, "cream": 1},
- "Кон Панна": {"coffee": 1, "cream": 1}
- }
-
- for cof in names:
- f = True
- for k in d[cof].keys():
- if d[cof][k] > in_stock[k]:
- f = False
- if f:
- for k in d[cof].keys():
- in_stock[k] -= d[cof][k]
- message = cof
- break
- return message
\ No newline at end of file
diff --git a/4.2/7.py b/4.2/7.py
deleted file mode 100644
index 56ea2338b3cc11e4074986f29d7dec3f122267fb..0000000000000000000000000000000000000000
--- a/4.2/7.py
+++ /dev/null
@@ -1,23 +0,0 @@
-def enter_results(*enter, nums=[]):
- nums += list(enter)
- return nums
-
-
-def get_sum():
- sum1, sum2 = 0, 0
- for n in enter_results()[::2]:
- sum1 += n
- for n in enter_results()[1::2]:
- sum2 += n
- return sum1, sum2
-
-
-def get_average():
- sum1, l1, sum2, l2 = 0, 0, 0, 0
- for n in enter_results()[::2]:
- sum1 += n
- l1 += 1
- for n in enter_results()[1::2]:
- sum2 += n
- l2 += 1
- return sum1 / l1, sum2 / l2
\ No newline at end of file
diff --git a/4.2/8.py b/4.2/8.py
deleted file mode 100644
index d9c8d3294599490889b5c540160eabcb409dac54..0000000000000000000000000000000000000000
--- a/4.2/8.py
+++ /dev/null
@@ -1 +0,0 @@
-lambda word: (len(word), word.lower())
\ No newline at end of file
diff --git a/4.2/9.py b/4.2/9.py
deleted file mode 100644
index 1e1fe4f693a579accc4bcc3cb18097aeaacd664f..0000000000000000000000000000000000000000
--- a/4.2/9.py
+++ /dev/null
@@ -1 +0,0 @@
-lambda num: sum(map(int, str(num))) % 2 == 0
\ No newline at end of file
diff --git a/4.3/1.py b/4.3/1.py
deleted file mode 100644
index ac054b6ac4a2d6021e8ee2376d72ac20cf84b61b..0000000000000000000000000000000000000000
--- a/4.3/1.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def recursive_sum(*nums):
- nums = list(nums)
- if nums:
- return nums[-1] + recursive_sum(*nums[:-1])
- else:
- return 0
\ No newline at end of file
diff --git a/4.3/10.py b/4.3/10.py
deleted file mode 100644
index 5fb3cb1e7ad42365ff3efbd796d019ac7564d5fc..0000000000000000000000000000000000000000
--- a/4.3/10.py
+++ /dev/null
@@ -1,9 +0,0 @@
-def make_linear(ldata):
- if type(ldata) is not list:
- return ldata
- i = 0
- while i != len(ldata):
- if type(ldata[i]) is list:
- ldata = ldata[:i] + make_linear(ldata[i]) + ldata[i + 1:]
- i += 1
- return ldata
\ No newline at end of file
diff --git a/4.3/2.py b/4.3/2.py
deleted file mode 100644
index 6828e8b918080aa1e20ad95121e0a7823e56b285..0000000000000000000000000000000000000000
--- a/4.3/2.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def recursive_digit_sum(nums):
- if type(nums) is int:
- nums = list(str(nums))
- if nums:
- return int(nums[-1]) + recursive_digit_sum(nums[:-1])
- else:
- return 0
\ No newline at end of file
diff --git a/4.3/3.py b/4.3/3.py
deleted file mode 100644
index 2ec6c490da8ce89f74f121858e849a055100fadd..0000000000000000000000000000000000000000
--- a/4.3/3.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def make_equation(*nums):
- nums = list(nums)
- if len(nums) > 1:
- return f"({make_equation(*nums[:-1])}) * x + {nums[-1]}"
- else:
- return nums[-1]
\ No newline at end of file
diff --git a/4.3/4.py b/4.3/4.py
deleted file mode 100644
index 0239b4090481fea5135fcdbb087dc69412864261..0000000000000000000000000000000000000000
--- a/4.3/4.py
+++ /dev/null
@@ -1,4 +0,0 @@
-def answer(f):
- def add_result(*args, **kwargs):
- return f"Результат функции: {f(*args, **kwargs)}"
- return add_result
\ No newline at end of file
diff --git a/4.3/5.py b/4.3/5.py
deleted file mode 100644
index e9db51278df18b768f2c3765f2026981a55b5655..0000000000000000000000000000000000000000
--- a/4.3/5.py
+++ /dev/null
@@ -1,14 +0,0 @@
-def result_accumulator(f):
- res_list = []
-
- def decorator(*args, method="accumulate"):
- nonlocal res_list
- res_list.append(f(*args))
- if method == "drop":
- a = res_list.copy()
- res_list = []
- return a
- else:
- return None
-
- return decorator
\ No newline at end of file
diff --git a/4.3/6.py b/4.3/6.py
deleted file mode 100644
index 3056bfe08164c08afbdd734c2aee53397e01113d..0000000000000000000000000000000000000000
--- a/4.3/6.py
+++ /dev/null
@@ -1,24 +0,0 @@
-def merge_sort(lnum):
- if len(lnum) > 1:
- return merge(merge_sort(lnum[:len(lnum) // 2]), merge_sort(lnum[len(lnum) // 2:]))
- else:
- return lnum
-
-
-def merge(nums1, nums2):
- res = []
- while nums1 or nums2:
- if not nums1:
- res.append(nums2[0])
- del nums2[0]
- elif not nums2:
- res.append(nums1[0])
- del nums1[0]
- else:
- if nums1[0] < nums2[0]:
- res.append(nums1[0])
- del nums1[0]
- else:
- res.append(nums2[0])
- del nums2[0]
- return res
\ No newline at end of file
diff --git a/4.3/7.py b/4.3/7.py
deleted file mode 100644
index 114b676f52aef0f595954b8a82efd6da1cf72f0f..0000000000000000000000000000000000000000
--- a/4.3/7.py
+++ /dev/null
@@ -1,9 +0,0 @@
-def same_type(func):
- def checker(*args):
- for i in range(len(args) - 1):
- if type(args[i]) is not type(args[i + 1]):
- print("Обнаружены различные типы данных")
- break
- else:
- return func(*args)
- return checker
\ No newline at end of file
diff --git a/4.3/8.py b/4.3/8.py
deleted file mode 100644
index 652d06cf35ec2164d385dda0f2137388f0244084..0000000000000000000000000000000000000000
--- a/4.3/8.py
+++ /dev/null
@@ -1,5 +0,0 @@
-def fibonacci(n):
- a, b = 0, 1
- for _ in range(n):
- yield a
- a, b = b, a + b
\ No newline at end of file
diff --git a/4.3/9.py b/4.3/9.py
deleted file mode 100644
index 2f13b40e88f706bd224367d3b2027d87d86a5dee..0000000000000000000000000000000000000000
--- a/4.3/9.py
+++ /dev/null
@@ -1,5 +0,0 @@
-def cycle(lnums):
- c = 0
- while True:
- yield lnums[c % len(lnums)]
- c += 1
\ No newline at end of file
diff --git a/4.4/1.py b/4.4/1.py
deleted file mode 100644
index 154b10296bbd534a2f8fdda17befbfe921e512ba..0000000000000000000000000000000000000000
--- a/4.4/1.py
+++ /dev/null
@@ -1,2 +0,0 @@
-def print_weather(wind, temperature):
- print(f"За окном дует ветер со скоростью {wind} м/с. Температура воздуха {temperature}°C.")
\ No newline at end of file
diff --git a/4.4/2.py b/4.4/2.py
deleted file mode 100644
index a76dc707524ed416acca7eb8a5ec1abf201e776a..0000000000000000000000000000000000000000
--- a/4.4/2.py
+++ /dev/null
@@ -1,12 +0,0 @@
-def add_number(num, f=True, lnums=[]):
- if f:
- lnums.append(num)
- return lnums
-
-
-def get_prod():
- lnums = add_number(0, f=False)
- mult = 1
- for num in lnums:
- mult *= num
- return " * ".join(map(str, lnums)) + f" = {mult}"
\ No newline at end of file
diff --git a/4.4/3.py b/4.4/3.py
deleted file mode 100644
index 0aa7df060ddf36c112b3800f77aae0844b34481f..0000000000000000000000000000000000000000
--- a/4.4/3.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def count_pairs(*numbers, div=10):
- count = 0
- for i in range(len(numbers) - 1):
- for j in range(i + 1, len(numbers)):
- if (numbers[i] + numbers[j]) % div == 0:
- count += 1
- return count
\ No newline at end of file
diff --git a/4.4/4.py b/4.4/4.py
deleted file mode 100644
index 50e2cb5fbdc6f4bad35b84f0e9f16d63589bfc78..0000000000000000000000000000000000000000
--- a/4.4/4.py
+++ /dev/null
@@ -1,11 +0,0 @@
-def index(text):
- s = set(text)
- delete = []
- for sim in s:
- if not sim.isalpha():
- delete.append(sim)
- for sim in delete:
- s.remove(sim)
- s = sorted(list(s))
- for let in s:
- yield let, text.index(let)
\ No newline at end of file
diff --git a/4.4/5.py b/4.4/5.py
deleted file mode 100644
index 7783de2a698f25cc5cc111f4a022fc56def15625..0000000000000000000000000000000000000000
--- a/4.4/5.py
+++ /dev/null
@@ -1,26 +0,0 @@
-def bunny(start, finish, length, way=[]):
- if not way:
- way = [start]
- if length == 0 and start == finish:
- return way
- elif length == 0 and start != finish:
- return way + [None]
- elif length != 0 and start == finish:
- return way + [None]
- else:
- ways = [bunny(start + 1, finish, length - 1, way=way + [start + 1]),
- bunny(start - 1, finish, length - 1, way=way + [start - 1]),
- bunny(start + 3, finish, length - 1, way=way + [start + 3]),
- bunny(start - 3, finish, length - 1, way=way + [start - 3])]
- nways = []
- for w1 in ways:
- if not w1:
- continue
- if type(w1[0]) is list:
- for w2 in w1:
- if w2[-1] is not None:
- nways.append(w2)
- else:
- if w1[-1] is not None:
- nways.append(w1)
- return nways
\ No newline at end of file
diff --git a/README.md b/README.md
index ae1f3a6bfafe22e01a352fa36505b79bb1ba0224..286b48275c25a861f72e1ac4f7f134cd226ea16b 100644
--- a/README.md
+++ b/README.md
@@ -1,93 +1,17 @@
-# Pythonlabs
-
-
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.mai.ru/ASZelenov/pythonlabs.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.mai.ru/ASZelenov/pythonlabs/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+Текстовый процессор представлен двумя файлами .py, первый обрабатывает один markdown. Для этого:
+1. В файл md1.txt необходимо скопировать всё условие задачи из яндекс лмс, включая таблицу
+2. Дописать в новой строке тип деления строк по столбцам в таблицах примеров. Если нужно, чтобы в первой колонке было N элементов, пишем N. Если нужно N элементов во второй, пишем -N, если Не нужно деление по столбцами, пишем _, тогда всё будет записываться в первую колонку.
+3. Запустить файл text_processor.py
+4. Скопировать обработанный текст из файла md1.txt
+5. Вставить текст в markdown
+
+Второй файл .py подходит для оформления всего файла ipynb. Для этого:
+1. В файл md1.txt необходимо скопировать условия задачи и python код
+2. Перед условием, необходимо на отдельной строке записать /md
+3. Для условия выполнить пункт 2 из первого списка
+4. После на отдельной строке написать /py и на следующей вставить python код
+5. На выходе создастся файл output.ipynb
+ВАЖНО: на данный момент обязательно записывать сначало условие, потом код
+Примечание 1: так как я немного криво пишу, текстовых файлах записаны примеры
+Примечание 2: на данный момент текстовый процессор некорректно работает с математическими выражениями типо 2<=N<=9, так что это необходимо исправлять вручную
+Примечание 3: впринципе стоит проверять текст на выходе
\ No newline at end of file
diff --git a/makefiles.py b/makefiles.py
deleted file mode 100644
index ff64a00fc4aab35064e14a9829045c31522119bf..0000000000000000000000000000000000000000
--- a/makefiles.py
+++ /dev/null
@@ -1,3 +0,0 @@
-for i in range(1, 6):
- file = open(f"4.4/{i}.py", 'w+')
- file.close()
\ No newline at end of file
diff --git a/md.txt b/md.txt
index d56232567fbfff75c14617f23b9c26a7e369d3c4..445767d4b91bde103ba6a9477ae1edfe913c6a9e 100644
--- a/md.txt
+++ b/md.txt
@@ -1,414 +1,38 @@
-/md
-Генератор списков
+Просто здравствуй, просто как дела
Ограничение времени 1 секунда
Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Большинство задач этой главы ориентировано на отработку навыков по разработке функций.
+Ввод стандартный ввод или input.txt
+Вывод стандартный вывод или output.txt
+Умение вести диалог — важный навык для воспитанного человека.
-Ваше решение будет использоваться как библиотека.
+Напишите диалоговую программу, которая сначала познакомится с пользователем, а затем поинтересуется его настроением.
-Напишите функцию make_list, которая создаёт, заполняет и возвращает список заданного размера.
+Формат ввода
+В первой строке записано имя пользователя.
+Во второй — ответ на вопрос: «хорошо» или «плохо».
-Параметры функции:
-
-length — требуемая длина списка;
-value — значение элементов списка (по-умолчанию 0).
-Примечание
-Ваше решение должно содержать только функции.
-В решении не должно быть вызовов требуемых функций.
-
-Пример 1
-Ввод Вывод
-result = make_list(3)
-result = [0, 0, 0]
-Пример 2
-Ввод Вывод
-result = make_list(5, 1)
-result = [1, 1, 1, 1, 1]
-1
-/md
-Генератор матриц
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Напишите функцию make_matrix, которая создаёт, заполняет и возвращает матрицу заданного размера.
-
-Параметры функции:
-
-size — кортеж (ширина, высота) или одно число (для создания квадратной матрицы);
-value — значение элементов списка (по-умолчанию 0).
-Примечание
-Ваше решение должно содержать только функции.
-В решении не должно быть вызовов требуемых функций.
-
-Пример 1
-Ввод Вывод
-result = make_matrix(3)
-result = [
- [0, 0, 0],
- [0, 0, 0],
- [0, 0, 0]
-]
-Пример 2
-Ввод Вывод
-result = make_matrix((4, 2), 1)
-result = [
- [1, 1, 1, 1],
- [1, 1, 1, 1]
-]
-1
-/md
-Функциональный нод 2.0
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Напишите функцию gcd, которая вычисляет наибольший общий делитель последовательности чисел.
-Параметрами функции выступают натуральные числа в произвольном количестве, но не менее одного.
-
-Примечание
-Ваше решение должно содержать только функции.
-В решении не должно быть вызовов требуемых функций.
-
-Пример 1
-Ввод Вывод
-result = gcd(3)
-result = 3
-Пример 2
-Ввод Вывод
-result = gcd(36, 48, 156, 100500)
-result = 12
-1
-/md
-РРјСЏ of the month 2.0
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Разработайте функцию month, которая возвращает название заданного месяца с заглавной буквы. Функция должна принимать номер месяца и дополнительно обозначение языка (по умолчанию "ru").
-
-Примечание
-Ваше решение должно содержать только функции.
-В решении не должно быть вызовов требуемых функций.
-
-Пример 1
-Ввод Вывод
-result = month(1, "en")
-result = 'January'
-Пример 2
-Ввод Вывод
-result = month(7)
-result = 'Рюль'
-1
-/md
-Подготовка данных
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Напишите функцию to_string, которая формирует из последовательности данных строку.
-Функция должна принимать:
-
-неопределённое количество данных;
-необязательный параметр sep (по умолчанию пробел);
-необязательный параметр end (по умолчанию \n).
-Примечание
-Ваше решение должно содержать только функции.
-В решении не должно быть вызовов требуемых функций.
-
-Пример 1
-Ввод Вывод
-result = to_string(1, 2, 3)
-result = '1 2 3\n'
-Пример 2
-Ввод Вывод
-data = [7, 3, 1, "hello", (1, 2, 3)]
-result = to_string(*data, sep=", ", end="!")
-result = '7, 3, 1, hello, (1, 2, 3)!'
--1
-/md
-Кофейня
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Руководство местной кофейни для программистов под названием Java-0x00 решило модернизировать систему заказа кофе.
-
-Для этого им требуется реализовать функцию order, которая принимает список предпочтений посетителя в порядке «убывания желания».
-
-Согласно положению, каждый напиток в кофейне строго определён рецептом:
-
-Рспрессо готовится РёР·: 1 порции кофейных зерен.
-Капучино готовится из: 1 порции кофейных зерен и 3 порций молока.
-Макиато готовится из: 2 порций кофейных зерен и 1 порции молока.
-Кофе по-венски готовится из: 1 порции кофейных зерен и 2 порций взбитых сливок.
-Латте Макиато готовится из: 1 порции кофейных зерен, 2 порций молока и 1 порции взбитых сливок.
-Кон Панна готовится из: 1 порции кофейных зерен и 1 порции взбитых сливок.
-В глобальной переменной in_stock содержится словарь, описывающий ингредиенты в наличии. Ключи словаря: coffee, cream, milk.
-
-Функция должна вернуть:
-
-название напитка, который будет приготовлен;
-сообщение «К сожалению, не можем предложить Вам напиток», если ни одно из предпочтений не может быть приготовлено.
-Если заказ, может быть совершён, количество доступных ингредиентов должно соответствующим образом уменьшиться.
-
-Примечание
-В решении не должно быть вызовов требуемых функций.
-
-Пример 1
-Ввод Вывод
-in_stock = {"coffee": 1, "milk": 2, "cream": 3}
-print(order("Рспрессо", "Капучино", "Макиато", "Кофе РїРѕ-венски", "Латте Макиато", "РљРѕРЅ Панна"))
-print(order("Рспрессо", "Капучино", "Макиато", "Кофе РїРѕ-венски", "Латте Макиато", "РљРѕРЅ Панна"))
-Рспрессо
-К сожалению, не можем предложить Вам напиток
-Пример 2
-Ввод Вывод
-in_stock = {"coffee": 4, "milk": 4, "cream": 0}
-print(order("Капучино", "Макиато", "Рспрессо"))
-print(order("Капучино", "Макиато", "Рспрессо"))
-print(order("Капучино", "Макиато", "Рспрессо"))
-Капучино
-Макиато
-Рспрессо
-3 4
-/md
-Р’ эфире СЂСѓР±СЂРёРєР° В«Рксперименты»
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Лаборанты проводят эксперимент и запросили разработку системы обработки данных. Результатами эксперимента должны стать пары рациональных чисел.
-
-Для работы им требуются функции:
-
-enter_results(first, second, ...) — добавление данных одного или нескольких результатов (гарантируется, что количество параметров будет чётным);
-get_sum() — возвращает пару сумм результатов экспериментов;
-get_average() — возвращает пару средних арифметических значений результатов экспериментов.
-Все вычисления производятся с точностью до сотых.
-
-Примечание
-В решении не должно быть вызовов требуемых функций.
+Формат вывода
+В первой строке должен быть вопрос «Как Вас зовут?»
+Во второй строке — «Здравствуйте, %username%!»
+В третьей строке — вопрос «Как дела?»
+В четвёртой строке реакция на ответ пользователя:
+если пользователь ответил «хорошо», следует вывести сообщение «Я за вас рада!»;
+если пользователь ответил «плохо», следует вывести сообщение «Всё наладится!».
Пример 1
Ввод Вывод
-enter_results(1, 2, 3, 4, 5, 6)
-print(get_sum(), get_average())
-enter_results(1, 2)
-print(get_sum(), get_average())
-(9, 12) (3.0, 4.0)
-(10, 14) (2.5, 3.5)
+РђРЅСЏ
+хорошо
+Как Вас зовут?
+Здравствуйте, Аня!
+Как дела?
+Я за вас рада!
Пример 2
Ввод Вывод
-enter_results(3.5, 2.14, 45.2, 37.99)
-print(get_sum(), get_average())
-enter_results(5.2, 7.3)
-print(get_sum(), get_average())
-enter_results(1.23, 4.56, 3.14, 2.71, 0, 0)
-print(get_sum(), get_average())
-(48.7, 40.13) (24.35, 20.07)
-(53.9, 47.43) (17.97, 15.81)
-(58.27, 54.7) (9.71, 9.12)
-4 6
-/md
-Длинная сортировка
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Напишите lambda выражение для сортировки списка слов сначала по длине, а затем по алфавиту без учёта регистра.
-
-Примечание
-В решении не должно быть ничего, кроме выражения.
-
-Пример 1
-Ввод Вывод
-string = 'мама мыла раму'
-print(sorted(string.split(), key=<ваше выражение>))
-['мама', 'мыла', 'раму']
-Пример 2
-Ввод Вывод
-string = 'Яндекс использует Python во многих проектах'
-print(sorted(string.split(), key=<ваше выражение>))
-['во', 'Python', 'многих', 'Яндекс', 'проектах', 'использует']
--1
-/md
-Чётная фильтрация
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Напишите lambda выражение для фильтрации чисел с чётной суммой цифр.
-
-Примечание
-В решении не должно быть ничего, кроме выражения.
-
-Пример 1
-Ввод Вывод
-print(*filter(<ваше выражение>, (1, 2, 3, 4, 5)))
-2 4
-Пример 2
-Ввод Вывод
-print(*filter(<ваше выражение>, (32, 64, 128, 256, 512)))
-64 512
-1
-/md
-Ключевой секрет
-Ограничение времени 1 секунда
-Ограничение памяти 64.0 Мб
-Ввод стандартный ввод
-Вывод стандартный вывод
-Вася любит секреты и шифрование. Он часто пользуется шифром на основе замен и просит разработать вас функцию, которая позволит ему быстро шифровать сообщения.
-
-Напишите функцию secret_replace(text, **replaces), которая принимает:
-
-текст требующий шифрования;
-именованные аргументы — правила замен, представляющие собой кортежи из одного или нескольких значений.
-Функция должна вернуть зашифрованный текст.
-
-Примечание
-Ваше решение должно содержать только функции.
-В решении не должно быть вызовов требуемых функций.
-
-Обратите внимание, что позиционный аргумент требуемой функции не должен иметь однобуквенного имени. Для понимания ошибки исследуйте следующих код:
-
-def func(a, **b):
- ...
-
-func(1, **{'a': 2})
-Пример 1
-Ввод Вывод
-result = secret_replace("Hello, world!", l=("hi", "y"), o=("123", "z"))
-result = 'Hehiy123, wzrhid!'
-Пример 2
-Ввод Вывод
-result = secret_replace(
- "ABRA-KADABRA",
- A=("Z", "1", "!"),
- B=("3",),
- R=("X", "7"),
- K=("G", "H"),
- D=("0", "2"),
-)
-result = 'Z3X1-G!0Z371'
--1
-/py
-def make_list(length, value=0):
- return [value] * length
-/py
-def make_matrix(size, value=0):
- if type(size) is int:
- return [[value] * size for _ in range(size)]
- else:
- return [[value] * size[0] for _ in range(size[1])]
-/py
-def gcd(*nums):
- nums = list(nums)
- for i in range(len(nums) - 1):
- a, b = nums[i], nums[i + 1]
- while a != b:
- if a > b:
- a -= b
- else:
- b -= a
- nums[i + 1] = a
-
- return nums[-1]
-/py
-def month(num, lang="ru"):
- mths = (
- ("January", "Январь"),
- ("February", "Февраль"),
- ("March", "Март"),
- ("April", "Апрель"),
- ("May", "Май"),
- ("June", "РСЋРЅСЊ"),
- ("July", "Рюль"),
- ("August", "РђРІРіСѓСЃС‚"),
- ("September", "Сентябрь"),
- ("October", "Октябрь"),
- ("November", "РќРѕСЏР±СЂСЊ"),
- ("December", "Декабрь")
- )
- if lang == "en":
- return mths[num - 1][0]
- else:
- return mths[num - 1][1]
-/py
-def to_string(*nums, sep=" ", end="\n"):
- res = ''
- for i in range(len(nums)):
- res += str(nums[i])
- if i != len(nums) - 1:
- res += sep
- return res + end
-/py
-def order(*names):
- global in_stock
- res = ""
- message = "К сожалению, не можем предложить Вам напиток"
- d = {
- "Рспрессо": {"coffee": 1},
- "Капучино": {"coffee": 1, "milk": 3},
- "Макиато": {"coffee": 2, "milk": 1},
- "Кофе по-венски": {"coffee": 1, "cream": 2},
- "Латте Макиато": {"coffee": 1, "milk": 2, "cream": 1},
- "Кон Панна": {"coffee": 1, "cream": 1}
- }
-
- for cof in names:
- f = True
- for k in d[cof].keys():
- if d[cof][k] > in_stock[k]:
- f = False
- if f:
- for k in d[cof].keys():
- in_stock[k] -= d[cof][k]
- message = cof
- break
- return message
-/py
-def enter_results(*enter, nums=[]):
- nums += list(enter)
- return nums
-
-
-def get_sum():
- sum1, sum2 = 0, 0
- for n in enter_results()[::2]:
- sum1 += n
- for n in enter_results()[1::2]:
- sum2 += n
- return sum1, sum2
-
-
-def get_average():
- sum1, l1, sum2, l2 = 0, 0, 0, 0
- for n in enter_results()[::2]:
- sum1 += n
- l1 += 1
- for n in enter_results()[1::2]:
- sum2 += n
- l2 += 1
- return sum1 / l1, sum2 / l2
-/py
-lambda word: (len(word), word.lower())
-/py
-lambda num: sum(map(int, str(num))) % 2 == 0
-/py
-def secret_replace(text, **replaces):
- counter = {k: 0 for k in replaces.keys()}
- while True:
- f = False
- for k in replaces.keys():
- if k in text:
- text = text.replace(k, replaces[k][counter[k]], 1)
- if counter[k] >= len(replaces[k]) - 1:
- counter[k] = -1
- counter[k] += 1
- f = True
- if not f:
- break
- return text
\ No newline at end of file
+Боря
+плохо
+Как Вас зовут?
+Здравствуйте, Боря!
+Как дела?
+Всё наладится!
+2
\ No newline at end of file
diff --git a/md1.txt b/md1.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3744cf644e204307609e534f61833f15f7051cc
--- /dev/null
+++ b/md1.txt
@@ -0,0 +1,90 @@
+/md
+Просто здравствуй, просто как дела
+Ограничение времени 1 секунда
+Ограничение памяти 64.0 Мб
+Ввод стандартный ввод или input.txt
+Вывод стандартный вывод или output.txt
+Умение вести диалог — важный навык для воспитанного человека.
+
+Напишите диалоговую программу, которая сначала познакомится с пользователем, а затем поинтересуется его настроением.
+
+Формат ввода
+В первой строке записано имя пользователя.
+Во второй — ответ на вопрос: «хорошо» или «плохо».
+
+Формат вывода
+В первой строке должен быть вопрос «Как Вас зовут?»
+Во второй строке — «Здравствуйте, %username%!»
+В третьей строке — вопрос «Как дела?»
+В четвёртой строке реакция на ответ пользователя:
+
+если пользователь ответил «хорошо», следует вывести сообщение «Я за вас рада!»;
+если пользователь ответил «плохо», следует вывести сообщение «Всё наладится!».
+Пример 1
+Ввод Вывод
+РђРЅСЏ
+хорошо
+Как Вас зовут?
+Здравствуйте, Аня!
+Как дела?
+Я за вас рада!
+Пример 2
+Ввод Вывод
+Боря
+плохо
+Как Вас зовут?
+Здравствуйте, Боря!
+Как дела?
+Всё наладится!
+2
+/py
+name = input("Как Вас зовут?\n")
+print(f"Здравствуйте, {name}!")
+status = input("Как дела?\n")
+if status == "хорошо":
+ print("Я за вас рада!")
+else:
+ print("Всё наладится!")
+/md
+a, b = int(input()), int(input())
+if a > b:
+ print("Петя")
+else:
+ print("Вася")
+/md
+Кто быстрее?
+Ограничение времени 1 секунда
+Ограничение памяти 64.0 Мб
+Ввод стандартный ввод или input.txt
+Вывод стандартный вывод или output.txt
+Р’ главной велогонке РіРѕРґР° участвует более тысячи гонщиков. РРј предстоит пройти трассу длиной 43872Рј. Самая сложная Рё ответственная задача — определение победителя.
+
+Нам известны средние скорости двух фаворитов — Пети и Васи. Помогите выяснить, кто из них пришёл к финишу первым.
+
+Формат ввода
+В первой строке записана средняя скорость Пети.
+Во второй — Васи.
+
+Формат вывода
+РРјСЏ победителя РіРѕРЅРєРё.
+
+Примечание
+Гарантируется, что победителем стал только один.
+
+Пример 1
+Ввод Вывод
+10
+5
+Петя
+Пример 2
+Ввод Вывод
+5
+7
+Вася
+-1
+/py
+a, b = int(input()), int(input())
+if a > b:
+ print("Петя")
+else:
+ print("Вася")
\ No newline at end of file
diff --git a/py_write.py b/py_write.py
deleted file mode 100644
index f48f96329630dd127f6c443b9331eeba69c9d961..0000000000000000000000000000000000000000
--- a/py_write.py
+++ /dev/null
@@ -1,8 +0,0 @@
-w_file = open("md.txt", 'a', encoding="utf-8")
-
-for i in range(1, 11):
- in_file = open(f"4.2/{i}.py", "r", encoding="utf-8")
- w_file.write("\n/py\n")
- for s in in_file:
- w_file.write(s)
- in_file.close()
\ No newline at end of file
diff --git a/test.py b/test.py
deleted file mode 100644
index fb4c8b87f0ba530774cf9f37d12ff95b19ee4ad4..0000000000000000000000000000000000000000
--- a/test.py
+++ /dev/null
@@ -1,2 +0,0 @@
-s = " "
-print(s.split())
\ No newline at end of file
diff --git a/text_processor.py b/text_processor.py
index 90cf212eb91511492298d83dd0b24efd3008524b..dae20e6fe272a87c991f375bb1a9ea7110a9c07e 100644
--- a/text_processor.py
+++ b/text_processor.py
@@ -4,7 +4,7 @@ arr = []
for i in file:
arr.append(i.rstrip("\n"))
-#print(arr)
+print(arr)
new_arr = []
new_arr.append(f"## **{arr.pop(0)}**")
@@ -69,50 +69,28 @@ new_arr.append(f"|||{'<br>'.join(stek[:-1]).rstrip('<br>')}")
file.close()
input_count = stek[-1]
-if len(input_count.split()) > 1:
- input_count = [int(i) for i in input_count.split()]
-elif input_count != "_":
+if input_count != "_":
input_count = int(input_count)
-c = 0
-
for i in range(len(new_arr)):
if new_arr[i][:3] == "|||":
data = new_arr[i][3:].split("<br>")
if input_count == "_":
data = f"|{'<br>'.join(data)}||"
- elif isinstance(input_count, list):
- in_c = input_count[c]
-
- if in_c > 0:
- if 2 * in_c > len(data):
- data = f"|{'<br>'.join(data[:in_c])}<br>|{'<br>'.join(data[in_c:])}<br>{'<br>'.join([' '] * (2 * in_c - len(data)))}<br>|"
- elif 2 * in_c == len(data):
- data = f"|{'<br>'.join(data[:in_c])}<br>|{'<br>'.join(data[in_c:])}<br>|"
- else:
- data = f"|{'<br>'.join(data[:in_c])}<br>{'<br>'.join([' '] * (len(data) - 2 * in_c))}<br>|{'<br>'.join(data[in_c:])}<br>|"
- else:
- if -2 * in_c > len(data):
- data = f"|{'<br>'.join(data[:len(data) + in_c])}<br>{'<br>'.join([' '] * (-2 * in_c - len(data)))}<br>|{'<br>'.join(data[:-1 * in_c])}<br>|"
- elif -2 * in_c == len(data):
- data = f"|{'<br>'.join(data[:-1 * in_c])}<br>|{'<br>'.join(data[-1 * in_c:])}<br>|"
- else:
- data = f"|{'<br>'.join(data[:len(data) + in_c])}<br>|{'<br>'.join(data[len(data) + in_c:])}<br>{'<br>'.join([' '] * (len(data) - -2 * in_c))}<br>|"
- c += 1
elif input_count > 0:
if 2 * input_count > len(data):
- data = f"|{'<br>'.join(data[:input_count])}<br>|{'<br>'.join(data[input_count:])}<br>{'<br>'.join([' '] * (2 * input_count - len(data)))}<br>|"
+ data = f"|{'<br>'.join(data[:input_count])}|{'<br>'.join(data[input_count:])}<br>{'<br>'.join([' '] * (2 * input_count - len(data)))}<br>|"
elif 2 * input_count == len(data):
- data = f"|{'<br>'.join(data[:input_count])}<br>|{'<br>'.join(data[input_count:])}<br>|"
+ data = f"|{'<br>'.join(data[:input_count])}|{'<br>'.join(data[input_count:])}|"
else:
data = f"|{'<br>'.join(data[:input_count])}<br>{'<br>'.join([' '] * (len(data) - 2 * input_count))}<br>|{'<br>'.join(data[input_count:])}<br>|"
else:
if -2 * input_count > len(data):
- data = f"|{'<br>'.join(data[:len(data) + input_count])}<br>{'<br>'.join([' '] * (-2 * input_count - len(data)))}<br>|{'<br>'.join(data[:-1 * input_count])}<br>|"
+ data = f"|{'<br>'.join(data[:len(data) + input_count])}<br>{'<br>'.join([' '] * (-2 * input_count - len(data)))}<br>|{'<br>'.join(data[:-1 * input_count])}|"
elif -2 * input_count == len(data):
- data = f"|{'<br>'.join(data[:-1 * input_count])}<br>|{'<br>'.join(data[-1 * input_count:])}<br>|"
+ data = f"|{'<br>'.join(data[:-1 * input_count])}|{'<br>'.join(data[-1 * input_count:])}|"
else:
- data = f"|{'<br>'.join(data[:len(data) + input_count])}<br>|{'<br>'.join(data[len(data) + input_count:])}<br>{'<br>'.join([' '] * (len(data) - -2 * input_count))}<br>|"
+ data = f"|{'<br>'.join(data[:len(data) + input_count])}|{'<br>'.join(data[len(data) + input_count:])}<br>{'<br>'.join([' '] * (len(data) - -2 * input_count))}<br>|"
new_arr[i] = data
@@ -121,8 +99,6 @@ for i in range(len(new_arr)):
if new_arr[i] and (new_arr[i][0] == "|" or new_arr[i][0] == "#"):
continue
elems = new_arr[i].split("<br>")
-
- # ВЫДЕЛАЕТ ОТДЕЛЬНЫЕ БУКВЫ
del_ind = []
for j in range(len(elems) - 1):
if len(elems[j]) == 1 and elems[j] == elems[j + 1][0]:
@@ -132,139 +108,9 @@ for i in range(len(new_arr)):
for j in del_ind[::-1]:
if j:
buff = elems.pop(j + 1)
- if elems[j - 1][-1] == ".":
- elems[j] = "$" + buff[0] + "$" + buff[1:]
- else:
- elems[j - 1] = elems[j - 1] + "$" + buff[0] + "$" + buff[1:]
- del elems[j]
-
-
- # ВЫДЕЛЯЕТ ВЫРАЖЕНРРЇ
- del_ind = []
- for j in range(len(elems)):
- if not elems[j]:
- continue
- string = elems[j].split()
- first_word = string[0]
- if len(first_word) <= j and ''.join(elems[j - len(first_word):j]) == first_word:
- f = False
- signs = ["+", "-", "*", "/", "%", "=", "<", ">", "≤", "≥"]
- for sign in signs:
- if sign in first_word:
- f = True
-
- if not f:
- continue
-
- del_ind.append([count for count in range(j - len(first_word), j)])
-
- if del_ind:
- for j in del_ind[::-1]:
- ind = j[-1] + 1
- buff = elems[ind].split()
- if elems[j[0] - 1][-1] == ".":
- elems[ind] = "$" + buff[0] + "$ " + " ".join(buff[1:])
- for k in j[::-1]:
- if k:
- del elems[k]
- else:
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff[0] + "$ " + ' '.join(buff[1:])
- del elems[ind]
- for k in j[::-1]:
- if k:
- del elems[k]
-
-
- # ВЫДЕЛЯЕТ ДРУГРР• ВЫРАЖЕНРРЇ
- del_ind = []
- for j in range(len(elems) - 1):
- if not elems[j]:
- continue
- eq = elems[j].split()[0]
- f = False
-
- signs = ["+", "-", "*", "/", "%", "=", "<", ">", "≤", "≥"]
- for num in range(10):
- signs.append(str(num))
-
- for sign in signs:
- if sign in eq:
- f = True
-
- if not f or len(eq) == 1:
- continue
-
- print(eq)
- if ")" in eq:
- eq = eq[:eq.index(")")]
- if " " in eq:
- eq = eq[:-1]
-
- if elems[j - 1] == elems[j + 1]:
- f = False
- for ind in range(j - 3, -1, -1):
- if eq == "".join(elems[ind:j - 1]):
- f = True
- break
- if not f:
- continue
- del_ind.append([count for count in range(ind, j - 1)] + [j - 1, False])
- else:
- f = False
- for ind in range(j - 2, -1, -1):
- if eq == "".join(elems[ind:j]):
- f = True
- break
- if not f:
- continue
- del_ind.append([count for count in range(ind, j)] + [True])
-
- if del_ind:
- for j in del_ind[::-1]:
- if j[-1]:
- buff = elems.pop(j[-2] + 1)
- if ")" in buff:
- ind = buff.index(")")
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff[:ind] + "$" + buff[ind:]
- else:
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff + "$"
- for k in j[::-1][1:]:
- del elems[k]
- else:
- buff = elems.pop(j[-2] + 1)
-
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff[:-1] + "^" + elems[j[-2]] + "$"
- elems[j[0] - 1] = elems[j[0] - 1] + elems[j[-2] + 2][1:]
-
- del elems[j[-2] + 2]
- del elems[j[-2] + 1]
- del elems[j[-2]]
- for k in j[::-1][2:]:
- del elems[k]
-
-
-
- # ДЕЛАЕТ $x_i$
- del_ind = []
- for j in range(len(elems) - 4):
- if [elems[j] + " ", elems[j + 1]] == [elems[j + 2], elems[j + 3]] and elems[j + 4] == "\u200b":
- del_ind.append([j, j + 1])
-
-
- if del_ind:
- for j in del_ind[::-1]:
- if j:
- buff = f"${elems[j[0]]}_{elems[j[1]]}$"
- if j[0] != 0:
- elems[j[0] - 1] = elems[j[0] - 1] + buff + elems[j[1] + 4][1:]
- else:
- elems[j[0]] = buff + elems[j[1] + 4][1:]
-
- for count in range(4, -1, -1):
- del elems[j[1] + count]
- if j[0] != 0:
- del elems[j[0]]
-
+ elems[j - 1] = elems[j - 1] + "$" + buff[0] + "$" + buff[1:]
+ del elems[j]
+
new_arr[i] = "<br>".join(elems)
new_file = open("md1.txt", "w+", encoding="utf-8")
diff --git a/text_processor2.py b/text_processor2.py
index 36946ad56dab3085d6d6599a2019fb3d9a35cbd2..0cd74c78491b0a8ddff05380cdcccbb0c480954d 100644
--- a/text_processor2.py
+++ b/text_processor2.py
@@ -2,7 +2,6 @@ import codecs
import json
def text_process(arr):
-
new_arr = []
new_arr.append(f"## **{arr.pop(0)}**")
@@ -66,50 +65,28 @@ def text_process(arr):
new_arr.append(f"|||{'<br>'.join(stek[:-1]).rstrip('<br>')}")
input_count = stek[-1]
- if len(input_count.split()) > 1:
- input_count = [int(i) for i in input_count.split()]
- elif input_count != "_":
+ if input_count != "_":
input_count = int(input_count)
- c = 0
-
for i in range(len(new_arr)):
if new_arr[i][:3] == "|||":
data = new_arr[i][3:].split("<br>")
if input_count == "_":
data = f"|{'<br>'.join(data)}||"
- elif isinstance(input_count, list):
- in_c = input_count[c]
-
- if in_c > 0:
- if 2 * in_c > len(data):
- data = f"|{'<br>'.join(data[:in_c])}<br>|{'<br>'.join(data[in_c:])}<br>{'<br>'.join([' '] * (2 * in_c - len(data)))}<br>|"
- elif 2 * in_c == len(data):
- data = f"|{'<br>'.join(data[:in_c])}<br>|{'<br>'.join(data[in_c:])}<br>|"
- else:
- data = f"|{'<br>'.join(data[:in_c])}<br>{'<br>'.join([' '] * (len(data) - 2 * in_c))}<br>|{'<br>'.join(data[in_c:])}<br>|"
- else:
- if -2 * in_c > len(data):
- data = f"|{'<br>'.join(data[:len(data) + in_c])}<br>{'<br>'.join([' '] * (-2 * in_c - len(data)))}<br>|{'<br>'.join(data[:-1 * in_c])}<br>|"
- elif -2 * in_c == len(data):
- data = f"|{'<br>'.join(data[:-1 * in_c])}<br>|{'<br>'.join(data[-1 * in_c:])}<br>|"
- else:
- data = f"|{'<br>'.join(data[:len(data) + in_c])}<br>|{'<br>'.join(data[len(data) + in_c:])}<br>{'<br>'.join([' '] * (len(data) - -2 * in_c))}<br>|"
- c += 1
elif input_count > 0:
if 2 * input_count > len(data):
- data = f"|{'<br>'.join(data[:input_count])}<br>|{'<br>'.join(data[input_count:])}<br>{'<br>'.join([' '] * (2 * input_count - len(data)))}<br>|"
+ data = f"|{'<br>'.join(data[:input_count])}|{'<br>'.join(data[input_count:])}<br>{'<br>'.join([' '] * (2 * input_count - len(data)))}<br>|"
elif 2 * input_count == len(data):
- data = f"|{'<br>'.join(data[:input_count])}<br>|{'<br>'.join(data[input_count:])}<br>|"
+ data = f"|{'<br>'.join(data[:input_count])}|{'<br>'.join(data[input_count:])}|"
else:
data = f"|{'<br>'.join(data[:input_count])}<br>{'<br>'.join([' '] * (len(data) - 2 * input_count))}<br>|{'<br>'.join(data[input_count:])}<br>|"
else:
if -2 * input_count > len(data):
- data = f"|{'<br>'.join(data[:len(data) + input_count])}<br>{'<br>'.join([' '] * (-2 * input_count - len(data)))}<br>|{'<br>'.join(data[:-1 * input_count])}<br>|"
+ data = f"|{'<br>'.join(data[:len(data) + input_count])}<br>{'<br>'.join([' '] * (-2 * input_count - len(data)))}<br>|{'<br>'.join(data[:-1 * input_count])}|"
elif -2 * input_count == len(data):
- data = f"|{'<br>'.join(data[:-1 * input_count])}<br>|{'<br>'.join(data[-1 * input_count:])}<br>|"
+ data = f"|{'<br>'.join(data[:-1 * input_count])}|{'<br>'.join(data[-1 * input_count:])}|"
else:
- data = f"|{'<br>'.join(data[:len(data) + input_count])}<br>|{'<br>'.join(data[len(data) + input_count:])}<br>{'<br>'.join([' '] * (len(data) - -2 * input_count))}<br>|"
+ data = f"|{'<br>'.join(data[:len(data) + input_count])}|{'<br>'.join(data[len(data) + input_count:])}<br>{'<br>'.join([' '] * (len(data) - -2 * input_count))}<br>|"
new_arr[i] = data
@@ -118,8 +95,6 @@ def text_process(arr):
if new_arr[i] and (new_arr[i][0] == "|" or new_arr[i][0] == "#"):
continue
elems = new_arr[i].split("<br>")
-
- # ВЫДЕЛАЕТ ОТДЕЛЬНЫЕ БУКВЫ
del_ind = []
for j in range(len(elems) - 1):
if len(elems[j]) == 1 and elems[j] == elems[j + 1][0]:
@@ -129,139 +104,11 @@ def text_process(arr):
for j in del_ind[::-1]:
if j:
buff = elems.pop(j + 1)
- if elems[j - 1][-1] == ".":
- elems[j] = "$" + buff[0] + "$" + buff[1:]
- else:
- elems[j - 1] = elems[j - 1] + "$" + buff[0] + "$" + buff[1:]
- del elems[j]
-
-
- # ВЫДЕЛЯЕТ ВЫРАЖЕНРРЇ
- del_ind = []
- for j in range(len(elems)):
- if not elems[j]:
- continue
- string = elems[j].split()
- first_word = string[0]
- if len(first_word) <= j and ''.join(elems[j - len(first_word):j]) == first_word:
- f = False
- signs = ["+", "-", "*", "/", "%", "=", "<", ">", "≤", "≥"]
- for sign in signs:
- if sign in first_word:
- f = True
-
- if not f:
- continue
-
- del_ind.append([count for count in range(j - len(first_word), j)])
-
- if del_ind:
- for j in del_ind[::-1]:
- ind = j[-1] + 1
- buff = elems[ind].split()
- if elems[j[0] - 1][-1] == ".":
- elems[ind] = "$" + buff[0] + "$ " + " ".join(buff[1:])
- for k in j[::-1]:
- if k:
- del elems[k]
- else:
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff[0] + "$ " + ' '.join(buff[1:])
- del elems[ind]
- for k in j[::-1]:
- if k:
- del elems[k]
-
-
- # ВЫДЕЛЯЕТ ДРУГРР• ВЫРАЖЕНРРЇ
- del_ind = []
- for j in range(len(elems) - 1):
- if not elems[j]:
- continue
- eq = elems[j].split()[0]
- f = False
-
- signs = ["+", "-", "*", "/", "%", "=", "<", ">", "≤", "≥"]
- for num in range(10):
- signs.append(str(num))
-
- for sign in signs:
- if sign in eq:
- f = True
-
- if not f or len(eq) == 1:
- continue
-
- if ")" in eq:
- eq = eq[:eq.index(")")]
- if " " in eq:
- eq = eq[:-1]
-
- if elems[j - 1] == elems[j + 1]:
- f = False
- for ind in range(j - 3, -1, -1):
- if eq == "".join(elems[ind:j - 1]):
- f = True
- break
- if not f:
- continue
- del_ind.append([count for count in range(ind, j - 1)] + [j - 1, False])
- else:
- f = False
- for ind in range(j - 2, -1, -1):
- if eq == "".join(elems[ind:j]):
- f = True
- break
- if not f:
- continue
- del_ind.append([count for count in range(ind, j)] + [True])
-
- if del_ind:
- for j in del_ind[::-1]:
- if j[-1]:
- buff = elems.pop(j[-2] + 1)
- if ")" in buff:
- ind = buff.index(")")
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff[:ind] + "$" + buff[ind:]
- else:
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff + "$"
- for k in j[::-1][1:]:
- del elems[k]
- else:
- buff = elems.pop(j[-2] + 1)
-
- elems[j[0] - 1] = elems[j[0] - 1] + "$" + buff[:-1] + "^" + elems[j[-2]] + "$"
- elems[j[0] - 1] = elems[j[0] - 1] + elems[j[-2] + 2][1:]
-
- del elems[j[-2] + 2]
- del elems[j[-2] + 1]
- del elems[j[-2]]
- for k in j[::-1][2:]:
- del elems[k]
-
-
+ elems[j - 1] = elems[j - 1] + "$" + buff[0] + "$" + buff[1:]
+ del elems[j]
+
+ new_arr[i] = "<br>".join(elems)
- # ДЕЛАЕТ $x_i$
- del_ind = []
- for j in range(len(elems) - 4):
- if [elems[j] + " ", elems[j + 1]] == [elems[j + 2], elems[j + 3]] and elems[j + 4] == "\u200b":
- del_ind.append([j, j + 1])
-
-
- if del_ind:
- for j in del_ind[::-1]:
- if j:
- buff = f"${elems[j[0]]}_{elems[j[1]]}$"
- if j[0] != 0:
- elems[j[0] - 1] = elems[j[0] - 1] + buff + elems[j[1] + 4][1:]
- else:
- elems[j[0]] = buff + elems[j[1] + 4][1:]
-
- for count in range(4, -1, -1):
- del elems[j[1] + count]
- if j[0] != 0:
- del elems[j[0]]
-
- new_arr[i] = "<br>".join(elems)
return new_arr
@@ -296,13 +143,7 @@ data = {'cells':[],
'nbformat': 4,
'nbformat_minor': 2}
-arr1, arr2 = arr[:len(arr) // 2], arr[len(arr) // 2:]
-task_ammount = int(input("Введите количество заданий: "))
-for i in range(0, 2 * task_ammount - 1, 2):
- arr[i] = arr1[i // 2]
- arr[i + 1] = arr2[i // 2]
-
-# print(*arr, sep="\n")
+print(*arr, sep="\n")
for i in range(len(arr)):
if i % 2 == 0:
py_data = {'cell_type': 'markdown',