├── .gitattributes ├── README.md ├── Средний элемент.ipynb ├── Площадь треугольника.ipynb ├── Голосование.ipynb ├── Длина отрезка.ipynb ├── Сумма факториалов.ipynb ├── Упорядочить три числа.ipynb ├── Пересадки.ipynb ├── Проверка числа на простоту.ipynb ├── Количество цифр.ipynb ├── Узник замка Иф.ipynb ├── Треугольники.ipynb ├── Словарь синонимов.ipynb ├── Ферзи.ipynb ├── Принадлежит ли точка квадрату 2.ipynb ├── Majority.ipynb ├── Теорема Легранжа.ipynb ├── Возрастает ли список.ipynb ├── Наибольшее произведение трех чисел.ipynb ├── Частотный анализ.ipynb ├── Строительство лесенок.ipynb ├── Повторяющееся число.ipynb ├── Продажи.ipynb ├── Кружки.ipynb ├── Разница во времени.ipynb ├── Алфавит 1.ipynb ├── Максимальная длина монотонного фрагмента.ipynb ├── Выборы в США.ipynb ├── Родословная подсчет уровней.ipynb ├── Ошибка.ipynb ├── Лог без дат.ipynb ├── Степень четырёх.ipynb ├── Больше своих соседей.ipynb ├── Угадай число.ipynb ├── Рекурсивные числа Фибоначчи.ipynb ├── Подпоследовательность.ipynb ├── Наибольшее произведение двух чисел.ipynb ├── Кубики.ipynb ├── Выведите последовательность.ipynb ├── Значения функции.ipynb ├── Работа из дома.ipynb ├── Гардероб.ipynb ├── Уравнение с корнем.ipynb ├── Лишняя буква.ipynb ├── Покупка домов.ipynb ├── Симметричная последовательность.ipynb ├── Палиндром.ipynb ├── Канонический путь.ipynb ├── Ближайшее число.ipynb ├── Полиномиальный хэш.ipynb ├── Списочная форма.ipynb ├── Забастовки.ipynb ├── Семипроцентный барьер.ipynb ├── Коньки.ipynb ├── Факторизация.ipynb ├── Утилита paste.ipynb ├── Количество положительных на отрезке.ipynb ├── Чётные и нечетные числа.ipynb ├── Замена слов.ipynb ├── Жизнь в квадрате.ipynb ├── Разноцветные палочки.ipynb ├── Быки и коровы.ipynb ├── Фибоначчи по модулю.ipynb ├── Застёжка-молния.ipynb ├── Большее число.ipynb ├── Анаграммная группировка.ipynb ├── Комбинации.ipynb ├── Игра с заменами.ipynb ├── Угадай число 2.ipynb ├── Мониторинг.ipynb ├── Сломай палиндром.ipynb ├── Двоичная система.ipynb ├── Телефонные номера.ipynb ├── Скользящее среднее.ipynb ├── Форматирование календаря.ipynb ├── Детали.ipynb ├── Клумбы.ipynb ├── Две фишки.ipynb ├── Поиск в сломанном массиве.ipynb ├── Пузырек.ipynb ├── Хаотичность погоды.ipynb ├── Стек_Max.ipynb ├── Расстановка ноутбуков.ipynb ├── Скобочная последовательность.ipynb ├── Сапер.ipynb ├── Соседи.ipynb ├── Списочная очередь.ipynb ├── Банковские счета.ipynb ├── Самое длинное слово.ipynb ├── Контрольная по ударениям.ipynb ├── Два велосипеда.ipynb ├── Генератор скобок.ipynb ├── .gitignore └── Ловкость рук.ipynb /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | *.ipynb linguist-language=PYTHON -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Yandex_contest 2 | 3 | Решение алгоритмических задач различных контестов в рамках: 4 | 5 | * Обучения в ЯндексПрактикуме 6 | * Обучения в Matshub 7 | * Тренировок Яндекса по алгоритмам 8 | * Самостоятельных занятий 9 | 10 | Помогло решение? Поставь репозиторию звезду)) 11 | -------------------------------------------------------------------------------- /Средний элемент.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Средний элемент\n", 9 | "\n", 10 | "Рассмотрим три числа. Упорядочим их по возрастанию. \n", 11 | "Какое число будет стоять между двумя другими?\n", 12 | "\n", 13 | "Формат ввода \n", 14 | "В единственной строке записаны три целых числа, числа разделены одиночными пробелами.\n", 15 | "\n", 16 | "Формат вывода \n", 17 | "Выведите число, которое будет стоять между двумя другими после упорядочивания." 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "A, B, C = map(int, input().split())\n", 27 | "print(max(min(A,B), min(B,C), min(A,C)))" 28 | ] 29 | } 30 | ], 31 | "metadata": { 32 | "language_info": { 33 | "name": "python" 34 | }, 35 | "orig_nbformat": 4 36 | }, 37 | "nbformat": 4, 38 | "nbformat_minor": 2 39 | } 40 | -------------------------------------------------------------------------------- /Площадь треугольника.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt\n", 13 | "\n", 14 | "Даны длины сторон треугольника. Вычислите площадь треугольника.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Вводятся три положительных числа.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите ответ на задачу." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "A, B, C = int(input()), int(input()), int(input())\n", 30 | "hp = (A+B+C)/2\n", 31 | "S = (hp*(hp-A)*(hp-B)*(hp-C))**0.5\n", 32 | "print(S)" 33 | ] 34 | } 35 | ], 36 | "metadata": { 37 | "language_info": { 38 | "name": "python" 39 | }, 40 | "orig_nbformat": 4 41 | }, 42 | "nbformat": 4, 43 | "nbformat_minor": 2 44 | } 45 | -------------------------------------------------------------------------------- /Голосование.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Голосование\n", 9 | "\n", 10 | "Напишите \"функцию голосования\", def Election(x, y, z), возвращающую то значение (True или False), которое среди значений ее аргументов x, y, z встречается чаще.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводится 3 числа - x, y и z (x, y и z равны 0 или 1, 0 соответствует значению False, 1 соответствует значению True).\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Необходимо вывести значение функции от x, y и z." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "x = map(int, input().split())\n", 26 | "\n", 27 | "def Election(x, y, z):\n", 28 | " return (x+y+z)//2\n", 29 | "\n", 30 | "print(Election(*x))" 31 | ] 32 | } 33 | ], 34 | "metadata": { 35 | "language_info": { 36 | "name": "python" 37 | }, 38 | "orig_nbformat": 4 39 | }, 40 | "nbformat": 4, 41 | "nbformat_minor": 2 42 | } 43 | -------------------------------------------------------------------------------- /Длина отрезка.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Длина отрезка\n", 9 | "\n", 10 | "Даны четыре действительных числа: x1, y1, x2, y2. Напишите функцию distance(x1, y1, x2, y2), вычисляющую расстояние между точкой (x1,y1) и (x2,y2). Считайте четыре действительных числа и выведите результат работы этой функции.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводятся четыре действительных числа.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите ответ на задачу." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "x1, y1, x2, y2 = float(input()), float(input()), float(input()), float(input())\n", 26 | "def distance(x1, y1, x2, y2):\n", 27 | " return ((x2-x1)**2 + (y2-y1)**2) **0.5\n", 28 | "\n", 29 | "print(distance(x1, y1, x2, y2))" 30 | ] 31 | } 32 | ], 33 | "metadata": { 34 | "language_info": { 35 | "name": "python" 36 | }, 37 | "orig_nbformat": 4 38 | }, 39 | "nbformat": 4, 40 | "nbformat_minor": 2 41 | } 42 | -------------------------------------------------------------------------------- /Сумма факториалов.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Сумма факториалов \n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "По данному натуральном n вычислите сумму . В решении этой задачи можно использовать только один цикл.\n", 16 | "\n", 17 | "Формат ввода \n", 18 | "Вводится натуральное число n.\n", 19 | "\n", 20 | "Формат вывода \n", 21 | "Выведите ответ на задачу." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "x = int(input())\n", 31 | "fact = 1\n", 32 | "sum_f = 0\n", 33 | "for i in range(1,x+1):\n", 34 | " fact *= i\n", 35 | " sum_f += fact\n", 36 | "print(sum_f)" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "language_info": { 42 | "name": "python" 43 | }, 44 | "orig_nbformat": 4 45 | }, 46 | "nbformat": 4, 47 | "nbformat_minor": 2 48 | } 49 | -------------------------------------------------------------------------------- /Упорядочить три числа.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Дано три числа. Упорядочите их в порядке неубывания. Программа должна считывать три числа a, b, c, затем программа должна менять их значения так, чтобы стали выполнены условия , затем программа выводит тройку a, b, c.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Вводятся три числа.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите ответ на задачу." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "a, b, c = int(input()), int(input()), int(input())\n", 30 | "a, b, c = min(a,b,c), max(min(a,b), min(b,c), min(a,c)), max(a,b,c)\n", 31 | "print(a,b,c)" 32 | ] 33 | } 34 | ], 35 | "metadata": { 36 | "language_info": { 37 | "name": "python" 38 | }, 39 | "orig_nbformat": 4 40 | }, 41 | "nbformat": 4, 42 | "nbformat_minor": 2 43 | } 44 | -------------------------------------------------------------------------------- /Пересадки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Пересадки\n", 9 | "\n", 10 | "На Новом проспекте для разгрузки было решено пустить два новых автобусных маршрута на разных участках проспекта. Известны конечные остановки каждого из автобусов. Определите количество остановок, на которых можно пересесть с одного автобуса на другой.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводятся четыре числа, не превосходящие 100, задающие номера конечных остановок. Сначала для первого, потом второго автобуса (см. примеры и рисунок).\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Ваша программа должна выводить одно число – искомое количество остановок. " 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "a, b, x, y = map(int, input().split())\n", 26 | "first = set([i for i in range(min(a,b),max(a,b)+1)])\n", 27 | "second = set([i for i in range(min(x,y), max(x,y)+1)])\n", 28 | "print(len(first & second))" 29 | ] 30 | } 31 | ], 32 | "metadata": { 33 | "language_info": { 34 | "name": "python" 35 | }, 36 | "orig_nbformat": 4 37 | }, 38 | "nbformat": 4, 39 | "nbformat_minor": 2 40 | } 41 | -------------------------------------------------------------------------------- /Проверка числа на простоту.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Проверка числа на простоту\n", 9 | "\n", 10 | "Дано натуральное число n>1. Проверьте, является ли оно простым. Программа должна вывести слово YES, если число простое и NO, если число составное. Решение оформите в виде функции IsPrime(n), которая возвращает True для простых чисел и False для составных чисел. Решение должно иметь сложность O(sqrt(n)).\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводится натуральное число.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите ответ на задачу." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "x = int(input())\n", 26 | "def IsPrime(x):\n", 27 | " if x%2 == 0 and x != 2:\n", 28 | " return 'NO'\n", 29 | " for i in range(2, int(x**0.5)+1):\n", 30 | " if x%i == 0:\n", 31 | " return 'NO'\n", 32 | " return 'YES'\n", 33 | "print(IsPrime(x))" 34 | ] 35 | } 36 | ], 37 | "metadata": { 38 | "language_info": { 39 | "name": "python" 40 | }, 41 | "orig_nbformat": 4 42 | }, 43 | "nbformat": 4, 44 | "nbformat_minor": 2 45 | } 46 | -------------------------------------------------------------------------------- /Количество цифр.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Количество цифр\n", 9 | "\n", 10 | "Дана последовательность чисел, состоящая только из чисел 1, ..., 9. Последовательность завершается числом 0. Каждое число записано в отдельной строке.\n", 11 | "\n", 12 | "Подсчитайте, сколько раз в этой последовательности встречаются значения 1, 2, ..., 9. Сохранять всю последовательность введенных чисел в списке нельзя.\n", 13 | "\n", 14 | "Программа должна вывести ровно 9 чисел: количество единиц, двоек, ..., девяток в данной последовательности." 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 24 | "x = file.readlines()\n", 25 | "result = dict.fromkeys(range(1,10), 0)\n", 26 | "for i in x:\n", 27 | " i = i.strip()\n", 28 | " if i == '0':\n", 29 | " break\n", 30 | " result[int(i)] = result.get(int(i),0) + 1\n", 31 | "\n", 32 | "for i in result.values():\n", 33 | " print(i, end = ' ')" 34 | ] 35 | } 36 | ], 37 | "metadata": { 38 | "language_info": { 39 | "name": "python" 40 | }, 41 | "orig_nbformat": 4 42 | }, 43 | "nbformat": 4, 44 | "nbformat_minor": 2 45 | } 46 | -------------------------------------------------------------------------------- /Узник замка Иф.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt\n", 13 | "\n", 14 | "За многие годы заточения узник замка Иф проделал в стене прямоугольное отверстие размером D × E. Замок Иф сложен из кирпичей, размером A × B × C. Определите, сможет ли узник выбрасывать кирпичи в море через это отверстие, если стороны кирпича должны быть параллельны сторонам отверстия.\n", 15 | "\n", 16 | "Формат ввода\n", 17 | "Программа получает на вход числа A, B, C, D, E.\n", 18 | "\n", 19 | "Формат вывода\n", 20 | "Программа должна вывести слово YES или NO." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "A, B, C, D, E = int(input()), int(input()), int(input()), int(input()), int(input())\n", 30 | "if min(A,B,C) <= min(D,E) and max(min(A,B), min(B,C)) <= max(D,E):\n", 31 | " print('YES')\n", 32 | "else:\n", 33 | " print('NO')" 34 | ] 35 | } 36 | ], 37 | "metadata": { 38 | "language_info": { 39 | "name": "python" 40 | }, 41 | "orig_nbformat": 4 42 | }, 43 | "nbformat": 4, 44 | "nbformat_minor": 2 45 | } 46 | -------------------------------------------------------------------------------- /Треугольники.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Треугольники\n", 9 | "\n", 10 | "Дан набор из N отрезков различной длины. Сколькими способами можно выбрать из этих отрезков три, из которых можно составить (невырожденный) треугольник?\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Сначала вводится количество отрезков, затем длины этих отрезков (еще N чисел).\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Программа должна вывести одно число - искомое количество способов. Количество отрезков - не менее 3 и не более 20. Длина каждого отрезка - натуральное число, не превосходящее 1000. Все отрезки имеют разную длину." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import itertools\n", 26 | "\n", 27 | "n = int(input())\n", 28 | "x = map(int, input().split())\n", 29 | "result = 0\n", 30 | "\n", 31 | "\n", 32 | "for a, b, c in itertools.combinations(x, 3):\n", 33 | " if min(a,b,c) + max(min(a,b), min(b,c), min(a,c)) > max(a,b,c):\n", 34 | " result += 1\n", 35 | "\n", 36 | "print(result)" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "language_info": { 42 | "name": "python" 43 | }, 44 | "orig_nbformat": 4 45 | }, 46 | "nbformat": 4, 47 | "nbformat_minor": 2 48 | } 49 | -------------------------------------------------------------------------------- /Словарь синонимов.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Словарь синонимов\n", 9 | "\n", 10 | "Вам дан словарь, состоящий из пар слов. Каждое слово является синонимом к парному ему слову. Все слова в словаре различны. Для одного данного слова определите его синоним.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Программа получает на вход количество пар синонимов N. Далее следует N строк, каждая строка содержит ровно два слова-синонима. После этого следует одно слово.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Программа должна вывести синоним к данному слову. Примечание\n", 17 | "\n", 18 | "Эту задачу можно решить и без словарей (сохранив все входные данные в списке), но решение со словарем будет более простым." 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 28 | "x = file.readlines()\n", 29 | "pares = int(x[0])\n", 30 | "sin_dict = {}\n", 31 | "for line in x[1:pares+1]:\n", 32 | " k,v = line.split()\n", 33 | " sin_dict[k] = v\n", 34 | " sin_dict[v] = k\n", 35 | "\n", 36 | "print(sin_dict.get(x[pares+1].strip()))" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "language_info": { 42 | "name": "python" 43 | }, 44 | "orig_nbformat": 4 45 | }, 46 | "nbformat": 4, 47 | "nbformat_minor": 2 48 | } 49 | -------------------------------------------------------------------------------- /Ферзи.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Известно, что на доске 8×8 можно расставить 8 ферзей так, чтобы они не били друг друга. Вам дана расстановка 8 ферзей на доске, определите, есть ли среди них пара бьющих друг друга.\n", 9 | "\n", 10 | "Формат ввода \n", 11 | "Программа получает на вход восемь пар чисел, каждое число от 1 до 8 - координаты 8 ферзей.\n", 12 | "\n", 13 | "Формат вывода \n", 14 | "Если ферзи не бьют друг друга, выведите слово NO, иначе выведите YES." 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "n = 8\n", 24 | "lines = []\n", 25 | "columns = []\n", 26 | "for i in range(n):\n", 27 | " x, y = [int(s) for s in input().split()]\n", 28 | " columns.append(y)\n", 29 | " lines.append(x)\n", 30 | "\n", 31 | "result = True\n", 32 | "for i in range(n):\n", 33 | " for j in range(i + 1, n):\n", 34 | " if lines[i] == lines[j] or columns[i] == columns[j] or abs(lines[i] - lines[j]) == abs(columns[i] - columns[j]):\n", 35 | " result = False\n", 36 | "\n", 37 | "if result:\n", 38 | " print('NO')\n", 39 | "else:\n", 40 | " print('YES')" 41 | ] 42 | } 43 | ], 44 | "metadata": { 45 | "language_info": { 46 | "name": "python" 47 | }, 48 | "orig_nbformat": 4 49 | }, 50 | "nbformat": 4, 51 | "nbformat_minor": 2 52 | } 53 | -------------------------------------------------------------------------------- /Принадлежит ли точка квадрату 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Принадлежит ли точка квадрату - 2\n", 9 | "\n", 10 | "Даны два действительных числа x и y. Проверьте, принадлежит ли точка с координатами (x,y) заштрихованному квадрату (включая его границу). Если точка принадлежит квадрату, выведите слово YES, иначе выведите слово NO. На рисунке сетка проведена с шагом 1.\n", 11 | "\n", 12 | "Вершины квадрата [(-1,0),(0,1),(1,0),(0,-1)]\n", 13 | "\n", 14 | "Решение должно содержать функцию IsPointInSquare(x, y), возвращающую True, если точка принадлежит квадрату и False, если не принадлежит. Основная программа должна считать координаты точки, вызвать функцию IsPointInSquare и в зависимости от возвращенного значения вывести на экран необходимое сообщение.\n", 15 | "\n", 16 | "Функция IsPointInSquare не должна содержать инструкцию if." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "x, y= float(input()), float(input())\n", 26 | "def IsPointInSquare(x, y):\n", 27 | " sum_coord = abs(x) + abs(y)\n", 28 | " return sum_coord <= 1\n", 29 | "\n", 30 | "result = ('NO','YES')\n", 31 | "print(result[int(IsPointInSquare(x, y))])" 32 | ] 33 | } 34 | ], 35 | "metadata": { 36 | "language_info": { 37 | "name": "python" 38 | }, 39 | "orig_nbformat": 4 40 | }, 41 | "nbformat": 4, 42 | "nbformat_minor": 2 43 | } 44 | -------------------------------------------------------------------------------- /Majority.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Majority\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "Majority (в дословном переводе \"большинство\") — это значение элемента, который в массиве длиной n встречается более чем n / 2 раз. Определите majority массива, если гарантируется, что такой элемент существует.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке вводится число n (1 ≤ n ≤ 5 × 104). \n", 20 | "Во второй строке вводится n чисел через пробел, числа не превосходят 109 по модулю.\n", 21 | "\n", 22 | "Формат вывода \n", 23 | "Выведите majority массива." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "N = int(input())\n", 33 | "input_values = list(map(int, input().split()))\n", 34 | "\n", 35 | "def majority(N, input_values):\n", 36 | " K = N // 2\n", 37 | " counter = {}\n", 38 | " for i in input_values:\n", 39 | " counter[i] = counter.get(i, 0) + 1\n", 40 | " if counter[i] > K:\n", 41 | " return i\n", 42 | "\n", 43 | "print(majority(N, input_values))" 44 | ] 45 | } 46 | ], 47 | "metadata": { 48 | "language_info": { 49 | "name": "python" 50 | }, 51 | "orig_nbformat": 4 52 | }, 53 | "nbformat": 4, 54 | "nbformat_minor": 2 55 | } 56 | -------------------------------------------------------------------------------- /Теорема Легранжа.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Теорема Лагранжа\n", 9 | "\n", 10 | "Теорема Лагранжа утверждает, что любое натуральное число можно представить в виде суммы четырех точных квадратов. По данному числу n найдите такое представление: напечатайте от 1 до 4 натуральных чисел, квадраты которых дают в сумме данное число.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Программа получает на вход одно натуральное число n < 10000.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Программа должна вывести от 1 до 4 натуральных чисел, квадраты которых дают в сумме данное число." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import math\n", 26 | "\n", 27 | "x = int(input())\n", 28 | "\n", 29 | "for i in range(int(math.sqrt(x)), 0, -1):\n", 30 | " result = []\n", 31 | " y = x\n", 32 | " f_sq = i\n", 33 | " result.append(f_sq)\n", 34 | " y -= f_sq**2\n", 35 | " while y > 0:\n", 36 | " if len(result) == 4:\n", 37 | " break\n", 38 | " sq = int(math.sqrt(y))\n", 39 | " result.append(sq)\n", 40 | " y -= sq**2\n", 41 | " if y > 0:\n", 42 | " continue\n", 43 | " else:\n", 44 | " break\n", 45 | "\n", 46 | "assert y == 0\n", 47 | " \n", 48 | "print(' '.join([str(i) for i in result]))" 49 | ] 50 | } 51 | ], 52 | "metadata": { 53 | "language_info": { 54 | "name": "python" 55 | }, 56 | "orig_nbformat": 4 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 2 60 | } 61 | -------------------------------------------------------------------------------- /Возрастает ли список.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Дан список. Определите, является ли он монотонно возрастающим(то есть верно ли, что каждый элемент этого списка больше предыдущего).\n", 15 | "\n", 16 | "Выведите YES, если массив монотонно возрастает и NO в противном случае." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "x = list(map(int, input().split()))\n", 26 | "\n", 27 | "def check_list(x: list):\n", 28 | " for i in range(1, len(x)):\n", 29 | " if x[i] > x[i-1]:\n", 30 | " continue\n", 31 | " else:\n", 32 | " print('NO')\n", 33 | " return\n", 34 | " print('YES')\n", 35 | "\n", 36 | "check_list(x)" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "kernelspec": { 42 | "display_name": "Python 3", 43 | "language": "python", 44 | "name": "python3" 45 | }, 46 | "language_info": { 47 | "codemirror_mode": { 48 | "name": "ipython", 49 | "version": 3 50 | }, 51 | "file_extension": ".py", 52 | "mimetype": "text/x-python", 53 | "name": "python", 54 | "nbconvert_exporter": "python", 55 | "pygments_lexer": "ipython3", 56 | "version": "3.10.6" 57 | }, 58 | "orig_nbformat": 4, 59 | "vscode": { 60 | "interpreter": { 61 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 62 | } 63 | } 64 | }, 65 | "nbformat": 4, 66 | "nbformat_minor": 2 67 | } 68 | -------------------------------------------------------------------------------- /Наибольшее произведение трех чисел.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "В данном списке из n ≤ 105 целых чисел найдите три числа,произведение которых максимально.\n", 15 | "\n", 16 | "Решение должно иметь сложность O(n), где n - размер списка.\n", 17 | "\n", 18 | "Выведите три искомых числа в любом порядке." 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "x = [int(i) for i in input().split()]\n", 28 | "m1 = m2 = m3 = -10**5 - 1\n", 29 | "n1 = n2 = 10**5 + 1\n", 30 | "for i in x:\n", 31 | " if i > m1:\n", 32 | " m1, m2, m3 = i, m1, m2\n", 33 | " elif i > m2:\n", 34 | " m2, m3 = i, m2\n", 35 | " elif i > m3:\n", 36 | " m3 = i\n", 37 | " if i < n1:\n", 38 | " n1, n2 = i, n1\n", 39 | " elif i < n2:\n", 40 | " n2 = i\n", 41 | " \n", 42 | "if m1*m2*m3 > m1*n1*n2:\n", 43 | " print(m1,m2,m3)\n", 44 | "else:\n", 45 | " print(m1,n1,n2)" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "kernelspec": { 51 | "display_name": "venv", 52 | "language": "python", 53 | "name": "python3" 54 | }, 55 | "language_info": { 56 | "name": "python", 57 | "version": "3.10.6" 58 | }, 59 | "orig_nbformat": 4, 60 | "vscode": { 61 | "interpreter": { 62 | "hash": "e688ee72b1c52c0fb07e5f21353202736868602701a19717d3e26524e4041c77" 63 | } 64 | } 65 | }, 66 | "nbformat": 4, 67 | "nbformat_minor": 2 68 | } 69 | -------------------------------------------------------------------------------- /Частотный анализ.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Частотный анализ\n", 9 | "\n", 10 | "Дан текст. Выведите все слова, встречающиеся в тексте, по одному на каждую строку. Слова должны быть отсортированы по убыванию их количества появления в тексте, а при одинаковой частоте появления — в лексикографическом порядке. Указание. После того, как вы создадите словарь всех слов, вам захочется отсортировать его по частоте встречаемости слова. Желаемого можно добиться, если создать список, элементами которого будут кортежи из двух элементов: частота встречаемости слова и само слово. Например, [(2, 'hi'), (1, 'what'), (3, 'is')]. Тогда стандартная сортировка будет сортировать список кортежей, при этом кортежи сравниваются по первому элементу, а если они равны — то по второму. Это почти то, что требуется в задаче.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводится текст.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите ответ на задачу." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 26 | "x = file.readlines()\n", 27 | "\n", 28 | "result = {}\n", 29 | "\n", 30 | "for line in x:\n", 31 | " y = line.split()\n", 32 | " for k in y:\n", 33 | " result[k] = result.get(k, 0) + 1\n", 34 | "items_d = [(v,k) for k,v in result.items()]\n", 35 | "items_d.sort(key=lambda x: (-x[0], x[1]))\n", 36 | "\n", 37 | "for i in items_d:\n", 38 | " print(i[1])" 39 | ] 40 | } 41 | ], 42 | "metadata": { 43 | "language_info": { 44 | "name": "python" 45 | }, 46 | "orig_nbformat": 4 47 | }, 48 | "nbformat": 4, 49 | "nbformat_minor": 2 50 | } 51 | -------------------------------------------------------------------------------- /Строительство лесенок.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Строительство лесенок\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "Вася занимается строительством лесенок из блоков. Лесенка состоит из ступенек, при этом i-ая ступенька должна состоять ровно из i блоков.\n", 17 | "\n", 18 | "По заданному числу блоков n определите максимальное количество ступенек в лесенке, которую можно построить из этих блоков.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "Ввводится одно число n (1 ≤ n ≤ 231 - 1).\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите одно число — количество ступенек в лесенке." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "n = int(input())\n", 34 | "\n", 35 | "next_step = 1\n", 36 | "\n", 37 | "steps = 0\n", 38 | "\n", 39 | "while next_step <= n:\n", 40 | " n -= next_step\n", 41 | " steps += 1\n", 42 | " next_step += 1\n", 43 | "\n", 44 | "print(steps)" 45 | ] 46 | } 47 | ], 48 | "metadata": { 49 | "kernelspec": { 50 | "display_name": "Python 3", 51 | "language": "python", 52 | "name": "python3" 53 | }, 54 | "language_info": { 55 | "codemirror_mode": { 56 | "name": "ipython", 57 | "version": 3 58 | }, 59 | "file_extension": ".py", 60 | "mimetype": "text/x-python", 61 | "name": "python", 62 | "nbconvert_exporter": "python", 63 | "pygments_lexer": "ipython3", 64 | "version": "3.10.6" 65 | }, 66 | "orig_nbformat": 4 67 | }, 68 | "nbformat": 4, 69 | "nbformat_minor": 2 70 | } 71 | -------------------------------------------------------------------------------- /Повторяющееся число.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Повторяющееся число\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "Вам дана последовательность измерений некоторой величины. Требуется определить, повторялась ли какое-либо число, причём расстояние между повторами не превосходило k.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке задаются два числа n и k (1 ≤ n, k ≤ 105). \n", 20 | "Во второй строке задаются n чисел, по модулю не превосходящих 109.\n", 21 | "\n", 22 | "Формат вывода \n", 23 | "Выведите YES, если найдется повторяющееся число и расстояние между повторами не превосходит k и NO в противном случае." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "N, K = map(int, input().split())\n", 33 | "check = list(map(int, input().split()))\n", 34 | "\n", 35 | "positions = {}\n", 36 | "\n", 37 | "def check_list(check, N, K):\n", 38 | " for i in range(N):\n", 39 | " last_index = positions.get(check[i])\n", 40 | " if last_index is not None:\n", 41 | " if (i - last_index) <= K:\n", 42 | " return'YES'\n", 43 | " else:\n", 44 | " positions[check[i]] = i\n", 45 | " else:\n", 46 | " positions[check[i]] = i\n", 47 | " return 'NO'\n", 48 | "\n", 49 | "print(check_list(check, N, K))" 50 | ] 51 | } 52 | ], 53 | "metadata": { 54 | "language_info": { 55 | "name": "python" 56 | }, 57 | "orig_nbformat": 4 58 | }, 59 | "nbformat": 4, 60 | "nbformat_minor": 2 61 | } 62 | -------------------------------------------------------------------------------- /Продажи.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Продажи\n", 9 | "\n", 10 | "Дана база данных о продажах некоторого интернет-магазина. Каждая строка входного файла представляет собой запись вида Покупатель товар количество, где Покупатель — имя покупателя (строка без пробелов), товар — название товара (строка без пробелов), количество — количество приобретенных единиц товара. Создайте список всех покупателей, а для каждого покупателя подсчитайте количество приобретенных им единиц каждого вида товаров.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводятся сведения о покупках в указанном формате.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите список всех покупателей в лексикографическом порядке, после имени каждого покупателя выведите двоеточие, затем выведите список названий всех приобретенных данным покупателем товаров в лексикографическом порядке, после названия каждого товара выведите количество единиц товара, приобретенных данным покупателем. Информация о каждом товаре выводится в отдельной строке." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 26 | "x = file.readlines()\n", 27 | "result = {}\n", 28 | "for line in x:\n", 29 | " man, good, g_count = line.split()\n", 30 | " result.setdefault(man, {})\n", 31 | " result[man][good] = result[man].get(good, 0) + int(g_count)\n", 32 | "\n", 33 | "for i in sorted(result.items()):\n", 34 | " print(f'{i[0]}:')\n", 35 | " for k in sorted(i[1].items()):\n", 36 | " print(f'{k[0]} {k[1]}')" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "language_info": { 42 | "name": "python" 43 | }, 44 | "orig_nbformat": 4 45 | }, 46 | "nbformat": 4, 47 | "nbformat_minor": 2 48 | } 49 | -------------------------------------------------------------------------------- /Кружки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "В компании, где работает Тимофей, заботятся о досуге сотрудников и устраивают различные кружки по интересам. Когда кто-то записывается на занятие, в лог вносится название кружка.\n", 15 | "\n", 16 | "По записям в логе составьте список всех кружков, в которые ходит хотя бы один человек.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке даётся натуральное число n, не превосходящее 10 000 –— количество записей в логе.\n", 20 | "\n", 21 | "В следующих n строках —– названия кружков.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите уникальные названия кружков по одному на строке, в порядке появления во входных данных." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "x = int(input())\n", 34 | "total = {}\n", 35 | "\n", 36 | "for i in range(x):\n", 37 | " input_text = input()\n", 38 | " total[input_text] = 1\n", 39 | "\n", 40 | "print(*total.keys(), sep='\\n')" 41 | ] 42 | } 43 | ], 44 | "metadata": { 45 | "kernelspec": { 46 | "display_name": "Python 3", 47 | "language": "python", 48 | "name": "python3" 49 | }, 50 | "language_info": { 51 | "codemirror_mode": { 52 | "name": "ipython", 53 | "version": 3 54 | }, 55 | "file_extension": ".py", 56 | "mimetype": "text/x-python", 57 | "name": "python", 58 | "nbconvert_exporter": "python", 59 | "pygments_lexer": "ipython3", 60 | "version": "3.10.6" 61 | }, 62 | "orig_nbformat": 4 63 | }, 64 | "nbformat": 4, 65 | "nbformat_minor": 2 66 | } 67 | -------------------------------------------------------------------------------- /Разница во времени.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Разница во времени\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "Каждые сутки на вокзал прибывает n электричек. По заданному расписанию прибытия электричек определите минимальное время между прибытием двух разных электричек.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке задано число n (1 ≤ n ≤ 2 × 104) — количество электричек. \n", 20 | "Во второй строке задано n моментов времени в формате HH:MM (0 ≤ HH ≤ 23, 0 ≤ MM ≤ 59) через пробел.\n", 21 | "\n", 22 | "Формат вывода \n", 23 | "Выведите одно число — минимальное время в минутах между прибытием двух электричек." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "from itertools import pairwise\n", 33 | "\n", 34 | "count_trains = int(input())\n", 35 | "time_trains = input().split()\n", 36 | "\n", 37 | "time_in_mins = []\n", 38 | "\n", 39 | "for i in time_trains:\n", 40 | " z = list(map(int,i.split(':')))\n", 41 | " if z[0] == 0:\n", 42 | " hours = 24\n", 43 | " else:\n", 44 | " hours = z[0] \n", 45 | " mins = z[1]\n", 46 | " time_in_mins.append(hours*60 + mins)\n", 47 | "\n", 48 | "diffs = sorted([f-h for (h, f) in pairwise(sorted(time_in_mins))])\n", 49 | "\n", 50 | "if not diffs:\n", 51 | " print('1440')\n", 52 | "else:\n", 53 | " print(diffs[0])" 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "language_info": { 59 | "name": "python" 60 | }, 61 | "orig_nbformat": 4 62 | }, 63 | "nbformat": 4, 64 | "nbformat_minor": 2 65 | } 66 | -------------------------------------------------------------------------------- /Алфавит 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Алфавит - 1 (old)\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "Вася пишет программу, автоматически определяющую язык запроса пользователя в поисковую систему. У Васи есть алфавиты известных ему языков. Помогите Васе для каждого запроса определить, к каким языкам он может относиться, если смотреть только на алфавит. Запрос может относиться к языку, если в нем есть хотя бы один символ из алфавита этого языка.\n", 16 | "\n", 17 | "Формат ввода \n", 18 | "Сначала задано число L - количество языков. Далее идет L пар строк. Первая строка в паре - название языка. Вторая строка - алфавит языка. Далее идет N - число запросов. Потому идут сами запросы. Длина всех строк не превосходит 200.\n", 19 | "\n", 20 | "Формат вывода \n", 21 | "Для каждого запроса на отдельной строке выведите черех пробел возможные языки запроса в лексикографическом порядке." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "lang = int(input())\n", 31 | "dicts = {}\n", 32 | "\n", 33 | "for i in range(lang):\n", 34 | " l = input()\n", 35 | " dicts[l] = set(input())\n", 36 | "\n", 37 | "query = int(input())\n", 38 | "\n", 39 | "for i in range(query):\n", 40 | " q = set(input())\n", 41 | " res = []\n", 42 | " for k in dicts:\n", 43 | " if bool(q&dicts[k]):\n", 44 | " res.append(k)\n", 45 | " res.sort()\n", 46 | " print(*res)" 47 | ] 48 | } 49 | ], 50 | "metadata": { 51 | "language_info": { 52 | "name": "python" 53 | }, 54 | "orig_nbformat": 4 55 | }, 56 | "nbformat": 4, 57 | "nbformat_minor": 2 58 | } 59 | -------------------------------------------------------------------------------- /Максимальная длина монотонного фрагмента.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt\n", 13 | "\n", 14 | "Дана последовательность натуральных чисел, завершающаяся число 0. Определите наибольшую длину монотонного фрагмента последовательности (то есть такого фрагмента, где все элементы либо больше предыдущего, либо меньше).\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите ответ на задачу." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "x = int(input())\n", 30 | "mono_up = 1\n", 31 | "mono_down = 1\n", 32 | "max_count = 1\n", 33 | "while True:\n", 34 | " y = int(input())\n", 35 | " if y == 0:\n", 36 | " break\n", 37 | " if y > x:\n", 38 | " mono_up += 1\n", 39 | " mono_down = 1\n", 40 | " if mono_up > max_count:\n", 41 | " max_count = mono_up\n", 42 | " x = y\n", 43 | " elif y < x:\n", 44 | " mono_down += 1\n", 45 | " mono_up = 1\n", 46 | " if mono_down > max_count:\n", 47 | " max_count = mono_down\n", 48 | " x = y \n", 49 | " else:\n", 50 | " mono_up = 1\n", 51 | " mono_down = 1\n", 52 | " x = y\n", 53 | "print(max_count)" 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "language_info": { 59 | "name": "python" 60 | }, 61 | "orig_nbformat": 4 62 | }, 63 | "nbformat": 4, 64 | "nbformat_minor": 2 65 | } 66 | -------------------------------------------------------------------------------- /Выборы в США.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Выборы в США\n", 9 | "\n", 10 | "Как известно, в США президент выбирается не прямым голосованием, а путем двухуровневого голосования. Сначала проводятся выборы в каждом штате и определяется победитель выборов в данном штате. Затем проводятся государственные выборы: на этих выборах каждый штат имеет определенное число голосов — число выборщиков от этого штата. На практике, все выборщики от штата голосуют в соответствии с результами голосования внутри штата, то есть на заключительной стадии выборов в голосовании участвуют штаты, имеющие различное число голосов. Вам известно за кого проголосовал каждый штат и сколько голосов было отдано данным штатом. Подведите итоги выборов: для каждого из участника голосования определите число отданных за него голосов.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Каждая строка входного файла содержит фамилию кандидата, за которого отдают голоса выборщики этого штата, затем через пробел идет количество выборщиков, отдавших голоса за этого кандидата.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите фамилии всех кандидатов в лексикографическом порядке, затем, через пробел, количество отданных за них голосов." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 26 | "x = file.readlines()\n", 27 | "elections = {}\n", 28 | "\n", 29 | "for line in x:\n", 30 | " man, votes = line.split()\n", 31 | " elections[man] = elections.get(man, 0) + int(votes)\n", 32 | "\n", 33 | "y = sorted([(k,v) for k,v in elections.items()])\n", 34 | "\n", 35 | "for i in y:\n", 36 | " print(f'{i[0]} {i[1]}')" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "language_info": { 42 | "name": "python" 43 | }, 44 | "orig_nbformat": 4 45 | }, 46 | "nbformat": 4, 47 | "nbformat_minor": 2 48 | } 49 | -------------------------------------------------------------------------------- /Родословная подсчет уровней.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Родословная: подсчет уровней\n", 9 | "\n", 10 | "В генеалогическом древе у каждого человека, кроме родоначальника, есть ровно один родитель. Каждом элементу дерева сопоставляется целое неотрицательное число, называемое высотой. У родоначальника высота равна 0, у любого другого элемента высота на 1 больше, чем у его родителя. Вам дано генеалогическое древо, определите высоту всех его элементов.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Программа получает на вход число элементов в генеалогическом древе N. Далее следует N-1 строка, задающие родителя для каждого элемента древа, кроме родоначальника. Каждая строка имеет вид имя_потомка имя_родителя.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Программа должна вывести список всех элементов древа в лексикографическом порядке. После вывода имени каждого элемента необходимо вывести его высоту." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 26 | "x = file.readlines()\n", 27 | "strings = int(x[0])\n", 28 | "pares = {}\n", 29 | "rangs = {}\n", 30 | "\n", 31 | "for line in x[1:strings+1]:\n", 32 | " child, parent = line.split()\n", 33 | " pares[child] = parent\n", 34 | " rangs.setdefault(child, 0)\n", 35 | " rangs.setdefault(parent, 0)\n", 36 | "\n", 37 | "for person in pares.keys():\n", 38 | " point = person\n", 39 | " while point in pares.keys():\n", 40 | " point = pares[point]\n", 41 | " rangs[person] += 1\n", 42 | "\n", 43 | "for i in sorted(rangs.items()):\n", 44 | " print(f'{i[0]} {i[1]}')" 45 | ] 46 | } 47 | ], 48 | "metadata": { 49 | "language_info": { 50 | "name": "python" 51 | }, 52 | "orig_nbformat": 4 53 | }, 54 | "nbformat": 4, 55 | "nbformat_minor": 2 56 | } 57 | -------------------------------------------------------------------------------- /Ошибка.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ошибка\n", 9 | "\n", 10 | "Вы обслуживаете сайт и отслеживаете возникающие проблемы. Клиент получил ошибку после того, как попытался добавить свой пост в систему. Вы хотите понять, на каком из серверов эта ошибка произошла.\n", 11 | "\n", 12 | "Есть n серверов, на i-й из них приходится a процентов запросов, из которых b процентов завершаются с ошибкой. Для каждого сервера найдите вероятность того, что ошибка произошла именно на нём.\n", 13 | "\n", 14 | "Формат ввода \n", 15 | "В первой строке входного файла содержится одно целое число n(1≤n≤100) — количество серверов.\n", 16 | "\n", 17 | "В каждой из следующих n строк содержится два целых числа a и b вероятность того, что запрос пойдёт на i-й сервер, в процентах и вероятность того, что на i-м сервере случится ошибка, в процентах.\n", 18 | "\n", 19 | "Гарантируется, что сумма всех a равна 100, и ошибка в системе может произойти.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Выведите n строк. В каждой строке должно находиться одно вещественное число вероятность, что ошибка произошла на соответствующем сервере.\n", 23 | "\n", 24 | "Абсолютная или относительная погрешность каждого из ответов не должна превышать 10−9." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "n = int(input())\n", 34 | "servers = []\n", 35 | "\n", 36 | "for _ in range(n):\n", 37 | " a, b = map(int, input().split())\n", 38 | " p = (a / 100) * (b / 100)\n", 39 | " servers.append(p)\n", 40 | "\n", 41 | "total_probability = sum(servers)\n", 42 | "\n", 43 | "for server in servers:\n", 44 | " print(round(server / total_probability, 12))" 45 | ] 46 | } 47 | ], 48 | "metadata": { 49 | "language_info": { 50 | "name": "python" 51 | }, 52 | "orig_nbformat": 4 53 | }, 54 | "nbformat": 4, 55 | "nbformat_minor": 2 56 | } 57 | -------------------------------------------------------------------------------- /Лог без дат.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Лог без дат\n", 8 | "\n", 9 | "Ограничение времени\t2 секунды \n", 10 | "Ограничение памяти\t256Mb \n", 11 | "\n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "Вася решил обработать логи с сервера, но обнаружил, что из-за ошибки разработчиков для каждого события в логе записывается только время этого события в формате HH:MM:SS, а дата не записывается. \n", 16 | "Известно, что все события записаны в хронологическом порядке и два события не могли произойти в одну и ту же секунду. Определите минимальное количество дней, в течение которых записывался лог.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "Первая строка входных данных содержит единственное число n (1≤n≤100000) — количество событий в логе. Следующие n строк описывают времена событий. Каждая строка имеет формат HH:MM:SS, где HH — число от 0 до 23, а MM и SS — числа от 0 до 59. Все записи чисел состоят ровно из двух цифр.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Выведите одно целое число — минимальное количество дней, в течение которых записывался лог." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "def time_to_seconds(time):\n", 32 | " h, m, s = time.split(':')\n", 33 | " return int(h) * 3600 + int(m) * 60 + int(s)\n", 34 | "\n", 35 | "counter = int(input())\n", 36 | "last_log = time_to_seconds(input())\n", 37 | "days = 1\n", 38 | "\n", 39 | "for i in range(counter-1):\n", 40 | " new_log = time_to_seconds(input())\n", 41 | " if new_log <= last_log:\n", 42 | " days += 1\n", 43 | " last_log = new_log\n", 44 | "\n", 45 | "print(days)" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "language_info": { 51 | "name": "python" 52 | }, 53 | "orig_nbformat": 4 54 | }, 55 | "nbformat": 4, 56 | "nbformat_minor": 2 57 | } 58 | -------------------------------------------------------------------------------- /Степень четырёх.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Напишите программу, которая определяет, будет ли положительное целое число степенью четвёрки.\n", 15 | "\n", 16 | "Подсказка: степенью четвёрки будут все числа вида 4**n, где n – целое неотрицательное число.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "На вход подаётся целое число в диапазоне от 1 до 10000.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Выведите «True», если число является степенью четырёх, «False» –— в обратном случае." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 6, 28 | "metadata": {}, 29 | "outputs": [ 30 | { 31 | "name": "stdout", 32 | "output_type": "stream", 33 | "text": [ 34 | "False\n" 35 | ] 36 | } 37 | ], 38 | "source": [ 39 | "etalon = [4**i for i in range(7)]\n", 40 | "\n", 41 | "def is_power_of_four(number: int) -> bool:\n", 42 | " if number in etalon:\n", 43 | " return True\n", 44 | " return False\n", 45 | "\n", 46 | "print(is_power_of_four(int(input())))" 47 | ] 48 | } 49 | ], 50 | "metadata": { 51 | "kernelspec": { 52 | "display_name": "Python 3", 53 | "language": "python", 54 | "name": "python3" 55 | }, 56 | "language_info": { 57 | "codemirror_mode": { 58 | "name": "ipython", 59 | "version": 3 60 | }, 61 | "file_extension": ".py", 62 | "mimetype": "text/x-python", 63 | "name": "python", 64 | "nbconvert_exporter": "python", 65 | "pygments_lexer": "ipython3", 66 | "version": "3.10.6" 67 | }, 68 | "orig_nbformat": 4, 69 | "vscode": { 70 | "interpreter": { 71 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 72 | } 73 | } 74 | }, 75 | "nbformat": 4, 76 | "nbformat_minor": 2 77 | } 78 | -------------------------------------------------------------------------------- /Больше своих соседей.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Дан список чисел. Определите, сколько в этом списке элементов, которые больше двух своих соседей и выведите количество таких элементов.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Вводится список чисел. Все числа списка находятся на одной строке.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите ответ на задачу." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "x = list(map(int, input().split()))\n", 30 | "\n", 31 | "def check_list(x: list):\n", 32 | " counter = 0\n", 33 | " if len(x) < 3:\n", 34 | " return counter\n", 35 | " more_left = x[1] > x[0]\n", 36 | " for i in range(1, len(x)-1):\n", 37 | " more_right = x[i] > x[i+1]\n", 38 | " if more_left and more_right:\n", 39 | " counter += 1\n", 40 | " more_left = not more_right\n", 41 | " return counter\n", 42 | "\n", 43 | "print(check_list(x))" 44 | ] 45 | } 46 | ], 47 | "metadata": { 48 | "kernelspec": { 49 | "display_name": "Python 3", 50 | "language": "python", 51 | "name": "python3" 52 | }, 53 | "language_info": { 54 | "codemirror_mode": { 55 | "name": "ipython", 56 | "version": 3 57 | }, 58 | "file_extension": ".py", 59 | "mimetype": "text/x-python", 60 | "name": "python", 61 | "nbconvert_exporter": "python", 62 | "pygments_lexer": "ipython3", 63 | "version": "3.10.6" 64 | }, 65 | "orig_nbformat": 4, 66 | "vscode": { 67 | "interpreter": { 68 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 69 | } 70 | } 71 | }, 72 | "nbformat": 4, 73 | "nbformat_minor": 2 74 | } 75 | -------------------------------------------------------------------------------- /Угадай число.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Угадай число\n", 9 | "\n", 10 | "Август и Беатриса играют в игру. Август загадал натуральное число от 1 до n. Беатриса пытается угадать это число, для этого она называет некоторые множества натуральных чисел. Август отвечает Беатрисе YES, если среди названных ей чисел есть задуманное или NO в противном случае. После нескольких заданных вопросов Беатриса запуталась в том, какие вопросы она задавала и какие ответы получила и просит вас помочь ей определить, какие числа мог задумать Август.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Первая строка входных данных содержит число n — наибольшее число, которое мог загадать Август. Далее идут строки, содержащие вопросы Беатрисы. Каждая строка представляет собой набор чисел, разделенных пробелами. После каждой строки с вопросом идет ответ Августа: YES или NO. Наконец, последняя строка входных данных содержит одно слово HELP.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Вы должны вывести (через пробел, в порядке возрастания) все числа, которые мог задумать Август." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 26 | "x = file.readlines()\n", 27 | "max_int = int(x[0])\n", 28 | "result = set(range(1, max_int+1))\n", 29 | "for line in range(1, len(x)+1,2):\n", 30 | " if x[line].strip() == 'HELP':\n", 31 | " break\n", 32 | " else:\n", 33 | " y = set(filter(lambda x: x <= max_int, map(int, x[line].split())))\n", 34 | " if x[line+1].strip() == 'YES':\n", 35 | " result &= y\n", 36 | " else:\n", 37 | " result -= y\n", 38 | "\n", 39 | "print(*sorted(result))" 40 | ] 41 | } 42 | ], 43 | "metadata": { 44 | "language_info": { 45 | "name": "python" 46 | }, 47 | "orig_nbformat": 4 48 | }, 49 | "nbformat": 4, 50 | "nbformat_minor": 2 51 | } 52 | -------------------------------------------------------------------------------- /Рекурсивные числа Фибоначчи.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени 1.5 секунд \n", 9 | "Ограничение памяти 64Mb \n", 10 | "\n", 11 | "Ввод стандартный ввод или input.txt \n", 12 | "Вывод стандартный вывод или output.txt\n", 13 | "\n", 14 | "У Тимофея было n(0≤n≤32) стажёров. Каждый стажёр хотел быть лучше своих предшественников, поэтому i-й стажёр делал столько коммитов, сколько делали два предыдущих стажёра в сумме. Два первых стажёра были менее инициативными —– они сделали по одному коммиту. Пусть Fi — число коммитов, сделанных i-м стажёром (стажёры нумеруются с нуля). Тогда выполняется следующее: F0=F1=1. Для всех i≥2 выполнено Fi=Fi−1+Fi−2. Определите, сколько кода напишет следующий стажёр –— найдите Fn. Решение должно быть реализовано рекурсивно.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "На вход подаётся n — целое число в диапазоне от 0 до 32.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Нужно вывести Fn." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "def fibonacci(n):\n", 30 | " if n in (1, 2):\n", 31 | " return 1\n", 32 | " return fibonacci(n - 1) + fibonacci(n - 2)\n", 33 | "\n", 34 | "x = int(input()) + 1\n", 35 | "print(fibonacci(x))" 36 | ] 37 | } 38 | ], 39 | "metadata": { 40 | "kernelspec": { 41 | "display_name": "Python 3", 42 | "language": "python", 43 | "name": "python3" 44 | }, 45 | "language_info": { 46 | "codemirror_mode": { 47 | "name": "ipython", 48 | "version": 3 49 | }, 50 | "file_extension": ".py", 51 | "mimetype": "text/x-python", 52 | "name": "python", 53 | "nbconvert_exporter": "python", 54 | "pygments_lexer": "ipython3", 55 | "version": "3.10.6" 56 | }, 57 | "orig_nbformat": 4, 58 | "vscode": { 59 | "interpreter": { 60 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 61 | } 62 | } 63 | }, 64 | "nbformat": 4, 65 | "nbformat_minor": 2 66 | } 67 | -------------------------------------------------------------------------------- /Подпоследовательность.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.12 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Гоша любит играть в игру «Подпоследовательность»: даны 2 строки, и нужно понять, является ли первая из них подпоследовательностью второй. Когда строки достаточно длинные, очень трудно получить ответ на этот вопрос, просто посмотрев на них. Помогите Гоше написать функцию, которая решает эту задачу.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке записана строка s.\n", 18 | "\n", 19 | "Во второй —- строка t.\n", 20 | "\n", 21 | "Обе строки состоят из маленьких латинских букв, длины строк не превосходят 150000. Строки не могут быть пустыми.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите True, если s является подпоследовательностью t, иначе —– False." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "x = input()\n", 34 | "y = input()\n", 35 | "\n", 36 | "def search(x, y):\n", 37 | " start = -1\n", 38 | " for i in x:\n", 39 | " try:\n", 40 | " start = y.index(i, start+1)\n", 41 | " except ValueError:\n", 42 | " return False\n", 43 | " return True\n", 44 | "\n", 45 | "print(search(x, y))" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "kernelspec": { 51 | "display_name": "Python 3", 52 | "language": "python", 53 | "name": "python3" 54 | }, 55 | "language_info": { 56 | "codemirror_mode": { 57 | "name": "ipython", 58 | "version": 3 59 | }, 60 | "file_extension": ".py", 61 | "mimetype": "text/x-python", 62 | "name": "python", 63 | "nbconvert_exporter": "python", 64 | "pygments_lexer": "ipython3", 65 | "version": "3.10.6" 66 | }, 67 | "orig_nbformat": 4 68 | }, 69 | "nbformat": 4, 70 | "nbformat_minor": 2 71 | } 72 | -------------------------------------------------------------------------------- /Наибольшее произведение двух чисел.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "Ввод\tстандартный ввод или input.txt \n", 11 | "Вывод\tстандартный вывод или output.txt \n", 12 | "\n", 13 | "Дан список, заполненный произвольными целыми числами. Найдите в этом списке два числа, произведение которых максимально. Выведите эти числа в порядке неубывания.\n", 14 | "\n", 15 | "Список содержит не менее двух элементов. Числа подобраны так, что ответ однозначен.\n", 16 | "\n", 17 | "Решение должно иметь сложность O(n), где n - размер списка." 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "x = [int(i) for i in input().split()]\n", 27 | "\n", 28 | "def max_multi(x: list):\n", 29 | " p1 = p2 = 0\n", 30 | " n1 = n2 = 0\n", 31 | " if len(x) == 2:\n", 32 | " return sorted(x)\n", 33 | "\n", 34 | " for i in x:\n", 35 | " if i > 0:\n", 36 | " if i > p1:\n", 37 | " p1, p2 = i, p1\n", 38 | " elif i > p2:\n", 39 | " p2 = i\n", 40 | " if i < 0:\n", 41 | " if i < n1:\n", 42 | " n1, n2 = i, n1\n", 43 | " elif i < n2:\n", 44 | " n2 = i\n", 45 | "\n", 46 | " if n1*n2 > p1*p2:\n", 47 | " return [n1, n2]\n", 48 | " else:\n", 49 | " return [p2, p1]\n", 50 | "\n", 51 | "print(*max_multi(x)) " 52 | ] 53 | } 54 | ], 55 | "metadata": { 56 | "kernelspec": { 57 | "display_name": "Python 3", 58 | "language": "python", 59 | "name": "python3" 60 | }, 61 | "language_info": { 62 | "name": "python", 63 | "version": "3.10.6" 64 | }, 65 | "orig_nbformat": 4, 66 | "vscode": { 67 | "interpreter": { 68 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 69 | } 70 | } 71 | }, 72 | "nbformat": 4, 73 | "nbformat_minor": 2 74 | } 75 | -------------------------------------------------------------------------------- /Кубики.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Кубики\n", 9 | "\n", 10 | "Аня и Боря любят играть в разноцветные кубики, причем у каждого из них свой набор и в каждом наборе все кубики различны по цвету. Однажды дети заинтересовались, сколько существуют цветов таких, что кубики каждого цвета присутствуют в обоих наборах. Для этого они занумеровали все цвета случайными числами. На этом их энтузиазм иссяк, поэтому вам предлагается помочь им в оставшейся части. Номер любого цвета — это целое число в пределах от 0 до 109.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "В первой строке входного файла записаны числа N и M — количество кубиков у Ани и Бори соответственно. В следующих N строках заданы номера цветов кубиков Ани. В последних M строках номера цветов кубиков Бори.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите сначала количество, а затем отсортированные по возрастанию номера цветов таких, что кубики каждого цвета есть в обоих наборах, затем количество и отсортированные по возрастанию номера остальных цветов у Ани, потом количество и отсортированные по возрастанию номера остальных цветов у Бори." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "n, m = map(int, input().split())\n", 26 | "first = []\n", 27 | "second = []\n", 28 | "while n != 0:\n", 29 | " first.append(int(input()))\n", 30 | " n -= 1\n", 31 | "while m != 0:\n", 32 | " second.append(int(input()))\n", 33 | " m -= 1\n", 34 | "first = set(first)\n", 35 | "second = set(second)\n", 36 | "x = first & second\n", 37 | "print(len(x))\n", 38 | "print(' '.join(list(map(str, sorted(x)))))\n", 39 | "y = first - second\n", 40 | "print(len(y))\n", 41 | "print(' '.join(list(map(str, sorted(y)))))\n", 42 | "z = second - first\n", 43 | "print(len(z))\n", 44 | "print(' '.join(list(map(str, sorted(z)))))" 45 | ] 46 | } 47 | ], 48 | "metadata": { 49 | "language_info": { 50 | "name": "python" 51 | }, 52 | "orig_nbformat": 4 53 | }, 54 | "nbformat": 4, 55 | "nbformat_minor": 2 56 | } 57 | -------------------------------------------------------------------------------- /Выведите последовательность.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Из тестовых заданий: \n", 8 | "\n", 9 | "Напишите программу, которая выводит _n_ первых элементов последовательности 122333444455555… (число повторяется столько раз, чему оно равно)." 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "def sequence(n: int) -> None:\n", 19 | " \"\"\"Вывод последовательности в терминал.\"\"\"\n", 20 | " num: int = 1\n", 21 | "\n", 22 | " while n > 0:\n", 23 | " print(str(num) * min(num, n), end='')\n", 24 | " n -= num\n", 25 | " num += 1\n", 26 | "\n", 27 | " print()\n", 28 | "\n", 29 | "\n", 30 | "def main() -> None:\n", 31 | " \"\"\"Основная функция.\"\"\"\n", 32 | " n: int = int(input(\"Введите количество элементов: \"))\n", 33 | " if n < 1:\n", 34 | " raise ValueError(\n", 35 | " \"Количество элементов не может быть меньше единицы числом\"\n", 36 | " )\n", 37 | " sequence(n)\n", 38 | "\n", 39 | "\n", 40 | "if __name__ == '__main__':\n", 41 | " try:\n", 42 | " main()\n", 43 | " except ValueError as e:\n", 44 | " print(e)" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": {}, 50 | "source": [ 51 | "сознательно сделан вывод в консоль внутри функции, а не через return результирующей строки - в этой реализации выполняется задача вывода в консоль, но при больших числах в памяти не копится вся строка." 52 | ] 53 | } 54 | ], 55 | "metadata": { 56 | "kernelspec": { 57 | "display_name": "Python 3", 58 | "language": "python", 59 | "name": "python3" 60 | }, 61 | "language_info": { 62 | "codemirror_mode": { 63 | "name": "ipython", 64 | "version": 3 65 | }, 66 | "file_extension": ".py", 67 | "mimetype": "text/x-python", 68 | "name": "python", 69 | "nbconvert_exporter": "python", 70 | "pygments_lexer": "ipython3", 71 | "version": "3.10.12" 72 | }, 73 | "orig_nbformat": 4 74 | }, 75 | "nbformat": 4, 76 | "nbformat_minor": 2 77 | } 78 | -------------------------------------------------------------------------------- /Значения функции.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вася делает тест по математике: вычисляет значение функций в различных точках. Стоит отличная погода, и друзья зовут Васю гулять. Но мальчик решил сначала закончить тест и только после этого идти к друзьям. К сожалению, Вася пока не умеет программировать. Зато вы умеете. Помогите Васе написать код функции, вычисляющей y = ax2 + bx + c. Напишите программу, которая будет по коэффициентам a, b, c и числу x выводить значение функции в точке x.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "На вход через пробел подаются целые числа a, x, b, c. В конце ввода находится перенос строки.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите одно число — значение функции в точке x." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "-183\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "def evaluate_function(a: int, b: int, c: int, x: int) -> int:\n", 38 | " return a*x**2 + b*x + c\n", 39 | "\n", 40 | "a, x, b, c = map(int, input().strip().split())\n", 41 | "print(evaluate_function(a, b, c, x))" 42 | ] 43 | } 44 | ], 45 | "metadata": { 46 | "kernelspec": { 47 | "display_name": "Python 3", 48 | "language": "python", 49 | "name": "python3" 50 | }, 51 | "language_info": { 52 | "codemirror_mode": { 53 | "name": "ipython", 54 | "version": 3 55 | }, 56 | "file_extension": ".py", 57 | "mimetype": "text/x-python", 58 | "name": "python", 59 | "nbconvert_exporter": "python", 60 | "pygments_lexer": "ipython3", 61 | "version": "3.10.6" 62 | }, 63 | "orig_nbformat": 4, 64 | "vscode": { 65 | "interpreter": { 66 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 67 | } 68 | } 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 2 72 | } 73 | -------------------------------------------------------------------------------- /Работа из дома.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вася реализовал функцию, которая переводит целое число из десятичной системы в двоичную. Но, кажется, она получилась не очень оптимальной.\n", 15 | "\n", 16 | "Попробуйте написать более эффективную программу.\n", 17 | "\n", 18 | "Не используйте встроенные средства языка по переводу чисел в бинарное представление.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "На вход подаётся целое число в диапазоне от 0 до 10000.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите двоичное представление этого числа." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "def to_binary(number: int) -> str:\n", 34 | " answer = []\n", 35 | " if number == 0:\n", 36 | " return 0\n", 37 | " else:\n", 38 | " while number != 1:\n", 39 | " answer.insert(0, number%2)\n", 40 | " number = number//2\n", 41 | " answer.insert(0, number%2)\n", 42 | " return ''.join(map(str, answer))\n", 43 | "\n", 44 | "def read_input() -> int:\n", 45 | " return int(input().strip())\n", 46 | "\n", 47 | "print(to_binary(read_input()))" 48 | ] 49 | } 50 | ], 51 | "metadata": { 52 | "kernelspec": { 53 | "display_name": "Python 3", 54 | "language": "python", 55 | "name": "python3" 56 | }, 57 | "language_info": { 58 | "codemirror_mode": { 59 | "name": "ipython", 60 | "version": 3 61 | }, 62 | "file_extension": ".py", 63 | "mimetype": "text/x-python", 64 | "name": "python", 65 | "nbconvert_exporter": "python", 66 | "pygments_lexer": "ipython3", 67 | "version": "3.10.6" 68 | }, 69 | "orig_nbformat": 4, 70 | "vscode": { 71 | "interpreter": { 72 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 73 | } 74 | } 75 | }, 76 | "nbformat": 4, 77 | "nbformat_minor": 2 78 | } 79 | -------------------------------------------------------------------------------- /Гардероб.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt\n", 13 | "\n", 14 | "Рита решила оставить у себя одежду только трёх цветов: розового, жёлтого и малинового. После того как вещи других расцветок были убраны, Рита захотела отсортировать свой новый гардероб по цветам. Сначала должны идти вещи розового цвета, потом —– жёлтого, и в конце —– малинового. Помогите Рите справиться с этой задачей.\n", 15 | "\n", 16 | "Примечание: попробуйте решить задачу за один проход по массиву!\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке задано количество предметов в гардеробе: n –— оно не превосходит 1000000. Во второй строке даётся массив, в котором указан цвет для каждого предмета. Розовый цвет обозначен 0, жёлтый —– 1, малиновый –— 2.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Нужно вывести в строку через пробел цвета предметов в правильном порядке." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "size = int(input())\n", 32 | "array = input().split()\n", 33 | "\n", 34 | "zero = [] \n", 35 | "one = []\n", 36 | "two = []\n", 37 | "\n", 38 | "for i in array:\n", 39 | " if i == '0':\n", 40 | " zero.append(i)\n", 41 | " elif i == '1':\n", 42 | " one.append(i)\n", 43 | " elif i == '2':\n", 44 | " two.append(i)\n", 45 | "\n", 46 | "print(*zero, *one, *two)" 47 | ] 48 | } 49 | ], 50 | "metadata": { 51 | "kernelspec": { 52 | "display_name": "Python 3", 53 | "language": "python", 54 | "name": "python3" 55 | }, 56 | "language_info": { 57 | "codemirror_mode": { 58 | "name": "ipython", 59 | "version": 3 60 | }, 61 | "file_extension": ".py", 62 | "mimetype": "text/x-python", 63 | "name": "python", 64 | "nbconvert_exporter": "python", 65 | "pygments_lexer": "ipython3", 66 | "version": "3.10.6" 67 | }, 68 | "orig_nbformat": 4 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 2 72 | } 73 | -------------------------------------------------------------------------------- /Уравнение с корнем.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "Ввод\tстандартный ввод или input.txt \n", 11 | "Вывод\tстандартный вывод или output.txt \n", 12 | "\n", 13 | "Решите в целых числах уравнение:\n", 14 | "\n", 15 | "sqtr(ax+b) = c\n", 16 | "\n", 17 | "a, b, c – данные целые числа: найдите все решения или сообщите, что решений в целых числах нет.\n", 18 | "\n", 19 | "Формат ввода \n", 20 | "Вводятся три числа a, b и c по одному в строке.\n", 21 | "\n", 22 | "Формат вывода \n", 23 | "Программа должна вывести все решения уравнения в порядке возрастания, либо NO SOLUTION (заглавными буквами), если решений нет. Если решений бесконечно много, вывести MANY SOLUTIONS." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 21, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "name": "stdout", 33 | "output_type": "stream", 34 | "text": [ 35 | "0\n" 36 | ] 37 | } 38 | ], 39 | "source": [ 40 | "a, b, c = int(input()), int(input()), int(input())\n", 41 | "\n", 42 | "if c < 0:\n", 43 | " print(\"NO SOLUTION\")\n", 44 | "elif (a + b) == c * c and (2 * a + b) == c * c:\n", 45 | " print(\"MANY SOLUTIONS\")\n", 46 | "else:\n", 47 | " if a != 0 and (c * c - b) / a == (c * c - b) // a:\n", 48 | " print((c * c - b) // a)\n", 49 | " else:\n", 50 | " print(\"NO SOLUTION\")" 51 | ] 52 | } 53 | ], 54 | "metadata": { 55 | "kernelspec": { 56 | "display_name": "Python 3", 57 | "language": "python", 58 | "name": "python3" 59 | }, 60 | "language_info": { 61 | "codemirror_mode": { 62 | "name": "ipython", 63 | "version": 3 64 | }, 65 | "file_extension": ".py", 66 | "mimetype": "text/x-python", 67 | "name": "python", 68 | "nbconvert_exporter": "python", 69 | "pygments_lexer": "ipython3", 70 | "version": "3.10.6" 71 | }, 72 | "orig_nbformat": 4, 73 | "vscode": { 74 | "interpreter": { 75 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 76 | } 77 | } 78 | }, 79 | "nbformat": 4, 80 | "nbformat_minor": 2 81 | } 82 | -------------------------------------------------------------------------------- /Лишняя буква.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Васе очень нравятся задачи про строки, поэтому он придумал свою. Есть 2 строки s и t, состоящие только из строчных букв. Строка t получена перемешиванием букв строки s и добавлением 1 буквы в случайную позицию. Нужно найти добавленную букву.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "На вход подаются строки s и t, разделённые переносом строки. Длины строк не превосходят 1000 символов. Строки не бывают пустыми.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите лишнюю букву." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "from typing import Tuple\n", 30 | "\n", 31 | "def get_excessive_letter(shorter: str, longer: str) -> str:\n", 32 | " shorter = list(shorter)\n", 33 | " longer = list(longer)\n", 34 | " for i in shorter:\n", 35 | " longer.remove(i)\n", 36 | " return longer[0]\n", 37 | "\n", 38 | "def read_input() -> Tuple[str, str]:\n", 39 | " shorter = input().strip()\n", 40 | " longer = input().strip()\n", 41 | " return shorter, longer\n", 42 | "\n", 43 | "shorter, longer = read_input()\n", 44 | "print(get_excessive_letter(shorter, longer))" 45 | ] 46 | } 47 | ], 48 | "metadata": { 49 | "kernelspec": { 50 | "display_name": "Python 3", 51 | "language": "python", 52 | "name": "python3" 53 | }, 54 | "language_info": { 55 | "codemirror_mode": { 56 | "name": "ipython", 57 | "version": 3 58 | }, 59 | "file_extension": ".py", 60 | "mimetype": "text/x-python", 61 | "name": "python", 62 | "nbconvert_exporter": "python", 63 | "pygments_lexer": "ipython3", 64 | "version": "3.10.6" 65 | }, 66 | "orig_nbformat": 4, 67 | "vscode": { 68 | "interpreter": { 69 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 70 | } 71 | } 72 | }, 73 | "nbformat": 4, 74 | "nbformat_minor": 2 75 | } 76 | -------------------------------------------------------------------------------- /Покупка домов.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.12 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Тимофей решил купить несколько домов на знаменитом среди разработчиков Алгосском архипелаге. Он нашёл n объявлений о продаже, где указана стоимость каждого дома в алгосских франках. А у Тимофея есть k франков. Помогите ему определить, какое наибольшее количество домов на Алгосах он сможет приобрести за эти деньги.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке через пробел записаны натуральные числа n и k.\n", 18 | "\n", 19 | "n — количество домов, которые рассматривает Тимофей, оно не превосходит 100000;\n", 20 | "\n", 21 | "k — общий бюджет, не превосходит 100000;\n", 22 | "\n", 23 | "В следующей строке через пробел записано n стоимостей домов. Каждое из чисел не превосходит 100000. Все стоимости — натуральные числа.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите одно число —– наибольшее количество домов, которое может купить Тимофей." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "n, k = map(int, input().split())\n", 36 | "prices = sorted(list(map(int, input().split())))\n", 37 | "counter = 0\n", 38 | "\n", 39 | "for i in prices:\n", 40 | " if k - i >= 0:\n", 41 | " counter += 1\n", 42 | " k -= i\n", 43 | " else:\n", 44 | " break\n", 45 | "\n", 46 | "print(counter)" 47 | ] 48 | } 49 | ], 50 | "metadata": { 51 | "kernelspec": { 52 | "display_name": "Python 3", 53 | "language": "python", 54 | "name": "python3" 55 | }, 56 | "language_info": { 57 | "codemirror_mode": { 58 | "name": "ipython", 59 | "version": 3 60 | }, 61 | "file_extension": ".py", 62 | "mimetype": "text/x-python", 63 | "name": "python", 64 | "nbconvert_exporter": "python", 65 | "pygments_lexer": "ipython3", 66 | "version": "3.10.6" 67 | }, 68 | "orig_nbformat": 4 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 2 72 | } 73 | -------------------------------------------------------------------------------- /Симметричная последовательность.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Последовательность чисел назовем симметричной, если она одинаково читается как слева направо, так и справа налево. Например, следующие последовательности являются симметричными: \n", 15 | "1 2 3 4 5 4 3 2 1 \n", 16 | "1 2 1 2 2 1 2 1 \n", 17 | "\n", 18 | "Вашей программе будет дана последовательность чисел. Требуется определить, какое минимальное количество и каких чисел надо приписать в конец этой последовательности, чтобы она стала симметричной.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "Сначала вводится число N — количество элементов исходной последовательности (1 ≤ N ≤ 100). Далее идут N чисел — элементы этой последовательности, натуральные числа от 1 до 9.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите сначала число M — минимальное количество элементов, которое надо дописать к последовательности, а потом M чисел (каждое — от 1 до 9) — числа, которые надо дописать к последовательности." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "n = int(input())\n", 34 | "x = input()\n", 35 | "if x == x[::-1]:\n", 36 | " print(0)\n", 37 | "else:\n", 38 | " x = x.split()\n", 39 | " for i in range(1,n):\n", 40 | " check = x[i:]\n", 41 | " if check == check[::-1]:\n", 42 | " ans = x[:i][::-1]\n", 43 | " print(len(ans))\n", 44 | " print(*ans)\n", 45 | " break" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "kernelspec": { 51 | "display_name": "venv", 52 | "language": "python", 53 | "name": "python3" 54 | }, 55 | "language_info": { 56 | "name": "python", 57 | "version": "3.10.6" 58 | }, 59 | "orig_nbformat": 4, 60 | "vscode": { 61 | "interpreter": { 62 | "hash": "e688ee72b1c52c0fb07e5f21353202736868602701a19717d3e26524e4041c77" 63 | } 64 | } 65 | }, 66 | "nbformat": 4, 67 | "nbformat_minor": 2 68 | } 69 | -------------------------------------------------------------------------------- /Палиндром.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Помогите Васе понять, будет ли фраза палиндромом. Учитываются только буквы и цифры, заглавные и строчные буквы считаются одинаковыми.\n", 15 | "\n", 16 | "Решение должно работать за O(N), где N — длина строки на входе.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В единственной строке записана фраза или слово. Буквы могут быть только латинские. Длина текста не превосходит 20000 символов.\n", 20 | "\n", 21 | "Фраза может состоять из строчных и прописных латинских букв, цифр, знаков препинания.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите «True», если фраза является палиндромом, и «False», если не является." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 16, 30 | "metadata": {}, 31 | "outputs": [ 32 | { 33 | "name": "stdout", 34 | "output_type": "stream", 35 | "text": [ 36 | "False\n" 37 | ] 38 | } 39 | ], 40 | "source": [ 41 | "import string\n", 42 | "\n", 43 | "def is_palindrome(line: str) -> bool:\n", 44 | " line = line.lower().translate(str.maketrans('', '', string.punctuation)).replace(' ', '')\n", 45 | " if line == line[::-1]:\n", 46 | " return True\n", 47 | " return False\n", 48 | "\n", 49 | "print(is_palindrome(input().strip()))" 50 | ] 51 | } 52 | ], 53 | "metadata": { 54 | "kernelspec": { 55 | "display_name": "Python 3", 56 | "language": "python", 57 | "name": "python3" 58 | }, 59 | "language_info": { 60 | "codemirror_mode": { 61 | "name": "ipython", 62 | "version": 3 63 | }, 64 | "file_extension": ".py", 65 | "mimetype": "text/x-python", 66 | "name": "python", 67 | "nbconvert_exporter": "python", 68 | "pygments_lexer": "ipython3", 69 | "version": "3.10.6" 70 | }, 71 | "orig_nbformat": 4, 72 | "vscode": { 73 | "interpreter": { 74 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 75 | } 76 | } 77 | }, 78 | "nbformat": 4, 79 | "nbformat_minor": 2 80 | } 81 | -------------------------------------------------------------------------------- /Канонический путь.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Канонический путь\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "По заданной строке, являющейся абсолютным адресом в Unix-системе, вам необходимо получить канонический адрес.\n", 17 | "\n", 18 | "В Unix-системе \".\" соответсвутет текущей директории, \"..\" — родительской директории, при этом будем считать, что любое количество точек подряд, большее двух, соответствует директории с таким названием (состоящем из точек). \"/\" является разделителем вложенных директорий, причем несколько \"/\" подряд должны интерпретироваться как один \"/\".\n", 19 | "\n", 20 | "Канонический путь должен обладать следующими свойствами:\n", 21 | "\n", 22 | "1. всегда начинаться с одного \"/\"\n", 23 | "2. любые две вложенные директории разделяются ровно одним знаком \"/\"\n", 24 | "3. путь не заканчивается \"/\" (за исключением корневой директории, состоящего только из символа \"/\")\n", 25 | "4. в каноническом пути есть только директории, т.е. нет ни одного вхождения \".\" или \"..\" как соответствия текущей или родительской директории\n", 26 | "\n", 27 | "Формат ввода \n", 28 | "Вводится строка с абсолютным адресом, её длина не превосходит 100.\n", 29 | "\n", 30 | "Формат вывода \n", 31 | "Выведите канонический путь." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "abs_path = input().split('/')\n", 41 | "\n", 42 | "canon_path =[]\n", 43 | "\n", 44 | "for i in abs_path:\n", 45 | " if not i or i == '.' or (i == '..' and not canon_path):\n", 46 | " continue\n", 47 | " if i == '..' and canon_path:\n", 48 | " canon_path.pop()\n", 49 | " continue\n", 50 | " canon_path.append(i)\n", 51 | "\n", 52 | "\n", 53 | "print('/' + '/'.join(canon_path))" 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "language_info": { 59 | "name": "python" 60 | }, 61 | "orig_nbformat": 4 62 | }, 63 | "nbformat": 4, 64 | "nbformat_minor": 2 65 | } 66 | -------------------------------------------------------------------------------- /Ближайшее число.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Напишите программу, которая находит в массиве элемент, самый близкий по величине к данному числу.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке задается одно натуральное число N, не превосходящее 1000 – размер массива. Во второй строке содержатся N чисел – элементы массива (целые числа, не превосходящие по модулю 1000). В третьей строке вводится одно целое число x, не превосходящее по модулю 1000.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Вывести значение элемента массива, ближайшее к x. Если таких чисел несколько, выведите любое из них." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "K = int(input())\n", 30 | "check_list = map(int, input().split())\n", 31 | "N = int(input())\n", 32 | "\n", 33 | "def check(arr, N):\n", 34 | " closer = None\n", 35 | " diff = 2001\n", 36 | " for i in arr:\n", 37 | " if i == N:\n", 38 | " return N\n", 39 | " if i == closer:\n", 40 | " continue\n", 41 | " if abs(N - i) < diff:\n", 42 | " diff = abs(N - i)\n", 43 | " closer = i\n", 44 | " return closer\n", 45 | "\n", 46 | "print(check(check_list, N))" 47 | ] 48 | } 49 | ], 50 | "metadata": { 51 | "kernelspec": { 52 | "display_name": "Python 3", 53 | "language": "python", 54 | "name": "python3" 55 | }, 56 | "language_info": { 57 | "codemirror_mode": { 58 | "name": "ipython", 59 | "version": 3 60 | }, 61 | "file_extension": ".py", 62 | "mimetype": "text/x-python", 63 | "name": "python", 64 | "nbconvert_exporter": "python", 65 | "pygments_lexer": "ipython3", 66 | "version": "3.10.6" 67 | }, 68 | "orig_nbformat": 4, 69 | "vscode": { 70 | "interpreter": { 71 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 72 | } 73 | } 74 | }, 75 | "nbformat": 4, 76 | "nbformat_minor": 2 77 | } 78 | -------------------------------------------------------------------------------- /Полиномиальный хэш.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.65 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Алле очень понравился алгоритм вычисления полиномиального хеша. Помогите ей написать функцию, вычисляющую хеш строки s. В данной задаче необходимо использовать в качестве значений отдельных символов их коды в таблице ASCII.\n", 15 | "\n", 16 | "Полиномиальный хеш считается по формуле (x - умножение, ^ - возведение в степень): \n", 17 | "\n", 18 | "h(s) = (s_1 x a^n-1 + s_2 x a^n-1 + ... + s_n-1 x a + s_n) mod m\n", 19 | "\n", 20 | "Формат ввода\n", 21 | "В первой строке дано число a (1 ≤ a ≤ 1000) –— основание, по которому считается хеш.\n", 22 | "\n", 23 | "Во второй строке дано число m (1 ≤ m ≤ 109) –— модуль.\n", 24 | "\n", 25 | "В третьей строке дана строка s (0 ≤ |s| ≤ 106), состоящая из больших и маленьких латинских букв.\n", 26 | "\n", 27 | "Формат вывода\n", 28 | "Выведите целое неотрицательное число –— хеш заданной строки." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "a = int(input())\n", 38 | "m = int(input())\n", 39 | "s = input()\n", 40 | "\n", 41 | "def hash(s: str, a:int, m:int):\n", 42 | " hash = 0\n", 43 | " len_string = len(s)\n", 44 | " step_a = 1\n", 45 | " for i in s:\n", 46 | " hash = (hash + ord(i)*step_a) % m\n", 47 | " step_a = (step_a * a) % m\n", 48 | " return hash % m\n", 49 | "\n", 50 | "print(hash(s[::-1], a, m))" 51 | ] 52 | } 53 | ], 54 | "metadata": { 55 | "kernelspec": { 56 | "display_name": "Python 3", 57 | "language": "python", 58 | "name": "python3" 59 | }, 60 | "language_info": { 61 | "codemirror_mode": { 62 | "name": "ipython", 63 | "version": 3 64 | }, 65 | "file_extension": ".py", 66 | "mimetype": "text/x-python", 67 | "name": "python", 68 | "nbconvert_exporter": "python", 69 | "pygments_lexer": "ipython3", 70 | "version": "3.10.6" 71 | }, 72 | "orig_nbformat": 4 73 | }, 74 | "nbformat": 4, 75 | "nbformat_minor": 2 76 | } 77 | -------------------------------------------------------------------------------- /Списочная форма.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вася просил Аллу помочь решить задачу. На этот раз по информатике.\n", 15 | "\n", 16 | "Для неотрицательного целого числа X списочная форма –— это массив его цифр слева направо. К примеру, для 1231 списочная форма будет [1,2,3,1]. На вход подается количество цифр числа Х, списочная форма неотрицательного числа Х и неотрицательное число K. Число К не превосходят 10000. Длина числа Х не превосходит 1000.\n", 17 | "\n", 18 | "Нужно вернуть списочную форму числа X + K.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке — длина списочной формы числа X. На следующей строке — сама списочная форма с цифрами записанными через пробел.\n", 22 | "\n", 23 | "В последней строке записано число K, 0 ≤ K ≤ 10000.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите списочную форму числа X+K." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "from typing import Tuple\n", 36 | "\n", 37 | "\n", 38 | "def read_input() -> Tuple[int, int]:\n", 39 | " n = int(input())\n", 40 | " number = int(input().replace(' ', ''))\n", 41 | " k = int(input())\n", 42 | " return number, k\n", 43 | "\n", 44 | "number, k = read_input()\n", 45 | "print(*list(str(k+number)))" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "kernelspec": { 51 | "display_name": "Python 3", 52 | "language": "python", 53 | "name": "python3" 54 | }, 55 | "language_info": { 56 | "codemirror_mode": { 57 | "name": "ipython", 58 | "version": 3 59 | }, 60 | "file_extension": ".py", 61 | "mimetype": "text/x-python", 62 | "name": "python", 63 | "nbconvert_exporter": "python", 64 | "pygments_lexer": "ipython3", 65 | "version": "3.10.6" 66 | }, 67 | "orig_nbformat": 4, 68 | "vscode": { 69 | "interpreter": { 70 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 71 | } 72 | } 73 | }, 74 | "nbformat": 4, 75 | "nbformat_minor": 2 76 | } 77 | -------------------------------------------------------------------------------- /Забастовки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Забастовки\n", 9 | "\n", 10 | "Политическая жизнь одной страны очень оживленная. В стране действует K политических партий, каждая из которых регулярно объявляет национальную забастовку. Дни, когда хотя бы одна из партий объявляет забастовку, при условии, что это не суббота или воскресенье (когда и так никто не работает), наносят большой ущерб экономике страны. i-я партия объявляет забастовки строго каждые bi дней, начиная с дня с номером ai. То есть i-я партия объявляет забастовки в дни ai, ai+bi, ai+2bi и т.д. Если в какой-то день несколько партий объявляет забастовку, то это считается одной общенациональной забастовкой. В календаре страны N дней, пронумерованных от 1 до N. Первый день года является понедельником, шестой и седьмой дни года — выходные, неделя состоит из семи дней.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Программа получает на вход число дней в году N (1≤ N≤106) и число политических партий K (1≤ K≤100). Далее идет K строк, описывающие графики проведения забастовок. i-я строка содержит числа ai и bi (1≤ ai, bi≤ N).\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите единственное число: количество забастовок, произошедших в течение года." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "d, parties = map(int, input().split())\n", 26 | "days = list(range(1, d+1))\n", 27 | "\n", 28 | "def null_weekends(begin, step):\n", 29 | " for i in range(begin-1, d, step):\n", 30 | " days[i] = 0\n", 31 | "\n", 32 | "def null_days(begin, step):\n", 33 | " for i in range(begin-1, d, step):\n", 34 | " if days[i] == 0:\n", 35 | " continue\n", 36 | " else:\n", 37 | " days[i] = 'b'\n", 38 | "\n", 39 | "null_weekends(6, 7)\n", 40 | "null_weekends(7, 7)\n", 41 | "\n", 42 | "while parties != 0:\n", 43 | " begin, step = map(int, input().split())\n", 44 | " null_days(begin, step)\n", 45 | " parties -= 1\n", 46 | "\n", 47 | "print(days.count('b'))" 48 | ] 49 | } 50 | ], 51 | "metadata": { 52 | "language_info": { 53 | "name": "python" 54 | }, 55 | "orig_nbformat": 4 56 | }, 57 | "nbformat": 4, 58 | "nbformat_minor": 2 59 | } 60 | -------------------------------------------------------------------------------- /Семипроцентный барьер.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Семипроцентный барьер\n", 9 | "\n", 10 | "В Государственную Думу Федерального Собрания Российской Федерации выборы производятся по партийным спискам. Каждый избиратель указывает одну партию, за которую он отдает свой голос. В Государственную Думу попадают партии, которые набрали не менее 7% от числа голосов избирателей.\n", 11 | "\n", 12 | "Дан список партий и список голосов избирателей. Выведите список партий, которые попадут в Государственную Думу.\n", 13 | "\n", 14 | "Формат ввода \n", 15 | "В первой строке входного файла написано слово PARTIES:. Далее идет список партий, участвующих в выборах.\n", 16 | "\n", 17 | "Затем идет строка, содержащая слово VOTES:. За ним идут названия партий, за которые проголосовали избиратели, по одному названию в строке. Названия могут быть только строками из первого списка.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Программа должна вывести названия партий, получивших не менее 7% от числа голосов в том порядке, в котором они следуют в первом списке." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "file1 = open(\"input.txt\", \"r\", encoding='utf-8')\n", 30 | "parties = False\n", 31 | "votes = False\n", 32 | "electors = 0\n", 33 | "election = {}\n", 34 | "\n", 35 | "while True:\n", 36 | " line = file1.readline()\n", 37 | " if not line:\n", 38 | " break\n", 39 | " if 'PARTIES' in line:\n", 40 | " parties = True\n", 41 | " continue\n", 42 | " if 'VOTES' in line:\n", 43 | " parties = False\n", 44 | " votes = True\n", 45 | " continue\n", 46 | " if parties is True:\n", 47 | " election[line.strip()] = 0\n", 48 | " if votes is True:\n", 49 | " election[line.strip()] += 1\n", 50 | " electors += 1\n", 51 | "\n", 52 | "for i in election:\n", 53 | " election[i] /= electors\n", 54 | "\n", 55 | "print('\\n'.join([i for i in election if election[i]>=0.07]))" 56 | ] 57 | } 58 | ], 59 | "metadata": { 60 | "language_info": { 61 | "name": "python" 62 | }, 63 | "orig_nbformat": 4 64 | }, 65 | "nbformat": 4, 66 | "nbformat_minor": 2 67 | } 68 | -------------------------------------------------------------------------------- /Коньки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Коньки\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "В школе есть много коньков самых разных размеров. Школьник может надеть коньки любого размера, который не меньше размеров его ноги. Известны размеры всех коньков и размеры ног школьников. Определите, какое наибольшее число школьников сможет одновременно пойти покататься.\n", 16 | "\n", 17 | "Формат ввода \n", 18 | "Первая строка содержит список натуральных чисел размеры коньков. Вторая строка содержит список размеров ног школьников.\n", 19 | "\n", 20 | "Формат вывода \n", 21 | "Выведите единственное число — наибольшее количество школьников, которое сможет пойти на каток." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "sizes = sorted(list(map(int,input().split())))\n", 31 | "need = list(map(int,input().split()))\n", 32 | "\n", 33 | "def binary_search(arr, val):\n", 34 | " if len(arr) == 0:\n", 35 | " return None\n", 36 | " low_ind = 0\n", 37 | " high_ind = len(arr) - 1\n", 38 | " while(high_ind - low_ind > 1):\n", 39 | " mid_index = (high_ind + low_ind) // 2\n", 40 | " if(arr[mid_index] < val):\n", 41 | " low_ind = mid_index\n", 42 | " else:\n", 43 | " high_ind = mid_index\n", 44 | " if val == arr[low_ind] or arr[high_ind] == val:\n", 45 | " return val\n", 46 | " elif val < arr[low_ind]:\n", 47 | " return arr[low_ind]\n", 48 | " elif val < arr[high_ind]:\n", 49 | " return arr[high_ind]\n", 50 | " else:\n", 51 | " return None\n", 52 | "\n", 53 | "var = 0\n", 54 | "\n", 55 | "for i in need:\n", 56 | " res = binary_search(sizes, i)\n", 57 | " if res:\n", 58 | " sizes.remove(res)\n", 59 | " var += 1\n", 60 | "\n", 61 | "print(var)" 62 | ] 63 | } 64 | ], 65 | "metadata": { 66 | "language_info": { 67 | "name": "python" 68 | }, 69 | "orig_nbformat": 4 70 | }, 71 | "nbformat": 4, 72 | "nbformat_minor": 2 73 | } 74 | -------------------------------------------------------------------------------- /Факторизация.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.2 секунды \n", 9 | "Ограничение памяти 64Mb \n", 10 | "\n", 11 | "Ввод стандартный ввод или input.txt \n", 12 | "Вывод стандартный вывод или output.txt \n", 13 | "\n", 14 | "Основная теорема арифметики говорит: любое число раскладывается на произведение простых множителей единственным образом, с точностью до их перестановки.\n", 15 | "\n", 16 | "Разложение числа на простые множители называется факторизацией числа.\n", 17 | "\n", 18 | "Напишите программу, которая производит факторизацию переданного числа.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В единственной строке дано число n (2 ≤ n ≤ 10**9), которое нужно факторизовать.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите в порядке неубывания простые множители, на которые раскладывается число n." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "from typing import List\n", 34 | "\n", 35 | "\n", 36 | "def factorize(n: int) -> List[int]:\n", 37 | " result = []\n", 38 | "\n", 39 | " for i in range(2, int(n**0.5)+1):\n", 40 | " while not n % i:\n", 41 | " result.append(i)\n", 42 | " n = n // i\n", 43 | " if n == 1:\n", 44 | " break\n", 45 | "\n", 46 | " if n > 1:\n", 47 | " result.append(n)\n", 48 | " return result\n", 49 | "\n", 50 | "result = factorize(int(input()))\n", 51 | "print(' '.join(map(str, result)))" 52 | ] 53 | } 54 | ], 55 | "metadata": { 56 | "kernelspec": { 57 | "display_name": "Python 3", 58 | "language": "python", 59 | "name": "python3" 60 | }, 61 | "language_info": { 62 | "codemirror_mode": { 63 | "name": "ipython", 64 | "version": 3 65 | }, 66 | "file_extension": ".py", 67 | "mimetype": "text/x-python", 68 | "name": "python", 69 | "nbconvert_exporter": "python", 70 | "pygments_lexer": "ipython3", 71 | "version": "3.10.6" 72 | }, 73 | "orig_nbformat": 4, 74 | "vscode": { 75 | "interpreter": { 76 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 77 | } 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 2 82 | } 83 | -------------------------------------------------------------------------------- /Утилита paste.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Утилита paste\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "Вам необходимо реализовать упрощенный аналог консольной утилиты paste. В Linux эта утилита принимает на вход несколько файлов и выписывает очередные строки этих файлов, склеенные через знак табуляции. В этой задаче отдельных входных файлов не будет: вместо этого данные будут просто последовательно подаваться на вход программы.\n", 16 | "\n", 17 | "Формат ввода \n", 18 | "В первой строке указано неотрицательное целое M — количество \"файлов\". Далее идёт M блоков данных. В начале каждого блока сначала указано неотрицательное целое число Ni — количество строк очередного \"файла\". Затем идут сами строки, состоящие из латинских букв, цифр и знаков пунктуации, но не содержащие пробельных разделителей (то есть, вы можете их читать просто через std::cin >> word). Гарантируется, что строки непусты. Количество файлов, количество строк в каждом файле и количество символов в каждой строке не превосходит 100.\n", 19 | "\n", 20 | "Формат вывода \n", 21 | "Выведите сначала первые строки всех файлов (склеив их через табуляцию), затем вторые строки и т. д. В конце каждой строки должен быть напечатан символ перевода строки. Если в каком-то из файлов строки закончатся раньше, не выводите в соответствующем поле ничего (но символ табуляции перед таким полем, если оно не первое, всё равно должен быть)." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "from itertools import zip_longest\n", 31 | "\n", 32 | "n = int(input())\n", 33 | "result = []\n", 34 | "\n", 35 | "for i in range(1,n+1):\n", 36 | " m = int(input())\n", 37 | " element = []\n", 38 | " for k in range(m):\n", 39 | " element.append(input())\n", 40 | " result.append(element)\n", 41 | "\n", 42 | "for i in list(zip_longest(*result, fillvalue='')):\n", 43 | " print(*i, sep='\\t')" 44 | ] 45 | } 46 | ], 47 | "metadata": { 48 | "language_info": { 49 | "name": "python" 50 | }, 51 | "orig_nbformat": 4 52 | }, 53 | "nbformat": 4, 54 | "nbformat_minor": 2 55 | } 56 | -------------------------------------------------------------------------------- /Количество положительных на отрезке.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Количество положительных на отрезке\n", 9 | "\n", 10 | "Ограничение времени\t2 секунды \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt\n", 15 | "\n", 16 | "Дана последовательность чисел и запросы вида \"определите сколько положительных чисел на отрезке с индексами от L до R\".\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке вводится число n (1 ≤ n ≤ 100000) — длина последовательности.\n", 20 | "\n", 21 | "Во второй строке вводится последовательность из n целых чисел, все числа по модулю не превосходят 100000. Нумерация в последовательности начинается с единицы.\n", 22 | "\n", 23 | "В первой строке вводится число q (1 ≤ q ≤ 100000) — количество запросов.\n", 24 | "\n", 25 | "В каждой из следующих q строк вводятся запросы — два индекса l и r (1 ≤ l ≤ r ≤ n)\n", 26 | "\n", 27 | "Формат вывода \n", 28 | "Для каждого запроса выведите количество положительных на отрезке." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "count_numbers = int(input())\n", 38 | "numbers = list(map(int, input().split()))\n", 39 | "\n", 40 | "def prefix(count_numbers, numbers):\n", 41 | " positive_cumm = [0] * count_numbers\n", 42 | " prev_value = 0\n", 43 | " for i in range(count_numbers):\n", 44 | " if numbers[i] > 0:\n", 45 | " prev_value += 1\n", 46 | " positive_cumm[i] = prev_value\n", 47 | " return positive_cumm\n", 48 | "\n", 49 | "def count_positive(start, finish, positive_cumm):\n", 50 | " if start == 1:\n", 51 | " return positive_cumm[finish-1]\n", 52 | " return positive_cumm[finish-1] - positive_cumm[start-2]\n", 53 | "\n", 54 | "prefix_list = prefix(count_numbers, numbers)\n", 55 | "\n", 56 | "for i in range(int(input())):\n", 57 | " start, finish = map(int, input().split())\n", 58 | " print(count_positive(start, finish, prefix_list))" 59 | ] 60 | } 61 | ], 62 | "metadata": { 63 | "language_info": { 64 | "name": "python" 65 | }, 66 | "orig_nbformat": 4 67 | }, 68 | "nbformat": 4, 69 | "nbformat_minor": 2 70 | } 71 | -------------------------------------------------------------------------------- /Чётные и нечетные числа.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Представьте себе онлайн-игру для поездки в метро: игрок нажимает на кнопку, и на экране появляются три случайных числа. Если все три числа оказываются одной чётности, игрок выигрывает.\n", 15 | "\n", 16 | "Напишите программу, которая по трём числам определяет, выиграл игрок или нет.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке записаны три случайных целых числа a, b и c. Числа не превосходят 109 по модулю.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Выведите «WIN», если игрок выиграл, и «FAIL» в противном случае." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 15, 28 | "metadata": {}, 29 | "outputs": [ 30 | { 31 | "name": "stdout", 32 | "output_type": "stream", 33 | "text": [ 34 | "FAIL\n" 35 | ] 36 | } 37 | ], 38 | "source": [ 39 | "def check_parity(a: int, b: int, c: int) -> bool:\n", 40 | " if all((a%2, b%2, c%2)):\n", 41 | " return True\n", 42 | " if not any((a%2, b%2, c%2)):\n", 43 | " return True\n", 44 | " return False\n", 45 | " \n", 46 | "def print_result(result: bool) -> None:\n", 47 | " if result:\n", 48 | " print(\"WIN\")\n", 49 | " else:\n", 50 | " print(\"FAIL\")\n", 51 | "\n", 52 | "a, b, c = map(int, input().strip().split())\n", 53 | "print_result(check_parity(a, b, c))" 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "kernelspec": { 59 | "display_name": "Python 3", 60 | "language": "python", 61 | "name": "python3" 62 | }, 63 | "language_info": { 64 | "codemirror_mode": { 65 | "name": "ipython", 66 | "version": 3 67 | }, 68 | "file_extension": ".py", 69 | "mimetype": "text/x-python", 70 | "name": "python", 71 | "nbconvert_exporter": "python", 72 | "pygments_lexer": "ipython3", 73 | "version": "3.10.6" 74 | }, 75 | "orig_nbformat": 4, 76 | "vscode": { 77 | "interpreter": { 78 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 79 | } 80 | } 81 | }, 82 | "nbformat": 4, 83 | "nbformat_minor": 2 84 | } 85 | -------------------------------------------------------------------------------- /Замена слов.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Замена слов\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "С целью экономии чернил в картридже принтера было принято решение укоротить некоторые слова в тексте. Для этого был составлен словарь слов, до которых можно сокращать более длинные слова. Слово из текста можно сократить, если в словаре найдется слово, являющееся началом слова из текста. Например, если в списке есть слово \"лом\", то слова из текста \"ломбард\", \"ломоносов\" и другие слова, начинающиеся на \"лом\", можно сократить до \"лом\".\n", 17 | "\n", 18 | "Если слово из текста можно сократить до нескольких слов из словаря, то следует сокращать его до самого короткого слова.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке через пробел вводятся слова из словаря, слова состоят из маленьких латинских букв. Гарантируется, что словарь не пуст и количество слов в словаре не превышет 1000, а длина слов — 100 символов.\n", 22 | "\n", 23 | "Во второй строке через пробел вводятся слова текста (они также состоят только из маленьких латинских букв). Количество слов в тексте не превосходит 105, а суммарное количество букв в них — 106.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите текст, в котором осуществлены замены." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "dictionary = input().split()\n", 36 | "text = input().split()\n", 37 | "\n", 38 | "def short_text(text, dictionary):\n", 39 | " dictionary.sort(key=lambda x: (len(x), x))\n", 40 | " for i in range(len(text)):\n", 41 | " for j in dictionary:\n", 42 | " if len(text[i]) <= len(j):\n", 43 | " break\n", 44 | " if text[i].startswith(j):\n", 45 | " text[i] = j\n", 46 | " break\n", 47 | " return ' '.join(text)\n", 48 | "\n", 49 | "print(short_text(text, dictionary))" 50 | ] 51 | } 52 | ], 53 | "metadata": { 54 | "language_info": { 55 | "name": "python" 56 | }, 57 | "orig_nbformat": 4 58 | }, 59 | "nbformat": 4, 60 | "nbformat_minor": 2 61 | } 62 | -------------------------------------------------------------------------------- /Жизнь в квадрате.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Жизнь в квадрате\n", 9 | "\n", 10 | "В некоторых клетках квадрата N x N живут микроорганизмы (не более одного в одной клетке). Каждую секунду происходит следующее:\n", 11 | "\n", 12 | "– все микроорганизмы, у которых менее 2-х соседей, умирают от скуки (соседями называются микроорганизмы, живущие в клетках, имеющих общую сторону или вершину);\n", 13 | "– все микроорганизмы, у которых более 3-х соседей, умирают от перенаселенности;\n", 14 | "– в клетках, у которых ровно 2 соседа ничего не меняется;\n", 15 | "– на всех пустых клетках, у которых ровно в трех соседних клетках жили микроорганизмы, появляются новые микроорганизмы.\n", 16 | "\n", 17 | "Все изменения происходят одновременно, то есть для каждой клетки сначала выясняется ее судьба, а затем происходят изменения сразу во всех клетках. Требуется по данной конфигурации определить, во что она превратится через T секунд.\n", 18 | "\n", 19 | "Формат ввода \n", 20 | "В первой строке вводятся два натуральных числа – N (1 ≤ N ≤ 10) и T (1 ≤ T ≤ 100).\n", 21 | "\n", 22 | "Далее записано N строчек по N чисел, описывающих начальную конфигурацию (0 – пустая клетка, 1 – микроорганизм). Числа в строках разделены пробелами.\n", 23 | "\n", 24 | "Формат вывода \n", 25 | "Требуется вывести N строк по N чисел – описание конфигурации через T секунд (в том же формате, как и во входных данных)." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "n, t = map(int, input().split())\n", 35 | "tbl = [[0] * (n + 2)] + [[0] + list(map(int, input().split())) + [0] for _ in range(n)] + [[0] * (n + 2)]\n", 36 | "for _ in range(t):\n", 37 | " tmp = [[0 for _ in range(n + 2)] for _ in range(n + 2)]\n", 38 | " for i in range(1, n + 1):\n", 39 | " for j in range(1, n + 1):\n", 40 | " s = sum([sum(k[j - 1 : j + 2]) for k in tbl[i - 1 : i + 2]]) - tbl[i][j]\n", 41 | " if s == 3 : tmp[i][j] = 1\n", 42 | " elif s == 2: tmp[i][j] = tbl[i][j]\n", 43 | " tbl = tmp\n", 44 | "for i in range(1, n + 1): \n", 45 | " print(*tbl[i][1 : n + 1])" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "language_info": { 51 | "name": "python" 52 | }, 53 | "orig_nbformat": 4 54 | }, 55 | "nbformat": 4, 56 | "nbformat_minor": 2 57 | } 58 | -------------------------------------------------------------------------------- /Разноцветные палочки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Разноцветные палочки\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t256Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "Есть 10 вертикальных палочек, пронумерованных от 0 до 9 и n колец трёх цветов красного «R», зеленого «G» и голубого «B», которые на надеты на палочки. Ваша задача по строке s, кодирующей, где находится каждое из колец определить количество палочек, на которое надеты кольца всех трёх цветов. Строка представляет из себя последовательность чётной длины, где на нечётных позициях (1, 3, 5 и т.д.) написан цвет кольца, а на чётных позициях (2, 4, 6 и т.д.) — номер палочки, на которую надето кольцо. Таким образом, кольцо номер i имеет цвет s2i−1 и находится на палочке номер s2i. Например, строка «R2G1R1B2G2» кодирует 5 колец: \n", 17 | "\n", 18 | "Первое кольцо имеет красный цвет и находится на палочке 2; \n", 19 | "Второе кольцо имеет зеленый цвет и находится на палочке 1; \n", 20 | "Третье кольцо имеет красный цвет и находится на палочке 1; \n", 21 | "Четвертое кольцо имеет синий цвет и находится на палочке 2; \n", 22 | "Пятое кольцо имеет зеленый цвет и находится на палочке 2; \n", 23 | "\n", 24 | "Формат ввода \n", 25 | "Первая строка входных данных — это непустая строка четной длины s (1≤|s|≤1000), состоящая из символов «R», «G» или «B» и цифр от 0 до 9.\n", 26 | "\n", 27 | "Формат вывода \n", 28 | "Выведите единственное целое число — количество палочек, на которых имеются кольца всех трёх цветов." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "sticks = dict((i, set()) for i in range(10))\n", 38 | "\n", 39 | "data = list(input())\n", 40 | "\n", 41 | "for i in range(1, len(data), 2):\n", 42 | " sticks[int(data[i])].add(data[i-1])\n", 43 | "\n", 44 | "answer = 0\n", 45 | "\n", 46 | "for i in sticks.items():\n", 47 | " if len(i[1]) == 3:\n", 48 | " answer += 1\n", 49 | "\n", 50 | "print(answer)" 51 | ] 52 | } 53 | ], 54 | "metadata": { 55 | "language_info": { 56 | "name": "python" 57 | }, 58 | "orig_nbformat": 4 59 | }, 60 | "nbformat": 4, 61 | "nbformat_minor": 2 62 | } 63 | -------------------------------------------------------------------------------- /Быки и коровы.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Быки и коровы\n", 8 | "\n", 9 | "Ограничение времени\t1 секунда \n", 10 | "Ограничение памяти\t256Mb \n", 11 | "\n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "Вася и Петя играют в игру «Быки и коровы».\n", 16 | "Вася загадал число состоящее из N цифр, а Петя пытается его отгадать. Петя называет число из N цифр, а Вася отвечает, сколько в нем «быков» и «коров». \n", 17 | "Количество «быков» вычисляется как количество цифр, стоящих на своем месте. \n", 18 | "Количество «коров» вычисляется как количество цифр, которые есть и загаданном Васей числе и в названном Петей, но стоят на разных местах. То есть эти цифры могут быть переставлены таким образом, чтобы стать «Быками». \n", 19 | "По загаданному Васей и названному Петей числам определите количество «быков» и «коров». \n", 20 | "\n", 21 | "Формат ввода \n", 22 | "Загаданное Васей и Петей числа положительные и вводятся по одному в строке. Количество цифр в числах не превосходит 1000. Числа не имеют ведущих нулей.\n", 23 | "\n", 24 | "Формат вывода \n", 25 | "В первой строке выведите количество «быков», а во второй — «коров»." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "def indexing_int(some_int_list):\n", 35 | " int_index = {}\n", 36 | " for i, j in enumerate(some_int_list):\n", 37 | " if j in int_index:\n", 38 | " int_index[j].add(i)\n", 39 | " else:\n", 40 | " int_index[j] = set([i])\n", 41 | " return int_index\n", 42 | "\n", 43 | "first_int_index = indexing_int(list(map(int, input())))\n", 44 | "second_int_index = indexing_int(list(map(int, input())))\n", 45 | "\n", 46 | "bulls = 0\n", 47 | "cows = 0\n", 48 | "\n", 49 | "for i in second_int_index:\n", 50 | " if i in first_int_index:\n", 51 | " bulls += len(second_int_index[i] & first_int_index[i])\n", 52 | " cows += min(len(first_int_index[i] - second_int_index[i]), len(second_int_index[i] - first_int_index[i])) \n", 53 | "\n", 54 | "print(bulls)\n", 55 | "print(cows)" 56 | ] 57 | } 58 | ], 59 | "metadata": { 60 | "language_info": { 61 | "name": "python" 62 | }, 63 | "orig_nbformat": 4 64 | }, 65 | "nbformat": 4, 66 | "nbformat_minor": 2 67 | } 68 | -------------------------------------------------------------------------------- /Фибоначчи по модулю.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени 0.7 секунд \n", 9 | "Ограничение памяти 64Mb \n", 10 | "\n", 11 | "Ввод стандартный ввод или input.txt \n", 12 | "Вывод стандартный вывод или output.txt\n", 13 | "\n", 14 | "У Тимофея было очень много стажёров, целых N (0 ≤ N ≤ 106) человек. Каждый стажёр хотел быть лучше своих предшественников, поэтому i-й стажёр делал столько коммитов, сколько делали два предыдущих стажёра в сумме. Два первых стажёра были менее инициативными — они сделали по одному коммиту.\n", 15 | "\n", 16 | "Пусть Fi —– число коммитов, сделанных i-м стажёром (стажёры нумеруются с нуля). Первые два стажёра сделали по одному коммиту: F0=F1=1. Для всех i≥ 2 выполнено Fi=Fi−1+Fi−2.\n", 17 | "\n", 18 | "Определите, сколько кода напишет следующий стажёр –— найдите последние k цифр числа Fn.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке записаны через пробел два целых числа n (0 ≤ n ≤ 106) и k (1 ≤ k ≤ 8).\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите единственное число – последние k цифр числа Fn.\n", 25 | "\n", 26 | "Если в искомом числе меньше k цифр, то выведите само число без ведущих нулей." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "def fibonacci(number, K):\n", 36 | " num_1, num_2 = 1, 1\n", 37 | " if number <= 1:\n", 38 | " return 1\n", 39 | " else:\n", 40 | " for _ in range(number - 1):\n", 41 | " num_1, num_2 = num_2, (num_2 + num_1) % 10 ** K\n", 42 | " return num_2\n", 43 | "\n", 44 | "x, K = map(int, input().split())\n", 45 | "print(fibonacci(x, K))" 46 | ] 47 | } 48 | ], 49 | "metadata": { 50 | "kernelspec": { 51 | "display_name": "Python 3", 52 | "language": "python", 53 | "name": "python3" 54 | }, 55 | "language_info": { 56 | "codemirror_mode": { 57 | "name": "ipython", 58 | "version": 3 59 | }, 60 | "file_extension": ".py", 61 | "mimetype": "text/x-python", 62 | "name": "python", 63 | "nbconvert_exporter": "python", 64 | "pygments_lexer": "ipython3", 65 | "version": "3.10.6" 66 | }, 67 | "orig_nbformat": 4, 68 | "vscode": { 69 | "interpreter": { 70 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 71 | } 72 | } 73 | }, 74 | "nbformat": 4, 75 | "nbformat_minor": 2 76 | } 77 | -------------------------------------------------------------------------------- /Застёжка-молния.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Даны два массива чисел длины n. Составьте из них один массив длины 2n, в котором числа из входных массивов чередуются (первый — второй — первый — второй — ...). При этом относительный порядок следования чисел из одного массива должен быть сохранён.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке записано целое число n –— длина каждого из массивов, 1 ≤ n ≤ 1000.\n", 18 | "\n", 19 | "Во второй строке записано n чисел из первого массива, через пробел.\n", 20 | "\n", 21 | "В третьей строке –— n чисел из второго массива.\n", 22 | "\n", 23 | "Значения всех чисел –— натуральные и не превосходят 1000.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите 2n чисел из объединённого массива через пробел." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "from typing import List, Tuple\n", 36 | "\n", 37 | "def zipper(a: List[int], b: List[int]) -> List[int]:\n", 38 | " answer = []\n", 39 | " for i in zip(a, b):\n", 40 | " answer.extend(i)\n", 41 | " return answer\n", 42 | "\n", 43 | "def read_input() -> Tuple[List[int], List[int]]:\n", 44 | " n = int(input())\n", 45 | " a = list(map(int, input().strip().split()))\n", 46 | " b = list(map(int, input().strip().split()))\n", 47 | " return a, b\n", 48 | "\n", 49 | "a, b = read_input()\n", 50 | "print(\" \".join(map(str, zipper(a, b))))" 51 | ] 52 | } 53 | ], 54 | "metadata": { 55 | "kernelspec": { 56 | "display_name": "Python 3", 57 | "language": "python", 58 | "name": "python3" 59 | }, 60 | "language_info": { 61 | "codemirror_mode": { 62 | "name": "ipython", 63 | "version": 3 64 | }, 65 | "file_extension": ".py", 66 | "mimetype": "text/x-python", 67 | "name": "python", 68 | "nbconvert_exporter": "python", 69 | "pygments_lexer": "ipython3", 70 | "version": "3.10.6" 71 | }, 72 | "orig_nbformat": 4, 73 | "vscode": { 74 | "interpreter": { 75 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 76 | } 77 | } 78 | }, 79 | "nbformat": 4, 80 | "nbformat_minor": 2 81 | } 82 | -------------------------------------------------------------------------------- /Большее число.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.5 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вечером ребята решили поиграть в игру «Большое число».\n", 15 | "Даны числа. Нужно определить, какое самое большое число можно из них составить.\n", 16 | "\n", 17 | "Формат ввода \n", 18 | "В первой строке записано n — количество чисел. Оно не превосходит 100.\n", 19 | "Во второй строке через пробел записаны n неотрицательных чисел, каждое из которых не превосходит 1000.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Нужно вывести самое большое число, которое можно составить из данных чисел." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "def element_compare(first, second):\n", 32 | " max_len = max(len(first), len(second))\n", 33 | " first_new = first + first[0]*(max_len - len(first))\n", 34 | " second_new = second + second[0]*(max_len - len(second))\n", 35 | " for i, j in zip(list(first_new), list(second_new)):\n", 36 | " if i != j:\n", 37 | " return int(i) < int(j)\n", 38 | " if int(first[-1]) < int(second[-1]):\n", 39 | " return True\n", 40 | " return False\n", 41 | "\n", 42 | "\n", 43 | "def bubble(array, array_len):\n", 44 | " for j in range(array_len-1):\n", 45 | " for i in range(array_len-1-j):\n", 46 | " if element_compare(array[i], array[i+1]):\n", 47 | " array[i], array[i+1] = array[i+1], array[i]\n", 48 | " print(''.join(array))\n", 49 | "\n", 50 | "\n", 51 | "array_len = int(input())\n", 52 | "array = input().split()\n", 53 | "\n", 54 | "bubble(array, array_len)" 55 | ] 56 | } 57 | ], 58 | "metadata": { 59 | "kernelspec": { 60 | "display_name": "Python 3", 61 | "language": "python", 62 | "name": "python3" 63 | }, 64 | "language_info": { 65 | "codemirror_mode": { 66 | "name": "ipython", 67 | "version": 3 68 | }, 69 | "file_extension": ".py", 70 | "mimetype": "text/x-python", 71 | "name": "python", 72 | "nbconvert_exporter": "python", 73 | "pygments_lexer": "ipython3", 74 | "version": "3.10.6" 75 | }, 76 | "orig_nbformat": 4 77 | }, 78 | "nbformat": 4, 79 | "nbformat_minor": 2 80 | } 81 | -------------------------------------------------------------------------------- /Анаграммная группировка.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Ограничение времени\t1 секунда \n", 8 | "Ограничение памяти\t64Mb \n", 9 | "\n", 10 | "Ввод\tстандартный ввод или input.txt \n", 11 | "Вывод\tстандартный вывод или output.txt \n", 12 | "\n", 13 | "Вася решил избавиться от проблем с произношением и стать певцом. Он обратился за помощью к логопеду. Тот посоветовал Васе выполнять упражнение, которое называется анаграммная группировка. В качестве подготовительного этапа нужно выбрать из множества строк анаграммы.\n", 14 | "\n", 15 | "Анаграммы –— это строки, которые получаются друг из друга перестановкой символов. Например, строки «SILENT» и «LISTEN» являются анаграммами.\n", 16 | "\n", 17 | "Помогите Васе найти анаграммы.\n", 18 | "\n", 19 | "Формат ввода \n", 20 | "В первой строке записано число n —– количество строк. Далее в строку через пробел записаны n строк. n не превосходит 6000. Длина каждой строки не более 100 символов.\n", 21 | "\n", 22 | "Формат вывода \n", 23 | "Нужно вывести в отсортированном порядке индексы строк, которые являются анаграммами.\n", 24 | "\n", 25 | "Каждая группа индексов должна быть выведена в отдельной строке. Индексы внутри одной группы должны быть отсортированы по возрастанию. Группы между собой должны быть отсортированы по возрастанию первого индекса.\n", 26 | "\n", 27 | "Обратите внимание, что группа анаграмм может состоять и из одной строки. Например, если в исходном наборе нет анаграмм, то надо вывести n групп, каждая из которых состоит из одного индекса." 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "counter: int = int(input())\n", 37 | "s: list[str] = input().split()\n", 38 | "\n", 39 | "def hash(s: str) -> int:\n", 40 | " hash = 0\n", 41 | " for i in s: \n", 42 | " hash += (ord(i)*7*13%1009)**3\n", 43 | " return hash\n", 44 | "\n", 45 | "hash_map: dict[int, list[int]] = {}\n", 46 | "\n", 47 | "for i in range(counter):\n", 48 | " value = hash(s[i])\n", 49 | " map_value = hash_map.get(value, [])\n", 50 | " map_value.append(i)\n", 51 | " hash_map[value] = map_value\n", 52 | "\n", 53 | "for i in sorted(hash_map.values()):\n", 54 | " print(*i)" 55 | ] 56 | } 57 | ], 58 | "metadata": { 59 | "language_info": { 60 | "name": "python" 61 | }, 62 | "orig_nbformat": 4 63 | }, 64 | "nbformat": 4, 65 | "nbformat_minor": 2 66 | } 67 | -------------------------------------------------------------------------------- /Комбинации.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "На клавиатуре старых мобильных телефонов каждой цифре соответствовало несколько букв. Примерно так:\n", 15 | "\n", 16 | "2: 'abc', \n", 17 | "3: 'def', \n", 18 | "4: 'ghi', \n", 19 | "5: 'jkl', \n", 20 | "6: 'mno', \n", 21 | "7: 'pqrs', \n", 22 | "8: 'tuv', \n", 23 | "9: 'wxyz' \n", 24 | "\n", 25 | "Вам известно в каком порядке были нажаты кнопки телефона, без учета повторов. Напечатайте все комбинации букв, которые можно набрать такой последовательностью нажатий.\n", 26 | "\n", 27 | "Формат ввода \n", 28 | "На вход подается строка, состоящая из цифр 2-9 включительно. Длина строки не превосходит 10 символов.\n", 29 | "\n", 30 | "Формат вывода \n", 31 | "Выведите все возможные комбинации букв через пробел." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "key_letter = {\n", 41 | " '2':'abc',\n", 42 | " '3':'def',\n", 43 | " '4':'ghi',\n", 44 | " '5':'jkl',\n", 45 | " '6':'mno',\n", 46 | " '7':'pqrs',\n", 47 | " '8':'tuv',\n", 48 | " '9':'wxyz',\n", 49 | "}\n", 50 | "\n", 51 | "def combinate(key_history, len_key_history, prefix):\n", 52 | " if len_key_history == 0:\n", 53 | " print(prefix, end = ' ')\n", 54 | " else:\n", 55 | " for i in key_letter[key_history[0]]:\n", 56 | " combinate(key_history[1:], len_key_history-1, prefix+i)\n", 57 | "\n", 58 | "key_history = input()\n", 59 | "len_key_history = len(key_history)\n", 60 | "prefix = ''\n", 61 | "\n", 62 | "combinate(key_history, len_key_history, prefix)\n" 63 | ] 64 | } 65 | ], 66 | "metadata": { 67 | "kernelspec": { 68 | "display_name": "Python 3", 69 | "language": "python", 70 | "name": "python3" 71 | }, 72 | "language_info": { 73 | "codemirror_mode": { 74 | "name": "ipython", 75 | "version": 3 76 | }, 77 | "file_extension": ".py", 78 | "mimetype": "text/x-python", 79 | "name": "python", 80 | "nbconvert_exporter": "python", 81 | "pygments_lexer": "ipython3", 82 | "version": "3.10.6" 83 | }, 84 | "orig_nbformat": 4 85 | }, 86 | "nbformat": 4, 87 | "nbformat_minor": 2 88 | } 89 | -------------------------------------------------------------------------------- /Игра с заменами.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Игра с заменами\n", 8 | "\n", 9 | "Ограничение времени\t1 секунда \n", 10 | "Ограничение памяти\t256Mb \n", 11 | "\n", 12 | "Ввод\tстандартный ввод или input.txt \n", 13 | "Вывод\tстандартный вывод или output.txt \n", 14 | "\n", 15 | "Вася придумал игру для умного телевизора: можно сколько угодно раз выбрать две произвольные буквы латинского алфавита и заменить в строке все вхождения первой буквы на вторую, а второй — на первую. Так при выборе буквы a и b строка abc превратится в bac. Если выбрать буквы a и x, то строка abc превратится в строку xbc. Цель игры состоит в том, чтобы получить из строки s1 строку s2.\n", 16 | "\n", 17 | "К сожалению, Вася умеет только генерировать гениальные идеи, но не программировать. Он придумал много пар строк s1 и s2. Для каждой пары определите, возможно ли получить из строки s1 строку s2 по правилам игры.\n", 18 | "\n", 19 | "Формат ввода \n", 20 | "В первой строке задано число t (1 ≤ t ≤ 100) — количество пар строк, придуманных Васей. В следующих 2t строках вводятся t пар слов равной длины, разделенных переводом строки и состоящих из строчных латинских букв — s1 и s2 соответственно.\n", 21 | "\n", 22 | "Гарантируется, что суммарная длина всех слов не превосходит 105 символов.\n", 23 | "\n", 24 | "Формат вывода \n", 25 | "Для каждой пары слов выведите YES, если из s1 можно получить s2 по правилам игры и NO в противном случае." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "counter = int(input())\n", 35 | "\n", 36 | "def check_string_pare(s1, s2):\n", 37 | " mapping1 = {}\n", 38 | " mapping2 = {}\n", 39 | " for i in range(len(s1)):\n", 40 | " if s1[i] in mapping1 and mapping1[s1[i]] != s2[i]:\n", 41 | " return 'NO'\n", 42 | " elif s2[i] in mapping2 and mapping2[s2[i]] != s1[i]:\n", 43 | " return 'NO'\n", 44 | " else:\n", 45 | " mapping1[s1[i]] = s2[i]\n", 46 | " mapping2[s2[i]] = s1[i]\n", 47 | " else:\n", 48 | " return 'YES'\n", 49 | "\n", 50 | "\n", 51 | "for i in range(counter):\n", 52 | " s1 = input()\n", 53 | " s2 = input()\n", 54 | " print(check_string_pare(s1, s2))" 55 | ] 56 | } 57 | ], 58 | "metadata": { 59 | "language_info": { 60 | "name": "python" 61 | }, 62 | "orig_nbformat": 4 63 | }, 64 | "nbformat": 4, 65 | "nbformat_minor": 2 66 | } 67 | -------------------------------------------------------------------------------- /Угадай число 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Угадай число - 2\n", 9 | "\n", 10 | "Август загадал натуральное число от 1 до n. Беатриса пытается угадать это число, для этого она называет некоторые множества натуральных чисел. Август отвечает Беатрисе YES, если среди названных ей чисел есть задуманное или NO в противном случае. После нескольких заданных вопросов Беатриса запуталась в том, какие вопросы она задавала и какие ответы получила и просит вас помочь ей определить, какие числа мог задумать Август.\n", 11 | "\n", 12 | "Август и Беатриса продолжают играть в игру, но Август начал жульничать. На каждый из вопросов Беатрисы он выбирает такой вариант ответа YES или NO, чтобы множество возможных задуманных чисел оставалось как можно больше. Например, если Август задумал число от 1 до 5, а Беатриса спросила про числа 1 и 2, то Август ответит NO, а если Беатриса спросит про 1, 2, 3, то Август ответит YES. Если же Бетриса в своем вопросе перечисляет ровно половину из задуманных чисел, то Август из вредности всегда отвечает NO. Наконец, Август при ответе учитывает все предыдущие вопросы Беатрисы и свои ответы на них, то есть множество возможных задуманных чисел уменьшается.\n", 13 | "\n", 14 | "Формат ввода \n", 15 | "Вам дана последовательность вопросов Беатрисы. Приведите ответы Августа на них. Первая строка входных данных содержит число n — наибольшее число, которое мог загадать Август. Далее идут строки, содержащие вопросы Беатрисы. Каждая строка представляет собой набор чисел, разделенных пробелами. Последняя строка входных данных содержит одно слово HELP.\n", 16 | "\n", 17 | "Формат вывода \n", 18 | "Для каждого вопроса Беатрисы выведите ответ Августа на этот вопрос. После этого выведите (через пробел, в порядке возрастания) все числа, которые мог загадать Август после ответа на все вопросы Беатрисы." 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "yes_pile = set(map(str, range(1, int(input()) + 1)))\n", 28 | "for line in iter(input, 'HELP'):\n", 29 | " guesses = yes_pile.intersection(line.split())\n", 30 | " if len(guesses) > (len(yes_pile) - len(guesses)):\n", 31 | " print('YES')\n", 32 | " yes_pile = guesses\n", 33 | " else:\n", 34 | " print('NO')\n", 35 | " yes_pile -= guesses\n", 36 | "print(*sorted(yes_pile, key=int))" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "language_info": { 42 | "name": "python" 43 | }, 44 | "orig_nbformat": 4 45 | }, 46 | "nbformat": 4, 47 | "nbformat_minor": 2 48 | } 49 | -------------------------------------------------------------------------------- /Мониторинг.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени 1 секунда \n", 9 | "Ограничение памяти 64Mb \n", 10 | "\n", 11 | "Ввод стандартный ввод или input.txt \n", 12 | "Вывод стандартный вывод или output.txt\n", 13 | "\n", 14 | "Алла получила задание, связанное с мониторингом работы различных серверов. Требуется понять, сколько времени обрабатываются определённые запросы на конкретных серверах. Эту информацию нужно хранить в матрице, где номер столбца соответствуют идентификатору запроса, а номер строки — идентификатору сервера. Алла перепутала строки и столбцы местами. С каждым бывает. Помогите ей исправить баг.\n", 15 | "\n", 16 | "Есть матрица размера m × n. Нужно написать функцию, которая её транспонирует.\n", 17 | "\n", 18 | "Транспонированная матрица получается из исходной заменой строк на столбцы.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке задано число n — количество строк матрицы.\n", 22 | "Во второй строке задано m — число столбцов, m и n не превосходят 1000. В следующих n строках задана матрица. Числа в ней не превосходят по модулю 1000.\n", 23 | "\n", 24 | "Формат вывода \n", 25 | "Напечатайте транспонированную матрицу в том же формате, который задан во входных данных. Каждая строка матрицы выводится на отдельной строке, элементы разделяются пробелами." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "def transpose(matrix, col):\n", 35 | " for i in range(col):\n", 36 | " for k in matrix:\n", 37 | " print(k[i], end=' ')\n", 38 | " print('\\n', end='')\n", 39 | "\n", 40 | "row = int(input())\n", 41 | "col = int(input())\n", 42 | "matrix = []\n", 43 | "\n", 44 | "for i in range(row):\n", 45 | " x = input().split()\n", 46 | " matrix.append(x)\n", 47 | "\n", 48 | "transpose(matrix, col)" 49 | ] 50 | } 51 | ], 52 | "metadata": { 53 | "kernelspec": { 54 | "display_name": "Python 3", 55 | "language": "python", 56 | "name": "python3" 57 | }, 58 | "language_info": { 59 | "codemirror_mode": { 60 | "name": "ipython", 61 | "version": 3 62 | }, 63 | "file_extension": ".py", 64 | "mimetype": "text/x-python", 65 | "name": "python", 66 | "nbconvert_exporter": "python", 67 | "pygments_lexer": "ipython3", 68 | "version": "3.10.6" 69 | }, 70 | "orig_nbformat": 4, 71 | "vscode": { 72 | "interpreter": { 73 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 74 | } 75 | } 76 | }, 77 | "nbformat": 4, 78 | "nbformat_minor": 2 79 | } 80 | -------------------------------------------------------------------------------- /Сломай палиндром.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Сломай палиндром\n", 9 | "\n", 10 | "Ограничение времени\t1 секунда \n", 11 | "Ограничение памяти\t64Mb \n", 12 | "\n", 13 | "Ввод\tстандартный ввод или input.txt \n", 14 | "Вывод\tстандартный вывод или output.txt \n", 15 | "\n", 16 | "Палиндромом называется строка, которая читается одинаково слева-направо и справа-налево.\n", 17 | "\n", 18 | "В заданной строке-палиндроме необходимо заменить один символ, чтобы она перестала быть палиндромом. При этом полученная строка должна быть лексикографически минимальной.\n", 19 | "\n", 20 | "Строка A лексикографически меньше строки B (той же длины), если на первой различающейся позиции в строке A стоит меньший символ, чем в B. Например, строка adbc меньше строки adca, т.к. первые два символа в строках совпадают, а на третьем месте в строке adbc стоит символ b, который меньше символа c, стоящего на третьей позиции в строке adca.\n", 21 | "\n", 22 | "Формат ввода \n", 23 | "Вводится строка-палиндром, состоящая из маленьких букв латинского алфавита. Длина строки не превосходит 1000.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите лексикографически минимальную строку, не являющуюяся палиндромом, полученную из исходной строки заменой одного символа.\n", 27 | "\n", 28 | "Если получить такую строку невозможно - выведите пустую строку." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "input_string = list(input())\n", 38 | "\n", 39 | "def break_palindrome(input_string):\n", 40 | " if set(input_string) == {'a'} and len(input_string) != 1:\n", 41 | " input_string[-1] = 'b'\n", 42 | " return input_string\n", 43 | " for i in range(len(input_string)):\n", 44 | " if input_string[i] == 'a':\n", 45 | " continue\n", 46 | " last_value = input_string[i]\n", 47 | " input_string[i] = 'a'\n", 48 | " if set(input_string) == {'a'} and len(input_string) != 1:\n", 49 | " input_string[i] = last_value\n", 50 | " input_string[-1] = 'b'\n", 51 | " return input_string\n", 52 | " return input_string\n", 53 | " return []\n", 54 | "\n", 55 | "x = break_palindrome(input_string)\n", 56 | "\n", 57 | "if x == x[::-1]:\n", 58 | " print('')\n", 59 | "else:\n", 60 | " print(''.join(x))" 61 | ] 62 | } 63 | ], 64 | "metadata": { 65 | "language_info": { 66 | "name": "python" 67 | }, 68 | "orig_nbformat": 4 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 2 72 | } 73 | -------------------------------------------------------------------------------- /Двоичная система.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.1 секунда\t \n", 9 | "Ограничение памяти 64Mb \n", 10 | "\n", 11 | "Ввод стандартный ввод или input.txt \n", 12 | "Вывод стандартный вывод или output.txt \n", 13 | "\n", 14 | "Тимофей записал два числа в двоичной системе счисления и попросил Гошу вывести их сумму, также в двоичной системе. Встроенную в язык программирования возможность сложения двоичных чисел применять нельзя. Помогите Гоше решить задачу.\n", 15 | "\n", 16 | "Решение должно работать за O(N), где N –— количество разрядов максимального числа на входе.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "Два числа в двоичной системе счисления, каждое на отдельной строке. Длина каждого числа не превосходит 10 000 символов.\n", 20 | "\n", 21 | "Формат вывода \n", 22 | "Одно число в двоичной системе счисления." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 39, 28 | "metadata": {}, 29 | "outputs": [ 30 | { 31 | "name": "stdout", 32 | "output_type": "stream", 33 | "text": [ 34 | "0\n" 35 | ] 36 | } 37 | ], 38 | "source": [ 39 | "first_number = [*map(int, input().strip())]\n", 40 | "second_number = [*map(int, input().strip())]\n", 41 | "\n", 42 | "first_number = first_number[::-1]\n", 43 | "second_number = second_number[::-1]\n", 44 | "\n", 45 | "size = max(len(first_number), len(second_number))\n", 46 | "\n", 47 | "first_number += [0] * (size - len(first_number))\n", 48 | "second_number += [0] * (size - len(second_number))\n", 49 | "\n", 50 | "add = 0\n", 51 | "answer = []\n", 52 | "\n", 53 | "for obj in zip(first_number, second_number):\n", 54 | " current_sum = sum(obj, add)\n", 55 | " add = current_sum // 2\n", 56 | " answer.append(current_sum % 2)\n", 57 | "\n", 58 | "if add == 1:\n", 59 | " answer.append(1)\n", 60 | "\n", 61 | "print(\"\".join(map(str, answer[::-1])))" 62 | ] 63 | } 64 | ], 65 | "metadata": { 66 | "kernelspec": { 67 | "display_name": "Python 3", 68 | "language": "python", 69 | "name": "python3" 70 | }, 71 | "language_info": { 72 | "codemirror_mode": { 73 | "name": "ipython", 74 | "version": 3 75 | }, 76 | "file_extension": ".py", 77 | "mimetype": "text/x-python", 78 | "name": "python", 79 | "nbconvert_exporter": "python", 80 | "pygments_lexer": "ipython3", 81 | "version": "3.10.6" 82 | }, 83 | "orig_nbformat": 4, 84 | "vscode": { 85 | "interpreter": { 86 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 87 | } 88 | } 89 | }, 90 | "nbformat": 4, 91 | "nbformat_minor": 2 92 | } 93 | -------------------------------------------------------------------------------- /Телефонные номера.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Телефонные номера\n", 9 | "\n", 10 | "Телефонные номера в адресной книге мобильного телефона имеют один из следующих форматов: +7<код><номер>, 8<код><номер>, <номер>, где <номер> — это семь цифр, а <код> — это три цифры или три цифры в круглых скобках. Если код не указан, то считается, что он равен 495. Кроме того, в записи телефонного номера может стоять знак “-” между любыми двумя цифрами (см. пример). На данный момент в адресной книге телефона Васи записано всего три телефонных номера, и он хочет записать туда еще один. Но он не может понять, не записан ли уже такой номер в телефонной книге. Помогите ему! Два телефонных номера совпадают, если у них равны коды и равны номера. Например, +7(916)0123456 и 89160123456 — это один и тот же номер.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "В первой строке входных данных записан номер телефона, который Вася хочет добавить в адресную книгу своего телефона. В следующих трех строках записаны три номера телефонов, которые уже находятся в адресной книге телефона Васи. Гарантируется, что каждая из записей соответствует одному из трех приведенных в условии форматов.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Для каждого телефонного номера в адресной книге выведите YES (заглавными буквами), если он совпадает с тем телефонным номером, который Вася хочет добавить в адресную книгу или NO (заглавными буквами) в противном случае." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "search = list(input().replace('-','').replace('(','').replace(')',''))\n", 26 | "if len(search) > 7:\n", 27 | " if search[0] == '+':\n", 28 | " search = search[2:]\n", 29 | " elif search[0] == '8':\n", 30 | " search = search[1:]\n", 31 | "elif len(search) == 7:\n", 32 | " code = ['5', '9', '4']\n", 33 | " for i in code:\n", 34 | " search.insert(0, i)\n", 35 | "for i in range(3):\n", 36 | " new = list(input().replace('-','').replace('(','').replace(')',''))\n", 37 | " if len(new) > 7:\n", 38 | " if new[0] == '+':\n", 39 | " new = new[2:]\n", 40 | " elif new[0] == '8':\n", 41 | " new = new[1:]\n", 42 | " elif len(new) == 7:\n", 43 | " code = ['5', '9', '4']\n", 44 | " for i in code:\n", 45 | " new.insert(0, i)\n", 46 | " if search == new:\n", 47 | " print('YES')\n", 48 | " else:\n", 49 | " print('NO')" 50 | ] 51 | } 52 | ], 53 | "metadata": { 54 | "language_info": { 55 | "name": "python" 56 | }, 57 | "orig_nbformat": 4 58 | }, 59 | "nbformat": 4, 60 | "nbformat_minor": 2 61 | } 62 | -------------------------------------------------------------------------------- /Скользящее среднее.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вам дана статистика по числу запросов в секунду к вашему любимому рекомендательному сервису.\n", 15 | "\n", 16 | "Измерения велись n секунд.\n", 17 | "\n", 18 | "В секунду i поступает qi запросов.\n", 19 | "\n", 20 | "Примените метод скользящего среднего с длиной окна k к этим данным и выведите результат.\n", 21 | "\n", 22 | "Формат ввода \n", 23 | "В первой строке передаётся натуральное число n, количество секунд, в течение которых велись измерения. 1 ≤ n ≤ 105\n", 24 | "\n", 25 | "Во второй строке через пробел записаны n целых неотрицательных чисел qi, каждое лежит в диапазоне от 0 до 103.\n", 26 | "\n", 27 | "В третьей строке записано натуральное число k (1 ≤ k ≤ n) —– окно сглаживания.\n", 28 | "\n", 29 | "Формат вывода \n", 30 | "Выведите через пробел результат применения метода скользящего среднего к серии измерений. Должно быть выведено n - k + 1 элементов, каждый элемент -— вещественное (дробное) число." 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "from typing import List, Tuple\n", 40 | "\n", 41 | "def moving_average(arr: List[int], window_size: int) -> List[float]:\n", 42 | " result = []\n", 43 | " current_sum = sum(arr[0:window_size])\n", 44 | " result.append(current_sum / window_size)\n", 45 | " for i in range(0, len(arr) - window_size):\n", 46 | " current_sum -= arr[i]\n", 47 | " current_sum += arr[i+window_size]\n", 48 | " current_avg = current_sum / window_size\n", 49 | " result.append(current_avg)\n", 50 | " return result\n", 51 | "\n", 52 | "def read_input() -> Tuple[List[int], int]:\n", 53 | " n = int(input())\n", 54 | " arr = list(map(int, input().strip().split()))\n", 55 | " window_size = int(input())\n", 56 | " return arr, window_size\n", 57 | "\n", 58 | "arr, window_size = read_input()\n", 59 | "print(\" \".join(map(str, moving_average(arr, window_size))))" 60 | ] 61 | } 62 | ], 63 | "metadata": { 64 | "kernelspec": { 65 | "display_name": "Python 3", 66 | "language": "python", 67 | "name": "python3" 68 | }, 69 | "language_info": { 70 | "name": "python", 71 | "version": "3.10.6" 72 | }, 73 | "orig_nbformat": 4, 74 | "vscode": { 75 | "interpreter": { 76 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 77 | } 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 2 82 | } 83 | -------------------------------------------------------------------------------- /Форматирование календаря.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Форматирование календаря\n", 9 | "\n", 10 | "Для отрисовки календаря в студенческом проекте было решено выделить функциональность форматирования в отдельный модуль.\n", 11 | "\n", 12 | "Параметрами модуля (формально для функции, которую можно будет импортировать из модуля) будут количество дней в месяце и название дня недели, на который приходится первое число месяца, записанное на английском языке.\n", 13 | "\n", 14 | "Выведите все дни месяца по неделям, дополнив первую неделю пустыми значениями, если это требуется.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В единственной строке входных данных записаны две величины:\n", 18 | "количество дней в месяце, день недели, на который приходится первое число месяца.\n", 19 | "\n", 20 | "Формат вывода \n", 21 | "Выведите k строк (4 ≤ k ≤ 6), в i-й строке выведите даты, которые попадают на i-ю неделю месяца.\n", 22 | "\n", 23 | "При выводе следуйте следующим правилам: \n", 24 | "все строки, кроме последней, должны долны иметь ровно 7 элементов (в последней строке также может оказаться 7 элементов);\n", 25 | "при выводе дней с номерами от 1 до 9 следует добавить символ точки (.) перед цифрой;\n", 26 | "при выводе дней первой недели перед первым числом используйте две точки (..)." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "def make_calendar(days, day_of_week):\n", 36 | " week = {\n", 37 | " 'Monday': 0,\n", 38 | " 'Tuesday': 1,\n", 39 | " 'Wednesday': 2,\n", 40 | " 'Thursday': 3,\n", 41 | " 'Friday': 4,\n", 42 | " 'Saturday': 5,\n", 43 | " 'Sunday': 6,\n", 44 | " }\n", 45 | " start_day = week[day_of_week]\n", 46 | " elems = start_day + days\n", 47 | " lines = elems//7 + bool(elems%7)\n", 48 | " calendar = [['..']*7 for _ in range(lines)]\n", 49 | "\n", 50 | " for i in range(1, days+1):\n", 51 | " index = start_day + i - 1\n", 52 | " if i < 10:\n", 53 | " calendar[index//7][index%7] = f'.{i}'\n", 54 | " else:\n", 55 | " calendar[index//7][index%7] = f'{i}'\n", 56 | "\n", 57 | " while '..' in calendar[-1]:\n", 58 | " calendar[-1].pop()\n", 59 | "\n", 60 | " return calendar\n", 61 | " \n", 62 | "if __name__ == '__main__':\n", 63 | " x = input().split()\n", 64 | " days = int(x[0])\n", 65 | " day_of_week = x[1]\n", 66 | "\n", 67 | " for i in make_calendar(days, day_of_week):\n", 68 | " print(' '.join(i))" 69 | ] 70 | } 71 | ], 72 | "metadata": { 73 | "language_info": { 74 | "name": "python" 75 | }, 76 | "orig_nbformat": 4 77 | }, 78 | "nbformat": 4, 79 | "nbformat_minor": 2 80 | } 81 | -------------------------------------------------------------------------------- /Детали.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Имеется N кг металлического сплава. Из него изготавливают заготовки массой K кг каждая. После этого из каждой заготовки вытачиваются детали массой M кг каждая (из каждой заготовки вытачивают максимально возможное количество деталей). Если от заготовок после этого что-то остается, то этот материал возвращают к началу производственного цикла и сплавляют с тем, что осталось при изготовлении заготовок. Если того сплава, который получился, достаточно для изготовления хотя бы одной заготовки, то из него снова изготавливают заготовки, из них – детали и т.д. Напишите программу, которая вычислит, какое количество деталей может быть получено по этой технологии из имеющихся исходно N кг сплава.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Вводятся N, K, M. Все числа натуральные и не превосходят 200.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите одно число — количество деталей, которое может получиться по такой технологии." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 16, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "0\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "N, K, M = map(int, input().split())\n", 38 | "\n", 39 | "ans = 0\n", 40 | "\n", 41 | "def make_detail(N, K, M):\n", 42 | " if N and M and K:\n", 43 | " global ans\n", 44 | " if N < K or K < M:\n", 45 | " return\n", 46 | " no_use = 0\n", 47 | " cnt_K = N // K\n", 48 | " no_use += N % K\n", 49 | " cnt_M_from_one_K = K // M\n", 50 | " no_use_from_one_K = K % M\n", 51 | " ans += cnt_M_from_one_K * cnt_K\n", 52 | " no_use += no_use_from_one_K * cnt_K\n", 53 | " make_detail(no_use, K, M)\n", 54 | " else:\n", 55 | " return\n", 56 | "\n", 57 | "make_detail(N, K, M)\n", 58 | "\n", 59 | "print(ans)" 60 | ] 61 | } 62 | ], 63 | "metadata": { 64 | "kernelspec": { 65 | "display_name": "Python 3", 66 | "language": "python", 67 | "name": "python3" 68 | }, 69 | "language_info": { 70 | "codemirror_mode": { 71 | "name": "ipython", 72 | "version": 3 73 | }, 74 | "file_extension": ".py", 75 | "mimetype": "text/x-python", 76 | "name": "python", 77 | "nbconvert_exporter": "python", 78 | "pygments_lexer": "ipython3", 79 | "version": "3.10.6" 80 | }, 81 | "orig_nbformat": 4, 82 | "vscode": { 83 | "interpreter": { 84 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 85 | } 86 | } 87 | }, 88 | "nbformat": 4, 89 | "nbformat_minor": 2 90 | } 91 | -------------------------------------------------------------------------------- /Клумбы.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Алла захотела, чтобы у неё под окном были узкие клумбы с тюльпанам. На схеме земельного участка клумбы обозначаются просто горизонтальными отрезками, лежащими на одной прямой. Для ландшафтных работ было нанято n садовников. Каждый из них обрабатывал какой-то отрезок на схеме. Процесс был организован не очень хорошо, иногда один и тот же отрезок или его часть могли быть обработаны сразу несколькими садовниками. Таким образом, отрезки, обрабатываемые двумя разными садовниками, сливаются в один. Непрерывный обработанный отрезок затем станет клумбой. Нужно определить границы будущих клумб.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке задано количество садовников n. Число садовников не превосходит 100000. В следующих n строках через пробел записаны координаты клумб в формате: start end, где start —– координата начала, end —– координата конца. Оба числа целые, неотрицательные и не превосходят 10**7. start строго меньше, чем end.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Нужно вывести координаты каждой из получившихся клумб в отдельных строках. Данные должны выводиться в отсортированном порядке —– сначала клумбы с меньшими координатами, затем —– с бОльшими." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "count_workers = int(input())\n", 30 | "workers = []\n", 31 | "\n", 32 | "for i in range(count_workers):\n", 33 | " worker = list(map(int, input().split()))\n", 34 | " workers.append(worker)\n", 35 | "\n", 36 | "workers.sort()\n", 37 | "\n", 38 | "begin = workers[0][0]\n", 39 | "end = workers[0][1]\n", 40 | "start = current_index = 1\n", 41 | "\n", 42 | "while current_index <= count_workers-1:\n", 43 | " if workers[current_index][0] <= end:\n", 44 | " end = max(end, workers[current_index][1])\n", 45 | " current_index += 1\n", 46 | " else:\n", 47 | " print(begin, end)\n", 48 | " begin = workers[current_index][0]\n", 49 | " end = workers[current_index][1]\n", 50 | " current_index += 1\n", 51 | "print(begin, end)" 52 | ] 53 | } 54 | ], 55 | "metadata": { 56 | "kernelspec": { 57 | "display_name": "Python 3", 58 | "language": "python", 59 | "name": "python3" 60 | }, 61 | "language_info": { 62 | "codemirror_mode": { 63 | "name": "ipython", 64 | "version": 3 65 | }, 66 | "file_extension": ".py", 67 | "mimetype": "text/x-python", 68 | "name": "python", 69 | "nbconvert_exporter": "python", 70 | "pygments_lexer": "ipython3", 71 | "version": "3.10.6" 72 | }, 73 | "orig_nbformat": 4 74 | }, 75 | "nbformat": 4, 76 | "nbformat_minor": 2 77 | } 78 | -------------------------------------------------------------------------------- /Две фишки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t256Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Рита и Гоша играют в игру. У Риты есть n фишек, на каждой из которых написано количество очков. Фишки лежат на столе в порядке неубывания очков на них. Сначала Гоша называет число k, затем Рита должна выбрать две фишки, сумма очков на которых равна заданному числу.\n", 15 | "\n", 16 | "Рите надоело искать фишки самой, и она решила применить свои навыки программирования для решения этой задачи. Помогите ей написать программу для поиска нужных фишек.\n", 17 | "\n", 18 | "Формат ввода \n", 19 | "В первой строке записано количество фишек n, 2 ≤ n ≤ 105.\n", 20 | "\n", 21 | "Во второй строке записано n целых чисел в порядке неубывания —– очки на фишках Риты в диапазоне от -105 до 105.\n", 22 | "\n", 23 | "В третьей строке —– загаданное Гошей целое число k, -105 ≤ k ≤ 105.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Нужно вывести два числа —– очки на двух фишках, в сумме дающие k.\n", 27 | "\n", 28 | "Если таких пар несколько, то можно вывести любую из них.\n", 29 | "\n", 30 | "Если таких пар не существует, то вывести «None»." 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "from typing import List, Tuple, Optional\n", 40 | "\n", 41 | "def two_sum(arr: List[int], target_sum: int) -> Optional[Tuple[int, int]]:\n", 42 | " previous = set()\n", 43 | "\n", 44 | " for A in arr:\n", 45 | " Y = target_sum - A\n", 46 | " if Y in previous:\n", 47 | " return A, Y\n", 48 | " else:\n", 49 | " previous.add(A)\n", 50 | "\n", 51 | " return None\n", 52 | "\n", 53 | "def read_input() -> Tuple[List[int], int]:\n", 54 | " n = int(input())\n", 55 | " arr = list(map(int, input().strip().split()))\n", 56 | " target_sum = int(input())\n", 57 | " return arr, target_sum\n", 58 | "\n", 59 | "def print_result(result: Optional[Tuple[int, int]]) -> None:\n", 60 | " if result is None:\n", 61 | " print(None)\n", 62 | " else:\n", 63 | " print(\" \".join(map(str, result)))\n", 64 | "\n", 65 | "arr, target_sum = read_input()\n", 66 | "print_result(two_sum(arr, target_sum))" 67 | ] 68 | } 69 | ], 70 | "metadata": { 71 | "kernelspec": { 72 | "display_name": "Python 3", 73 | "language": "python", 74 | "name": "python3" 75 | }, 76 | "language_info": { 77 | "name": "python", 78 | "version": "3.10.6" 79 | }, 80 | "orig_nbformat": 4, 81 | "vscode": { 82 | "interpreter": { 83 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 84 | } 85 | } 86 | }, 87 | "nbformat": 4, 88 | "nbformat_minor": 2 89 | } 90 | -------------------------------------------------------------------------------- /Поиск в сломанном массиве.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Алла ошиблась при копировании из одной структуры данных в другую. Она хранила массив чисел в кольцевом буфере. Массив был отсортирован по возрастанию, и в нём можно было найти элемент за логарифмическое время. Алла скопировала данные из кольцевого буфера в обычный массив, но сдвинула данные исходной отсортированной последовательности. Теперь массив не является отсортированным. Тем не менее, нужно обеспечить возможность находить в нем элемент за O(logn).\n", 12 | "\n", 13 | "Можно предполагать, что в массиве только уникальные элементы.\n", 14 | "\n", 15 | "От вас требуется реализовать функцию, осуществляющую поиск в сломанном массиве. \n", 16 | "\n", 17 | "Формат ввода \n", 18 | "Функция принимает массив натуральных чисел и искомое число k. Длина массива не превосходит 10000. Элементы массива и число k не превосходят по значению 10000.\n", 19 | "\n", 20 | "Формат вывода \n", 21 | "Функция должна вернуть индекс элемента, равного k, если такой есть в массиве (нумерация с нуля). Если элемент не найден, функция должна вернуть −1. Изменять массив нельзя. Для отсечения неэффективных решений ваша функция будет запускаться от 100000 до 1000000 раз." 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "from typing import List\n", 31 | "\n", 32 | "\n", 33 | "def broken_search(nums: List[int], target: int) -> int:\n", 34 | " \"\"\"Циклический вариант поиска элемента в\n", 35 | " сортированном списке со сдвигом.\"\"\"\n", 36 | " left = 0\n", 37 | " right = len(nums) - 1\n", 38 | "\n", 39 | " while left <= right:\n", 40 | " mid = (left + right) // 2\n", 41 | "\n", 42 | " if target == nums[mid]:\n", 43 | " return mid\n", 44 | "\n", 45 | " if nums[left] <= nums[mid]:\n", 46 | " if nums[left] <= target < nums[mid]:\n", 47 | " right = mid - 1\n", 48 | " else:\n", 49 | " left = mid + 1\n", 50 | " else:\n", 51 | " if nums[mid] < target <= nums[right]:\n", 52 | " left = mid + 1\n", 53 | " else:\n", 54 | " right = mid - 1\n", 55 | " return -1" 56 | ] 57 | } 58 | ], 59 | "metadata": { 60 | "kernelspec": { 61 | "display_name": "Python 3", 62 | "language": "python", 63 | "name": "python3" 64 | }, 65 | "language_info": { 66 | "codemirror_mode": { 67 | "name": "ipython", 68 | "version": 3 69 | }, 70 | "file_extension": ".py", 71 | "mimetype": "text/x-python", 72 | "name": "python", 73 | "nbconvert_exporter": "python", 74 | "pygments_lexer": "ipython3", 75 | "version": "3.10.6" 76 | }, 77 | "orig_nbformat": 4 78 | }, 79 | "nbformat": 4, 80 | "nbformat_minor": 2 81 | } 82 | -------------------------------------------------------------------------------- /Пузырек.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1.5 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Чтобы выбрать самый лучший алгоритм для решения задачи, Гоша продолжил изучать разные сортировки.\n", 15 | "\n", 16 | "Её алгоритм следующий (сортируем по неубыванию):\n", 17 | "\n", 18 | "На каждой итерации проходим по массиву, поочередно сравнивая пары соседних элементов. Если элемент на позиции i больше элемента на позиции i + 1, меняем их местами. После первой итерации самый большой элемент всплывёт в конце массива. \n", 19 | "Проходим по массиву, выполняя указанные действия до тех пор, пока на очередной итерации не окажется, что обмены больше не нужны, то есть массив уже отсортирован. \n", 20 | "После не более чем n – 1 итераций выполнение алгоритма заканчивается, так как на каждой итерации хотя бы один элемент оказывается на правильной позиции. \n", 21 | "\n", 22 | "Помогите Гоше написать код алгоритма.\n", 23 | "\n", 24 | "Формат ввода \n", 25 | "В первой строке на вход подаётся натуральное число n — длина массива, 2 ≤ n ≤ 1000. \n", 26 | "Во второй строке через пробел записано n целых чисел. \n", 27 | "Каждое из чисел по модулю не превосходит 1000. \n", 28 | "\n", 29 | "Формат вывода \n", 30 | "После каждого прохода по массиву, на котором какие-то элементы меняются местами, выводите его промежуточное состояние. \n", 31 | "Таким образом, если сортировка завершена за k меняющих массив итераций, то надо вывести k строк по n чисел в каждой — элементы массива после каждой из итераций. \n", 32 | "Если массив был изначально отсортирован, то просто выведите его." 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "def bubble(array, array_len):\n", 42 | " sorted = False\n", 43 | " for j in range(array_len-1):\n", 44 | " F = 0\n", 45 | " for i in range(array_len-1-j):\n", 46 | " if array[i] > array[i+1]:\n", 47 | " array[i], array[i+1] = array[i+1], array[i]\n", 48 | " F = 1\n", 49 | " if not sorted:\n", 50 | " sorted = True\n", 51 | " if F == 1:\n", 52 | " print(*array)\n", 53 | " if not sorted:\n", 54 | " print(*array)\n", 55 | "\n", 56 | "\n", 57 | "array_len = int(input())\n", 58 | "array = list(map(int, input().split()))\n", 59 | "\n", 60 | "bubble(array, array_len)" 61 | ] 62 | } 63 | ], 64 | "metadata": { 65 | "kernelspec": { 66 | "display_name": "Python 3", 67 | "language": "python", 68 | "name": "python3" 69 | }, 70 | "language_info": { 71 | "name": "python", 72 | "version": "3.10.6" 73 | }, 74 | "orig_nbformat": 4 75 | }, 76 | "nbformat": 4, 77 | "nbformat_minor": 2 78 | } 79 | -------------------------------------------------------------------------------- /Хаотичность погоды.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени 0.2 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод стандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Метеорологическая служба вашего города решила исследовать погоду новым способом.\n", 15 | "\n", 16 | "Под температурой воздуха в конкретный день будем понимать максимальную температуру в этот день.\n", 17 | "Под хаотичностью погоды за n дней служба понимает количество дней, в которые температура строго больше, чем в день до (если такой существует) и в день после текущего (если такой существует). Например, если за 5 дней максимальная температура воздуха составляла [1, 2, 5, 4, 8] градусов, то хаотичность за этот период равна 2: в 3-й и 5-й дни выполнялись описанные условия.\n", 18 | "Определите по ежедневным показаниям температуры хаотичность погоды за этот период.\n", 19 | "\n", 20 | "Заметим, что если число показаний n=1, то единственный день будет хаотичным.\n", 21 | "\n", 22 | "Формат ввода \n", 23 | "В первой строке дано число n –— длина периода измерений в днях, 1 ≤ n≤ 105. Во второй строке даны n целых чисел –— значения температуры в каждый из n дней. Значения температуры не превосходят 273 по модулю.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите единственное число — хаотичность за данный период." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 8, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "0\n" 39 | ] 40 | } 41 | ], 42 | "source": [ 43 | "n = int(input())\n", 44 | "values = list(map(int, input().split()))\n", 45 | "counter_ans = 0\n", 46 | "\n", 47 | "if len(values) == 1:\n", 48 | " print(1)\n", 49 | "else:\n", 50 | " prev_check = True\n", 51 | " for i in range(n-1): \n", 52 | " post_check = values[i] > values[i+1]\n", 53 | " if all((prev_check, post_check)):\n", 54 | " counter_ans += 1\n", 55 | " prev_check = not (post_check or values[i] == values[i+1])\n", 56 | " if prev_check:\n", 57 | " counter_ans += 1\n", 58 | " print(counter_ans)" 59 | ] 60 | } 61 | ], 62 | "metadata": { 63 | "kernelspec": { 64 | "display_name": "Python 3", 65 | "language": "python", 66 | "name": "python3" 67 | }, 68 | "language_info": { 69 | "codemirror_mode": { 70 | "name": "ipython", 71 | "version": 3 72 | }, 73 | "file_extension": ".py", 74 | "mimetype": "text/x-python", 75 | "name": "python", 76 | "nbconvert_exporter": "python", 77 | "pygments_lexer": "ipython3", 78 | "version": "3.10.6" 79 | }, 80 | "orig_nbformat": 4, 81 | "vscode": { 82 | "interpreter": { 83 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 84 | } 85 | } 86 | }, 87 | "nbformat": 4, 88 | "nbformat_minor": 2 89 | } 90 | -------------------------------------------------------------------------------- /Стек_Max.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Нужно реализовать класс StackMax, который поддерживает операцию определения максимума среди всех элементов в стеке. Класс должен поддерживать операции push(x), где x – целое число, pop() и get_max().\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке записано одно число n — количество команд, которое не превосходит 10000. В следующих n строках идут команды. Команды могут быть следующих видов:\n", 18 | "\n", 19 | "push(x) — добавить число x в стек;\n", 20 | "pop() — удалить число с вершины стека;\n", 21 | "get_max() — напечатать максимальное число в стеке;\n", 22 | "Если стек пуст, при вызове команды get_max() нужно напечатать «None», для команды pop() — «error».\n", 23 | "\n", 24 | "Формат вывода \n", 25 | "Для каждой команды get_max() напечатайте результат её выполнения. Если стек пустой, для команды get_max() напечатайте «None». Если происходит удаление из пустого стека — напечатайте «error»." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "class StackMax:\n", 35 | " def __init__(self):\n", 36 | " self.items = []\n", 37 | "\n", 38 | " def size(self):\n", 39 | " return len(self.items) \n", 40 | "\n", 41 | " def push(self, item):\n", 42 | " self.items.append(item)\n", 43 | "\n", 44 | " def pop(self): \n", 45 | " if self.size():\n", 46 | " self.items.pop()\n", 47 | " else:\n", 48 | " print('error')\n", 49 | "\n", 50 | " def get_max(self):\n", 51 | " if self.size():\n", 52 | " print(max(self.items))\n", 53 | " else:\n", 54 | " print('None')\n", 55 | "\n", 56 | "x = int(input())\n", 57 | "stack = StackMax()\n", 58 | "\n", 59 | "for i in range(x):\n", 60 | " input_text = input().split()\n", 61 | " if input_text[0] == 'get_max':\n", 62 | " stack.get_max()\n", 63 | " elif input_text[0] == 'pop':\n", 64 | " stack.pop()\n", 65 | " elif input_text[0] == 'push':\n", 66 | " stack.push(int(input_text[1]))" 67 | ] 68 | } 69 | ], 70 | "metadata": { 71 | "kernelspec": { 72 | "display_name": "Python 3", 73 | "language": "python", 74 | "name": "python3" 75 | }, 76 | "language_info": { 77 | "codemirror_mode": { 78 | "name": "ipython", 79 | "version": 3 80 | }, 81 | "file_extension": ".py", 82 | "mimetype": "text/x-python", 83 | "name": "python", 84 | "nbconvert_exporter": "python", 85 | "pygments_lexer": "ipython3", 86 | "version": "3.10.6" 87 | }, 88 | "orig_nbformat": 4, 89 | "vscode": { 90 | "interpreter": { 91 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 92 | } 93 | } 94 | }, 95 | "nbformat": 4, 96 | "nbformat_minor": 2 97 | } 98 | -------------------------------------------------------------------------------- /Расстановка ноутбуков.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "В школе решили на один прямоугольный стол поставить два прямоугольных ноутбука. Ноутбуки нужно поставить так, чтобы их стороны были параллельны сторонам стола. Определите, какие размеры должен иметь стол, чтобы оба ноутбука на него поместились, и площадь стола была минимальна.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Вводится четыре натуральных числа, первые два задают размеры одного ноутбука, а следующие два — размеры второго. Числа не превышают 1000.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Выведите два числа — размеры стола. Если возможно несколько ответов, выведите любой из них (но только один)." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 15, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "[(0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 0, 4)]\n", 33 | "1 0 0\n" 34 | ] 35 | } 36 | ], 37 | "source": [ 38 | "n1, m1, n2, m2 = map(int, input().split())\n", 39 | "\n", 40 | "def sq1(n1, m1, n2, m2):\n", 41 | " tm = max(n1, m1) + max(n2, m2)\n", 42 | " tn = max(min(n1, m1), min(n2, m2))\n", 43 | " return (tn, tm, tn*tm, 1)\n", 44 | "\n", 45 | "def sq2(n1, m1, n2, m2):\n", 46 | " tm = min(n1, m1) + min(n2, m2)\n", 47 | " tn = max(max(n1, m1), max(n2, m2))\n", 48 | " return (tn, tm, tn*tm, 2)\n", 49 | "\n", 50 | "def sq3(n1, m1, n2, m2):\n", 51 | " tm = max(n1, m1) + min(n2, m2)\n", 52 | " tn = max(min(n1, m1), max(n2, m2))\n", 53 | " return (tn, tm, tn*tm, 3)\n", 54 | "\n", 55 | "def sq4(n1, m1, n2, m2):\n", 56 | " tm = min(n1, m1) + max(n2, m2)\n", 57 | " tn = max(max(n1, m1), min(n2, m2))\n", 58 | " return (tn, tm, tn*tm, 4)\n", 59 | "\n", 60 | "vars = []\n", 61 | "\n", 62 | "for i in (sq1, sq2, sq3, sq4):\n", 63 | " x = i(n1, m1, n2, m2)\n", 64 | " vars.append(x)\n", 65 | "\n", 66 | "vars = sorted(vars, key=lambda y: y[2])\n", 67 | "\n", 68 | "print(vars[0][0], vars[0][1])" 69 | ] 70 | } 71 | ], 72 | "metadata": { 73 | "kernelspec": { 74 | "display_name": "Python 3", 75 | "language": "python", 76 | "name": "python3" 77 | }, 78 | "language_info": { 79 | "codemirror_mode": { 80 | "name": "ipython", 81 | "version": 3 82 | }, 83 | "file_extension": ".py", 84 | "mimetype": "text/x-python", 85 | "name": "python", 86 | "nbconvert_exporter": "python", 87 | "pygments_lexer": "ipython3", 88 | "version": "3.10.6" 89 | }, 90 | "orig_nbformat": 4, 91 | "vscode": { 92 | "interpreter": { 93 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 94 | } 95 | } 96 | }, 97 | "nbformat": 4, 98 | "nbformat_minor": 2 99 | } 100 | -------------------------------------------------------------------------------- /Скобочная последовательность.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Ограничение времени 1 секунда \n", 8 | "Ограничение памяти 64Mb \n", 9 | "\n", 10 | "Ввод стандартный ввод или input.txt \n", 11 | "Вывод стандартный вывод или output.txt \n", 12 | "\n", 13 | "Вот какую задачу Тимофей предложил на собеседовании одному из кандидатов. Если вы с ней ещё не сталкивались, то наверняка столкнётесь –— она довольно популярная.\n", 14 | "\n", 15 | "Дана скобочная последовательность. Нужно определить, правильная ли она.\n", 16 | "\n", 17 | "Будем придерживаться такого определения:\n", 18 | "\n", 19 | "пустая строка —– правильная скобочная последовательность;\n", 20 | "правильная скобочная последовательность, взятая в скобки одного типа, –— правильная скобочная последовательность;\n", 21 | "правильная скобочная последовательность с приписанной слева или справа правильной скобочной последовательностью —– тоже правильная.\n", 22 | "На вход подаётся последовательность из скобок трёх видов: [], (), {}.\n", 23 | "Напишите функцию is_correct_bracket_seq, которая принимает на вход скобочную последовательность и возвращает True, если последовательность правильная, а иначе False.\n", 24 | "\n", 25 | "Формат ввода\n", 26 | "На вход подаётся одна строка, содержащая скобочную последовательность. Скобки записаны подряд, без пробелов.\n", 27 | "\n", 28 | "Формат вывода\n", 29 | "Выведите «True» или «False»." 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "def is_correct_bracket_seq(check_string):\n", 39 | " if not len(check_string):\n", 40 | " return True\n", 41 | " if len(check_string) % 2:\n", 42 | " return False\n", 43 | " etalon = {\n", 44 | " ')': '(',\n", 45 | " '}': '{',\n", 46 | " ']': '[',\n", 47 | " }\n", 48 | " stack = []\n", 49 | " for i in check_string:\n", 50 | " if i in etalon.values():\n", 51 | " stack.append(i)\n", 52 | " continue\n", 53 | " if len(stack) and etalon[i] == stack[-1]:\n", 54 | " stack.pop()\n", 55 | " continue\n", 56 | " return False\n", 57 | " if not len(stack):\n", 58 | " return True\n", 59 | " return False\n", 60 | "\n", 61 | "check_string = input()\n", 62 | "print(is_correct_bracket_seq(check_string))" 63 | ] 64 | } 65 | ], 66 | "metadata": { 67 | "kernelspec": { 68 | "display_name": "Python 3", 69 | "language": "python", 70 | "name": "python3" 71 | }, 72 | "language_info": { 73 | "codemirror_mode": { 74 | "name": "ipython", 75 | "version": 3 76 | }, 77 | "file_extension": ".py", 78 | "mimetype": "text/x-python", 79 | "name": "python", 80 | "nbconvert_exporter": "python", 81 | "pygments_lexer": "ipython3", 82 | "version": "3.10.6" 83 | }, 84 | "orig_nbformat": 4, 85 | "vscode": { 86 | "interpreter": { 87 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 88 | } 89 | } 90 | }, 91 | "nbformat": 4, 92 | "nbformat_minor": 2 93 | } 94 | -------------------------------------------------------------------------------- /Сапер.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вам необходимо построить поле для игры \"Сапер\" по его конфигурации – размерам и координатам расставленных на нем мин.\n", 15 | "\n", 16 | "Вкратце напомним правила построения поля для игры \"Сапер\":\n", 17 | "\n", 18 | "Поле состоит из клеток с минами и пустых клеток\n", 19 | "Клетки с миной обозначаются символом *\n", 20 | "Пустые клетки содержат число ki,j, 0≤ ki, j ≤ 8 – количество мин на соседних клетках. Соседними клетками являются восемь клеток, имеющих смежный угол или сторону.\n", 21 | "\n", 22 | "Формат ввода \n", 23 | "В первой строке содержатся три числа: N, 1 ≤ N ≤ 100 - количество строк на поле, M, 1 ≤ M ≤ 100 - количество столбцов на поле, K, 0 ≤ K ≤ N ⋅ M - количество мин на поле.\n", 24 | "\n", 25 | "В следующих K строках содержатся по два числа с координатами мин: p, 1 ≤ p ≤ N - номер строки мины, q, 1 ≤ 1 ≤ M - номер столбца мины.\n", 26 | "\n", 27 | "Формат вывода \n", 28 | "Выведите построенное поле, разделяя строки поля переводом строки, а столбцы - пробелом." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "lins, cols, cnt_mines = map(int, input().split())\n", 38 | "field = [[0]*cols for _ in range (lins)]\n", 39 | "\n", 40 | "def update_field(lin, col):\n", 41 | " coords = [\n", 42 | " (lin-1,col-1),\n", 43 | " (lin-1, col),\n", 44 | " (lin-1, col+1),\n", 45 | " (lin, col-1),\n", 46 | " (lin, col+1),\n", 47 | " (lin+1,col-1),\n", 48 | " (lin+1, col),\n", 49 | " (lin+1, col+1),\n", 50 | " ]\n", 51 | " for i,j in coords:\n", 52 | " if i < 0 or j < 0 or i > lins-1 or j > cols-1:\n", 53 | " continue\n", 54 | " if field[i][j] == '*':\n", 55 | " continue\n", 56 | " field[i][j] += 1\n", 57 | "\n", 58 | "\n", 59 | "for i in range(0, cnt_mines):\n", 60 | " lin, col = map(int, input().split())\n", 61 | " field[lin-1][col-1] = '*'\n", 62 | " update_field(lin-1, col-1)\n", 63 | "\n", 64 | "\n", 65 | "for i in field:\n", 66 | " print(*i)" 67 | ] 68 | } 69 | ], 70 | "metadata": { 71 | "kernelspec": { 72 | "display_name": "Python 3", 73 | "language": "python", 74 | "name": "python3" 75 | }, 76 | "language_info": { 77 | "codemirror_mode": { 78 | "name": "ipython", 79 | "version": 3 80 | }, 81 | "file_extension": ".py", 82 | "mimetype": "text/x-python", 83 | "name": "python", 84 | "nbconvert_exporter": "python", 85 | "pygments_lexer": "ipython3", 86 | "version": "3.10.6" 87 | }, 88 | "orig_nbformat": 4, 89 | "vscode": { 90 | "interpreter": { 91 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 92 | } 93 | } 94 | }, 95 | "nbformat": 4, 96 | "nbformat_minor": 2 97 | } 98 | -------------------------------------------------------------------------------- /Соседи.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Дана матрица. Нужно написать функцию, которая для элемента возвращает всех его соседей. Соседним считается элемент, находящийся от текущего на одну ячейку влево, вправо, вверх или вниз. Диагональные элементы соседними не считаются.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "В первой строке задано n — количество строк матрицы. Во второй — количество столбцов m. Числа m и n не превосходят 1000. В следующих n строках задана матрица. Элементы матрицы — целые числа, по модулю не превосходящие 1000. В последних двух строках записаны координаты элемента, соседей которого нужно найти. Индексация начинается с нуля.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Напечатайте нужные числа в возрастающем порядке через пробел." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 25, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "9\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "from typing import List, Tuple\n", 38 | "\n", 39 | "def get_neighbours(matrix: List[List[int]], row: int, col: int, n: int, m: int) -> List[int]:\n", 40 | " neighbours = []\n", 41 | " for i in range(row-1, row+2, 2):\n", 42 | " if i < 0 or i > n-1:\n", 43 | " continue\n", 44 | " else:\n", 45 | " neighbours.append(matrix[i][col])\n", 46 | " for i in range(col-1, col+2, 2):\n", 47 | " if i < 0 or i > m-1:\n", 48 | " continue\n", 49 | " else:\n", 50 | " neighbours.append(matrix[row][i])\n", 51 | " return sorted(neighbours)\n", 52 | "\n", 53 | "def read_input() -> Tuple[List[List[int]], int, int]:\n", 54 | " n = int(input())\n", 55 | " m = int(input())\n", 56 | " matrix = []\n", 57 | " for i in range(n):\n", 58 | " matrix.append(list(map(int, input().strip().split())))\n", 59 | " row = int(input())\n", 60 | " col = int(input())\n", 61 | " return matrix, row, col, n, m\n", 62 | "\n", 63 | "matrix, row, col, n, m = read_input()\n", 64 | "print(\" \".join(map(str, get_neighbours(matrix, row, col, n, m))))" 65 | ] 66 | } 67 | ], 68 | "metadata": { 69 | "kernelspec": { 70 | "display_name": "Python 3", 71 | "language": "python", 72 | "name": "python3" 73 | }, 74 | "language_info": { 75 | "codemirror_mode": { 76 | "name": "ipython", 77 | "version": 3 78 | }, 79 | "file_extension": ".py", 80 | "mimetype": "text/x-python", 81 | "name": "python", 82 | "nbconvert_exporter": "python", 83 | "pygments_lexer": "ipython3", 84 | "version": "3.10.6" 85 | }, 86 | "orig_nbformat": 4, 87 | "vscode": { 88 | "interpreter": { 89 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 90 | } 91 | } 92 | }, 93 | "nbformat": 4, 94 | "nbformat_minor": 2 95 | } 96 | -------------------------------------------------------------------------------- /Списочная очередь.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t0.3 секунды \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Любимый вариант очереди Тимофея — очередь, написанная с использованием связного списка. Помогите ему с реализацией. Очередь должна поддерживать выполнение трёх команд:\n", 15 | "\n", 16 | "get() — вывести элемент, находящийся в голове очереди, и удалить его. Если очередь пуста, то вывести «error».\n", 17 | "put(x) — добавить число x в очередь\n", 18 | "size() — вывести текущий размер очереди\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке записано количество команд n — целое число, не превосходящее 1000. В каждой из следующих n строк записаны команды по одной строке.\n", 22 | "\n", 23 | "Формат вывода \n", 24 | "Выведите ответ на каждый запрос по одному в строке." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "class Node:\n", 34 | " def __init__(self, value, next_item=None):\n", 35 | " self.value = value\n", 36 | " self.next_item = next_item\n", 37 | "\n", 38 | "head = None\n", 39 | "tail = None\n", 40 | "size = 0\n", 41 | "\n", 42 | "def put(x):\n", 43 | " global head, size, tail\n", 44 | " new_node = Node(value=x, next_item=None)\n", 45 | " if not head:\n", 46 | " head = tail = new_node\n", 47 | " else:\n", 48 | " tail.next_item = new_node\n", 49 | " tail = new_node\n", 50 | " size += 1\n", 51 | "\n", 52 | "def get():\n", 53 | " global head, size\n", 54 | " if size:\n", 55 | " print(head.value)\n", 56 | " head = head.next_item\n", 57 | " size -= 1\n", 58 | " else:\n", 59 | " print('error')\n", 60 | "\n", 61 | "counter_commands = int(input())\n", 62 | "\n", 63 | "for i in range(counter_commands):\n", 64 | " input_text = input().split()\n", 65 | " if input_text[0] == 'get':\n", 66 | " get()\n", 67 | " elif input_text[0] == 'put':\n", 68 | " put(int(input_text[1]))\n", 69 | " elif input_text[0] == 'size':\n", 70 | " print(size)" 71 | ] 72 | } 73 | ], 74 | "metadata": { 75 | "kernelspec": { 76 | "display_name": "Python 3", 77 | "language": "python", 78 | "name": "python3" 79 | }, 80 | "language_info": { 81 | "codemirror_mode": { 82 | "name": "ipython", 83 | "version": 3 84 | }, 85 | "file_extension": ".py", 86 | "mimetype": "text/x-python", 87 | "name": "python", 88 | "nbconvert_exporter": "python", 89 | "pygments_lexer": "ipython3", 90 | "version": "3.10.6" 91 | }, 92 | "orig_nbformat": 4, 93 | "vscode": { 94 | "interpreter": { 95 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 96 | } 97 | } 98 | }, 99 | "nbformat": 4, 100 | "nbformat_minor": 2 101 | } 102 | -------------------------------------------------------------------------------- /Банковские счета.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Банковские счета\n", 9 | "\n", 10 | "Некоторый банк хочет внедрить систему управления счетами клиентов, поддерживающую следующие операции:\n", 11 | "\n", 12 | "Пополнение счета клиента. Снятие денег со счета. Запрос остатка средств на счете. Перевод денег между счетами клиентов. Начисление процентов всем клиентам.\n", 13 | "\n", 14 | "Вам необходимо реализовать такую систему. Клиенты банка идентифицируются именами (уникальная строка, не содержащая пробелов). Первоначально у банка нет ни одного клиента. Как только для клиента проводится операция пололнения, снятия или перевода денег, ему заводится счет с нулевым балансом. Все дальнейшие операции проводятся только с этим счетом. Сумма на счету может быть как положительной, так и отрицательной, при этом всегда является целым числом.\n", 15 | "\n", 16 | "Формат ввода \n", 17 | "Входной файл содержит последовательность операций. Возможны следующие операции: DEPOSIT name sum - зачислить сумму sum на счет клиента name. Если у клиента нет счета, то счет создается. WITHDRAW name sum - снять сумму sum со счета клиента name. Если у клиента нет счета, то счет создается. BALANCE name - узнать остаток средств на счету клиента name. TRANSFER name1 name2 sum - перевести сумму sum со счета клиента name1 на счет клиента name2. Если у какого-либо клиента нет счета, то ему создается счет. INCOME p - начислить всем клиентам, у которых открыты счета, p% от суммы счета. Проценты начисляются только клиентам с положительным остатком на счету, если у клиента остаток отрицательный, то его счет не меняется. После начисления процентов сумма на счету остается целой, то есть начисляется только целое число денежных единиц. Дробная часть начисленных процентов отбрасывается.\n", 18 | "\n", 19 | "Формат вывода \n", 20 | "Для каждого запроса BALANCE программа должна вывести остаток на счету данного клиента. Если же у клиента с запрашиваемым именем не открыт счет в банке, выведите ERROR." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "balances = {}\n", 30 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 31 | "x = file.readlines()\n", 32 | "for line in x:\n", 33 | " y = line.split()\n", 34 | " if y[0] == 'BALANCE':\n", 35 | " print(balances.get(y[1], 'ERROR'))\n", 36 | " if y[0] == 'DEPOSIT':\n", 37 | " balances[y[1]] = balances.setdefault(y[1], 0) + int(y[2])\n", 38 | " if y[0] == 'INCOME':\n", 39 | " for i in balances.keys():\n", 40 | " if int(balances.get(i)) > 0:\n", 41 | " balances[i] = int(balances.get(i) * (int(y[1])/100 + 1))\n", 42 | " if y[0] == 'WITHDRAW':\n", 43 | " balances[y[1]] = balances.setdefault(y[1], 0) - int(y[2])\n", 44 | " if y[0] == 'TRANSFER':\n", 45 | " balances[y[1]] = balances.setdefault(y[1], 0) - int(y[3])\n", 46 | " balances[y[2]] = balances.setdefault(y[2], 0) + int(y[3])" 47 | ] 48 | } 49 | ], 50 | "metadata": { 51 | "language_info": { 52 | "name": "python" 53 | }, 54 | "orig_nbformat": 4 55 | }, 56 | "nbformat": 4, 57 | "nbformat_minor": 2 58 | } 59 | -------------------------------------------------------------------------------- /Самое длинное слово.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Чтобы подготовиться к семинару, Гоше надо прочитать статью по эффективному менеджменту. Так как Гоша хочет спланировать день заранее, ему необходимо оценить сложность статьи.\n", 15 | "\n", 16 | "Он придумал такой метод оценки: берётся случайное предложение из текста и в нём ищется самое длинное слово. Его длина и будет условной сложностью статьи.\n", 17 | "\n", 18 | "Помогите Гоше справиться с этой задачей.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке дана длина текста L (1 ≤ L ≤ 105).\n", 22 | "\n", 23 | "В следующей строке записан текст, состоящий из строчных латинских букв и пробелов. Слово —– последовательность букв, не разделённых пробелами. Пробелы могут стоять в самом начале строки и в самом её конце. Текст заканчивается переносом строки, этот символ не включается в число остальных L символов.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "В первой строке выведите самое длинное слово. Во второй строке выведите его длину. Если подходящих слов несколько, выведите то, которое встречается раньше." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 6, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "jumps\n", 39 | "5\n" 40 | ] 41 | } 42 | ], 43 | "source": [ 44 | "def get_longest_word(n:int, line: str) -> str:\n", 45 | " size = n - line.count(' ')\n", 46 | " words = line.split()\n", 47 | " longest = ''\n", 48 | " len_longest = 0\n", 49 | " for i in words:\n", 50 | " if size < len_longest:\n", 51 | " return longest, str(len_longest)\n", 52 | " if len(i) > len_longest:\n", 53 | " longest = i\n", 54 | " len_longest = len(i)\n", 55 | " size -= len(i)\n", 56 | " return longest, str(len_longest)\n", 57 | "\n", 58 | "def read_input() -> tuple:\n", 59 | " n = int(input())\n", 60 | " line = input().strip()\n", 61 | " return n, line\n", 62 | "\n", 63 | "def print_result(result: tuple) -> None:\n", 64 | " print('\\n'.join(result))\n", 65 | "\n", 66 | "n, line = read_input()\n", 67 | "print_result(get_longest_word(n, line))" 68 | ] 69 | } 70 | ], 71 | "metadata": { 72 | "kernelspec": { 73 | "display_name": "Python 3", 74 | "language": "python", 75 | "name": "python3" 76 | }, 77 | "language_info": { 78 | "codemirror_mode": { 79 | "name": "ipython", 80 | "version": 3 81 | }, 82 | "file_extension": ".py", 83 | "mimetype": "text/x-python", 84 | "name": "python", 85 | "nbconvert_exporter": "python", 86 | "pygments_lexer": "ipython3", 87 | "version": "3.10.6" 88 | }, 89 | "orig_nbformat": 4, 90 | "vscode": { 91 | "interpreter": { 92 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 93 | } 94 | } 95 | }, 96 | "nbformat": 4, 97 | "nbformat_minor": 2 98 | } 99 | -------------------------------------------------------------------------------- /Контрольная по ударениям.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Контрольная по ударениям\n", 9 | "\n", 10 | "Учительница задала Пете домашнее задание — в заданном тексте расставить ударения в словах, после чего поручила Васе проверить это домашнее задание. Вася очень плохо знаком с данной темой, поэтому он нашел словарь, в котором указано, как ставятся ударения в словах. К сожалению, в этом словаре присутствуют не все слова. Вася решил, что в словах, которых нет в словаре, он будет считать, что Петя поставил ударения правильно, если в этом слове Петей поставлено ровно одно ударение. Оказалось, что в некоторых словах ударение может быть поставлено больше, чем одним способом. Вася решил, что в этом случае если то, как Петя поставил ударение, соответствует одному из приведенных в словаре вариантов, он будет засчитывать это как правильную расстановку ударения, а если не соответствует, то как ошибку. Вам дан словарь, которым пользовался Вася и домашнее задание, сданное Петей. Ваша задача — определить количество ошибок, которое в этом задании насчитает Вася.\n", 11 | "\n", 12 | "Формат ввода \n", 13 | "Вводится сначала число N — количество слов в словаре (0≤N≤20000). Далее идет N строк со словами из словаря. Каждое слово состоит не более чем из 30 символов. Все слова состоят из маленьких и заглавных латинских букв. В каждом слове заглавная ровно одна буква — та, на которую попадает ударение. Слова в словаре расположены в алфавитном порядке. Если есть несколько возможностей расстановки ударения в одном и том же слове, то эти варианты в словаре идут в произвольном порядке. Далее идет упражнение, выполненное Петей. Упражнение представляет собой строку текста, суммарным объемом не более 300000 символов. Строка состоит из слов, которые разделяются между собой ровно одним пробелом. Длина каждого слова не превышает 30 символов. Все слова состоят из маленьких и заглавных латинских букв (заглавными обозначены те буквы, над которыми Петя поставил ударение). Петя мог по ошибке в каком-то слове поставить более одного ударения или не поставить ударения вовсе.\n", 14 | "\n", 15 | "Формат вывода \n", 16 | "Выведите количество ошибок в Петином тексте, которые найдет Вася." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "file = open(\"input.txt\", \"r\", encoding='utf-8')\n", 26 | "x = file.readlines()\n", 27 | "words = int(x[0])\n", 28 | "words_dict = {}\n", 29 | "\n", 30 | "for line in x[1:words+1]:\n", 31 | " word = line.strip()\n", 32 | " word_lower = word.lower()\n", 33 | " words_dict.setdefault(word_lower, [])\n", 34 | " words_dict[word_lower].append(word)\n", 35 | "\n", 36 | "mistakes = 0\n", 37 | "\n", 38 | "for i in x[words+1].split():\n", 39 | " if not words_dict.get(i.lower()):\n", 40 | " if sum(map(str.isupper, i)) != 1:\n", 41 | " mistakes += 1\n", 42 | " else:\n", 43 | " if i in words_dict.get(i.lower()):\n", 44 | " continue\n", 45 | " else:\n", 46 | " mistakes += 1\n", 47 | "\n", 48 | "print(mistakes)" 49 | ] 50 | } 51 | ], 52 | "metadata": { 53 | "language_info": { 54 | "name": "python" 55 | }, 56 | "orig_nbformat": 4 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 2 60 | } 61 | -------------------------------------------------------------------------------- /Два велосипеда.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t256Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Вася решил накопить денег на два одинаковых велосипеда — себе и сестре. У Васи есть копилка, в которую каждый день он может добавлять деньги (если, конечно, у него есть такая финансовая возможность). В процессе накопления Вася не вынимает деньги из копилки.\n", 15 | "\n", 16 | "У вас есть информация о росте Васиных накоплений — сколько у Васи в копилке было денег в каждый из дней.\n", 17 | "\n", 18 | "Ваша задача — по заданной стоимости велосипеда определить\n", 19 | "\n", 20 | "первый день, в которой Вася смог бы купить один велосипед,\n", 21 | "и первый день, в который Вася смог бы купить два велосипеда.\n", 22 | "\n", 23 | "Формат ввода \n", 24 | "В первой строке дано число дней n, по которым велись наблюдения за Васиными накоплениями. 1 ≤ n ≤ 106. \n", 25 | "В следующей строке записаны n целых неотрицательных чисел. Числа идут в порядке неубывания. Каждое из чисел не превосходит 106. \n", 26 | "В третьей строке записано целое положительное число s — стоимость велосипеда. Это число не превосходит 106. \n", 27 | "\n", 28 | "Формат вывода \n", 29 | "Нужно вывести два числа — номера дней по условию задачи.\n", 30 | "\n", 31 | "Если необходимой суммы в копилке не нашлось, нужно вернуть -1 вместо номера дня." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "def binarySearch(arr, x, left, right):\n", 41 | " if right - left <= 1:\n", 42 | " if right >= len(arr):\n", 43 | " right = len(arr) - 1\n", 44 | " if left >= len(arr):\n", 45 | " left = len(arr) - 1\n", 46 | " if arr[left] < x and arr[right] < x:\n", 47 | " return -1\n", 48 | " elif arr[left] >= x:\n", 49 | " return left + 1\n", 50 | " else:\n", 51 | " return right + 1\n", 52 | " mid = (left + right) // 2\n", 53 | " if x <= arr[mid]:\n", 54 | " return binarySearch(arr, x, left, mid)\n", 55 | " else:\n", 56 | " return binarySearch(arr, x, mid + 1, right)\n", 57 | "\n", 58 | "days = int(input())\n", 59 | "money_per_days = list(map(int, input().split()))\n", 60 | "price_for_one = int(input())\n", 61 | "\n", 62 | "index = binarySearch(money_per_days, price_for_one, left = 0, right = days-1)\n", 63 | "index_2 = binarySearch(money_per_days, price_for_one*2, left = 0, right = days)\n", 64 | "\n", 65 | "print(index, index_2)" 66 | ] 67 | } 68 | ], 69 | "metadata": { 70 | "kernelspec": { 71 | "display_name": "Python 3", 72 | "language": "python", 73 | "name": "python3" 74 | }, 75 | "language_info": { 76 | "codemirror_mode": { 77 | "name": "ipython", 78 | "version": 3 79 | }, 80 | "file_extension": ".py", 81 | "mimetype": "text/x-python", 82 | "name": "python", 83 | "nbconvert_exporter": "python", 84 | "pygments_lexer": "ipython3", 85 | "version": "3.10.6" 86 | }, 87 | "orig_nbformat": 4 88 | }, 89 | "nbformat": 4, 90 | "nbformat_minor": 2 91 | } 92 | -------------------------------------------------------------------------------- /Генератор скобок.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Рита по поручению Тимофея наводит порядок в правильных скобочных последовательностях (ПСП), состоящих только из круглых скобок (). Для этого ей надо сгенерировать все ПСП длины 2n в алфавитном порядке —– алфавит состоит из ( и ) и открывающая скобка идёт раньше закрывающей.\n", 15 | "\n", 16 | "Помогите Рите —– напишите программу, которая по заданному n выведет все ПСП в нужном порядке.\n", 17 | "\n", 18 | "Пример 1 \n", 19 | "Ввод \n", 20 | "3\n", 21 | "\n", 22 | "Вывод \n", 23 | "((())) \n", 24 | "(()()) \n", 25 | "(())() \n", 26 | "()(()) \n", 27 | "()()() \n", 28 | "\n", 29 | "Пример 2 \n", 30 | "Ввод \n", 31 | "2\n", 32 | "\n", 33 | "Вывод \n", 34 | "(()) \n", 35 | "()() \n", 36 | "\n", 37 | "Рассмотрим второй пример. Надо вывести ПСП из четырёх символов. Таких всего две:\n", 38 | "\n", 39 | "(()) \n", 40 | "()() \n", 41 | "\n", 42 | "(()) идёт раньше ()(), так как первый символ у них одинаковый, а на второй позиции у первой ПСП стоит (, который идёт раньше ).\n", 43 | "\n", 44 | "Формат ввода \n", 45 | "На вход функция принимает n — целое число от 0 до 10.\n", 46 | "\n", 47 | "Формат вывода \n", 48 | "Функция должна напечатать все возможные скобочные последовательности заданной длины в алфавитном (лексикографическом) порядке.\n", 49 | "\n" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "def generate(count_psp, etalon, prefix, open, close):\n", 59 | " if count_psp == 0:\n", 60 | " print(prefix)\n", 61 | " else:\n", 62 | " if prefix == '':\n", 63 | " generate(count_psp-1, etalon, prefix+'(', open+1, close)\n", 64 | " else:\n", 65 | " if open == etalon:\n", 66 | " generate(count_psp-1, etalon, prefix+')', open, close+1)\n", 67 | " elif open == close:\n", 68 | " generate(count_psp-1, etalon, prefix+'(', open+1, close)\n", 69 | " else:\n", 70 | " generate(count_psp-1, etalon, prefix+'(', open+1, close)\n", 71 | " generate(count_psp-1, etalon, prefix+')', open, close+1)\n", 72 | "\n", 73 | "\n", 74 | "count_psp = int(input())\n", 75 | "prefix = ''\n", 76 | "open = 0\n", 77 | "close = 0\n", 78 | "\n", 79 | "generate(count_psp*2, count_psp, prefix, open, close)" 80 | ] 81 | } 82 | ], 83 | "metadata": { 84 | "kernelspec": { 85 | "display_name": "Python 3", 86 | "language": "python", 87 | "name": "python3" 88 | }, 89 | "language_info": { 90 | "codemirror_mode": { 91 | "name": "ipython", 92 | "version": 3 93 | }, 94 | "file_extension": ".py", 95 | "mimetype": "text/x-python", 96 | "name": "python", 97 | "nbconvert_exporter": "python", 98 | "pygments_lexer": "ipython3", 99 | "version": "3.10.6" 100 | }, 101 | "orig_nbformat": 4 102 | }, 103 | "nbformat": 4, 104 | "nbformat_minor": 2 105 | } 106 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # poetry 98 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 99 | # This is especially recommended for binary packages to ensure reproducibility, and is more 100 | # commonly ignored for libraries. 101 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 102 | #poetry.lock 103 | 104 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 105 | __pypackages__/ 106 | 107 | # Celery stuff 108 | celerybeat-schedule 109 | celerybeat.pid 110 | 111 | # SageMath parsed files 112 | *.sage.py 113 | 114 | # Environments 115 | .env 116 | .venv 117 | env/ 118 | venv/ 119 | ENV/ 120 | env.bak/ 121 | venv.bak/ 122 | 123 | # Spyder project settings 124 | .spyderproject 125 | .spyproject 126 | 127 | # Rope project settings 128 | .ropeproject 129 | 130 | # mkdocs documentation 131 | /site 132 | 133 | # mypy 134 | .mypy_cache/ 135 | .dmypy.json 136 | dmypy.json 137 | 138 | # Pyre type checker 139 | .pyre/ 140 | 141 | # pytype static type analyzer 142 | .pytype/ 143 | 144 | # Cython debug symbols 145 | cython_debug/ 146 | 147 | # PyCharm 148 | # JetBrains specific template is maintainted in a separate JetBrains.gitignore that can 149 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 150 | # and can be added to the global gitignore or merged into this file. For a more nuclear 151 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 152 | #.idea/ 153 | 154 | *.txt 155 | -------------------------------------------------------------------------------- /Ловкость рук.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Ограничение времени\t1 секунда \n", 9 | "Ограничение памяти\t64Mb \n", 10 | "\n", 11 | "Ввод\tстандартный ввод или input.txt \n", 12 | "Вывод\tстандартный вывод или output.txt \n", 13 | "\n", 14 | "Игра «Тренажёр для скоростной печати» представляет собой поле из клавиш 4x4. В нём на каждом раунде появляется конфигурация цифр и точек. На клавише написана либо точка, либо цифра от 1 до 9.\n", 15 | "\n", 16 | "В момент времени t игрок должен одновременно нажать на все клавиши, на которых написана цифра t. Гоша и Тимофей могут нажать в один момент времени на k клавиш каждый. Если в момент времени t нажаты все нужные клавиши, то игроки получают 1 балл.\n", 17 | "\n", 18 | "Найдите число баллов, которое смогут заработать Гоша и Тимофей, если будут нажимать на клавиши вдвоём.\n", 19 | "\n", 20 | "Формат ввода \n", 21 | "В первой строке дано целое число k (1 ≤ k ≤ 5).\n", 22 | "\n", 23 | "В четырёх следующих строках задан вид тренажёра -— по 4 символа в каждой строке. Каждый символ – либо точка, либо цифра от 1 до 9. Символы одной строки идут подряд и не разделены пробелами.\n", 24 | "\n", 25 | "Формат вывода \n", 26 | "Выведите единственное число -— максимальное количество баллов, которое смогут набрать Гоша и Тимофей." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "from typing import Tuple, List\n", 36 | "\n", 37 | "\n", 38 | "def read_input(matrix_size: int) -> Tuple[int, List[str]]:\n", 39 | " \"\"\"Считывает ввод в переменные.\"\"\"\n", 40 | " ONE_BOY_CAN_TAP = int(input())\n", 41 | " values = []\n", 42 | " for _ in range(matrix_size):\n", 43 | " values.extend(list(input()))\n", 44 | " return ONE_BOY_CAN_TAP, values\n", 45 | "\n", 46 | "\n", 47 | "def game(values: Tuple[int, List[str]], ONE_BOY_CAN_TAP: int,\n", 48 | " BOYS_COUNT: int) -> int:\n", 49 | " \"\"\"Проводит расчёт результатов игры.\"\"\"\n", 50 | " all_boys_can_tap = ONE_BOY_CAN_TAP*BOYS_COUNT\n", 51 | " fail_set = {'.'}\n", 52 | " counter_values = {}\n", 53 | " for i in values:\n", 54 | " if i in fail_set:\n", 55 | " continue\n", 56 | " counter_values[i] = counter_values.get(i, 0) + 1\n", 57 | " if counter_values[i] > all_boys_can_tap:\n", 58 | " fail_set.add(i)\n", 59 | " return len(counter_values) - len(fail_set) + 1\n", 60 | "\n", 61 | "\n", 62 | "if __name__ == '__main__':\n", 63 | " MATRIX_SIZE = 4\n", 64 | " BOYS_COUNT = 2\n", 65 | " ONE_BOY_CAN_TAP, values = read_input(MATRIX_SIZE)\n", 66 | " print(game(values, ONE_BOY_CAN_TAP, BOYS_COUNT))" 67 | ] 68 | } 69 | ], 70 | "metadata": { 71 | "kernelspec": { 72 | "display_name": "Python 3", 73 | "language": "python", 74 | "name": "python3" 75 | }, 76 | "language_info": { 77 | "codemirror_mode": { 78 | "name": "ipython", 79 | "version": 3 80 | }, 81 | "file_extension": ".py", 82 | "mimetype": "text/x-python", 83 | "name": "python", 84 | "nbconvert_exporter": "python", 85 | "pygments_lexer": "ipython3", 86 | "version": "3.10.6" 87 | }, 88 | "orig_nbformat": 4, 89 | "vscode": { 90 | "interpreter": { 91 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 92 | } 93 | } 94 | }, 95 | "nbformat": 4, 96 | "nbformat_minor": 2 97 | } 98 | --------------------------------------------------------------------------------