├── Веб-технологии └── web │ ├── ask │ ├── ask │ │ ├── __init__.py │ │ ├── wsgi.py │ │ ├── urls.py │ │ └── settings.py │ ├── qa │ │ ├── __init__.py │ │ ├── tests.py │ │ ├── admin.py │ │ ├── models.py │ │ ├── forms.py │ │ └── views.py │ ├── templates │ │ ├── login.html │ │ ├── ask.html │ │ ├── signup.html │ │ ├── question.html │ │ ├── index.html │ │ └── popular.html │ └── manage.py │ ├── nginx.conf │ └── init.sh ├── Python - основы и применение ├── README.md ├── 1.1 Введение 10.md ├── 3.3 Регулярные выражения в Python 10.md ├── 3.3 Регулярные выражения в Python 15.md ├── 1.3 Функции и стек вызовов 9.md ├── 3.3 Регулярные выражения в Python 9.md ├── 3.3 Регулярные выражения в Python 12.md ├── 2.4 Работа с файловой системой и файлами 4.md ├── 3.3 Регулярные выражения в Python 11.md ├── 3.3 Регулярные выражения в Python 14.md ├── 3.3 Регулярные выражения в Python 13.md ├── 3.5 Распространённые форматы текстовых файлов CSV, JSON 2.md ├── 2.5 Работа с функциями - functool и лямбда функции 6.md ├── 3.5 Распространённые форматы текстовых файлов CSV, JSON 2 (2).md ├── 3.3 Регулярные выражения в Python 8.md ├── 3.3 Регулярные выражения в Python 7.md ├── 2.1 Ошибки и исключения 6.md ├── 2.1 Ошибки и исключения 9.md ├── 2.4 Работа с файловой системой и файлами 6.md ├── 3.2 Стандартные методы и функции для строк 7.md ├── 1.6 Наследование классов 9.md ├── 2.3 Итераторы и генераторы 5.md ├── 1.2 Модель данных - объекты 9.md ├── 2.2 Работа с кодом - модули и импорт 5.md ├── 1.5 Введение в классы 8.md ├── 3.6 API 3.md ├── 2.2 Работа с кодом - модули и импорт 9.md ├── 3.2 Стандартные методы и функции для строк 6.md ├── 1.3 Функции и стек вызовов 15.md ├── 3.4 Обзорно об интернете http-запросы, html-страницы и requests 7.md ├── 3.5 Распространённые форматы текстовых файлов CSV, JSON 4.md ├── 1.6 Наследование классов 8.md ├── 3.7 XML, библиотека ElementTree, библиотека lxml 4.md ├── 3.4 Обзорно об интернете http-запросы, html-страницы и requests 6.md ├── 1.5 Введение в классы 9.md ├── 1.6 Наследование классов 7.md ├── 3.6 API 4.md ├── 2.1 Ошибки и исключения 7.md ├── 2.3 Итераторы и генераторы 4.md └── 1.4 Пространства имён и область видимости 9.md ├── Интерактивный тренажер по SQL ├── 2 Связи между таблицами │ ├── 1.2 Выборка данных │ │ ├── 2 Выборка отдельных столбцов.md │ │ ├── 7 Выборка данных по условию.md │ │ ├── 3 Выборка новых столбцов и присвоение им новых имен.md │ │ ├── 9 Выборка данных, операторы BETWEEN, IN.md │ │ ├── 1 Выборка всех данных.md │ │ ├── 8 Выборка данных, логические операции.md │ │ ├── 10 Выборка данных с сортировкой.md │ │ ├── 4 Выборка данных с созданием вычисляемого столбца.md │ │ ├── 5 Выборка данных, вычисляемые столбцы, математические функции.md │ │ ├── 11 Выборка данных, оператор LIKE.md │ │ └── 6 Выборка данных, вычисляемые столбцы, логические функции.md │ ├── 1.3 Запросы, групповые операции │ │ ├── 1 Выбор уникальных элементов столбца.md │ │ ├── 5 Вычисления по таблице целиком.md │ │ ├── 2 Выборка данных, групповые функции SUM и COUNT.md │ │ ├── 3 Выборка данных, групповые функции MIN, MAX и AVG.md │ │ ├── 6 Выборка данных по условию, групповые функции.md │ │ ├── 7 Выборка данных по условию, групповые функции, WHERE и HAVING.md │ │ └── 4 Выборка данных c вычислением, групповые функции.md │ ├── 1.5 Запросы корректировки данных │ │ ├── 5 Запросы на обновление.md │ │ ├── 1 Создание пустой таблицы.md │ │ ├── 3 Добавление записей из другой таблицы.md │ │ ├── 2 Добавление записей в таблицу.md │ │ ├── 6 Запросы на обновление нескольких столбцов.md │ │ ├── 8 Запросы на удаление.md │ │ ├── 4 Добавление записей, вложенные запросы.md │ │ ├── 7 Запросы на обновление нескольких таблиц.md │ │ └── 9 Запросы на создание таблицы.md │ ├── 2.1 Связи между таблицами │ │ ├── 2.md │ │ ├── 1.md │ │ ├── 5.md │ │ ├── 4 Действия при удалении записи главной таблицы.md │ │ └── 3 Создание таблицы с внешними ключами.md │ ├── 2.2 Запросы на выборку, соединение таблиц │ │ ├── 2 Внешнее соединение LEFT и RIGHT OUTER JOIN.md │ │ ├── 1 Соединение INNER JOIN.md │ │ ├── 4 Запросы на выборку из нескольких таблиц.md │ │ ├── 5 Запросы для нескольких таблиц с группировкой.md │ │ ├── 3 Перекрестное соединение CROSS JOIN.md │ │ ├── 6 Запросы для нескольких таблиц со вложенными запросами.md │ │ ├── 8 Операция соединение, использование USING().md │ │ └── 7 Вложенные запросы в операторах соединения.md │ ├── 2.3 Запросы корректировки, соединение таблиц │ │ ├── 4 Запрос на обновление, вложенные запросы.md │ │ ├── 5 Каскадное удаление записей связанных таблиц.md │ │ ├── 6 Удаление записей главной таблицы с сохранением записей в зависимой.md │ │ ├── 3 Запрос на добавление, связанные таблицы.md │ │ ├── 2 Запросы на добавление, связанные таблицы.md │ │ ├── 7 Удаление записей, использование связанных таблиц.md │ │ └── 1 Запросы на обновление, связанные таблицы.md │ ├── 1.4 Вложенные запросы │ │ ├── 4 Вложенный запрос, операторы ANY и ALL.md │ │ ├── 3 Вложенный запрос, оператор IN.md │ │ ├── 2 Использование вложенного запроса в выражении.md │ │ ├── 1 Вложенный запрос, возвращающий одно значение.md │ │ └── 5 Вложенный запрос после SELECT.md │ └── 1.1 Отношение (таблица) │ │ ├── 1 Создание таблицы.md │ │ ├── 2 Вставка записи в таблицу.md │ │ └── 3 Вставка записи в таблицу.md ├── 1 Основы реляционной модели │ ├── 1.2 Выборка данных │ │ ├── 2 Выборка отдельных столбцов.md │ │ ├── 7 Выборка данных по условию.md │ │ ├── 3 Выборка новых столбцов и присвоение им новых имен.md │ │ ├── 9 Выборка данных, операторы BETWEEN, IN.md │ │ ├── 1 Выборка всех данных.md │ │ ├── 8 Выборка данных, логические операции.md │ │ ├── 10 Выборка данных с сортировкой.md │ │ ├── 4 Выборка данных с созданием вычисляемого столбца.md │ │ ├── 5 Выборка данных, вычисляемые столбцы, математические функции.md │ │ ├── 11 Выборка данных, оператор LIKE.md │ │ └── 6 Выборка данных, вычисляемые столбцы, логические функции.md │ ├── 1.3 Запросы, групповые операции │ │ ├── 1 Выбор уникальных элементов столбца.md │ │ ├── 5 Вычисления по таблице целиком.md │ │ ├── 2 Выборка данных, групповые функции SUM и COUNT.md │ │ ├── 3 Выборка данных, групповые функции MIN, MAX и AVG.md │ │ ├── 6 Выборка данных по условию, групповые функции.md │ │ ├── 7 Выборка данных по условию, групповые функции, WHERE и HAVING.md │ │ └── 4 Выборка данных c вычислением, групповые функции.md │ ├── 1.5 Запросы корректировки данных │ │ ├── 5 Запросы на обновление.md │ │ ├── 1 Создание пустой таблицы.md │ │ ├── 3 Добавление записей из другой таблицы.md │ │ ├── 2 Добавление записей в таблицу.md │ │ ├── 6 Запросы на обновление нескольких столбцов.md │ │ ├── 8 Запросы на удаление.md │ │ ├── 4 Добавление записей, вложенные запросы.md │ │ ├── 7 Запросы на обновление нескольких таблиц.md │ │ └── 9 Запросы на создание таблицы.md │ ├── 1.4 Вложенные запросы │ │ ├── 4 Вложенный запрос, операторы ANY и ALL.md │ │ ├── 3 Вложенный запрос, оператор IN.md │ │ ├── 2 Использование вложенного запроса в выражении.md │ │ ├── 1 Вложенный запрос, возвращающий одно значение.md │ │ └── 5 Вложенный запрос после SELECT.md │ └── 1.1 Отношение (таблица) │ │ ├── 1 Создание таблицы.md │ │ ├── 2 Вставка записи в таблицу.md │ │ └── 3 Вставка записи в таблицу.md └── 3 Базы данных и SQL-запросы │ ├── 2.1 Связи между таблицами │ ├── 2.md │ ├── 1.md │ ├── 5.md │ ├── 4 Действия при удалении записи главной таблицы.md │ └── 3 Создание таблицы с внешними ключами.md │ ├── 2.2 Запросы на выборку, соединение таблиц │ ├── 2 Внешнее соединение LEFT и RIGHT OUTER JOIN.md │ ├── 1 Соединение INNER JOIN.md │ ├── 4 Запросы на выборку из нескольких таблиц.md │ ├── 5 Запросы для нескольких таблиц с группировкой.md │ ├── 3 Перекрестное соединение CROSS JOIN.md │ ├── 6 Запросы для нескольких таблиц со вложенными запросами.md │ ├── 8 Операция соединение, использование USING().md │ └── 7 Вложенные запросы в операторах соединения.md │ └── 2.3 Запросы корректировки, соединение таблиц │ ├── 4 Запрос на обновление, вложенные запросы.md │ ├── 5 Каскадное удаление записей связанных таблиц.md │ ├── 6 Удаление записей главной таблицы с сохранением записей в зависимой.md │ ├── 3 Запрос на добавление, связанные таблицы.md │ ├── 2 Запросы на добавление, связанные таблицы.md │ ├── 7 Удаление записей, использование связанных таблиц.md │ └── 1 Запросы на обновление, связанные таблицы.md ├── Python Course tasks ├── week 10 │ ├── primes.md │ └── kvadrat.md ├── week 6 │ └── first.md ├── week 7 │ ├── friends.md │ ├── fix_duplicates.md │ └── average_attempts.md.py ├── week 11 │ ├── student_ids.md │ ├── coords_min_max.md │ └── irises.md └── week 3 │ └── life.py ├── Алгоритмы методы ├── 2.2 Числа Фибоначчи.md ├── 2.3 Наибольший общий делитель.md ├── 2.3 Числа Фибоначчи.md ├── 4.1.11 Различные слагаемые.md ├── 6.1.4 Двоичный поиск.md ├── 4.3.8 Очередь с приоритетами.md ├── 4.1.10 Непрерывный рюкзак.md ├── 4.1.9 Покрыть отрезки точками.md ├── 4.2.5 Кодирование Хаффмана.md └── 4.2.6 Декодирование Хаффмана.md └── Адаптивный тренажёр Python ├── 5.19 Find a substring.md ├── 5.15 Simple continued fraction.md ├── 5.10 Length translator.md ├── 9.1 Durak.md ├── 7.1 Minesweeper field.md ├── 5.20 Game of life.md └── 9.2 Poker hand.md /Веб-технологии/web/ask/ask/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/qa/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/qa/tests.py: -------------------------------------------------------------------------------- 1 | from django.test import TestCase 2 | 3 | # Create your tests here. 4 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/templates/login.html: -------------------------------------------------------------------------------- 1 |
2 | {% csrf_token %} 3 | 4 | {{ form.as_p}} 5 | 6 | 7 |
-------------------------------------------------------------------------------- /Веб-технологии/web/ask/templates/ask.html: -------------------------------------------------------------------------------- 1 |
2 | {% csrf_token %} 3 | {{ form.as_p }} 4 |
5 | 6 |
7 |
-------------------------------------------------------------------------------- /Веб-технологии/web/ask/templates/signup.html: -------------------------------------------------------------------------------- 1 |
2 | {% csrf_token %} 3 | {{ form.as_p }} 4 |
5 | 6 |
7 |
-------------------------------------------------------------------------------- /Python - основы и применение/README.md: -------------------------------------------------------------------------------- 1 | Решения из текущего репозитория представлены исключительно в демонстрационных целях. Пожалуйста, используйте собственные решения чтобы получить сертификат Stepic. Plagiarism is bad, mkay? -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/2 Выборка отдельных столбцов.md: -------------------------------------------------------------------------------- 1 | # Выборка отдельных столбцов 2 | 3 | ## Задание 4 | 5 | Выбрать авторов, название книг и их цену из таблицы **book**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select author, title, price from book 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/2 Выборка отдельных столбцов.md: -------------------------------------------------------------------------------- 1 | # Выборка отдельных столбцов 2 | 3 | ## Задание 4 | 5 | Выбрать авторов, название книг и их цену из таблицы **book**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select author, title, price from book 11 | ``` 12 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/manage.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | import os 3 | import sys 4 | 5 | if __name__ == "__main__": 6 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ask.settings") 7 | 8 | from django.core.management import execute_from_command_line 9 | 10 | execute_from_command_line(sys.argv) 11 | -------------------------------------------------------------------------------- /Python Course tasks/week 10/primes.md: -------------------------------------------------------------------------------- 1 | Выведите на печать все простые числа до 1000 через пробел. 2 | 3 | Ограничьтесь одной строкой и 200 символами. 4 | 5 | **Решение** 6 | 7 | ```python 8 | print(' '.join([str(2)] + [str(n) for n in range(3, 1001, 2) if all([False if n % x == 0 else True for x in range(2, int(n ** 0.5 + 1))])])) 9 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/7 Выборка данных по условию.md: -------------------------------------------------------------------------------- 1 | # Выборка данных по условию 2 | 3 | ## Задание 4 | 5 | Вывести автора, название и цены тех книг, количество которых меньше 10. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select author, title, price from book where amount < 10; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/7 Выборка данных по условию.md: -------------------------------------------------------------------------------- 1 | # Выборка данных по условию 2 | 3 | ## Задание 4 | 5 | Вывести автора, название и цены тех книг, количество которых меньше 10. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select author, title, price from book where amount < 10; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/1 Выбор уникальных элементов столбца.md: -------------------------------------------------------------------------------- 1 | # Выбор уникальных элементов столбца 2 | 3 | ## Задание 4 | 5 | Отобрать различные (уникальные) элементы столбца amount таблицы book. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select distinct amount from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/qa/admin.py: -------------------------------------------------------------------------------- 1 | from django.contrib import admin 2 | 3 | from .models import Question, Answer 4 | 5 | 6 | class QuestionAdmin(admin.ModelAdmin): 7 | pass 8 | 9 | 10 | class AnswerAdmin(admin.ModelAdmin): 11 | pass 12 | 13 | admin.site.register(Question, QuestionAdmin) 14 | admin.site.register(Answer, AnswerAdmin) 15 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/1 Выбор уникальных элементов столбца.md: -------------------------------------------------------------------------------- 1 | # Выбор уникальных элементов столбца 2 | 3 | ## Задание 4 | 5 | Отобрать различные (уникальные) элементы столбца amount таблицы book. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select distinct amount from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/templates/question.html: -------------------------------------------------------------------------------- 1 |
{{ question.title }}
2 |
{{ question.text }}
3 | 4 |
5 | {% csrf_token %} 6 | {{ form.as_p }} 7 |
8 | 9 |
10 |
11 | 12 | {% for answer in answers %} 13 |
{{ answer.text }}
14 | {% endfor %} -------------------------------------------------------------------------------- /Python Course tasks/week 10/kvadrat.md: -------------------------------------------------------------------------------- 1 | 2 | Выведите одной строчкой кода на печать квадрат из цифр как в примере. 3 | 4 | Уложитесь в 100 символов. 5 | 6 | Вам поможет оператор '%' 7 | 8 | Не используйте символ переноса строки "\n". 9 | 10 | Используйте list comprehension. 11 | 12 | **Решение** 13 | 14 | ```python 15 | [print(''.join([str((y + x) % 10) for y in range(10)])) for x in range(10)] 16 | ``` 17 | 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/5 Запросы на обновление.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление 2 | 3 | ## Задание 4 | 5 | Уменьшить на 10% цену тех книг в таблице `book`, количество которых принадлежит интервалу от 5 до 10, включая границы. 6 | 7 | ## Решение 8 | 9 | ``` 10 | update 11 | book 12 | set 13 | price = price * 0.9 14 | where amount between 5 and 10 15 | ``` 16 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/5 Запросы на обновление.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление 2 | 3 | ## Задание 4 | 5 | Уменьшить на 10% цену тех книг в таблице `book`, количество которых принадлежит интервалу от 5 до 10, включая границы. 6 | 7 | ## Решение 8 | 9 | ``` 10 | update 11 | book 12 | set 13 | price = price * 0.9 14 | where amount between 5 and 10 15 | ``` 16 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/3 Выборка новых столбцов и присвоение им новых имен.md: -------------------------------------------------------------------------------- 1 | # Выборка новых столбцов и присвоение им новых имен 2 | 3 | ## Задание 4 | 5 | Выбрать названия книг и авторов из таблицы **book**, для поля **title** задать имя (псевдоним) **Название**, для поля `author` – **Автор**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title Название, author Автор from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.1 Связи между таблицами/2.md: -------------------------------------------------------------------------------- 1 | ## Задание 2 | 3 | Заполнить таблицу `author`. В нее включить следующих авторов: 4 | 5 | - Булгаков М.А. 6 | - Достоевский Ф.М. 7 | - Есенин С.А. 8 | - Пастернак Б.Л. 9 | 10 | ## Решение 11 | 12 | ``` 13 | insert into author (name_author) values 14 | ('Булгаков М.А.'), 15 | ('Достоевский Ф.М.'), 16 | ('Есенин С.А.'), 17 | ('Пастернак Б.Л.') 18 | ``` 19 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.1 Связи между таблицами/2.md: -------------------------------------------------------------------------------- 1 | ## Задание 2 | 3 | Заполнить таблицу `author`. В нее включить следующих авторов: 4 | 5 | - Булгаков М.А. 6 | - Достоевский Ф.М. 7 | - Есенин С.А. 8 | - Пастернак Б.Л. 9 | 10 | ## Решение 11 | 12 | ``` 13 | insert into author (name_author) values 14 | ('Булгаков М.А.'), 15 | ('Достоевский Ф.М.'), 16 | ('Есенин С.А.'), 17 | ('Пастернак Б.Л.') 18 | ``` 19 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/3 Выборка новых столбцов и присвоение им новых имен.md: -------------------------------------------------------------------------------- 1 | # Выборка новых столбцов и присвоение им новых имен 2 | 3 | ## Задание 4 | 5 | Выбрать названия книг и авторов из таблицы **book**, для поля **title** задать имя (псевдоним) **Название**, для поля `author` – **Автор**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title Название, author Автор from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.1 Связи между таблицами/1.md: -------------------------------------------------------------------------------- 1 | ## Задание 2 | 3 | Создать таблицу `author` следующей структуры:: 4 | 5 | | Поле | Тип, описание | 6 | |---|---| 7 | | author_id | `INT PRIMARY KEY AUTO_INCREMENT` | 8 | | name_author |`VARCHAR(50)` | 9 | 10 | ## Решение 11 | 12 | ``` 13 | create table author ( 14 | author_id INT PRIMARY KEY AUTO_INCREMENT, 15 | name_author varchar(50) 16 | ) 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.1 Связи между таблицами/1.md: -------------------------------------------------------------------------------- 1 | ## Задание 2 | 3 | Создать таблицу `author` следующей структуры:: 4 | 5 | | Поле | Тип, описание | 6 | |---|---| 7 | | author_id | `INT PRIMARY KEY AUTO_INCREMENT` | 8 | | name_author |`VARCHAR(50)` | 9 | 10 | ## Решение 11 | 12 | ``` 13 | create table author ( 14 | author_id INT PRIMARY KEY AUTO_INCREMENT, 15 | name_author varchar(50) 16 | ) 17 | ``` 18 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/ask/wsgi.py: -------------------------------------------------------------------------------- 1 | """ 2 | WSGI config for ask project. 3 | 4 | It exposes the WSGI callable as a module-level variable named ``application``. 5 | 6 | For more information on this file, see 7 | https://docs.djangoproject.com/en/1.6/howto/deployment/wsgi/ 8 | """ 9 | 10 | import os 11 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ask.settings") 12 | 13 | from django.core.wsgi import get_wsgi_application 14 | application = get_wsgi_application() 15 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/9 Выборка данных, операторы BETWEEN, IN.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, операторы BETWEEN, IN 2 | 3 | ## Задание 4 | 5 | Вывести название и авторов тех книг, цены которых принадлежат интервалу от 540.50 до 800 (включая границы), а количество или 2, или 3, или 5, или 7. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author from book where price between 540.5 and 800 and amount in (2, 3, 5, 7); 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/9 Выборка данных, операторы BETWEEN, IN.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, операторы BETWEEN, IN 2 | 3 | ## Задание 4 | 5 | Вывести название и авторов тех книг, цены которых принадлежат интервалу от 540.50 до 800 (включая границы), а количество или 2, или 3, или 5, или 7. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author from book where price between 540.5 and 800 and amount in (2, 3, 5, 7); 11 | ``` 12 | -------------------------------------------------------------------------------- /Python Course tasks/week 6/first.md: -------------------------------------------------------------------------------- 1 | Напишите функцию `first`, которая будет принимать вообще все что угодно и возвращать свой первый аргумент. Если все её аргументы именованные, то пускай она возвращает тот у которого самое маленькое имя. Если ей не передано ничего, то пускай она возвращает `None`. 2 | 3 | `first(0.0123) == 0.0123` 4 | 5 | ```python 6 | def first(*args, **kwargs): 7 | if args: 8 | return args[0] 9 | elif kwargs: 10 | return kwargs[min(kwargs.items)[0]] 11 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/1 Выборка всех данных.md: -------------------------------------------------------------------------------- 1 | # Выборка всех данных из таблицы 2 | 3 | ## Задание 4 | 5 | Вывести информацию о всех книгах, хранящихся на складе. 6 | 7 | Для этого: 8 | 9 | * Напишите SQL запрос в окне кода; 10 | * Отправьте на проверку (кнопка Отправить); 11 | * Если запрос работает неверно, исправьте его и снова отправьте на проверку. 12 | 13 | ## Решение 14 | 15 | ``` 16 | select * from book 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/1 Выборка всех данных.md: -------------------------------------------------------------------------------- 1 | # Выборка всех данных из таблицы 2 | 3 | ## Задание 4 | 5 | Вывести информацию о всех книгах, хранящихся на складе. 6 | 7 | Для этого: 8 | 9 | * Напишите SQL запрос в окне кода; 10 | * Отправьте на проверку (кнопка Отправить); 11 | * Если запрос работает неверно, исправьте его и снова отправьте на проверку. 12 | 13 | ## Решение 14 | 15 | ``` 16 | select * from book 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/2 Внешнее соединение LEFT и RIGHT OUTER JOIN.md: -------------------------------------------------------------------------------- 1 | # Внешнее соединение LEFT и RIGHT OUTER JOIN 2 | 3 | ## Задание 4 | 5 | Вывести все жанры, которые не представлены в книгах на складе. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | name_genre 12 | from 13 | genre g 14 | left join 15 | book b 16 | on b.genre_id = g.genre_id 17 | where 18 | b.book_id is null 19 | ``` 20 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/1 Создание пустой таблицы.md: -------------------------------------------------------------------------------- 1 | # Создание пустой таблицы 2 | 3 | ## Задание 4 | 5 | Создать таблицу поставка (supply), которая имеет ту же структуру, что и таблиц **book**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | create table supply ( 11 | supply_id int primary key auto_increment, 12 | title varchar(50), 13 | author varchar(30), 14 | price decimal(8,2), 15 | amount int 16 | ); 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/2 Внешнее соединение LEFT и RIGHT OUTER JOIN.md: -------------------------------------------------------------------------------- 1 | # Внешнее соединение LEFT и RIGHT OUTER JOIN 2 | 3 | ## Задание 4 | 5 | Вывести все жанры, которые не представлены в книгах на складе. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | name_genre 12 | from 13 | genre g 14 | left join 15 | book b 16 | on b.genre_id = g.genre_id 17 | where 18 | b.book_id is null 19 | ``` 20 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/1 Создание пустой таблицы.md: -------------------------------------------------------------------------------- 1 | # Создание пустой таблицы 2 | 3 | ## Задание 4 | 5 | Создать таблицу поставка (supply), которая имеет ту же структуру, что и таблиц **book**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | create table supply ( 11 | supply_id int primary key auto_increment, 12 | title varchar(50), 13 | author varchar(30), 14 | price decimal(8,2), 15 | amount int 16 | ); 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/8 Выборка данных, логические операции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, логические операции 2 | 3 | ## Задание 4 | 5 | Вывести название, автора, цену и количество всех книг, цена которых меньше 500 или больше 600, а стоимость всех экземпляров этих книг больше или равна 5000. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author, price, amount from book where (price < 500 or price > 600) and (price * amount >= 5000); 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/8 Выборка данных, логические операции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, логические операции 2 | 3 | ## Задание 4 | 5 | Вывести название, автора, цену и количество всех книг, цена которых меньше 500 или больше 600, а стоимость всех экземпляров этих книг больше или равна 5000. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author, price, amount from book where (price < 500 or price > 600) and (price * amount >= 5000); 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/10 Выборка данных с сортировкой.md: -------------------------------------------------------------------------------- 1 | # Выборка данных с сортировкой 2 | 3 | ## Задание 4 | 5 | Вывести автора и название книг, количество которых принадлежит интервалу от 2 до 14 (включая границы). Информацию отсортировать сначала по авторам (в обратном алфавитном порядке), а затем по названиям книг (по алфавиту). 6 | 7 | ## Решение 8 | 9 | ``` 10 | select author, title from book where amount between 2 and 14 order by author desc, title; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/10 Выборка данных с сортировкой.md: -------------------------------------------------------------------------------- 1 | # Выборка данных с сортировкой 2 | 3 | ## Задание 4 | 5 | Вывести автора и название книг, количество которых принадлежит интервалу от 2 до 14 (включая границы). Информацию отсортировать сначала по авторам (в обратном алфавитном порядке), а затем по названиям книг (по алфавиту). 6 | 7 | ## Решение 8 | 9 | ``` 10 | select author, title from book where amount between 2 and 14 order by author desc, title; 11 | ``` 12 | -------------------------------------------------------------------------------- /Python - основы и применение/1.1 Введение 10.md: -------------------------------------------------------------------------------- 1 | 2 | Реализуйте программу, которая принимает последовательность чисел и выводит их сумму. 3 | 4 | Вашей программе на вход подается последовательность строк. 5 | Первая строка содержит число n (1 ≤ n ≤ 100). 6 | В следующих n строках содержится по одному целому числу. 7 | 8 | Выведите одно число – сумму данных n чисел. 9 | 10 | # Решение 11 | 12 | ``` 13 | from functools import reduce 14 | n = int(input()) + 1 15 | print(int(reduce(lambda a, num: a + int(input()), range(n)))) 16 | ``` 17 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/1 Соединение INNER JOIN.md: -------------------------------------------------------------------------------- 1 | # Соединение INNER JOIN 2 | 3 | ## Задание 4 | 5 | Вывести название, жанр и цену тех книг, количество которых больше 8, в отсортированном по убыванию цены виде. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | b.title, g.name_genre, b.price 12 | from 13 | book b 14 | join 15 | genre g 16 | on g.genre_id = b.genre_id 17 | where 18 | b.amount > 8 19 | order by 20 | b.price desc 21 | ``` 22 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/3 Добавление записей из другой таблицы.md: -------------------------------------------------------------------------------- 1 | # Добавление записей из другой таблицы 2 | 3 | ## Задание 4 | 5 | Добавить из таблицы `supply` в таблицу `book`, все книги, кроме книг, написанных Булгаковым М.А. и Достоевским Ф.М. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into book(title, author, price, amount) 11 | select 12 | title, author, price, amount 13 | from 14 | supply 15 | where author not in ('Булгаков М.А.', 'Достоевский Ф.М.') 16 | ``` 17 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/1 Соединение INNER JOIN.md: -------------------------------------------------------------------------------- 1 | # Соединение INNER JOIN 2 | 3 | ## Задание 4 | 5 | Вывести название, жанр и цену тех книг, количество которых больше 8, в отсортированном по убыванию цены виде. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | b.title, g.name_genre, b.price 12 | from 13 | book b 14 | join 15 | genre g 16 | on g.genre_id = b.genre_id 17 | where 18 | b.amount > 8 19 | order by 20 | b.price desc 21 | ``` 22 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/3 Добавление записей из другой таблицы.md: -------------------------------------------------------------------------------- 1 | # Добавление записей из другой таблицы 2 | 3 | ## Задание 4 | 5 | Добавить из таблицы `supply` в таблицу `book`, все книги, кроме книг, написанных Булгаковым М.А. и Достоевским Ф.М. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into book(title, author, price, amount) 11 | select 12 | title, author, price, amount 13 | from 14 | supply 15 | where author not in ('Булгаков М.А.', 'Достоевский Ф.М.') 16 | ``` 17 | -------------------------------------------------------------------------------- /Алгоритмы методы/2.2 Числа Фибоначчи.md: -------------------------------------------------------------------------------- 1 | Дано целое число 1 ≤ n ≤ 40, необходимо вычислить n-е число Фибоначчи (напомним, что F0=0, F1=1, и Fn = Fn−1 + Fn−2 при n ≥ 2) 2 | 3 | **Sample Input**: 4 | 5 | 3 6 | 7 | **Sample Output**: 8 | 9 | 2 10 | 11 | # Решение / Solution 12 | 13 | ``` 14 | def fib(n): 15 | assert n >= 0 16 | f0, f1 = 0, 1 17 | for i in range(n - 1): 18 | f0, f1 = f1, f0 + f1 19 | return f1 20 | 21 | 22 | def main(): 23 | n = int(input()) 24 | print(fib(n)) 25 | 26 | 27 | if __name__ == "__main__": 28 | main() 29 | ``` -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 10.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | Выведите строки, содержащие обратный слеш "**\\**". 4 | 5 | --- 6 | 7 | **Sample Input**: 8 | 9 | ``` 10 | \w denotes word character 11 | No slashes here 12 | ``` 13 | 14 | **Sample Output**: 15 | 16 | `\w denotes word character` 17 | 18 | # Solution / Решение 19 | 20 | ``` 21 | import re 22 | import sys 23 | pattern = r'.*\\.*' 24 | for line in sys.stdin: 25 | line = line.rstrip() 26 | if re.search(pattern, line): 27 | print(line) 28 | ``` 29 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/5 Вычисления по таблице целиком.md: -------------------------------------------------------------------------------- 1 | # Вычисления по таблице целиком 2 | 3 | ## Задание 4 | 5 | Вывести цену самой дешевой книги, цену самой дорогой и среднюю цену книг на складе. Названия столбцов **Минимальная_цена**, **Максимальная_цена**, **Средняя_цена** соответственно. Среднюю цену округлить до двух знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | min(price) Минимальная_цена, max(price) Максимальная_цена, round(avg(price), 2) Средняя_цена 12 | from 13 | book 14 | ``` 15 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/4 Запрос на обновление, вложенные запросы.md: -------------------------------------------------------------------------------- 1 | # Запрос на обновление, вложенные запросы 2 | 3 | ## Задание 4 | 5 | Занести для книги «Стихотворения и поэмы» Лермонтова жанр «Поэзия», а для книги «Остров сокровищ» Стивенсона - «Приключения». (Использовать два запроса). 6 | 7 | ## Решение 8 | 9 | ``` 10 | update 11 | book 12 | set 13 | genre_id = 2 14 | where 15 | book_id = 10; 16 | update 17 | book 18 | set 19 | genre_id = 3 20 | where 21 | book_id = 11; 22 | ``` 23 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 15.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | В каждой строке замените все вхождения нескольких одинаковых букв на одну букву. 4 | 5 | Буквой считается символ из группы **\w**. 6 | 7 | --- 8 | 9 | **Sample Input**: 10 | 11 | ``` 12 | attraction 13 | buzzzz 14 | 15 | **Sample Output**: 16 | 17 | atraction 18 | buz 19 | ``` 20 | 21 | # Solution / Решение 22 | 23 | ``` 24 | import re 25 | import sys 26 | 27 | pattern = r'(\w)\1+' 28 | 29 | for line in sys.stdin: 30 | print(re.sub(pattern, r'\1', line.rstrip())) 31 | ``` 32 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/5 Вычисления по таблице целиком.md: -------------------------------------------------------------------------------- 1 | # Вычисления по таблице целиком 2 | 3 | ## Задание 4 | 5 | Вывести цену самой дешевой книги, цену самой дорогой и среднюю цену книг на складе. Названия столбцов **Минимальная_цена**, **Максимальная_цена**, **Средняя_цена** соответственно. Среднюю цену округлить до двух знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | min(price) Минимальная_цена, max(price) Максимальная_цена, round(avg(price), 2) Средняя_цена 12 | from 13 | book 14 | ``` 15 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/2 Выборка данных, групповые функции SUM и COUNT.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, групповые функции SUM и COUNT 2 | 3 | ## Задание 4 | 5 | Посчитать, количество различных книг и количество экземпляров книг каждого автора, хранящихся на складе. Столбцы назвать `Автор`, `Различных_книг` и `Количество_экземпляров` соответственно. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author Автор, count(title) Различных_книг, sum(amount) Количество_экземпляров 12 | from 13 | book 14 | group by 15 | author; 16 | ``` 17 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/5 Каскадное удаление записей связанных таблиц.md: -------------------------------------------------------------------------------- 1 | # Каскадное удаление записей связанных таблиц 2 | 3 | ## Задание 4 | 5 | Удалить всех авторов и все их книги, общее количество книг которых меньше 20. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from author 11 | where 12 | author_id in ( 13 | select 14 | author_id 15 | from 16 | book 17 | group by 18 | author_id 19 | having 20 | sum(amount) < 20 21 | ) 22 | ``` 23 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/4 Запрос на обновление, вложенные запросы.md: -------------------------------------------------------------------------------- 1 | # Запрос на обновление, вложенные запросы 2 | 3 | ## Задание 4 | 5 | Занести для книги «Стихотворения и поэмы» Лермонтова жанр «Поэзия», а для книги «Остров сокровищ» Стивенсона - «Приключения». (Использовать два запроса). 6 | 7 | ## Решение 8 | 9 | ``` 10 | update 11 | book 12 | set 13 | genre_id = 2 14 | where 15 | book_id = 10; 16 | update 17 | book 18 | set 19 | genre_id = 3 20 | where 21 | book_id = 11; 22 | ``` 23 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/2 Выборка данных, групповые функции SUM и COUNT.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, групповые функции SUM и COUNT 2 | 3 | ## Задание 4 | 5 | Посчитать, количество различных книг и количество экземпляров книг каждого автора, хранящихся на складе. Столбцы назвать `Автор`, `Различных_книг` и `Количество_экземпляров` соответственно. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author Автор, count(title) Различных_книг, sum(amount) Количество_экземпляров 12 | from 13 | book 14 | group by 15 | author; 16 | ``` 17 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/5 Каскадное удаление записей связанных таблиц.md: -------------------------------------------------------------------------------- 1 | # Каскадное удаление записей связанных таблиц 2 | 3 | ## Задание 4 | 5 | Удалить всех авторов и все их книги, общее количество книг которых меньше 20. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from author 11 | where 12 | author_id in ( 13 | select 14 | author_id 15 | from 16 | book 17 | group by 18 | author_id 19 | having 20 | sum(amount) < 20 21 | ) 22 | ``` 23 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/4 Выборка данных с созданием вычисляемого столбца.md: -------------------------------------------------------------------------------- 1 | # Выборка данных с созданием вычисляемого столбца 2 | 3 | ## Задание 4 | 5 | Для упаковки каждой книги требуется один лист бумаги, цена которого 1 рубль 65 копеек. Посчитать стоимость упаковки для каждой книги (сколько денег потребуется, чтобы упаковать все экземпляры книги). В запросе вывести название книги, ее количество и стоимость упаковки, последний столбец назвать **pack**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, amount, amount * 1.65 as pack from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/2 Добавление записей в таблицу.md: -------------------------------------------------------------------------------- 1 | # Добавление записей в таблицу 2 | 3 | ## Задание 4 | 5 | Занесите в таблицу `supply` четыре записи, чтобы получилась следующая таблица: 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into supply values (1, 'Лирика', 'Пастернак Б.Л.', 518.99, 2); 11 | insert into supply values (2, 'Черный человек', 'Есенин С.А.', 570.20, 6); 12 | insert into supply values (3, 'Белая гвардия', 'Булгаков М.А.', 540.50, 7); 13 | insert into supply values (4, 'Идиот', 'Достоевский Ф.М.', 360.80, 3); 14 | ``` 15 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/4 Выборка данных с созданием вычисляемого столбца.md: -------------------------------------------------------------------------------- 1 | # Выборка данных с созданием вычисляемого столбца 2 | 3 | ## Задание 4 | 5 | Для упаковки каждой книги требуется один лист бумаги, цена которого 1 рубль 65 копеек. Посчитать стоимость упаковки для каждой книги (сколько денег потребуется, чтобы упаковать все экземпляры книги). В запросе вывести название книги, ее количество и стоимость упаковки, последний столбец назвать **pack**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, amount, amount * 1.65 as pack from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/2 Добавление записей в таблицу.md: -------------------------------------------------------------------------------- 1 | # Добавление записей в таблицу 2 | 3 | ## Задание 4 | 5 | Занесите в таблицу `supply` четыре записи, чтобы получилась следующая таблица: 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into supply values (1, 'Лирика', 'Пастернак Б.Л.', 518.99, 2); 11 | insert into supply values (2, 'Черный человек', 'Есенин С.А.', 570.20, 6); 12 | insert into supply values (3, 'Белая гвардия', 'Булгаков М.А.', 540.50, 7); 13 | insert into supply values (4, 'Идиот', 'Достоевский Ф.М.', 360.80, 3); 14 | ``` 15 | -------------------------------------------------------------------------------- /Python - основы и применение/1.3 Функции и стек вызовов 9.md: -------------------------------------------------------------------------------- 1 | Напишите реализацию функции **closest_mod_5**, принимающую в качестве единственного аргумента целое число **x** и возвращающую самое маленькое целое число **y**, такое что: 2 | 3 | - **y** больше или равно **x** 4 | - **y** делится нацело на **5** 5 | 6 | Формат того, что ожидается от вас в качестве ответа: 7 | 8 | ``` 9 | def closest_mod_5(x): 10 | if x % 5 == 0: 11 | return x 12 | return "I don't know :(" 13 | ``` 14 | 15 | # Решение 16 | 17 | ``` 18 | def closest_mod_5(x): 19 | return x if x % 5 == 0 else closest_mod_5(x + 1) 20 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/3 Выборка данных, групповые функции MIN, MAX и AVG.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, групповые функции MIN, MAX и AVG 2 | 3 | ## Задание 4 | 5 | Вывести фамилию автора, минимальную, максимальную и среднюю цену книг каждого автора . Вычисляемые столбцы назвать **Минимальная_цена**, **Максимальная_цена** и **Средняя_цена** соответственно. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, min(price) Минимальная_цена, max(price) Максимальная_цена, avg(price) Средняя_цена 12 | from 13 | book 14 | group by 15 | author 16 | ``` 17 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/3 Выборка данных, групповые функции MIN, MAX и AVG.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, групповые функции MIN, MAX и AVG 2 | 3 | ## Задание 4 | 5 | Вывести фамилию автора, минимальную, максимальную и среднюю цену книг каждого автора . Вычисляемые столбцы назвать **Минимальная_цена**, **Максимальная_цена** и **Средняя_цена** соответственно. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, min(price) Минимальная_цена, max(price) Максимальная_цена, avg(price) Средняя_цена 12 | from 13 | book 14 | group by 15 | author 16 | ``` 17 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/5 Выборка данных, вычисляемые столбцы, математические функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, вычисляемые столбцы, математические функции 2 | 3 | ## Задание 4 | 5 | В конце года цену всех книг на складе пересчитывают – снижают ее на 30%. Написать SQL запрос, который из таблицы book выбирает названия, авторов, количества и вычисляет новые цены книг. Столбец с новой ценой назвать `new_price`, цену округлить до 2-х знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author, amount, round(price - price * 0.3, 2) new_price from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.4 Вложенные запросы/4 Вложенный запрос, операторы ANY и ALL.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос, операторы ANY и ALL 2 | 3 | ## Задание 4 | 5 | Вывести информацию о книгах(автор, название, цена), цена которых меньше самой большой из минимальных цен, вычисленных для каждого автора. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, price 12 | from 13 | book b 14 | where 15 | price < all( 16 | select 17 | max(price) 18 | from 19 | book b1 20 | where 21 | b1.author = b.author 22 | ) 23 | ``` 24 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/5 Выборка данных, вычисляемые столбцы, математические функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, вычисляемые столбцы, математические функции 2 | 3 | ## Задание 4 | 5 | В конце года цену всех книг на складе пересчитывают – снижают ее на 30%. Написать SQL запрос, который из таблицы book выбирает названия, авторов, количества и вычисляет новые цены книг. Столбец с новой ценой назвать `new_price`, цену округлить до 2-х знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author, amount, round(price - price * 0.3, 2) new_price from book; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.4 Вложенные запросы/4 Вложенный запрос, операторы ANY и ALL.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос, операторы ANY и ALL 2 | 3 | ## Задание 4 | 5 | Вывести информацию о книгах(автор, название, цена), цена которых меньше самой большой из минимальных цен, вычисленных для каждого автора. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, price 12 | from 13 | book b 14 | where 15 | price < all( 16 | select 17 | max(price) 18 | from 19 | book b1 20 | where 21 | b1.author = b.author 22 | ) 23 | ``` 24 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/6 Запросы на обновление нескольких столбцов.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление нескольких столбцов 2 | 3 | ## Задание 4 | 5 | В таблице **book** необходимо скорректировать значение для покупателя в столбце **buy** таким образом, чтобы оно не превышало количество экземпляров книг, указанных в столбце **amount**. А цену тех книг, которые покупатель не заказывал, снизить на 10%. 6 | 7 | ## Решение 8 | 9 | ``` 10 | update 11 | book 12 | set 13 | buy = if(buy > amount, amount, buy), 14 | price = if(buy = 0, price * 0.9, price); 15 | ``` 16 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/6 Запросы на обновление нескольких столбцов.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление нескольких столбцов 2 | 3 | ## Задание 4 | 5 | В таблице **book** необходимо скорректировать значение для покупателя в столбце **buy** таким образом, чтобы оно не превышало количество экземпляров книг, указанных в столбце **amount**. А цену тех книг, которые покупатель не заказывал, снизить на 10%. 6 | 7 | ## Решение 8 | 9 | ``` 10 | update 11 | book 12 | set 13 | buy = if(buy > amount, amount, buy), 14 | price = if(buy = 0, price * 0.9, price); 15 | ``` 16 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 9.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | Выведите строки, содержащие две буквы "**z**", между которыми ровно три символа. 4 | 5 | --- 6 | 7 | **Sample Input**: 8 | 9 | ``` 10 | zabcz 11 | zzz 12 | zzxzz 13 | zz 14 | zxz 15 | zzxzxxz 16 | ``` 17 | 18 | **Sample Output**: 19 | 20 | ``` 21 | zabcz 22 | zzxzz 23 | ``` 24 | 25 | --- 26 | 27 | # Solution / Решение 28 | 29 | ``` 30 | import re 31 | import sys 32 | pattern = r'(z.{3}z)' 33 | for line in sys.stdin: 34 | line = line.rstrip() 35 | if re.search(pattern, line): 36 | print(line) 37 | ``` 38 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.4 Вложенные запросы/3 Вложенный запрос, оператор IN.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос, оператор IN 2 | 3 | ## Задание 4 | 5 | Вывести информацию (автора, книгу и количество) о тех книгах, количество экземпляров которых в таблице **book** не дублируется. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, amount 12 | from 13 | book 14 | where 15 | amount not in ( 16 | select 17 | amount 18 | from 19 | book 20 | group by 21 | amount 22 | having 23 | count(amount) > 1 24 | ) 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.4 Вложенные запросы/3 Вложенный запрос, оператор IN.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос, оператор IN 2 | 3 | ## Задание 4 | 5 | Вывести информацию (автора, книгу и количество) о тех книгах, количество экземпляров которых в таблице **book** не дублируется. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, amount 12 | from 13 | book 14 | where 15 | amount not in ( 16 | select 17 | amount 18 | from 19 | book 20 | group by 21 | amount 22 | having 23 | count(amount) > 1 24 | ) 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/6 Выборка данных по условию, групповые функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных по условию, групповые функции 2 | 3 | ## Задание 4 | 5 | Вычислить среднюю цену и суммарную стоимость тех книг, количество экземпляров которых принадлежит интервалу от 5 до 14, включительно. Столбцы назвать **Средняя_цена** и **Стоимость**, значения округлить до 2-х знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | round(avg(price), 2) Средняя_цена, 12 | sum(price * amount) Стоимость 13 | from 14 | book 15 | where 16 | amount between 5 and 14 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/6 Выборка данных по условию, групповые функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных по условию, групповые функции 2 | 3 | ## Задание 4 | 5 | Вычислить среднюю цену и суммарную стоимость тех книг, количество экземпляров которых принадлежит интервалу от 5 до 14, включительно. Столбцы назвать **Средняя_цена** и **Стоимость**, значения округлить до 2-х знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | round(avg(price), 2) Средняя_цена, 12 | sum(price * amount) Стоимость 13 | from 14 | book 15 | where 16 | amount between 5 and 14 17 | ``` 18 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/templates/index.html: -------------------------------------------------------------------------------- 1 | {% for question in questions %} 2 |
{{ question }}
3 | {% endfor %} 4 | 5 | {% if paginator.has_previous %} 6 | ← 7 | {% endif %} 8 | 9 | {% for num in paginator.page_range %} 10 | {% if num == questions.number %} 11 | {{ num }} 12 | {% else %} 13 | {{ num }} 14 | {% endif %} 15 | {% endfor %} 16 | 17 | {% if paginator.has_next %} 18 | → 19 | {% endif %} -------------------------------------------------------------------------------- /Веб-технологии/web/ask/templates/popular.html: -------------------------------------------------------------------------------- 1 | {% for question in questions %} 2 |
{{ question }}
3 | {% endfor %} 4 | 5 | {% if paginator.has_previous %} 6 | ← 7 | {% endif %} 8 | 9 | {% for num in paginator.page_range %} 10 | {% if num == questions.number %} 11 | {{ num }} 12 | {% else %} 13 | {{ num }} 14 | {% endif %} 15 | {% endfor %} 16 | 17 | {% if paginator.has_next %} 18 | → 19 | {% endif %} -------------------------------------------------------------------------------- /Python Course tasks/week 7/friends.md: -------------------------------------------------------------------------------- 1 | Напишите функцию `friends`, которая из списка пар друзей сделает словарь, в котором для каждого человека будут перечислены все его друзья. 2 | 3 | **Пример** 4 | 5 | ```python 6 | >>> print(friends([("Ivan", "Maria"), ("Ella", "Ivan"), ("Ivan", "Oleg")]) 7 | 8 | {"Ivan":["Maria", "Ella", "Oleg"], "Ella":["Ivan"], "Maria": ["Ivan"], "Oleg": ["Ivan"]} 9 | ``` 10 | 11 | **Решение** 12 | 13 | ```python 14 | def friends(pairs): 15 | result = dict() 16 | [result.update({first: result.get(first, []) + [second], second: result.get(second, []) + [first]}) for first, second in pairs] 17 | return result 18 | ``` 19 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.4 Вложенные запросы/2 Использование вложенного запроса в выражении.md: -------------------------------------------------------------------------------- 1 | # Использование вложенного запроса в выражении 2 | 3 | ## Задание 4 | 5 | Вывести информацию (автора, название и цену) о тех книгах, цены которых превышают минимальную цену книги на складе не более чем на 150 рублей в отсортированном по возрастанию цены виде. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, price 12 | from 13 | book 14 | where 15 | price <= ( 16 | select 17 | min(price) 18 | from 19 | book 20 | ) + 150 21 | order by 22 | price 23 | ``` 24 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.4 Вложенные запросы/2 Использование вложенного запроса в выражении.md: -------------------------------------------------------------------------------- 1 | # Использование вложенного запроса в выражении 2 | 3 | ## Задание 4 | 5 | Вывести информацию (автора, название и цену) о тех книгах, цены которых превышают минимальную цену книги на складе не более чем на 150 рублей в отсортированном по возрастанию цены виде. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, price 12 | from 13 | book 14 | where 15 | price <= ( 16 | select 17 | min(price) 18 | from 19 | book 20 | ) + 150 21 | order by 22 | price 23 | ``` 24 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 12.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | В каждой строке замените все вхождения подстроки "**human**" на подстроку "**computer**" и выведите полученные строки. 4 | 5 | --- 6 | 7 | **Sample Input**: 8 | 9 | ``` 10 | I need to understand the human mind 11 | humanity 12 | ``` 13 | 14 | **Sample Output**: 15 | 16 | ``` 17 | I need to understand the computer mind 18 | computerity 19 | ``` 20 | 21 | # Solution / Решение 22 | 23 | ``` 24 | import re 25 | import sys 26 | 27 | pattern = r'human' 28 | 29 | for line in sys.stdin: 30 | print(re.sub(pattern, 'computer', line.rstrip())) 31 | ``` 32 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.1 Отношение (таблица)/1 Создание таблицы.md: -------------------------------------------------------------------------------- 1 | # Создание таблицы 2 | 3 | ## Задание 4 | 5 | Сформулируйте SQL запрос для создания таблицы **book**. Структура таблицы **book**: 6 | 7 | | Поле | Тип, описание | 8 | |---|---| 9 | | book_id | INT PRIMARY KEY AUTO_INCREMENT | 10 | | title | VARCHAR(50) | 11 | | author | VARCHAR(30) | 12 | | price | DECIMAL(8, 2) | 13 | | amount | INT | 14 | 15 | ## Решение 16 | 17 | ``` 18 | CREATE TABLE book( 19 | book_id INT PRIMARY KEY AUTO_INCREMENT, 20 | title VARCHAR(50), 21 | author VARCHAR(30), 22 | price DECIMAL(8, 2), 23 | amount INT 24 | ); 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.1 Отношение (таблица)/1 Создание таблицы.md: -------------------------------------------------------------------------------- 1 | # Создание таблицы 2 | 3 | ## Задание 4 | 5 | Сформулируйте SQL запрос для создания таблицы **book**. Структура таблицы **book**: 6 | 7 | | Поле | Тип, описание | 8 | |---|---| 9 | | book_id | INT PRIMARY KEY AUTO_INCREMENT | 10 | | title | VARCHAR(50) | 11 | | author | VARCHAR(30) | 12 | | price | DECIMAL(8, 2) | 13 | | amount | INT | 14 | 15 | ## Решение 16 | 17 | ``` 18 | CREATE TABLE book( 19 | book_id INT PRIMARY KEY AUTO_INCREMENT, 20 | title VARCHAR(50), 21 | author VARCHAR(30), 22 | price DECIMAL(8, 2), 23 | amount INT 24 | ); 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/4 Запросы на выборку из нескольких таблиц.md: -------------------------------------------------------------------------------- 1 | # Запросы на выборку из нескольких таблиц 2 | 3 | ## Задание 4 | 5 | Вывести информацию о книгах (жанр, книга, автор), относящихся к жанру, включающему слово «роман» в отсортированном по названиям книг виде. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | name_genre, title, name_author 12 | from 13 | genre g 14 | join 15 | book b 16 | on b.genre_id = g.genre_id 17 | join 18 | author a 19 | on a.author_id = b.author_id 20 | where 21 | name_genre like '%роман%' 22 | order by 23 | title 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/6 Удаление записей главной таблицы с сохранением записей в зависимой.md: -------------------------------------------------------------------------------- 1 | # Удаление записей главной таблицы с сохранением записей в зависимой 2 | 3 | ## Задание 4 | 5 | Удалить все жанры, к которым относится меньше 4-х книг. В таблице book для этих жанров установить значение `Null`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from genre 11 | where 12 | genre_id in ( 13 | select 14 | genre_id 15 | from 16 | book 17 | group by 18 | genre_id 19 | having 20 | count(*) < 4 21 | ) 22 | ``` 23 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/4 Запросы на выборку из нескольких таблиц.md: -------------------------------------------------------------------------------- 1 | # Запросы на выборку из нескольких таблиц 2 | 3 | ## Задание 4 | 5 | Вывести информацию о книгах (жанр, книга, автор), относящихся к жанру, включающему слово «роман» в отсортированном по названиям книг виде. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | name_genre, title, name_author 12 | from 13 | genre g 14 | join 15 | book b 16 | on b.genre_id = g.genre_id 17 | join 18 | author a 19 | on a.author_id = b.author_id 20 | where 21 | name_genre like '%роман%' 22 | order by 23 | title 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/6 Удаление записей главной таблицы с сохранением записей в зависимой.md: -------------------------------------------------------------------------------- 1 | # Удаление записей главной таблицы с сохранением записей в зависимой 2 | 3 | ## Задание 4 | 5 | Удалить все жанры, к которым относится меньше 4-х книг. В таблице book для этих жанров установить значение `Null`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from genre 11 | where 12 | genre_id in ( 13 | select 14 | genre_id 15 | from 16 | book 17 | group by 18 | genre_id 19 | having 20 | count(*) < 4 21 | ) 22 | ``` 23 | -------------------------------------------------------------------------------- /Python - основы и применение/2.4 Работа с файловой системой и файлами 4.md: -------------------------------------------------------------------------------- 1 | Вам дается текстовый файл, содержащий некоторое количество непустых строк. 2 | 3 | На основе него сгенерируйте новый текстовый файл, содержащий те же строки в обратном порядке. 4 | 5 | **Пример входного файла**: 6 | 7 | ``` 8 | ab 9 | c 10 | dde 11 | ff 12 | ``` 13 | 14 | **Пример выходного файла**: 15 | 16 | ``` 17 | ff 18 | dde 19 | c 20 | ab 21 | ``` 22 | 23 | # Решение 24 | 25 | ``` 26 | with open('dataset_24465_4.txt') as f1: 27 | f1_lines = f1.read().splitlines() 28 | 29 | with open('result.txt', 'w') as f2: 30 | for line in f1_lines[::-1]: 31 | f2.write('%s\n' % line) 32 | ``` 33 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 11.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | Выведите строки, содержащие слово, состоящее из двух одинаковых частей (тандемный повтор). 4 | 5 | --- 6 | 7 | **Sample Input**: 8 | 9 | ``` 10 | blabla is a tandem repetition 11 | 123123 is good too 12 | go go 13 | aaa 14 | ``` 15 | 16 | **Sample Output**: 17 | 18 | ``` 19 | blabla is a tandem repetition 20 | 123123 is good too 21 | ``` 22 | 23 | # Solution / Решение 24 | 25 | ``` 26 | import re 27 | import sys 28 | pattern = r'\b(.+)\1\b' 29 | for line in sys.stdin: 30 | line = line.rstrip() 31 | if re.search(pattern, line): 32 | print(line) 33 | ``` 34 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 14.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | В каждой строке поменяйте местами две первых буквы в каждом слове, состоящем хотя бы из двух букв. 4 | 5 | Буквой считается символ из группы **\w**. 6 | 7 | --- 8 | 9 | **Sample Input**: 10 | 11 | ``` 12 | this is a text 13 | "this' !is. ?n1ce, 14 | ``` 15 | 16 | **Sample Output**: 17 | 18 | ``` 19 | htis si a etxt 20 | "htis' !si. ?1nce, 21 | ``` 22 | 23 | # Solution / Решение 24 | 25 | ``` 26 | import re 27 | import sys 28 | 29 | pattern = r'\b(\w)(\w)(\w*)\b' 30 | 31 | for line in sys.stdin: 32 | print(re.sub(pattern, r'\2\1\3', line.rstrip())) 33 | ``` 34 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.4 Вложенные запросы/1 Вложенный запрос, возвращающий одно значение.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос, возвращающий одно значение 2 | 3 | ## Задание 4 | 5 | Вывести информацию (автора, название и цену) о книгах, цены которых меньше или равны средней цене книг на складе. Информацию вывести в отсортированном по убыванию цены виде. Среднее вычислить как среднее по цене книги. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, price 12 | from 13 | book 14 | where 15 | price <= ( 16 | select 17 | avg(price) 18 | from 19 | book 20 | ) 21 | order by 22 | price desc 23 | ``` 24 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.4 Вложенные запросы/1 Вложенный запрос, возвращающий одно значение.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос, возвращающий одно значение 2 | 3 | ## Задание 4 | 5 | Вывести информацию (автора, название и цену) о книгах, цены которых меньше или равны средней цене книг на складе. Информацию вывести в отсортированном по убыванию цены виде. Среднее вычислить как среднее по цене книги. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, title, price 12 | from 13 | book 14 | where 15 | price <= ( 16 | select 17 | avg(price) 18 | from 19 | book 20 | ) 21 | order by 22 | price desc 23 | ``` 24 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/8 Запросы на удаление.md: -------------------------------------------------------------------------------- 1 | # Запросы на удаление 2 | 3 | ## Задание 4 | 5 | Удалить из таблицы `supply` книги тех авторов, общее количество экземпляров книг которых в таблице `book` превышает 10. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from supply 11 | where author in ( 12 | select 13 | author 14 | from 15 | ( 16 | select 17 | author, 18 | sum(amount) 19 | from 20 | book 21 | group by 22 | author 23 | having 24 | sum(amount) > 10 25 | ) a2 26 | ) 27 | ``` 28 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/8 Запросы на удаление.md: -------------------------------------------------------------------------------- 1 | # Запросы на удаление 2 | 3 | ## Задание 4 | 5 | Удалить из таблицы `supply` книги тех авторов, общее количество экземпляров книг которых в таблице `book` превышает 10. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from supply 11 | where author in ( 12 | select 13 | author 14 | from 15 | ( 16 | select 17 | author, 18 | sum(amount) 19 | from 20 | book 21 | group by 22 | author 23 | having 24 | sum(amount) > 10 25 | ) a2 26 | ) 27 | ``` 28 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/3 Запрос на добавление, связанные таблицы.md: -------------------------------------------------------------------------------- 1 | # Запрос на добавление, связанные таблицы 2 | 3 | ## Задание 4 | 5 | Добавить новые книги из таблицы `supply` в таблицу `book` на основе сформированного выше запроса. Затем вывести для просмотра таблицу `book`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into 11 | book (title, author_id, genre_id, price, amount) 12 | select 13 | title, author_id, null genre_id, price, amount 14 | from 15 | author 16 | join 17 | supply on author.name_author = supply.author 18 | where 19 | amount != 0; 20 | select 21 | * 22 | from 23 | book 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/4 Добавление записей, вложенные запросы.md: -------------------------------------------------------------------------------- 1 | # Добавление записей, вложенные запросы 2 | 3 | ## Задание 4 | 5 | Занести из таблицы `supply` в таблицу `book` только те книги, авторов которых нет в `book`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into book (title, author, price, amount) 11 | select 12 | title, author, price, amount 13 | from 14 | supply 15 | where 16 | title not in ( 17 | select 18 | title 19 | from 20 | book 21 | ) and 22 | author not in ( 23 | select 24 | author 25 | from 26 | book 27 | ); 28 | ``` 29 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/3 Запрос на добавление, связанные таблицы.md: -------------------------------------------------------------------------------- 1 | # Запрос на добавление, связанные таблицы 2 | 3 | ## Задание 4 | 5 | Добавить новые книги из таблицы `supply` в таблицу `book` на основе сформированного выше запроса. Затем вывести для просмотра таблицу `book`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into 11 | book (title, author_id, genre_id, price, amount) 12 | select 13 | title, author_id, null genre_id, price, amount 14 | from 15 | author 16 | join 17 | supply on author.name_author = supply.author 18 | where 19 | amount != 0; 20 | select 21 | * 22 | from 23 | book 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/4 Добавление записей, вложенные запросы.md: -------------------------------------------------------------------------------- 1 | # Добавление записей, вложенные запросы 2 | 3 | ## Задание 4 | 5 | Занести из таблицы `supply` в таблицу `book` только те книги, авторов которых нет в `book`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into book (title, author, price, amount) 11 | select 12 | title, author, price, amount 13 | from 14 | supply 15 | where 16 | title not in ( 17 | select 18 | title 19 | from 20 | book 21 | ) and 22 | author not in ( 23 | select 24 | author 25 | from 26 | book 27 | ); 28 | ``` 29 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.1 Отношение (таблица)/2 Вставка записи в таблицу.md: -------------------------------------------------------------------------------- 1 | # Вставка записи в таблицу 2 | 3 | ## Задание 4 | 5 | Занесите новую строку в таблицу **book** (текстовые значения (тип `VARCHAR`) заключать либо в двойные, либо в одинарные кавычки): 6 | 7 | | **book_id** | **title** | **author** | **price** | **amount** | 8 | |---|---|---|---|---| 9 | | INT PRIMARY KEY AUTO_INCREMENT | VARCHAR(50) | VARCHAR(30) | DECIMAL(8,2) | INT | 10 | | 1 | Мастер и Маргарита | Булгаков М.А. | 670.99 | 3 | 11 | 12 | ## Решение 13 | 14 | ``` 15 | INSERT INTO book 16 | (book_id, title, author, price, amount) 17 | VALUES(1, 'Мастер и Маргарита', 'Булгаков М.А.', 670.99, 3); 18 | ``` 19 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.1 Отношение (таблица)/2 Вставка записи в таблицу.md: -------------------------------------------------------------------------------- 1 | # Вставка записи в таблицу 2 | 3 | ## Задание 4 | 5 | Занесите новую строку в таблицу **book** (текстовые значения (тип `VARCHAR`) заключать либо в двойные, либо в одинарные кавычки): 6 | 7 | | **book_id** | **title** | **author** | **price** | **amount** | 8 | |---|---|---|---|---| 9 | | INT PRIMARY KEY AUTO_INCREMENT | VARCHAR(50) | VARCHAR(30) | DECIMAL(8,2) | INT | 10 | | 1 | Мастер и Маргарита | Булгаков М.А. | 670.99 | 3 | 11 | 12 | ## Решение 13 | 14 | ``` 15 | INSERT INTO book 16 | (book_id, title, author, price, amount) 17 | VALUES(1, 'Мастер и Маргарита', 'Булгаков М.А.', 670.99, 3); 18 | ``` 19 | -------------------------------------------------------------------------------- /Алгоритмы методы/2.3 Наибольший общий делитель.md: -------------------------------------------------------------------------------- 1 | По данным двум числам 1 ≤ a, b ≤ 2*10^9, найдите их наибольший общий делитель. 2 | 3 | **Sample Input 1**: 4 | 5 | 18 35 6 | 7 | **Sample Output 1**: 8 | 9 | 1 10 | 11 | **Sample Input 2**: 12 | 13 | 14159572 63967072 14 | 15 | **Sample Output 2**: 16 | 17 | 4 18 | 19 | # Решение / Solution 20 | 21 | ``` 22 | def gcd(a, b): 23 | if a % b == 0 or b % a == 0: 24 | return min(a, b) 25 | else: 26 | if a >= b: 27 | return gcd(a % b, b) 28 | else: 29 | return gcd(a, b % a) 30 | 31 | 32 | def main(): 33 | a, b = map(int, input().split()) 34 | print(gcd(a, b)) 35 | 36 | 37 | if __name__ == "__main__": 38 | main() 39 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/2 Запросы на добавление, связанные таблицы.md: -------------------------------------------------------------------------------- 1 | # Запросы на добавление, связанные таблицы 2 | 3 | ## Задание 4 | 5 | Включить новых авторов в таблицу `author` с помощью запроса на добавление, а затем вывести все данные из таблицы `author`. Новыми считаются авторы, которые есть в таблице `supply`, но нет в таблице `author`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into 11 | author (name_author) 12 | select 13 | s.author name_author 14 | from 15 | supply s 16 | left join 17 | author a 18 | on s.author = a.name_author 19 | where 20 | a.name_author is null; 21 | select 22 | * 23 | from 24 | author 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/2 Запросы на добавление, связанные таблицы.md: -------------------------------------------------------------------------------- 1 | # Запросы на добавление, связанные таблицы 2 | 3 | ## Задание 4 | 5 | Включить новых авторов в таблицу `author` с помощью запроса на добавление, а затем вывести все данные из таблицы `author`. Новыми считаются авторы, которые есть в таблице `supply`, но нет в таблице `author`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | insert into 11 | author (name_author) 12 | select 13 | s.author name_author 14 | from 15 | supply s 16 | left join 17 | author a 18 | on s.author = a.name_author 19 | where 20 | a.name_author is null; 21 | select 22 | * 23 | from 24 | author 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/7 Запросы на обновление нескольких таблиц.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление нескольких таблиц 2 | 3 | ## Задание 4 | 5 | Для тех книг в таблице `book` , которые есть в таблице supply, не только увеличить их количество в таблице `book` ( увеличить их количество на значение столбца `amount` таблицы `supply`), но и пересчитать их цену (для каждой книги найти сумму цен из таблиц `book` и `supply` и разделить на 2). 6 | 7 | ## Решение 8 | 9 | ``` 10 | update book, supply 11 | set 12 | book.amount = book.amount + supply.amount, 13 | book.price = (book.price + supply.price) / 2 14 | where 15 | book.title = supply.title and 16 | book.author = supply.author 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/7 Запросы на обновление нескольких таблиц.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление нескольких таблиц 2 | 3 | ## Задание 4 | 5 | Для тех книг в таблице `book` , которые есть в таблице supply, не только увеличить их количество в таблице `book` ( увеличить их количество на значение столбца `amount` таблицы `supply`), но и пересчитать их цену (для каждой книги найти сумму цен из таблиц `book` и `supply` и разделить на 2). 6 | 7 | ## Решение 8 | 9 | ``` 10 | update book, supply 11 | set 12 | book.amount = book.amount + supply.amount, 13 | book.price = (book.price + supply.price) / 2 14 | where 15 | book.title = supply.title and 16 | book.author = supply.author 17 | ``` 18 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/11 Выборка данных, оператор LIKE.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, оператор LIKE 2 | 3 | ## Задание 4 | 5 | Вывести название и автора тех книг, название которых состоит из двух и более слов, а инициалы автора содержат букву «С». Считать, что в названии слова отделяются друг от друга пробелами и не содержат знаков препинания, между фамилией автора и инициалами обязателен пробел, инициалы записываются без пробела в формате: буква, точка, буква, точка. Информацию отсортировать по названию книги в алфавитном порядке. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author from book where title like '% %' and title not like ' ' and (author like '% С._.' or author like '% _.С.') order by title; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/11 Выборка данных, оператор LIKE.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, оператор LIKE 2 | 3 | ## Задание 4 | 5 | Вывести название и автора тех книг, название которых состоит из двух и более слов, а инициалы автора содержат букву «С». Считать, что в названии слова отделяются друг от друга пробелами и не содержат знаков препинания, между фамилией автора и инициалами обязателен пробел, инициалы записываются без пробела в формате: буква, точка, буква, точка. Информацию отсортировать по названию книги в алфавитном порядке. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select title, author from book where title like '% %' and title not like ' ' and (author like '% С._.' or author like '% _.С.') order by title; 11 | ``` 12 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/7 Удаление записей, использование связанных таблиц.md: -------------------------------------------------------------------------------- 1 | # Удаление записей, использование связанных таблиц 2 | 3 | ## Задание 4 | 5 | Удалить всех авторов, которые пишут в жанре "Поэзия". Из таблицы `book` удалить все книги этих авторов. В запросе для отбора авторов использовать полное название жанра, а не его `id`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from author 11 | using 12 | author 13 | join 14 | book 15 | on book.author_id = author.author_id 16 | where 17 | book.genre_id in ( 18 | select 19 | genre_id 20 | from 21 | genre 22 | where 23 | name_genre = 'Поэзия' 24 | ) 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/7 Удаление записей, использование связанных таблиц.md: -------------------------------------------------------------------------------- 1 | # Удаление записей, использование связанных таблиц 2 | 3 | ## Задание 4 | 5 | Удалить всех авторов, которые пишут в жанре "Поэзия". Из таблицы `book` удалить все книги этих авторов. В запросе для отбора авторов использовать полное название жанра, а не его `id`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | delete from author 11 | using 12 | author 13 | join 14 | book 15 | on book.author_id = author.author_id 16 | where 17 | book.genre_id in ( 18 | select 19 | genre_id 20 | from 21 | genre 22 | where 23 | name_genre = 'Поэзия' 24 | ) 25 | ``` 26 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 13.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | В каждой строке замените **первое** вхождение слова, состоящего только из латинских букв "**a**" (регистр не важен), на слово "**argh**". 4 | 5 | **Примечание**: 6 | 7 | Обратите внимание на параметр **count** у функции **sub**. 8 | 9 | --- 10 | 11 | **Sample Input**: 12 | 13 | ``` 14 | There’ll be no more "Aaaaaaaaaaaaaaa" 15 | AaAaAaA AaAaAaA 16 | ``` 17 | 18 | **Sample Output**: 19 | 20 | ``` 21 | There’ll be no more "argh" 22 | argh AaAaAaA 23 | ``` 24 | 25 | --- 26 | 27 | # Solution / Решение 28 | 29 | ``` 30 | import re 31 | import sys 32 | 33 | pattern = r'\b[Aa]+\b' 34 | 35 | for line in sys.stdin: 36 | print(re.sub(pattern, 'argh', line.rstrip(), 1)) 37 | ``` 38 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/5 Запросы для нескольких таблиц с группировкой.md: -------------------------------------------------------------------------------- 1 | # Запросы для нескольких таблиц с группировкой 2 | 3 | ## Задание 4 | 5 | Посчитать количество экземпляров книг каждого автора из таблицы `author`. Вывести тех авторов, количество книг которых меньше 10, в отсортированном по возрастанию количества виде. Последний столбец назвать `Количество`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | a.name_author, coalesce(sum(b.amount), null) Количество 12 | from 13 | author a 14 | left join 15 | book b 16 | on b.author_id = a.author_id 17 | group by 18 | a.name_author 19 | having 20 | sum(b.amount) < 10 or count(b.title) = 0 21 | order by 22 | coalesce(sum(b.amount), 0) 23 | ``` 24 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/5 Запросы для нескольких таблиц с группировкой.md: -------------------------------------------------------------------------------- 1 | # Запросы для нескольких таблиц с группировкой 2 | 3 | ## Задание 4 | 5 | Посчитать количество экземпляров книг каждого автора из таблицы `author`. Вывести тех авторов, количество книг которых меньше 10, в отсортированном по возрастанию количества виде. Последний столбец назвать `Количество`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | a.name_author, coalesce(sum(b.amount), null) Количество 12 | from 13 | author a 14 | left join 15 | book b 16 | on b.author_id = a.author_id 17 | group by 18 | a.name_author 19 | having 20 | sum(b.amount) < 10 or count(b.title) = 0 21 | order by 22 | coalesce(sum(b.amount), 0) 23 | ``` 24 | -------------------------------------------------------------------------------- /Python Course tasks/week 11/student_ids.md: -------------------------------------------------------------------------------- 1 | Есть файл в котором в каждой строчке два числа разделенных запятой: ID студента и ID решенной задачи. Пример: 2 | 3 | ``` 4 | 1,2 5 | 1,4 6 | 1,3 7 | 1,3 8 | 2,1 9 | 2,2 10 | 2,3 11 | 2,4 12 | ``` 13 | 14 | Напишите функцию, которая принимает имя файла и возвращает словарь, в котором для каждого студента будет указано количество решенных им задач. Записи о решенных задачах могут повторятся. 15 | 16 | **Решение** 17 | 18 | ``` 19 | def solved_tasks(filename): 20 | with open(filename) as f: 21 | data = f.readlines() 22 | lines = {tuple(int(y) for y in x.split(',')) for x in data} 23 | result = {} 24 | for line in lines: 25 | student, _ = line 26 | result[student] = result.get(student, 0) + 1 27 | return result 28 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/7 Выборка данных по условию, групповые функции, WHERE и HAVING.md: -------------------------------------------------------------------------------- 1 | # Выборка данных по условию, групповые функции, WHERE и HAVING 2 | 3 | ## Задание 4 | 5 | Посчитать стоимость всех экземпляров каждого автора без учета книг «Идиот» и «Белая гвардия». В результат включить только тех авторов, у которых суммарная стоимость книг более 5000 руб. Вычисляемый столбец назвать Стоимость. Результат отсортировать по убыванию стоимости. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, sum(price * amount) Стоимость 12 | from 13 | book 14 | where 15 | title <> 'Идиот' and title <> 'Белая гвардия' 16 | group by 17 | author 18 | having 19 | Стоимость > 5000 20 | order by 21 | Стоимость desc; 22 | ``` 23 | -------------------------------------------------------------------------------- /Python Course tasks/week 7/fix_duplicates.md: -------------------------------------------------------------------------------- 1 | Напишите функцию `fix_duplicates`, которая будет принимать на вход список строк-идентификаторов и исправлять их так, чтобы в результирующем списке не было дубликатов. Для этого она будет прибавлять к повторяющимся идентификаторам постфикс `_n`, где `n` - количество раз, сколько такой идентификатор уже встречался. 2 | 3 | **Пример** 4 | 5 | ```python 6 | ids = ["a", "b", "c", "a", "a", "d", "c"] 7 | fix_duplicates(ids) == ['a', 'b', 'c', 'a_1', 'a_2', 'd', 'c_1'] 8 | ``` 9 | 10 | **Решение** 11 | 12 | ```python 13 | def fix_duplicates(ids): 14 | result = [] 15 | for i, e in enumerate(ids): 16 | count = ids[:i].count(e) 17 | appendix = f'_{count}' if count else '' 18 | result.append(f'{e}{appendix}') 19 | return result 20 | ``` 21 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/7 Выборка данных по условию, групповые функции, WHERE и HAVING.md: -------------------------------------------------------------------------------- 1 | # Выборка данных по условию, групповые функции, WHERE и HAVING 2 | 3 | ## Задание 4 | 5 | Посчитать стоимость всех экземпляров каждого автора без учета книг «Идиот» и «Белая гвардия». В результат включить только тех авторов, у которых суммарная стоимость книг более 5000 руб. Вычисляемый столбец назвать Стоимость. Результат отсортировать по убыванию стоимости. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, sum(price * amount) Стоимость 12 | from 13 | book 14 | where 15 | title <> 'Идиот' and title <> 'Белая гвардия' 16 | group by 17 | author 18 | having 19 | Стоимость > 5000 20 | order by 21 | Стоимость desc; 22 | ``` 23 | -------------------------------------------------------------------------------- /Python - основы и применение/3.5 Распространённые форматы текстовых файлов CSV, JSON 2.md: -------------------------------------------------------------------------------- 1 | Вам дана частичная выборка из датасета зафиксированных преступлений, совершенных в городе Чикаго с 2001 года по настоящее время. 2 | 3 | Одним из атрибутов преступления является его тип – **Primary Type**. 4 | 5 | Вам необходимо узнать тип преступления, которое было зафиксировано максимальное число раз в 2015 году. 6 | 7 | Файл с данными: **Crimes.csv** 8 | 9 | # Solution / Решение 10 | 11 | ``` 12 | import csv 13 | from collections import Counter 14 | 15 | with open('Crimes.csv') as file: 16 | reader = csv.reader(file) 17 | data = list(reader)[1:] 18 | crimes = list(zip(*data))[5] 19 | crime_counts = Counter(crimes) 20 | print(crime_counts.most_common(1)) 21 | ``` -------------------------------------------------------------------------------- /Python - основы и применение/2.5 Работа с функциями - functool и лямбда функции 6.md: -------------------------------------------------------------------------------- 1 | Лямбда функции предоставляют нам удобный способ создать функцию «прямо на месте». Но иногда, когда нужно создавать много однотипных лямбда функций, еще удобнее будет создать функцию, которая будет их генерировать. 2 | 3 | Реализуйте функцию **mod_checker(x, mod=0)**, которая будет генерировать лямбда функцию от одного аргумента **y**, которая будет возвращать **True**, если остаток от деления **y** на **x** равен **mod**, и **False** иначе. 4 | 5 | **Пример использования**: 6 | 7 | ``` 8 | mod_3 = mod_checker(3) 9 | print(mod_3(3)) # True 10 | print(mod_3(4)) # False 11 | 12 | mod_3_1 = mod_checker(3, 1) 13 | print(mod_3_1(4)) # True 14 | ``` 15 | 16 | # Solution / Решение 17 | 18 | ``` 19 | def mod_checker(x, mod=0): 20 | return lambda y: y % x == mod 21 | ``` 22 | -------------------------------------------------------------------------------- /Python - основы и применение/3.5 Распространённые форматы текстовых файлов CSV, JSON 2 (2).md: -------------------------------------------------------------------------------- 1 | Вам дана частичная выборка из датасета зафиксированных преступлений, совершенных в городе Чикаго с 2001 года по настоящее время. 2 | 3 | Одним из атрибутов преступления является его тип – **Primary Type**. 4 | 5 | Вам необходимо узнать тип преступления, которое было зафиксировано максимальное число раз в 2015 году. 6 | 7 | Файл с данными: **Crimes.csv** 8 | 9 | # Solution / Решение 10 | 11 | ``` 12 | import csv 13 | from collections import Counter 14 | 15 | with open('Crimes.csv') as file: 16 | reader = csv.reader(file) 17 | data = list(reader)[1:] 18 | crimes = list(zip(*data))[5] 19 | crime_counts = Counter(crimes) 20 | print(crime_counts.most_common(1)) 21 | ``` 22 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 8.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | Выведите строки, содержащие "**cat**" в качестве слова. 4 | 5 | **Примечание**: 6 | 7 | Для работы со словами используйте группы символов **\b** и **\B**. Описание этих групп вы можете найти в документации. 8 | 9 | --- 10 | 11 | **Sample Input**: 12 | 13 | ``` 14 | cat 15 | catapult and cat 16 | catcat 17 | concat 18 | Cat 19 | "cat" 20 | !cat? 21 | ``` 22 | 23 | **Sample Output**: 24 | 25 | ``` 26 | cat 27 | catapult and cat 28 | "cat" 29 | !cat? 30 | ``` 31 | 32 | --- 33 | 34 | # Solution / Решение 35 | 36 | ``` 37 | import re 38 | import sys 39 | pattern = r'\bcat\b' 40 | for line in sys.stdin: 41 | line = line.rstrip() 42 | if re.search(pattern, line): 43 | print(line) 44 | ``` 45 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.5 Запросы корректировки данных/9 Запросы на создание таблицы.md: -------------------------------------------------------------------------------- 1 | # Запросы на создание таблицы 2 | 3 | ## Задание 4 | 5 | Создать таблицу заказ (`ordering`), куда включить авторов и названия тех книг, количество экземпляров которых в таблице book меньше среднего количества экземпляров книг в таблице `book`. В таблицу включить столбец `amount`, в котором для всех книг указать одинаковое значение - среднее количество экземпляров книг в таблице `book`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | create table ordering 11 | select 12 | author, title, ( 13 | select 14 | avg(amount) 15 | from 16 | book 17 | ) amount 18 | from 19 | book 20 | where 21 | amount < ( 22 | select 23 | avg(amount) 24 | from 25 | book 26 | ) 27 | ``` 28 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.5 Запросы корректировки данных/9 Запросы на создание таблицы.md: -------------------------------------------------------------------------------- 1 | # Запросы на создание таблицы 2 | 3 | ## Задание 4 | 5 | Создать таблицу заказ (`ordering`), куда включить авторов и названия тех книг, количество экземпляров которых в таблице book меньше среднего количества экземпляров книг в таблице `book`. В таблицу включить столбец `amount`, в котором для всех книг указать одинаковое значение - среднее количество экземпляров книг в таблице `book`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | create table ordering 11 | select 12 | author, title, ( 13 | select 14 | avg(amount) 15 | from 16 | book 17 | ) amount 18 | from 19 | book 20 | where 21 | amount < ( 22 | select 23 | avg(amount) 24 | from 25 | book 26 | ) 27 | ``` 28 | -------------------------------------------------------------------------------- /Python - основы и применение/3.3 Регулярные выражения в Python 7.md: -------------------------------------------------------------------------------- 1 | Вам дана последовательность строк. 2 | 3 | Выведите строки, содержащие "**cat**" в качестве подстроки хотя бы два раза. 4 | 5 | **Примечание**: 6 | 7 | Считать все строки по одной из стандартного потока ввода вы можете, например, так 8 | 9 | ``` 10 | import sys 11 | 12 | for line in sys.stdin: 13 | line = line.rstrip() 14 | # process line 15 | ``` 16 | 17 | --- 18 | 19 | **Sample Input**: 20 | 21 | ``` 22 | catcat 23 | cat and cat 24 | catac 25 | cat 26 | ccaatt 27 | ``` 28 | 29 | **Sample Output**: 30 | 31 | ``` 32 | catcat 33 | cat and cat 34 | ``` 35 | 36 | --- 37 | 38 | # Solution / Решение 39 | 40 | ``` 41 | import re 42 | import sys 43 | pattern = r'((cat).*){2,}' 44 | for line in sys.stdin: 45 | line = line.rstrip() 46 | if re.search(pattern, line): 47 | print(line) 48 | ``` 49 | -------------------------------------------------------------------------------- /Python - основы и применение/2.1 Ошибки и исключения 6.md: -------------------------------------------------------------------------------- 1 | Вашей программе будет доступна функция **foo**, которая может бросать исключения. 2 | 3 | Вам необходимо написать код, который запускает эту функцию, затем ловит исключения **ArithmeticError**, **AssertionError**, **ZeroDivisionError** и выводит имя пойманного исключения. 4 | 5 | Пример решения, которое вы должны отправить на проверку. 6 | 7 | ``` 8 | try: 9 | foo() 10 | except Exception: 11 | print("Exception") 12 | except BaseException: 13 | print("BaseException") 14 | ``` 15 | 16 | Подсказка: https://docs.python.org/3/library/exceptions.html#exception-hierarchy 17 | 18 | # Решение 19 | 20 | ``` 21 | try: 22 | foo() 23 | except ZeroDivisionError: 24 | print('ZeroDivisionError') 25 | except ArithmeticError: 26 | print('ArithmeticError') 27 | except AssertionError: 28 | print('AssertionError') 29 | ``` 30 | -------------------------------------------------------------------------------- /Алгоритмы методы/2.3 Числа Фибоначчи.md: -------------------------------------------------------------------------------- 1 | Дано число 1 ≤ n ≤ 10^7, необходимо найти последнюю цифру n-го числа Фибоначчи. 2 | 3 | Как мы помним, числа Фибоначчи растут очень быстро, поэтому при их вычислении нужно быть аккуратным с переполнением. В данной задаче, впрочем, этой проблемы можно избежать, поскольку нас интересует только последняя цифра числа Фибоначчи: если 0 ≤ a, b ≤ 9 — последние цифры чисел Fi и Fi+1 соответственно, то (a+b) mod 10 — последняя цифра числа Fi+2. 4 | 5 | **Sample Input**: 6 | 7 | 132941 8 | 9 | **Sample Output**: 10 | 11 | 1 12 | 13 | # Решение / Solution 14 | 15 | ``` 16 | def fib_digit(n): 17 | lst = [0, 1] + [x for x in range(1, n + 1)] 18 | for i in lst[3:]: 19 | lst[i] = (lst[i-1] + lst[i-2]) % 10 20 | return lst[n] 21 | 22 | 23 | def main(): 24 | n = int(input()) 25 | print(fib_digit(n)) 26 | 27 | 28 | if __name__ == "__main__": 29 | main() 30 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.4 Вложенные запросы/5 Вложенный запрос после SELECT.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос после SELECT 2 | 3 | ## Задание 4 | 5 | Посчитать сколько и каких экземпляров книг нужно заказать поставщикам, чтобы на складе стало одинаковое количество экземпляров каждой книги, равное значению самого большего количества экземпляров одной книги на складе. Вывести название книги, ее автора, текущее количество экземпляров на складе и количество заказываемых экземпляров книг. Последнему столбцу присвоить имя **Заказ**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | title, 12 | author, 13 | amount, 14 | ( 15 | select 16 | max(amount) 17 | from 18 | book 19 | ) - amount Заказ 20 | from 21 | book 22 | where 23 | amount <> ( 24 | select 25 | max(amount) 26 | from 27 | book 28 | ) 29 | ``` 30 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.1 Связи между таблицами/5.md: -------------------------------------------------------------------------------- 1 | ## Задание 2 | 3 | Добавьте три последние записи (с ключевыми значениями 6, 7, 8) в таблицу `book`, первые 5 записей уже добавлены: 4 | 5 | | book_id | title | author_id | genre_id | price | amount | 6 | |---|---|---|---|---|---| 7 | | 1 | Мастер и Маргарита |1 | 1 | 670.99 | 3 | 8 | | 2 | Белая гвардия |1 | 1 | 540.50 | 5 | 9 | | 3 | Идиот | 1 | 1 | 540.50 | 10 | 10 | | 4 | Братья Карамазовы | 2 | 1 | 799.01 | 3 | 11 | | 5 | Игрок |2 | 1 | 580.50 | 10 | 12 | | 6 | Стихотворения и поэмы | 3 | 3 | 570.20 | 15 | 13 | | 7 | Черный человек |3 | 2 | 570.20 | 6 | 14 | | 8 | Лирика |4 | 2 | 518.99 | 2 | 15 | 16 | ## Решение 17 | 18 | ``` 19 | insert into book (title, author_id, genre_id, price, amount) 20 | values 21 | ('Стихотворения и поэмы', 3, 2, 650.00, 15), 22 | ('Черный человек', 3, 2, 570.20, 6), 23 | ('Лирика', 4, 2, 518.99, 2) 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.1 Связи между таблицами/5.md: -------------------------------------------------------------------------------- 1 | ## Задание 2 | 3 | Добавьте три последние записи (с ключевыми значениями 6, 7, 8) в таблицу `book`, первые 5 записей уже добавлены: 4 | 5 | | book_id | title | author_id | genre_id | price | amount | 6 | |---|---|---|---|---|---| 7 | | 1 | Мастер и Маргарита |1 | 1 | 670.99 | 3 | 8 | | 2 | Белая гвардия |1 | 1 | 540.50 | 5 | 9 | | 3 | Идиот | 1 | 1 | 540.50 | 10 | 10 | | 4 | Братья Карамазовы | 2 | 1 | 799.01 | 3 | 11 | | 5 | Игрок |2 | 1 | 580.50 | 10 | 12 | | 6 | Стихотворения и поэмы | 3 | 3 | 570.20 | 15 | 13 | | 7 | Черный человек |3 | 2 | 570.20 | 6 | 14 | | 8 | Лирика |4 | 2 | 518.99 | 2 | 15 | 16 | ## Решение 17 | 18 | ``` 19 | insert into book (title, author_id, genre_id, price, amount) 20 | values 21 | ('Стихотворения и поэмы', 3, 2, 650.00, 15), 22 | ('Черный человек', 3, 2, 570.20, 6), 23 | ('Лирика', 4, 2, 518.99, 2) 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.4 Вложенные запросы/5 Вложенный запрос после SELECT.md: -------------------------------------------------------------------------------- 1 | # Вложенный запрос после SELECT 2 | 3 | ## Задание 4 | 5 | Посчитать сколько и каких экземпляров книг нужно заказать поставщикам, чтобы на складе стало одинаковое количество экземпляров каждой книги, равное значению самого большего количества экземпляров одной книги на складе. Вывести название книги, ее автора, текущее количество экземпляров на складе и количество заказываемых экземпляров книг. Последнему столбцу присвоить имя **Заказ**. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | title, 12 | author, 13 | amount, 14 | ( 15 | select 16 | max(amount) 17 | from 18 | book 19 | ) - amount Заказ 20 | from 21 | book 22 | where 23 | amount <> ( 24 | select 25 | max(amount) 26 | from 27 | book 28 | ) 29 | ``` 30 | -------------------------------------------------------------------------------- /Python Course tasks/week 7/average_attempts.md.py: -------------------------------------------------------------------------------- 1 | Даны два списка. В первом записи вида: id на Степике, id задачи, количество попыток. Во втором: id на Степике и имя. Напишите функцию, которая посчитает для каждого человека среднее число попыток и сделает словарь с результатами. 2 | 3 | **Пример** 4 | 5 | ```python 6 | attempts = [(1232323323415, 1, 43), 7 | (1232323323415, 2, 3), 8 | (114349, 1, 0) 9 | ] 10 | names = [(114349, "Arkady"), 11 | (1232323323415, "Random")] 12 | 13 | average_attempts(attempts, names) == {'Random': 23.0, 'Arkady': 0.0} 14 | ``` 15 | 16 | **Решение** 17 | 18 | ```python 19 | def average_attempts(attempts, names): 20 | d = {} 21 | for name in names: 22 | grades = [attempt[-1] for attempt in attempts if name[0] == attempt[0]] 23 | if grades: 24 | avg = sum(grades) / len(grades) 25 | d[name[1]] = avg 26 | return d 27 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.1 Отношение (таблица)/3 Вставка записи в таблицу.md: -------------------------------------------------------------------------------- 1 | # Вставка записи в таблицу 2 | 3 | ## Задание 4 | 5 | Занесите три последние записи в таблицуbook, первая запись уже добавлена на предыдущем шаге: 6 | 7 | | **book_id** | **title** | **author** | **price** | **amount** | 8 | |---|---|---|---|---| 9 | | INT PRIMARY KEY AUTO_INCREMENT | VARCHAR(50) | VARCHAR(30) | DECIMAL(8,2) | INT | 10 | | 1 | Мастер и Маргарита | Булгаков М.А. | 670.99 | 3 | 11 | | 2 | Белая гвардия | Булгаков М.А. | 540.50 | 5 | 12 | | 3 | Идиот | Достоевский Ф.М. | 460.00 | 10 | 13 | | 4 | Братья Карамазовы | Достоевский Ф.М. | 799.01 | 2 | 14 | 15 | ## Решение 16 | 17 | ``` 18 | INSERT INTO book 19 | (title, author, price, amount) 20 | VALUES 21 | ('Белая гвардия', 'Булгаков М.А.', 540.50, 5), 22 | ('Идиот', 'Достоевский Ф.М.', 460.00, 10), 23 | ('Братья Карамазовы', 'Достоевский Ф.М.', 799.01, 2); 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.1 Отношение (таблица)/3 Вставка записи в таблицу.md: -------------------------------------------------------------------------------- 1 | # Вставка записи в таблицу 2 | 3 | ## Задание 4 | 5 | Занесите три последние записи в таблицуbook, первая запись уже добавлена на предыдущем шаге: 6 | 7 | | **book_id** | **title** | **author** | **price** | **amount** | 8 | |---|---|---|---|---| 9 | | INT PRIMARY KEY AUTO_INCREMENT | VARCHAR(50) | VARCHAR(30) | DECIMAL(8,2) | INT | 10 | | 1 | Мастер и Маргарита | Булгаков М.А. | 670.99 | 3 | 11 | | 2 | Белая гвардия | Булгаков М.А. | 540.50 | 5 | 12 | | 3 | Идиот | Достоевский Ф.М. | 460.00 | 10 | 13 | | 4 | Братья Карамазовы | Достоевский Ф.М. | 799.01 | 2 | 14 | 15 | ## Решение 16 | 17 | ``` 18 | INSERT INTO book 19 | (title, author, price, amount) 20 | VALUES 21 | ('Белая гвардия', 'Булгаков М.А.', 540.50, 5), 22 | ('Идиот', 'Достоевский Ф.М.', 460.00, 10), 23 | ('Братья Карамазовы', 'Достоевский Ф.М.', 799.01, 2); 24 | ``` 25 | -------------------------------------------------------------------------------- /Python Course tasks/week 11/coords_min_max.md: -------------------------------------------------------------------------------- 1 | В каждой строчке файла даны координаты точки, два числа через пробел. Пример: 2 | 3 | ``` 4 | 1 2 5 | 3 4 6 | -2 23 7 | 3 -1 8 | ``` 9 | 10 | Напишите функцию, которая будет принимать имя файла и возвращать кортеж из четырех чисел: минимум и максимум первой координаты, минимум и максимум второй координаты. Для примера выше результатом будет: 11 | 12 | `(-2, 3, -1, 23)` 13 | 14 | 15 | Для пустого файла функция должна возвращать кортеж у которого все элементы будут None. 16 | 17 | В конце файла может быть пустая строка. 18 | 19 | **Решение** 20 | 21 | ``` 22 | def minmax_coords(filename): 23 | with open(filename) as f: 24 | data = f.readlines() 25 | if not data: 26 | return None, None, None, None 27 | floats = [[float(y) for y in x.split()] for x in data] 28 | xs, ys = list(zip(*floats)) 29 | return min(xs), max(xs), min(ys), max(ys) 30 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.1 Связи между таблицами/4 Действия при удалении записи главной таблицы.md: -------------------------------------------------------------------------------- 1 | # Действия при удалении записи главной таблицы 2 | 3 | ## Задание 4 | 5 | Создать таблицу `book` той же структуры, что и на предыдущем шаге. Будем считать, что при удалении автора из таблицы `author`, должны удаляться все записи о книгах из таблицы `book`, написанные этим автором. А при удалении жанра из таблицы genre для соответствующей записи `book` установить значение `Null` в столбце `genre_id`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | CREATE TABLE book ( 11 | book_id INT PRIMARY KEY AUTO_INCREMENT, 12 | title VARCHAR(50), 13 | author_id INT NOT NULL, 14 | genre_id INT, 15 | price DECIMAL(8,2), 16 | amount INT, 17 | FOREIGN KEY (author_id) REFERENCES author (author_id) ON DELETE CASCADE, 18 | FOREIGN KEY (genre_id) REFERENCES genre (genre_id) ON DELETE SET NULL 19 | ); 20 | ``` 21 | -------------------------------------------------------------------------------- /Алгоритмы методы/4.1.11 Различные слагаемые.md: -------------------------------------------------------------------------------- 1 | По данному числу 1 ≤ *n* ≤ 10^9 найдите максимальное число *k*, для которого *n* можно представить как сумму *k* различных натуральных слагаемых. Выведите в первой строке число *k*, во второй — *k* слагаемых. 2 | 3 | **Sample Input 1**: 4 | 5 | `4` 6 | 7 | **Sample Output 1**: 8 | 9 | ``` 10 | 2 11 | 1 3 12 | ``` 13 | 14 | **Sample Input 2**: 15 | 16 | `6` 17 | 18 | **Sample Output 2**: 19 | 20 | ``` 21 | 3 22 | 1 2 3 23 | ``` 24 | 25 | # Решение 26 | 27 | ``` 28 | def calculation(n): 29 | terms = [] 30 | a, b = 1, n - 1 31 | while b > a: 32 | terms.append(a) 33 | a += 1 34 | b = b - a 35 | terms.append(n-sum(terms)) 36 | return terms 37 | 38 | 39 | def main(): 40 | n = int(input()) 41 | result = calculation(n) 42 | print(len(result)) 43 | print(' '.join(map(str, result))) 44 | 45 | if __name__ == "__main__": 46 | main() 47 | ``` 48 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.1 Связи между таблицами/4 Действия при удалении записи главной таблицы.md: -------------------------------------------------------------------------------- 1 | # Действия при удалении записи главной таблицы 2 | 3 | ## Задание 4 | 5 | Создать таблицу `book` той же структуры, что и на предыдущем шаге. Будем считать, что при удалении автора из таблицы `author`, должны удаляться все записи о книгах из таблицы `book`, написанные этим автором. А при удалении жанра из таблицы genre для соответствующей записи `book` установить значение `Null` в столбце `genre_id`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | CREATE TABLE book ( 11 | book_id INT PRIMARY KEY AUTO_INCREMENT, 12 | title VARCHAR(50), 13 | author_id INT NOT NULL, 14 | genre_id INT, 15 | price DECIMAL(8,2), 16 | amount INT, 17 | FOREIGN KEY (author_id) REFERENCES author (author_id) ON DELETE CASCADE, 18 | FOREIGN KEY (genre_id) REFERENCES genre (genre_id) ON DELETE SET NULL 19 | ); 20 | ``` 21 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/3 Перекрестное соединение CROSS JOIN.md: -------------------------------------------------------------------------------- 1 | # Перекрестное соединение CROSS JOIN 2 | 3 | ## Задание 4 | 5 | Есть список городов, хранящийся в таблице `city`: 6 | 7 | | city_id | name_city | 8 | |---|---| 9 | | 1 | Москва | 10 | | 2 | Санкт-Петербург | 11 | | 3 | Владивосток | 12 | 13 | Необходимо в каждом городе провести выставку книг каждого автора в течение 2020 года. Дату проведения выставки выбрать случайным образом. Создать запрос, который выведет город, автора и дату проведения выставки. Последний столбец назвать **Дата**. Информацию вывести, отсортировав сначала в алфавитном порядке по названиям городов, а потом по убыванию дат проведения выставок. 14 | 15 | ## Решение 16 | 17 | ``` 18 | select 19 | name_city, name_author, date_add('2020-01-01', interval floor(rand() * 365) day) Дата 20 | from 21 | city, author 22 | order by 23 | 1, 3 desc 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/3 Перекрестное соединение CROSS JOIN.md: -------------------------------------------------------------------------------- 1 | # Перекрестное соединение CROSS JOIN 2 | 3 | ## Задание 4 | 5 | Есть список городов, хранящийся в таблице `city`: 6 | 7 | | city_id | name_city | 8 | |---|---| 9 | | 1 | Москва | 10 | | 2 | Санкт-Петербург | 11 | | 3 | Владивосток | 12 | 13 | Необходимо в каждом городе провести выставку книг каждого автора в течение 2020 года. Дату проведения выставки выбрать случайным образом. Создать запрос, который выведет город, автора и дату проведения выставки. Последний столбец назвать **Дата**. Информацию вывести, отсортировав сначала в алфавитном порядке по названиям городов, а потом по убыванию дат проведения выставок. 14 | 15 | ## Решение 16 | 17 | ``` 18 | select 19 | name_city, name_author, date_add('2020-01-01', interval floor(rand() * 365) day) Дата 20 | from 21 | city, author 22 | order by 23 | 1, 3 desc 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.2 Выборка данных/6 Выборка данных, вычисляемые столбцы, логические функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, вычисляемые столбцы, логические функции 2 | 3 | ## Задание 4 | 5 | При анализе продаж книг выяснилось, что наибольшей популярностью пользуются книги Михаила Булгакова, на втором месте книги Сергея Есенина. Исходя из этого решили поднять цену книг Булгакова на 10%, а цену книг Есенина - на 5%. Написать запрос, куда включить автора, название книги и новую цену, последний столбец назвать `new_price`. Значение округлить до двух знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, 12 | title, 13 | case 14 | when 15 | author like 'Булгаков%' 16 | then round(price * 1.1, 2) 17 | when 18 | author like 'Есенин%' 19 | then round(price * 1.05, 2) 20 | else 21 | price 22 | end new_price 23 | from book; 24 | ``` 25 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.2 Выборка данных/6 Выборка данных, вычисляемые столбцы, логические функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных, вычисляемые столбцы, логические функции 2 | 3 | ## Задание 4 | 5 | При анализе продаж книг выяснилось, что наибольшей популярностью пользуются книги Михаила Булгакова, на втором месте книги Сергея Есенина. Исходя из этого решили поднять цену книг Булгакова на 10%, а цену книг Есенина - на 5%. Написать запрос, куда включить автора, название книги и новую цену, последний столбец назвать `new_price`. Значение округлить до двух знаков после запятой. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | author, 12 | title, 13 | case 14 | when 15 | author like 'Булгаков%' 16 | then round(price * 1.1, 2) 17 | when 18 | author like 'Есенин%' 19 | then round(price * 1.05, 2) 20 | else 21 | price 22 | end new_price 23 | from book; 24 | ``` 25 | -------------------------------------------------------------------------------- /Python - основы и применение/2.1 Ошибки и исключения 9.md: -------------------------------------------------------------------------------- 1 | Реализуйте класс **PositiveList**, отнаследовав его от класса **list**, для хранения положительных целых чисел. 2 | 3 | Также реализуйте новое исключение **NonPositiveError**. 4 | 5 | В классе **PositiveList** переопределите метод **append(self, x)** таким образом, чтобы при попытке добавить неположительное целое число бросалось исключение **NonPositiveError** и число не добавлялось, а при попытке добавить положительное целое число, число добавлялось бы как в стандартный **list**. 6 | 7 | В данной задаче гарантируется, что в качестве аргумента **x** метода **append** всегда будет передаваться целое число. 8 | 9 | **Примечание** 10 | 11 | Положительными считаются числа, строго большие нуля. 12 | 13 | # Решение 14 | 15 | ``` 16 | class NonPositiveError(Exception): 17 | pass 18 | 19 | class PositiveList(list): 20 | def append(self, x): 21 | if x > 0: 22 | super(PositiveList, self).append(x) 23 | else: 24 | raise NonPositiveError 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/1.3 Запросы, групповые операции/4 Выборка данных c вычислением, групповые функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных c вычислением, групповые функции 2 | 3 | ## Задание 4 | 5 | Для каждого автора вычислить суммарную стоимость книг S (имя столбца **Стоимость**), а также вычислить налог на добавленную стоимость для полученных сумм (имя столбца НДС ) , который **включен в стоимость** и составляет k = 18%, а также стоимость книг (**Стоимость_без_НДС**) без него. Значения округлить до двух знаков после запятой. В запросе для расчета НДС(**tax**) и Стоимости без НДС (**S_without_tax**) использовать следующие формулы: 6 | 7 | ``` 8 | tax = (S * 1/100) / (1 + k/100) 9 | 10 | S_without_tax = S / (1 + k/100) 11 | ``` 12 | 13 | ## Решение 14 | 15 | ``` 16 | select 17 | author, 18 | sum(price * amount) Стоимость, 19 | round((sum(price * amount) * 0.18) / (1 + 0.18), 2) НДС, 20 | round(sum(price * amount) / (1 + 0.18), 2) Стоимость_без_НДС 21 | from 22 | book 23 | group by 24 | author 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/1 Основы реляционной модели/1.3 Запросы, групповые операции/4 Выборка данных c вычислением, групповые функции.md: -------------------------------------------------------------------------------- 1 | # Выборка данных c вычислением, групповые функции 2 | 3 | ## Задание 4 | 5 | Для каждого автора вычислить суммарную стоимость книг S (имя столбца **Стоимость**), а также вычислить налог на добавленную стоимость для полученных сумм (имя столбца НДС ) , который **включен в стоимость** и составляет k = 18%, а также стоимость книг (**Стоимость_без_НДС**) без него. Значения округлить до двух знаков после запятой. В запросе для расчета НДС(**tax**) и Стоимости без НДС (**S_without_tax**) использовать следующие формулы: 6 | 7 | ``` 8 | tax = (S * 1/100) / (1 + k/100) 9 | 10 | S_without_tax = S / (1 + k/100) 11 | ``` 12 | 13 | ## Решение 14 | 15 | ``` 16 | select 17 | author, 18 | sum(price * amount) Стоимость, 19 | round((sum(price * amount) * 0.18) / (1 + 0.18), 2) НДС, 20 | round(sum(price * amount) / (1 + 0.18), 2) Стоимость_без_НДС 21 | from 22 | book 23 | group by 24 | author 25 | ``` 26 | -------------------------------------------------------------------------------- /Python - основы и применение/2.4 Работа с файловой системой и файлами 6.md: -------------------------------------------------------------------------------- 1 | Вам дана в архиве (ссылка) файловая структура, состоящая из директорий и файлов. 2 | 3 | Вам необходимо распаковать этот архив, и затем найти в данной в файловой структуре все директории, в которых есть хотя бы один файл с расширением "**.py**". 4 | 5 | Ответом на данную задачу будет являться файл со списком таких директорий, **отсортированных в лексикографическом порядке**. 6 | 7 | Для лучшего понимания формата задачи, ознакомьтесь с примером. 8 | 9 | - Пример архива 10 | - Пример ответа 11 | 12 | # Solution/Решение 13 | 14 | ``` 15 | import os 16 | 17 | with open('result.txt', 'a') as f: 18 | for current_dir, dirs, files in os.walk('main'): 19 | if list(filter(lambda x: x.endswith('.py'), files)): 20 | f.write('{}\n'.format(current_dir)) 21 | ``` 22 | -------------------------------------------------------------------------------- /Адаптивный тренажёр Python/5.19 Find a substring.md: -------------------------------------------------------------------------------- 1 | Напишите программу, которая находит все позиции вхождения подстроки в строку. 2 | 3 | **Формат ввода**: 4 | 5 | На первой строке содержится исходная строка, на второй строке ввода указана подстрока, позиции которой требуется найти. Строки состоят из символов латинского алфавита. 6 | 7 | **Формат вывода**: 8 | 9 | Строка, содержащая индексы (индексация начинается с нуля) вхождения подстроки в строку, разделённые пробелом или число -1 в случае, когда подстрока не найдена. 10 | 11 | **Sample Input 1**: 12 | 13 | ``` 14 | abacabadaba 15 | aba 16 | ``` 17 | 18 | **Sample Output 1**: 19 | 20 | `0 4 8` 21 | 22 | **Sample Input 2**: 23 | 24 | ``` 25 | aaaa 26 | aa 27 | ``` 28 | 29 | **Sample Output 2**: 30 | 31 | `0 1 2` 32 | 33 | **Sample Input 3**: 34 | 35 | ``` 36 | abc 37 | d 38 | ``` 39 | 40 | **Sample Output 3**: 41 | 42 | `-1` 43 | 44 | # Solution/Решение 45 | 46 | ``` 47 | initial, s = input(), input() 48 | res = [i for i in range(len(initial) - len(s) + 1) if initial[i:i + len(s)] == s] 49 | print(' '.join(map(str, res)) if res else -1) 50 | ``` 51 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.1 Связи между таблицами/3 Создание таблицы с внешними ключами.md: -------------------------------------------------------------------------------- 1 | # Создание таблицы с внешними ключами 2 | 3 | ## Задание 4 | 5 | Перепишите запрос на создание таблицы `book`, чтобы ее структура соответствовала структуре, показанной на логической схеме (таблица `genre` уже создана, порядок следования столбцов - как на логической схеме в таблице `book`, `genre_id` - внешний ключ) . Для `genre_id` ограничение о недопустимости пустых значений **не задавать**. В качестве главной таблицы для описания поля `genre_id` использовать таблицу `genre` следующей структуры: 6 | 7 | | Поле | Тип, описание | 8 | |---|---| 9 | | author_id | `INT PRIMARY KEY AUTO_INCREMENT` | 10 | | name_author |`VARCHAR(30)` | 11 | 12 | ## Решение 13 | 14 | ``` 15 | create table book ( 16 | book_id int primary key auto_increment, 17 | title varchar(50), 18 | author_id int not null, 19 | genre_id int, 20 | price decimal(8,2), 21 | amount int, 22 | foreign key (author_id) references author (author_id), 23 | foreign key (genre_id) references genre (genre_id) 24 | ) 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.3 Запросы корректировки, соединение таблиц/1 Запросы на обновление, связанные таблицы.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление, связанные таблицы 2 | 3 | ## Задание 4 | 5 | Для книг, которые уже есть на складе (в таблице `book`), но по другой цене, чем в поставке (`supply`), необходимо в таблице `book` увеличить количество на значение, указанное в поставке, и пересчитать цену. А в таблице `supply` обнулить количество этих книг. Формула для пересчета цены: 6 | 7 | `price = (p1 * k1 + p2 * k2) / (k1 + k2)` 8 | 9 | где 10 | 11 | - `p1`, `p2` - цена книги в таблицах `book` и `supply`; 12 | - `k1`, `k2` - количество книг в таблицах `book` и `supply`. 13 | 14 | ## Решение 15 | 16 | ``` 17 | update 18 | book b 19 | join 20 | author a 21 | on a.author_id = b.author_id 22 | join supply s 23 | on s.title = b.title and s.author = a.name_author 24 | set 25 | b.price = (b.price * b.amount + s.price * s.amount) / (b.amount + s.amount), 26 | b.amount = b.amount + s.amount, 27 | s.amount = 0 28 | where 29 | b.price != s.price 30 | ``` 31 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.1 Связи между таблицами/3 Создание таблицы с внешними ключами.md: -------------------------------------------------------------------------------- 1 | # Создание таблицы с внешними ключами 2 | 3 | ## Задание 4 | 5 | Перепишите запрос на создание таблицы `book`, чтобы ее структура соответствовала структуре, показанной на логической схеме (таблица `genre` уже создана, порядок следования столбцов - как на логической схеме в таблице `book`, `genre_id` - внешний ключ) . Для `genre_id` ограничение о недопустимости пустых значений **не задавать**. В качестве главной таблицы для описания поля `genre_id` использовать таблицу `genre` следующей структуры: 6 | 7 | | Поле | Тип, описание | 8 | |---|---| 9 | | author_id | `INT PRIMARY KEY AUTO_INCREMENT` | 10 | | name_author |`VARCHAR(30)` | 11 | 12 | ## Решение 13 | 14 | ``` 15 | create table book ( 16 | book_id int primary key auto_increment, 17 | title varchar(50), 18 | author_id int not null, 19 | genre_id int, 20 | price decimal(8,2), 21 | amount int, 22 | foreign key (author_id) references author (author_id), 23 | foreign key (genre_id) references genre (genre_id) 24 | ) 25 | ``` 26 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.3 Запросы корректировки, соединение таблиц/1 Запросы на обновление, связанные таблицы.md: -------------------------------------------------------------------------------- 1 | # Запросы на обновление, связанные таблицы 2 | 3 | ## Задание 4 | 5 | Для книг, которые уже есть на складе (в таблице `book`), но по другой цене, чем в поставке (`supply`), необходимо в таблице `book` увеличить количество на значение, указанное в поставке, и пересчитать цену. А в таблице `supply` обнулить количество этих книг. Формула для пересчета цены: 6 | 7 | `price = (p1 * k1 + p2 * k2) / (k1 + k2)` 8 | 9 | где 10 | 11 | - `p1`, `p2` - цена книги в таблицах `book` и `supply`; 12 | - `k1`, `k2` - количество книг в таблицах `book` и `supply`. 13 | 14 | ## Решение 15 | 16 | ``` 17 | update 18 | book b 19 | join 20 | author a 21 | on a.author_id = b.author_id 22 | join supply s 23 | on s.title = b.title and s.author = a.name_author 24 | set 25 | b.price = (b.price * b.amount + s.price * s.amount) / (b.amount + s.amount), 26 | b.amount = b.amount + s.amount, 27 | s.amount = 0 28 | where 29 | b.price != s.price 30 | ``` 31 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/6 Запросы для нескольких таблиц со вложенными запросами.md: -------------------------------------------------------------------------------- 1 | # Запросы для нескольких таблиц со вложенными запросами 2 | 3 | ## Задание 4 | 5 | Вывести в алфавитном порядке всех авторов, которые пишут только в одном жанре. Поскольку у нас в таблицах так занесены данные, что у каждого автора книги только в одном жанре, для этого запроса внесем изменения в таблицу `book`. Пусть у нас книга Есенина «Черный человек» относится к жанру «Роман», а книга Булгакова «Белая гвардия» к «Приключениям» (эти изменения в таблицы уже внесены). 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | name_author 12 | from 13 | author 14 | where 15 | author_id in ( 16 | select 17 | a.author_id 18 | from 19 | author a 20 | join 21 | book b 22 | on b.author_id = a.author_id 23 | join 24 | genre g 25 | on g.genre_id = b.genre_id 26 | group by 27 | a.author_id 28 | having 29 | count(distinct b.genre_id) = 1 30 | ) 31 | ``` 32 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/6 Запросы для нескольких таблиц со вложенными запросами.md: -------------------------------------------------------------------------------- 1 | # Запросы для нескольких таблиц со вложенными запросами 2 | 3 | ## Задание 4 | 5 | Вывести в алфавитном порядке всех авторов, которые пишут только в одном жанре. Поскольку у нас в таблицах так занесены данные, что у каждого автора книги только в одном жанре, для этого запроса внесем изменения в таблицу `book`. Пусть у нас книга Есенина «Черный человек» относится к жанру «Роман», а книга Булгакова «Белая гвардия» к «Приключениям» (эти изменения в таблицы уже внесены). 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | name_author 12 | from 13 | author 14 | where 15 | author_id in ( 16 | select 17 | a.author_id 18 | from 19 | author a 20 | join 21 | book b 22 | on b.author_id = a.author_id 23 | join 24 | genre g 25 | on g.genre_id = b.genre_id 26 | group by 27 | a.author_id 28 | having 29 | count(distinct b.genre_id) = 1 30 | ) 31 | ``` 32 | -------------------------------------------------------------------------------- /Python - основы и применение/3.2 Стандартные методы и функции для строк 7.md: -------------------------------------------------------------------------------- 1 | Вашей программе на вход подаются две строки **s** и **t**, состоящие из строчных латинских букв. 2 | 3 | Выведите одно число – количество вхождений строки **t** в строку **s**. 4 | 5 | **Пример**: 6 | 7 | ``` 8 | s = "abababa" 9 | t = "aba" 10 | ``` 11 | 12 | Вхождения строки **t** в строку **s**: 13 | 14 | **aba**baba 15 | ab**aba**ba 16 | abab**aba** 17 | 18 | --- 19 | 20 | **Sample Input 1**: 21 | 22 | ``` 23 | abababa 24 | aba 25 | ``` 26 | 27 | **Sample Output 1**: 28 | 29 | `3` 30 | 31 | --- 32 | 33 | **Sample Input 2**: 34 | 35 | ``` 36 | abababa 37 | abc 38 | ``` 39 | 40 | **Sample Output 2**: 41 | 42 | `0` 43 | 44 | --- 45 | 46 | **Sample Input 3**: 47 | 48 | ``` 49 | abc 50 | abc 51 | ``` 52 | 53 | **Sample Output 3**: 54 | 55 | `1` 56 | 57 | --- 58 | 59 | **Sample Input 4**: 60 | 61 | ``` 62 | aaaaa 63 | a 64 | ``` 65 | 66 | **Sample Output 4**: 67 | 68 | `5` 69 | 70 | --- 71 | 72 | # Solution / Решение 73 | 74 | ``` 75 | s, t = (input() for _ in range(2)) 76 | counter = 0 77 | for i in range(len(s)): 78 | if s.find(t, i, i + len(t)) >= 0: 79 | counter += 1 80 | ``` 81 | -------------------------------------------------------------------------------- /Python Course tasks/week 11/irises.md: -------------------------------------------------------------------------------- 1 | У вас есть файл со следующим содержимым (первые 10 строк): 2 | 3 | "sepal.length","sepal.width","petal.length","petal.width","variety" 4 | 5.1,3.5,1.4,.2,"Setosa" 5 | 4.9,3,1.4,.2,"Setosa" 6 | 4.7,3.2,1.3,.2,"Setosa" 7 | 4.6,3.1,1.5,.2,"Setosa" 8 | 5,3.6,1.4,.2,"Setosa" 9 | 5.4,3.9,1.7,.4,"Setosa" 10 | 4.6,3.4,1.4,.3,"Setosa" 11 | 5,3.4,1.5,.2,"Setosa" 12 | 4.4,2.9,1.4,.2,"Setosa" 13 | В этом файле записаны данные о цветах ирисах: длина чашелистика, ширина чашелистика, длина и ширина лепестка и сорт ириса. 14 | 15 | Напишите функцию, которая будет принимать имя файла и название сорта и возвращать среднюю длину лепестка. 16 | 17 | Обратите внимание, название сорта будет передаваться без лишних кавычек. Например: 18 | 19 | `mean_petal('filename', 'Setosa')` 20 | 21 | **Решение** 22 | 23 | ``` 24 | def mean_petal(filename, variety): 25 | with open(filename) as f: 26 | data = f.read().split()[1:] 27 | result = [] 28 | for line in data: 29 | _, _, petal_length, _, line_variety = line.split(',') 30 | if variety == line_variety[1:-1]: 31 | result.append(float(petal_length)) 32 | if len(result): 33 | return sum(result) / len(result) 34 | return 0 35 | ``` -------------------------------------------------------------------------------- /Python - основы и применение/1.6 Наследование классов 9.md: -------------------------------------------------------------------------------- 1 | Одно из применений множественного наследование – расширение функциональности класса каким-то заранее определенным способом. Например, если нам понадобится логировать какую-то информацию при обращении к методам класса. 2 | 3 | Рассмотрим класс **Loggable**: 4 | 5 | ``` 6 | import time 7 | 8 | class Loggable: 9 | def log(self, msg): 10 | print(str(time.ctime()) + ": " + str(msg)) 11 | ``` 12 | 13 | У него есть ровно один метод **log**, который позволяет выводить в лог (в данном случае в stdout) какое-то сообщение, добавляя при этом текущее время. 14 | 15 | Реализуйте класс **LoggableList**, отнаследовав его от классов **list** и **Loggable** таким образом, чтобы при добавлении элемента в список посредством метода **append** в лог отправлялось сообщение, состоящее из только что добавленного элемента. 16 | 17 | **Примечание** 18 | 19 | Ваша программа не должна содержать класс **Loggable**. При проверке вашей программе будет доступен этот класс, и он будет содержать метод **log**, описанный выше. 20 | 21 | # Решение 22 | 23 | ``` 24 | class LoggableList(Loggable, list): 25 | def append(self, arg): 26 | super(LoggableList, self).append(arg) 27 | self.log(arg) 28 | ``` -------------------------------------------------------------------------------- /Веб-технологии/web/ask/qa/models.py: -------------------------------------------------------------------------------- 1 | from __future__ import unicode_literals 2 | 3 | from django.contrib.auth.models import User 4 | 5 | from django.db import models 6 | 7 | # Create your models here. 8 | 9 | 10 | class QuestionManager(models.Manager): 11 | 12 | def new(self): 13 | return Question.objects.order_by('-added_at') 14 | 15 | def popular(self): 16 | return Question.objects.order_by('-rating') 17 | 18 | 19 | class Question(models.Model): 20 | title = models.CharField(max_length=100) 21 | text = models.TextField() 22 | added_at = models.DateTimeField(auto_now_add=True) 23 | rating = models.IntegerField(default=0) 24 | author = models.ForeignKey(User, related_name='question_author', default=1) 25 | likes = models.ManyToManyField(User, related_name='question_likes') 26 | objects = QuestionManager() 27 | 28 | def __unicode__(self): 29 | return self.title 30 | 31 | 32 | class Answer(models.Model): 33 | text = models.TextField() 34 | added_at = models.DateTimeField(auto_now_add=True) 35 | question = models.ForeignKey('Question') 36 | author = models.ForeignKey(User, related_name='answer_author') 37 | 38 | def __unicode__(self): 39 | return self.text 40 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/ask/urls.py: -------------------------------------------------------------------------------- 1 | """ask URL Configuration 2 | 3 | The `urlpatterns` list routes URLs to views. For more information please see: 4 | https://docs.djangoproject.com/en/1.10/topics/http/urls/ 5 | Examples: 6 | Function views 7 | 1. Add an import: from my_app import views 8 | 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') 9 | Class-based views 10 | 1. Add an import: from other_app.views import Home 11 | 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') 12 | Including another URLconf 13 | 1. Import the include() function: from django.conf.urls import url, include 14 | 2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls')) 15 | """ 16 | from django.conf.urls import url 17 | from django.contrib import admin 18 | 19 | from qa import views 20 | 21 | admin.autodiscover() 22 | 23 | urlpatterns = [ 24 | url(r'^admin/', admin.site.urls), 25 | url(r'^login/$', views.login, name='login'), 26 | url(r'^signup/$', views.signup, name='signup'), 27 | url(r'^question/(?P[0-9]+)/$', views.question, name='question'), 28 | url(r'^ask/$', views.ask, name='ask'), 29 | url(r'^popular/$', views.popular, name='login'), 30 | url(r'^$', views.new, name='new') 31 | ] 32 | -------------------------------------------------------------------------------- /Адаптивный тренажёр Python/5.15 Simple continued fraction.md: -------------------------------------------------------------------------------- 1 | Finite simple continued fraction ([wiki](https://en.wikipedia.org/wiki/Continued_fraction)) −− это дробь вида 2 | 3 | a0 + 1/(a1 + 1/(a2 + 1/⋱ + 1/n)) 4 | 5 | Известно, что любую обыкновенную дробь можно записать в виде конечной простой непрерывной дроби. 6 | 7 | Напишите программу, которая преобразует обыкновенную дробь в последовательность коэффициентов *a0, a1, ..., an. 8 | 9 | Например, дроби 239/30239/30 будет соответствовать непрерывная дробь 10 | 11 | 7 + 1 / (1 + 1/29) 12 | 13 | Cоответственно, коэффициенты будут равны 7, 1 и 29. 14 | 15 | **Формат ввода**: 16 | 17 | Строка, содержащая обыкновенную дробь в формате числитель/знаменатель. 18 | 19 | **Формат вывода**: 20 | 21 | Строка с последовательностью коэффициентов, записанных через пробел. 22 | 23 | --- 24 | 25 | **Sample Input**: 26 | 27 | 239/30 28 | 29 | --- 30 | 31 | **Sample Output**: 32 | 33 | 7 1 29 34 | 35 | --- 36 | 37 | # Solution / Решение 38 | 39 | ``` 40 | a, b = input().split('/') 41 | a, b = int(a), int(b) 42 | 43 | 44 | def calc(a, b): 45 | while b > 0: 46 | q = a // b 47 | c = b 48 | b = a - b * q 49 | a = c 50 | yield str(q) 51 | 52 | print(' '.join(list(calc(a, b)))) 53 | ``` 54 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/8 Операция соединение, использование USING().md: -------------------------------------------------------------------------------- 1 | # Операция соединение, использование USING() 2 | 3 | ## Задание 4 | 5 | Если в таблицах `supply` и `book` есть одинаковые книги, которые имеют равную цену, вывести их название и автора, а также посчитать общее количество экземпляров книг в таблицах `supply` и `book`, столбцы назвать `Название`, `Автор` и `Количество`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | q.title Название, q.name_author Автор, q.cnt + s.cnt Количество 12 | from 13 | ( 14 | select 15 | b.title title, a.name_author name_author, sum(b.amount) cnt, b.price price 16 | from 17 | book b 18 | join 19 | author a 20 | on a.author_id = b.author_id 21 | group by 22 | title, name_author, price 23 | having 24 | cnt > 0 25 | ) q 26 | join 27 | ( 28 | select 29 | title, author name_author, sum(amount) cnt, price 30 | from 31 | supply 32 | group by 33 | title, name_author, price 34 | having 35 | cnt > 0 36 | ) s 37 | using(title, name_author, price) 38 | ``` 39 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/8 Операция соединение, использование USING().md: -------------------------------------------------------------------------------- 1 | # Операция соединение, использование USING() 2 | 3 | ## Задание 4 | 5 | Если в таблицах `supply` и `book` есть одинаковые книги, которые имеют равную цену, вывести их название и автора, а также посчитать общее количество экземпляров книг в таблицах `supply` и `book`, столбцы назвать `Название`, `Автор` и `Количество`. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | q.title Название, q.name_author Автор, q.cnt + s.cnt Количество 12 | from 13 | ( 14 | select 15 | b.title title, a.name_author name_author, sum(b.amount) cnt, b.price price 16 | from 17 | book b 18 | join 19 | author a 20 | on a.author_id = b.author_id 21 | group by 22 | title, name_author, price 23 | having 24 | cnt > 0 25 | ) q 26 | join 27 | ( 28 | select 29 | title, author name_author, sum(amount) cnt, price 30 | from 31 | supply 32 | group by 33 | title, name_author, price 34 | having 35 | cnt > 0 36 | ) s 37 | using(title, name_author, price) 38 | ``` 39 | -------------------------------------------------------------------------------- /Python - основы и применение/2.3 Итераторы и генераторы 5.md: -------------------------------------------------------------------------------- 1 | Целое положительное число называется простым, если оно имеет ровно два различных делителя, то есть делится только на единицу и на само себя. 2 | 3 | Например, число **2** является простым, так как делится только на **1** и **2**. Также простыми являются, например, числа **3**, **5**, **31**, и еще бесконечно много чисел. 4 | 5 | Число 4, например, не является простым, так как имеет три делителя – **1**, **2**, **4**. Также простым не является число **1**, так как оно имеет ровно один делитель – **1**. 6 | 7 | Реализуйте функцию-генератор **primes**, которая будет генерировать простые числа в порядке возрастания, начиная с числа **2**. 8 | 9 | **Example/Пример использования**: 10 | 11 | ``` 12 | print(list(itertools.takewhile(lambda x : x <= 31, primes()))) 13 | # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] 14 | ``` 15 | 16 | # Solution/Решение 17 | 18 | ``` 19 | def is_prime(num): 20 | if num == 2: return True 21 | if num % 2 == 0: return False 22 | for _ in range(3, num // 2, 2): 23 | if num % _ == 0: 24 | return False 25 | return True 26 | 27 | def primes(): 28 | num = 2 29 | while True: 30 | if is_prime(num): 31 | yield num 32 | num += 1 33 | ``` 34 | -------------------------------------------------------------------------------- /Адаптивный тренажёр Python/5.10 Length translator.md: -------------------------------------------------------------------------------- 1 | Требуется написать программу, осуществляющую преобразование из одних единиц измерения длины в другие. 2 | 3 | Должны поддерживаться 4 | 5 | - мили (1 mile = 1609 m), 6 | - ярды (1 yard = 0.9144 m), 7 | - футы (1 foot = 30.48 cm), 8 | - дюймы (1 inch = 2.54 cm), 9 | - километры (1 km = 1000 m), 10 | - метры (m), 11 | - сантиметры (1 cm = 0.01 m) 12 | - миллиметры (1 mm = 0.001 m) 13 | 14 | Используйте именно указанные в формулировке задачи единицы измерения с указанной точностью. 15 | 16 | **Формат ввода**: 17 | 18 | Одна строка с фразой следующего вида: 19 | 20 | ** in ** 21 | 22 | например, если пришла фраза "15.5 mile in km", то требуется перевести 15.5 миль в километры. 23 | 24 | **Формат вывода**: 25 | 26 | Дробное число в научном формате (экспоненциальном), с точностью ровно два знака после запятой. 27 | 28 | **Sample Input**: 29 | 30 | `15.5 mile in km` 31 | 32 | **Sample Output**: 33 | 34 | `2.49e+01` 35 | 36 | # Решение/Solution 37 | 38 | ``` 39 | mapping, inp = {'mile': 1609, 'yard': 0.9144, 'foot': 0.3048, 'inch': 0.0254, 'km': 1000, 'm': 1, 'cm': 0.01, 'mm': 0.001}, input().split() 40 | 41 | print('%.2e' % (float(inp[0]) * float(mapping[inp[1]]) / float(mapping[inp[3]]))) 42 | ``` -------------------------------------------------------------------------------- /Алгоритмы методы/6.1.4 Двоичный поиск.md: -------------------------------------------------------------------------------- 1 | В первой строке даны целое число 1 ≤ *n* ≤ 10^5 и массив A[1…n] из *n* различных натуральных чисел, не превышающих 10^9, в порядке возрастания, во второй — целое число 1 ≤ *k* ≤ 10^5 и *k* натуральных чисел *b1*, …, *bk*, не превышающих 10^9. Для каждого *i* от 1 до *k* необходимо вывести индекс 1 ≤ *j* ≤ *n*, для которого *A[j]* = *bi*, или −1. 2 | 3 | **Sample Input**: 4 | 5 | ``` 6 | 5 1 5 8 12 13 7 | 5 8 1 23 1 11 8 | ``` 9 | 10 | **Sample Output**: 11 | 12 | `3 1 -1 1 -1` 13 | 14 | # Решение 15 | 16 | ``` 17 | def binary_search(A, bi): 18 | lo = 0 19 | hi = len(A) - 1 20 | mid = len(A) // 2 21 | while hi >= lo: 22 | if bi == A[mid]: 23 | return mid + 1 24 | if bi < A[mid]: 25 | hi = mid - 1 26 | if bi > A[mid]: 27 | lo = mid + 1 28 | mid = (lo + hi) // 2 29 | return -1 30 | 31 | 32 | def main(): 33 | first_line = map(int, input().split()) 34 | n, *A = first_line 35 | second_line = map(int, input().split()) 36 | k, *b = second_line 37 | results = [] 38 | for i in range(k): 39 | result = binary_search(A, b[i]) 40 | results.append(result) 41 | print(' '.join(map(str, results))) 42 | 43 | if __name__ == '__main__': 44 | main() 45 | ``` 46 | -------------------------------------------------------------------------------- /Python - основы и применение/1.2 Модель данных - объекты 9.md: -------------------------------------------------------------------------------- 1 | Реализуйте программу, которая будет вычислять количество различных объектов в списке. 2 | Два объекта **a** и **b** считаются различными, если **a is b** равно **False**. 3 | 4 | Вашей программе доступна переменная с названием **objects**, которая ссылается на список, содержащий не более **100** объектов. Выведите количество различных объектов в этом списке. 5 | 6 | **Формат ожидаемой программы**: 7 | 8 | ``` 9 | ans = 0 10 | for obj in objects: # доступная переменная objects 11 | ans += 1 12 | 13 | print(ans) 14 | ``` 15 | 16 | **Примечание**: 17 | 18 | Количеством различных объектов называется максимальный размер множества объектов, в котором любые два объекта являются различными. 19 | 20 | Рассмотрим пример: 21 | 22 | `objects = [1, 2, 1, 2, 3]` # будем считать, что одинаковые числа соответствуют одинаковым объектам, а различные – различным 23 | 24 | Тогда все различные объекты являют собой множество **{1, 2, 3}**. Таким образом, количество различных объектов равно трём. 25 | 26 | # Решение 27 | 28 | ``` 29 | ans = 0 30 | matches = 0 31 | for i in range(len(objects)): 32 | for j in range(i + 1, len(objects)): 33 | if objects[j] is objects[i]: 34 | matches += 1 35 | if matches == 0: 36 | ans += 1 37 | matches = 0 38 | print(ans) 39 | ``` 40 | 41 | -------------------------------------------------------------------------------- /Python - основы и применение/2.2 Работа с кодом - модули и импорт 5.md: -------------------------------------------------------------------------------- 1 | В первой строке дано три числа, соответствующие некоторой дате **date** -- год, месяц и день. 2 | 3 | Во второй строке дано одно число **days** -- число дней. 4 | 5 | Вычислите и выведите год, месяц и день даты, которая наступит, когда с момента исходной даты **date** пройдет число дней, равное **days**. 6 | 7 | **Примечание**: 8 | 9 | Для решения этой задачи используйте стандартный модуль **datetime**. Вам будут полезны класс **datetime.date** для хранения даты и класс **datetime.timedelta** для прибавления дней к дате. 10 | 11 | --- 12 | 13 | **Sample Input 1**: 14 | 15 | ``` 16 | 2016 4 20 17 | 14 18 | ``` 19 | 20 | --- 21 | 22 | **Sample Output 1**: 23 | 24 | `2016 5 4` 25 | 26 | --- 27 | 28 | **Sample Input 2**: 29 | 30 | ``` 31 | 2016 2 20 32 | 9 33 | ``` 34 | 35 | --- 36 | 37 | **Sample Output 2**: 38 | 2016 2 29 39 | 40 | --- 41 | 42 | **Sample Input 3**: 43 | 44 | ``` 45 | 2015 12 31 46 | 1 47 | ``` 48 | 49 | --- 50 | 51 | 52 | **Sample Output 3**: 53 | 54 | 2016 1 1 55 | 56 | --- 57 | 58 | # Решение 59 | 60 | ``` 61 | from datetime import date, timedelta 62 | inp1 = list(map(int, input().split())) 63 | inp2 = int(input()) 64 | 65 | date = date(*inp1) 66 | days = timedelta(days=inp2) 67 | result = date + days 68 | 69 | print(result.year, result.month, result.day) 70 | ``` 71 | -------------------------------------------------------------------------------- /Python - основы и применение/1.5 Введение в классы 8.md: -------------------------------------------------------------------------------- 1 | Реализуйте класс **MoneyBox**, для работы с виртуальной копилкой. 2 | 3 | Каждая копилка имеет ограниченную вместимость, которая выражается целым числом – количеством монет, которые можно положить в копилку. Класс должен поддерживать информацию о количестве монет в копилке, предоставлять возможность добавлять монеты в копилку и узнавать, можно ли добавить в копилку ещё какое-то количество монет, не превышая ее вместимость. 4 | 5 | Класс должен иметь следующий вид 6 | 7 | ``` 8 | class MoneyBox: 9 | def __init__(self, capacity): 10 |      # конструктор с аргументом – вместимость копилки 11 | 12 | def can_add(self, v): 13 | # True, если можно добавить v монет, False иначе 14 | 15 | def add(self, v): 16 | # положить v монет в копилку 17 | ``` 18 | 19 | При создании копилки, число монет в ней равно **0**. 20 | 21 | **Примечание**: 22 | 23 | Гарантируется, что метод **add(self, v)** будет вызываться только если **can_add(self, v) – True**. 24 | 25 | # Решение 26 | 27 | ``` 28 | class MoneyBox: 29 | def __init__(self, capacity): 30 | self.capacity = capacity 31 | self.count = 0 32 | 33 | def can_add(self, v): 34 | return self.count + v <= self.capacity 35 | 36 | def add(self, v): 37 | if self.can_add(v): 38 | self.count += v 39 | ``` 40 | -------------------------------------------------------------------------------- /Python - основы и применение/3.6 API 3.md: -------------------------------------------------------------------------------- 1 | В этой задаче вам необходимо воспользоваться API сайта numbersapi.com. 2 | 3 | Вам дается набор чисел. Для каждого из чисел необходимо узнать, существует ли интересный математический факт об этом числе. 4 | 5 | Для каждого числа выведите **Interesting**, если для числа существует интересный факт, и **Boring** иначе. 6 | Выводите информацию об интересности чисел в таком же порядке, в каком следуют числа во входном файле. 7 | 8 | Пример запроса к интересному числу: 9 | 10 | `http://numbersapi.com/31/math?json=true` 11 | 12 | Пример запроса к скучному числу: 13 | 14 | `http://numbersapi.com/999/math?json=true` 15 | 16 | **Пример входного файла**: 17 | 18 | ``` 19 | 31 20 | 999 21 | 1024 22 | 502 23 | ``` 24 | 25 | **Пример выходного файла**: 26 | 27 | ``` 28 | Interesting 29 | Boring 30 | Interesting 31 | Boring 32 | ``` 33 | 34 | # Solution / Решение 35 | 36 | ``` 37 | import requests 38 | import json 39 | 40 | with open('dataset_24476_3.txt') as file: 41 | for number in file: 42 | number = number.strip() 43 | params = {'default': 'Boring number is boring', 'json': True} 44 | url = 'http://numbersapi.com/{}/math'.format(number) 45 | res = requests.get(url, params=params).text 46 | data = json.loads(res) 47 | if 'Boring' in data['text']: 48 | print('Boring') 49 | else: 50 | print('Interesting') 51 | ``` 52 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/qa/forms.py: -------------------------------------------------------------------------------- 1 | from django import forms 2 | from django.contrib.auth.models import User 3 | from .models import Question, Answer 4 | from django.contrib.auth import authenticate 5 | 6 | 7 | class SignupForm(forms.ModelForm): 8 | 9 | class Meta: 10 | model = User 11 | fields = ('username', 'email', 'password') 12 | 13 | 14 | class AskForm(forms.ModelForm): 15 | 16 | class Meta: 17 | model = Question 18 | fields = ('title', 'text',) 19 | 20 | 21 | class AnswerForm(forms.ModelForm): 22 | 23 | class Meta: 24 | model = Answer 25 | fields = ('text', 'question',) 26 | 27 | 28 | class LoginForm(forms.Form): 29 | username = forms.CharField(max_length=100) 30 | password = forms.CharField(widget=forms.PasswordInput) 31 | 32 | def clean_username(self): 33 | username = self.cleaned_data['username'] 34 | if username.strip() == '': 35 | raise forms.ValidationError('Username is empty', 36 | code='validation_error') 37 | return username 38 | 39 | def clean_password(self): 40 | password = self.cleaned_data['password'] 41 | if password.strip() == '': 42 | raise forms.ValidationError('Password is empty', 43 | code='validation_error') 44 | return password 45 | 46 | def save(self): 47 | auth = authenticate(**self.cleaned_data) 48 | return auth 49 | -------------------------------------------------------------------------------- /Алгоритмы методы/4.3.8 Очередь с приоритетами.md: -------------------------------------------------------------------------------- 1 | Первая строка входа содержит число операций 1 ≤ *n* ≤ 10^5. Каждая из последующих nn строк задают операцию одного из следующих двух типов: 2 | 3 | - 𝙸𝚗𝚜𝚎𝚛𝚝 x, где 0 ≤ *x* ≤ 10^9 — целое число; 4 | - 𝙴𝚡𝚝𝚛𝚊𝚌𝚝𝙼𝚊𝚡. 5 | 6 | Первая операция добавляет число *x* в очередь с приоритетами, вторая — извлекает максимальное число и выводит его. 7 | 8 | **Sample Input**: 9 | 10 | ``` 11 | 6 12 | Insert 200 13 | Insert 10 14 | ExtractMax 15 | Insert 5 16 | Insert 500 17 | ExtractMax 18 | ``` 19 | 20 | **Sample Output**: 21 | 22 | ``` 23 | 200 24 | 500 25 | ``` 26 | 27 | # Решение 28 | 29 | ``` 30 | import heapq 31 | 32 | 33 | class PriorityQueue: 34 | def __init__(self): 35 | self._queue = [] 36 | self._index = 0 37 | 38 | def push(self, item, priority): 39 | heapq.heappush(self._queue, (-priority, self._index, item)) 40 | self._index += 1 41 | 42 | def pop(self): 43 | return heapq.heappop(self._queue)[-1] 44 | 45 | 46 | def main(): 47 | n = int(input()) 48 | pq = PriorityQueue() 49 | maxs = [] 50 | for _ in range(n): 51 | command = input() 52 | if command.startswith('Insert'): 53 | _, priority = command.split() 54 | priority = int(priority) 55 | pq.push(priority, priority) 56 | else: 57 | maxs.append(pq.pop()) 58 | for m in maxs: 59 | print(m) 60 | 61 | if __name__ == '__main__': 62 | main() 63 | ``` 64 | -------------------------------------------------------------------------------- /Алгоритмы методы/4.1.10 Непрерывный рюкзак.md: -------------------------------------------------------------------------------- 1 | Первая строка содержит количество предметов 1 ≤ *n* ≤10^3 и вместимость рюкзака 0 ≤ *W* ≤2⋅10^6. Каждая из следующих *n* строк задаёт стоимость 0 ≤ *ci* ≤ 2⋅10^6 и объём 0 < *wi* ≤ 2⋅10^6 (*n*, *W*, *ci*, *wi* — целые числа). Выведите максимальную стоимость частей предметов (от каждого предмета можно отделить любую часть, стоимость и объём при этом пропорционально уменьшатся), помещающихся в данный рюкзак, с точностью не менее трёх знаков после запятой. 2 | 3 | **Sample Input**: 4 | 5 | ``` 6 | 3 50 7 | 60 20 8 | 100 50 9 | 120 30 10 | ``` 11 | 12 | **Sample Output**: 13 | 14 | `180.000` 15 | 16 | # Решение 17 | 18 | ``` 19 | def calculation(c, items): 20 | capacity = c 21 | sack_value = 0 22 | while len(items) > 0: 23 | value, volume, value_per_unit = items[0] 24 | if capacity > 0: 25 | if capacity >= volume: 26 | sack_value += volume * value_per_unit 27 | capacity -= volume 28 | else: 29 | sack_value += capacity * value_per_unit 30 | break 31 | items = items[1:] 32 | return '%.3f' % sack_value 33 | 34 | 35 | def main(): 36 | n, c = map(int, input().split()) 37 | items = [] 38 | 39 | for i in range(n): 40 | total_value, volume = map(int, input().split()) 41 | value_per_unit = total_value / volume 42 | items.append((total_value, volume, value_per_unit)) 43 | 44 | items.sort(key=lambda x: x[2], reverse=True) 45 | print(calculation(c, items)) 46 | 47 | if __name__ == "__main__": 48 | main() 49 | ``` -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/2 Связи между таблицами/2.2 Запросы на выборку, соединение таблиц/7 Вложенные запросы в операторах соединения.md: -------------------------------------------------------------------------------- 1 | # Вложенные запросы в операторах соединения 2 | 3 | ## Задание 4 | 5 | Вывести информацию о книгах (название книги, фамилию и инициалы автора, название жанра, цену и количество экземпляров книги), написанных в самых популярных жанрах, в отсортированном в алфавитном порядке по названию книг виде. Самым популярным считать жанр, общее количество экземпляров книг которого на складе максимально. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | b.title, a.name_author, g.name_genre, b.price, b.amount 12 | from 13 | book b 14 | join 15 | author a 16 | on a.author_id = b.author_id 17 | join 18 | genre g 19 | on g.genre_id = b.genre_id 20 | join 21 | ( 22 | select 23 | q1.genre_id 24 | from 25 | ( 26 | select 27 | genre_id, sum(amount) sum_amount 28 | from 29 | book 30 | group by 31 | genre_id 32 | ) q1 33 | join 34 | ( 35 | select 36 | genre_id, sum(amount) sum_amount 37 | from 38 | book 39 | group by 40 | genre_id 41 | order by 42 | sum_amount desc 43 | limit 1 44 | ) q2 45 | on q1.sum_amount = q2.sum_amount 46 | ) g1 47 | on g1.genre_id = g.genre_id 48 | order by 49 | b.title 50 | ``` 51 | -------------------------------------------------------------------------------- /Интерактивный тренажер по SQL/3 Базы данных и SQL-запросы/2.2 Запросы на выборку, соединение таблиц/7 Вложенные запросы в операторах соединения.md: -------------------------------------------------------------------------------- 1 | # Вложенные запросы в операторах соединения 2 | 3 | ## Задание 4 | 5 | Вывести информацию о книгах (название книги, фамилию и инициалы автора, название жанра, цену и количество экземпляров книги), написанных в самых популярных жанрах, в отсортированном в алфавитном порядке по названию книг виде. Самым популярным считать жанр, общее количество экземпляров книг которого на складе максимально. 6 | 7 | ## Решение 8 | 9 | ``` 10 | select 11 | b.title, a.name_author, g.name_genre, b.price, b.amount 12 | from 13 | book b 14 | join 15 | author a 16 | on a.author_id = b.author_id 17 | join 18 | genre g 19 | on g.genre_id = b.genre_id 20 | join 21 | ( 22 | select 23 | q1.genre_id 24 | from 25 | ( 26 | select 27 | genre_id, sum(amount) sum_amount 28 | from 29 | book 30 | group by 31 | genre_id 32 | ) q1 33 | join 34 | ( 35 | select 36 | genre_id, sum(amount) sum_amount 37 | from 38 | book 39 | group by 40 | genre_id 41 | order by 42 | sum_amount desc 43 | limit 1 44 | ) q2 45 | on q1.sum_amount = q2.sum_amount 46 | ) g1 47 | on g1.genre_id = g.genre_id 48 | order by 49 | b.title 50 | ``` 51 | -------------------------------------------------------------------------------- /Python - основы и применение/2.2 Работа с кодом - модули и импорт 9.md: -------------------------------------------------------------------------------- 1 | Алиса владеет интересной информацией, которую хочет заполучить Боб. 2 | Алиса умна, поэтому она хранит свою информацию в зашифрованном файле. 3 | У Алисы плохая память, поэтому она хранит все свои пароли в открытом виде в текстовом файле. 4 | 5 | Бобу удалось завладеть зашифрованным файлом с интересной информацией и файлом с паролями, но он не смог понять какой из паролей ему нужен. Помогите ему решить эту проблему. 6 | 7 | Алиса зашифровала свою информацию с помощью библиотеки simple-crypt. 8 | Она представила информацию в виде строки, и затем записала в бинарный файл результат работы метода **simplecrypt.encrypt**. 9 | 10 | Вам необходимо установить библиотеку simple-crypt, и с помощью метода **simplecrypt.decrypt** узнать, какой из паролей служит ключом для расшифровки файла с интересной информацией. 11 | 12 | Ответом для данной задачи служит расшифрованная интересная информация Алисы. 13 | 14 | - Файл с информацией 15 | - Файл с паролями 16 | 17 | # Решение 18 | 19 | ``` 20 | import simplecrypt 21 | import urllib.request as urllib 22 | 23 | passwords = urllib.urlopen('https://stepik.org/media/attachments/lesson/24466/passwords.txt') 24 | 25 | with open('encrypted.bin', 'rb') as inp: 26 | encrypted = inp.read() 27 | 28 | for password in passwords: 29 | password = password[:-1] 30 | try: 31 | print(simplecrypt.decrypt(password, encrypted).decode('utf8')) 32 | except simplecrypt.DecryptionException: 33 | print(password, 'is wrong') 34 | else: 35 | print(password, 'is correct') 36 | ``` 37 | -------------------------------------------------------------------------------- /Веб-технологии/web/nginx.conf: -------------------------------------------------------------------------------- 1 | #user nobody; 2 | worker_processes 5; 3 | 4 | #error_log logs/error.log; 5 | #error_log logs/error.log notice; 6 | #error_log logs/error.log info; 7 | 8 | #pid logs/nginx.pid; 9 | 10 | 11 | events { 12 | worker_connections 1024; 13 | } 14 | 15 | http { 16 | include mime.types; 17 | default_type application/octet-stream; 18 | 19 | #log_format main '$remote_addr - $remote_user [$time_local] "$request" ' 20 | # '$status $body_bytes_sent "$http_referer" ' 21 | # '"$http_user_agent" "$http_x_forwarded_for"'; 22 | 23 | #access_log logs/access.log main; 24 | 25 | sendfile on; 26 | keepalive_timeout 65; 27 | 28 | server { 29 | listen 80 default_server; 30 | 31 | # for uploaded files. 32 | #location ^~ /uploads/ { 33 | # root /home/box/web/; 34 | #} 35 | 36 | # for files with any extensions 37 | #location ~* \.(.*?)$ { 38 | # root /home/box/web/public/; 39 | #} 40 | 41 | # for files with no extensions 42 | #location ~* ^([^.]+)$ { 43 | # return 404; 44 | #} 45 | 46 | # echo server 47 | location /hello/ { 48 | proxy_pass http://0.0.0.0:8080/; 49 | } 50 | 51 | location / { 52 | proxy_pass http://0.0.0.0:8000/; 53 | } 54 | 55 | #error_page 404 /404.html; 56 | 57 | # redirect server error pages to the static page /50x.html 58 | # 59 | error_page 500 502 503 504 /50x.html; 60 | 61 | location = /50x.html { 62 | root html; 63 | } 64 | } 65 | include servers/*; 66 | } -------------------------------------------------------------------------------- /Алгоритмы методы/4.1.9 Покрыть отрезки точками.md: -------------------------------------------------------------------------------- 1 | По данным *n* отрезкам необходимо найти множество точек минимального размера, для которого каждый из отрезков содержит хотя бы одну из точек. 2 | 3 | В первой строке дано число 1 ≤ *n* ≤ 100 отрезков. Каждая из последующих *n* 4 | строк содержит по два числа 0 ≤ *l* ≤ *r* ≤ 109, задающих начало и конец отрезка. Выведите оптимальное число *m* точек и сами *m* точек. Если таких множеств точек несколько, выведите любое из них. 5 | 6 | **Sample Input 1**: 7 | 8 | ``` 9 | 3 10 | 1 3 11 | 2 5 12 | 3 6 13 | ``` 14 | 15 | **Sample Output 1**: 16 | 17 | ``` 18 | 1 19 | 3 20 | ``` 21 | 22 | **Sample Input 2**: 23 | 24 | ``` 25 | 4 26 | 4 7 27 | 1 3 28 | 2 5 29 | 5 6 30 | ``` 31 | 32 | **Sample Output 2**: 33 | 34 | ``` 35 | 2 36 | 3 6 37 | ``` 38 | 39 | # Решение/Solution 40 | 41 | ``` 42 | def dots(segments): 43 | resulting_segments = [] 44 | while len(segments) > 0: 45 | if len(segments) < 2: 46 | seg = segments.pop() 47 | resulting_segments.append(seg) 48 | else: 49 | a, b = segments[0], segments[1] 50 | if b[0] <= a[1]: 51 | left, right = b[0], b[1] if b[1] <= a[1] else a[1] 52 | overlapping = (left, right) 53 | segments = segments[2:] 54 | segments = [overlapping] + segments 55 | else: 56 | resulting_segments.append(segments[0]) 57 | segments = segments[1:] 58 | return [x[1] for x in resulting_segments] 59 | 60 | 61 | def main(): 62 | n = int(input()) 63 | segments = [] 64 | for i in range(n): 65 | segments.append(tuple(map(int, input().split()))) 66 | segments.sort(key=lambda x: (x[0], x[1])) 67 | result = dots(segments) 68 | print(len(result)) 69 | print(' '.join(map(str, result))) 70 | 71 | 72 | if __name__ == "__main__": 73 | main() 74 | ``` 75 | -------------------------------------------------------------------------------- /Python - основы и применение/3.2 Стандартные методы и функции для строк 6.md: -------------------------------------------------------------------------------- 1 | Вашей программе на вход подаются три строки **s**, **a**, **b**, состоящие из строчных латинских букв. 2 | За одну операцию вы можете заменить все вхождения строки **a** в строку **s** на строку **b**. 3 | 4 | Например, **s = "abab"**, **a = "ab"**, **b = "ba"**, тогда после выполнения одной операции строка **s** перейдет в строку **"baba"**, после выполнения двух и операций – в строку **"bbaa"**, и дальнейшие операции не будут изменять строку **s**. 5 | 6 | Необходимо узнать, после какого минимального количества операций в строке **s** не останется вхождений строки **a**, либо же определить, что это невозможно. 7 | 8 | Выведите одно число – минимальное число операций, после применения которых в строке **s** не останется вхождений строки **a**. 9 | 10 | Если после применения любого числа операций в строке **s** останутся вхождения строки **a**, выведите **Impossible**. 11 | 12 | --- 13 | 14 | **Sample Input 1**: 15 | 16 | ``` 17 | ababa 18 | a 19 | b 20 | ``` 21 | 22 | **Sample Output 1**: 23 | 24 | `1` 25 | 26 | --- 27 | 28 | **Sample Input 2**: 29 | 30 | ``` 31 | ababa 32 | b 33 | a 34 | ``` 35 | 36 | **Sample Output 2**: 37 | 38 | `1` 39 | 40 | --- 41 | 42 | **Sample Input 3**: 43 | 44 | ``` 45 | ababa 46 | c 47 | c 48 | ``` 49 | 50 | **Sample Output 3**: 51 | 52 | `0` 53 | 54 | --- 55 | 56 | **Sample Input 4**: 57 | 58 | ``` 59 | ababac 60 | c 61 | c 62 | ``` 63 | 64 | **Sample Output 4**: 65 | 66 | `Impossible` 67 | 68 | --- 69 | 70 | # Solution / Решение 71 | 72 | ``` 73 | s, a, b = (input() for _ in range(3)) 74 | 75 | def f(s, a, b, counter=0): 76 | if a in b and a in s: 77 | return 'Impossible' 78 | if s == s.replace(a, b): 79 | return counter 80 | else: 81 | counter += 1 82 | s = s.replace(a, b) 83 | return f(s, a, b, counter) 84 | 85 | print(f(s, a, b)) 86 | ``` 87 | -------------------------------------------------------------------------------- /Веб-технологии/web/init.sh: -------------------------------------------------------------------------------- 1 | # upgrade package info 2 | # sudo apt-get update 3 | 4 | # install nginx 5 | # sudo apt-get install nginx 6 | 7 | # creating project structure 8 | mkdir -p /home/box/web/etc/ 9 | mkdir -p /home/box/web/uploads/ 10 | mkdir -p /home/box/web/public/css/ 11 | mkdir -p /home/box/web/public/img/ 12 | mkdir -p /home/box/web/public/js/ 13 | 14 | # Configure NGINX 15 | sudo rm -rf /etc/nginx/nginx.conf 16 | sudo rm -rf /etc/nginx/sites-enabled/default 17 | cp nginx.conf /home/box/web/etc 18 | sudo ln -s /home/box/web/etc/nginx.conf /etc/nginx/nginx.conf 19 | 20 | # Run NGINX 21 | sudo /etc/init.d/nginx restart 22 | 23 | 24 | # Configure Gunicorn and echo WSGI server 25 | cp hello.py /home/box/web/ 26 | cp ./conf/hello.py /home/box/web/etc/ 27 | sudo ln -sf /home/box/web/etc/hello.py /etc/gunicorn.d/hello.py 28 | sudo /etc/init.d/gunicorn restart 29 | # sudo gunicorn -b 0.0.0.0:8080 hello:application 30 | 31 | sudo /etc/init.d/mysql start 32 | mysql -uroot -e "CREATE DATABASE ask;" 33 | 34 | # django-admin startproject ask 35 | # rm -rf ask 36 | # mv my_ask ask 37 | cd ask 38 | ./manage.py syncdb 39 | ./manage.py runserver 0.0.0.0:8000 40 | 41 | # cp -r /home/box/stepic_course_web/ask /home/box/web 42 | # cd /home/box/web/ask 43 | 44 | #install myysql 45 | #sudo apt-get install mysql-server #sql - сервер 46 | 47 | #sudo apt-get install mysql-client #sql -клиент 48 | 49 | # sudo apt-get install python-mysqldb #сама библиотека 50 | # sudo -H pip install pymysql 51 | 52 | # Start daemon 53 | # sudo /etc/init.d/mysql start 54 | 55 | # mysql -uroot -e "CREATE DATABASE ask;" 56 | 57 | # Create migrate 58 | # python manage.py migrate 59 | 60 | # Deploying echo server and Django project 61 | # gunicorn hello:app & --bind 0.0.0.0:8080 & 62 | # gunicorn ask.wsgi -b 0.0.0.0:8000 & 63 | # sudo ln -sf /home/box/web/etc/gunicorn_hello.conf /etc/gunicorn.d/test-wsgi 64 | # sudo ln -sf /home/box/web/etc/gunicorn_django.conf /etc/gunicorn.d/test-django 65 | # sudo /etc/init.d/gunicorn restart -------------------------------------------------------------------------------- /Python - основы и применение/1.3 Функции и стек вызовов 15.md: -------------------------------------------------------------------------------- 1 | *Сочетанием из n элементов по **k*** называется подмножество этих **n** элементов размера **k**. 2 | 3 | Два сочетания называются *различными*, если одно из сочетаний содержит элемент, который не содержит другое. 4 | 5 | *Числом сочетаний из **n** по **k*** называется количество различных сочетаний из **n** по **k**. Обозначим это число за **C(n, k)**. 6 | 7 | **Пример**: 8 | 9 | Пусть **n = 3**, т. е. есть три элемента **(1, 2, 3)**. Пусть **k = 2**. 10 | 11 | Все различные сочетания из **3** элементов по **2**: **(1, 2), (1, 3), (2, 3)**. 12 | 13 | Различных сочетаний три, поэтому **C(3, 2) = 3**. 14 | 15 | Несложно понять, что **C(n, 0) = 1**, так как из **n** элементов выбрать **0** можно единственным образом, а именно, ничего не выбрать. Также несложно понять, что если **k > n**, то **C(n, k) = 0**, так как невозможно, например, из трех элементов выбрать пять. 16 | 17 | Для вычисления **C(n, k)** в других случаях используется следующая рекуррентная формула: **C(n, k) = C(n - 1, k) + C(n - 1, k - 1)**. 18 | 19 | Реализуйте программу, которая для заданных **n** и **k** вычисляет **C(n, k)**. 20 | 21 | Вашей программе на вход подается строка, содержащая два целых числа **n** и **k (1 ≤ n ≤ 10, 0 ≤ k ≤ 10)**. Ваша программа должна вывести единственное число: **C(n, k)**. 22 | 23 | **Примечание**: 24 | 25 | Считать два числа **n** и **k** вы можете, например, следующим образом: 26 | 27 | **n, k = map(int, input().split())** 28 | 29 | --- 30 | 31 | **Sample Input 1**: 32 | 33 | 3 2 34 | 35 | **Sample Output 1**: 36 | 37 | 3 38 | 39 | --- 40 | 41 | **Sample Input 2**: 42 | 43 | **10 5** 44 | 45 | **Sample Output 2**: 46 | 47 | 252 48 | 49 | --- 50 | 51 | # Решение 52 | 53 | ``` 54 | n, k = map(int, input().split()) 55 | 56 | def c(n, k): 57 | if k == 0: 58 | return 1 59 | elif k > n: 60 | return 0 61 | else: 62 | return c(n - 1, k) + c(n - 1, k - 1) 63 | 64 | print(c(n, k)) 65 | ``` 66 | -------------------------------------------------------------------------------- /Python - основы и применение/3.4 Обзорно об интернете http-запросы, html-страницы и requests 7.md: -------------------------------------------------------------------------------- 1 | Вашей программе на вход подается ссылка на HTML файл. 2 | Вам необходимо скачать этот файл, затем найти в нем все ссылки вида **** и вывести список сайтов, на которые есть ссылка. 3 | 4 | Сайтом в данной задаче будем называть имя домена вместе с именами поддоменов. То есть, это последовательность символов, которая следует сразу после символов протокола, если он есть, до символов порта или пути, если они есть, за исключением случаев с относительными ссылками вида ****. 5 | 6 | Сайты следует выводить в алфавитном порядке. 7 | 8 | **Пример HTML файла**: 9 | 10 | ``` 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | ``` 19 | 20 | **Пример ответа**: 21 | 22 | ``` 23 | mail.ru 24 | neerc.ifmo.ru 25 | stepic.org 26 | www.ya.ru 27 | ya.ru 28 | ``` 29 | 30 | # Solution / Решение 31 | 32 | ``` 33 | import re 34 | import urllib.request 35 | from urllib.parse import urlparse 36 | 37 | url = input() 38 | 39 | 40 | def get_links(): 41 | try: 42 | fp = urllib.request.urlopen(url) 43 | mybytes = fp.read() 44 | mystr = mybytes.decode("utf8") 45 | fp.close() 46 | links = re.findall(r' 1: 55 | freq1, _count1, left = heapq.heappop(h) 56 | freq2, _count2, right = heapq.heappop(h) 57 | heapq.heappush(h, (freq1 + freq2, count, Node(left, right))) 58 | count += 1 59 | code = {} 60 | if h: 61 | [(_freq, _count, root)] = h 62 | root.walk(code, '') 63 | return code 64 | 65 | 66 | def main(): 67 | s = input() 68 | code = huffman_encode(s) 69 | encoded = ''.join(code[ch] for ch in s) 70 | print(len(code), len(encoded)) 71 | for ch in sorted(code): 72 | print('{}: {}'.format(ch, code[ch])) 73 | print(encoded) 74 | 75 | if __name__ == "__main__": 76 | main() 77 | ``` 78 | -------------------------------------------------------------------------------- /Python - основы и применение/3.5 Распространённые форматы текстовых файлов CSV, JSON 4.md: -------------------------------------------------------------------------------- 1 | Вам дано описание наследования классов в формате JSON. 2 | 3 | Описание представляет из себя массив JSON-объектов, которые соответствуют классам. У каждого JSON-объекта есть поле **name**, которое содержит имя класса, и поле **parents**, которое содержит список имен прямых предков. 4 | 5 | **Пример**: 6 | 7 | `[{"name": "A", "parents": []}, {"name": "B", "parents": ["A", "C"]}, {"name": "C", "parents": ["A"]}]` 8 | 9 | Эквивалент на Python: 10 | 11 | ``` 12 | class A: 13 | pass 14 | 15 | class B(A, C): 16 | pass 17 | 18 | class C(A): 19 | pass 20 | ``` 21 | 22 | Гарантируется, что никакой класс не наследуется от себя явно или косвенно, и что никакой класс не наследуется явно от одного класса более одного раза. 23 | 24 | Для каждого класса вычислите предком скольких классов он является и выведите эту информацию в следующем формате. 25 | 26 | **<имя класса> : <количество потомков>** 27 | 28 | Выводить классы следует в лексикографическом порядке. 29 | 30 | **Sample Input**: 31 | 32 | `[{"name": "A", "parents": []}, {"name": "B", "parents": ["A", "C"]}, {"name": "C", "parents": ["A"]}]` 33 | 34 | **Sample Output**: 35 | 36 | ``` 37 | A : 3 38 | B : 1 39 | C : 2 40 | ``` 41 | 42 | # Solution / Решение 43 | 44 | ``` 45 | import json 46 | 47 | initial = json.loads(input()) 48 | 49 | with_children = {element['name']: [] for element in initial} 50 | 51 | for eli in initial: 52 | for elc in with_children: 53 | if elc in eli['parents']: 54 | with_children[elc].append(eli['name']) 55 | 56 | for element in with_children: 57 | with_children[element] = set(with_children[element]) 58 | 59 | def dfs(graph, start, visited=None): 60 | if visited is None: 61 | visited = set() 62 | visited.add(start) 63 | for next in graph[start] - visited: 64 | dfs(graph, next, visited) 65 | return visited 66 | 67 | for element in sorted(with_children.keys()): 68 | print(element, ':', len(dfs(with_children, element))) 69 | ``` -------------------------------------------------------------------------------- /Python - основы и применение/1.6 Наследование классов 8.md: -------------------------------------------------------------------------------- 1 | Реализуйте структуру данных, представляющую собой расширенную структуру стек. Необходимо поддерживать добавление элемента на вершину стека, удаление с вершины стека, и необходимо поддерживать операции сложения, вычитания, умножения и целочисленного деления. 2 | 3 | Операция сложения на стеке определяется следующим образом. Со стека снимается верхний элемент (**top1**), затем снимается следующий верхний элемент (**top2**), и затем как результат операции сложения на вершину стека кладется элемент, равный **top1 + top2**. 4 | 5 | Аналогичным образом определяются операции вычитания (**top1 - top2**), умножения (**top1 * top2**) и целочисленного деления (**top1 // top2**). 6 | 7 | Реализуйте эту структуру данных как класс **ExtendedStack**, отнаследовав его от стандартного класса list. 8 | 9 | Требуемая структура класса: 10 | 11 | ``` 12 | class ExtendedStack(list): 13 | def sum(self): 14 | # операция сложения 15 | 16 | def sub(self): 17 | # операция вычитания 18 | 19 | def mul(self): 20 | # операция умножения 21 | 22 | def div(self): 23 | # операция целочисленного деления 24 | ``` 25 | 26 | **Примечание** 27 | 28 | Для добавления элемента на стек используется метод **`append`**, а для снятия со стека – метод **`pop`**. 29 | 30 | Гарантируется, что операции будут совершаться только когда в стеке есть хотя бы два элемента. 31 | 32 | # Решение 33 | 34 | ``` 35 | class ExtendedStack(list): 36 | def sum(self): 37 | top1 = self.pop() 38 | top2 = self.pop() 39 | self.append(top1 + top2) 40 | return self 41 | 42 | def sub(self): 43 | top1 = self.pop() 44 | top2 = self.pop() 45 | self.append(top1 - top2) 46 | return self 47 | 48 | def mul(self): 49 | top1 = self.pop() 50 | top2 = self.pop() 51 | self.append(top1 * top2) 52 | return self 53 | 54 | def div(self): 55 | top1 = self.pop() 56 | top2 = self.pop() 57 | self.append(top1 // top2) 58 | return self 59 | ``` 60 | -------------------------------------------------------------------------------- /Python Course tasks/week 3/life.py: -------------------------------------------------------------------------------- 1 | k = int(input()) 2 | 3 | world = [ 4 | ['.', '#', '.', '.', '.', '.', '.', '.', '.', '.'], 5 | ['.', '.', '#', '.', '.', '.', '.', '.', '.', '.'], 6 | ['#', '#', '#', '.', '.', '.', '.', '.', '.', '.'], 7 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'], 8 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'], 9 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'], 10 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'], 11 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'], 12 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'], 13 | ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.'] 14 | ] 15 | 16 | world_size = len(world) 17 | 18 | 19 | def get_vicinity_borders(coord): 20 | start = coord - 1 21 | stop = coord + 2 22 | if coord == 0: 23 | start = 0 24 | if coord == world_size - 1: 25 | stop = world_size 26 | return start, stop 27 | 28 | 29 | def get_vicinity(start_x, stop_x, start_y, stop_y): 30 | vicinity = [ 31 | world[x][y] 32 | for x in range(start_x, stop_x) 33 | for y in range(start_y, stop_y) 34 | ] 35 | return vicinity 36 | 37 | 38 | def calculate_new_cell(x, y, vicinity): 39 | cell = world[x][y] 40 | new_cell = cell 41 | if cell == '.': 42 | if vicinity.count('#') == 3: 43 | new_cell = '#' 44 | else: 45 | if vicinity.count('#') - 1 < 2 or vicinity.count('#') - 1 > 3: 46 | new_cell = '.' 47 | return new_cell 48 | 49 | 50 | def generate_next_world(): 51 | next_world = [] 52 | for x in range(world_size): 53 | start_x, stop_x = get_vicinity_borders(x) 54 | next_world.append([]) 55 | for y in range(world_size): 56 | start_y, stop_y = get_vicinity_borders(y) 57 | vicinity = get_vicinity(start_x, stop_x, start_y, stop_y) 58 | new_cell = calculate_new_cell(x, y, vicinity) 59 | next_world[x].append(new_cell) 60 | return next_world 61 | 62 | for _ in range(k): 63 | world = generate_next_world() 64 | 65 | for row in world: 66 | print(row) 67 | -------------------------------------------------------------------------------- /Алгоритмы методы/4.2.6 Декодирование Хаффмана.md: -------------------------------------------------------------------------------- 1 | Восстановите строку по её коду и беспрефиксному коду символов. 2 | 3 | В первой строке входного файла заданы два целых числа *k* и *l* через пробел — количество различных букв, встречающихся в строке, и размер получившейся закодированной строки, соответственно. В следующих *k* строках записаны коды букв в формате "letter: code". Ни один код не является префиксом другого. Буквы могут быть перечислены в любом порядке. В качестве букв могут встречаться лишь строчные буквы латинского алфавита; каждая из этих букв встречается в строке хотя бы один раз. Наконец, в последней строке записана закодированная строка. Исходная строка и коды всех букв непусты. Заданный код таков, что закодированная строка имеет минимальный возможный размер. 4 | 5 | 6 | В первой строке выходного файла выведите строку ss. Она должна состоять из строчных букв латинского алфавита. Гарантируется, что длина правильного ответа не превосходит 10^4 символов. 7 | 8 | **Sample Input 1**: 9 | 10 | ``` 11 | 1 1 12 | a: 0 13 | 0 14 | ``` 15 | 16 | **Sample Output 1**: 17 | 18 | `a` 19 | 20 | **Sample Input 2**: 21 | 22 | ``` 23 | 4 14 24 | a: 0 25 | b: 10 26 | c: 110 27 | d: 111 28 | 01001100100111 29 | ``` 30 | 31 | Sample Output 2: 32 | 33 | `abacabad` 34 | 35 | # Решение 36 | 37 | ``` 38 | def huffman_decode(code_table, s): 39 | decoded = '' 40 | while len(s) > 0: 41 | i = 0 42 | acc = '' 43 | while i < len(s): 44 | current_char = s[i] 45 | acc += current_char 46 | if acc in code_table.values(): 47 | new_dict = dict(zip(code_table.values(), code_table.keys())) 48 | acc = new_dict[acc] 49 | i += 1 50 | break 51 | i += 1 52 | s = s[i:] 53 | decoded += acc 54 | return decoded 55 | 56 | 57 | def main(): 58 | letters_amount, encoded_length = map(int, input().split()) 59 | code_table = {} 60 | for _ in range(letters_amount): 61 | letter, code = input().split(': ') 62 | code_table[letter] = code 63 | s = input() 64 | print(huffman_decode(code_table, s)) 65 | 66 | 67 | if __name__ == "__main__": 68 | main() 69 | ``` 70 | -------------------------------------------------------------------------------- /Python - основы и применение/3.7 XML, библиотека ElementTree, библиотека lxml 4.md: -------------------------------------------------------------------------------- 1 | Вам дано описание пирамиды из кубиков в формате XML. 2 | 3 | Кубики могут быть трех цветов: красный (**red**), зеленый (**green**) и синий (**blue**). 4 | 5 | Для каждого кубика известны его цвет, и известны кубики, расположенные прямо под ним. 6 | 7 | Пример: 8 | 9 | ``` 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | ``` 19 | 20 | Введем понятие ценности для кубиков. Самый верхний кубик, соответствующий корню XML документа имеет ценность **1**. Кубики, расположенные прямо под ним, имеют ценность **2**. Кубики, расположенные прямо под нижележащими кубиками, имеют ценность **3**. И т. д. 21 | 22 | Ценность цвета равна сумме ценностей всех кубиков этого цвета. 23 | 24 | Выведите через пробел три числа: ценности красного, зеленого и синего цветов. 25 | 26 | **Sample Input**: 27 | 28 | `` 29 | 30 | **Sample Output**: 31 | 32 | 4 3 1 33 | 34 | # Решение / Solution 35 | 36 | ``` 37 | from xml.etree.ElementTree import XMLParser 38 | 39 | xml = input() 40 | 41 | class ColorWeights: # The target object of the parser 42 | depth = 0 43 | weights = {'red': 0, 'green': 0, 'blue': 0} 44 | 45 | def start(self, tag, attrib): # Called for each opening tag. 46 | self.depth += 1 47 | self.add_weight(attrib) 48 | 49 | def add_weight(self, attrib): 50 | self.weights[attrib['color']] += self.depth 51 | 52 | def end(self, tag): # Called for each closing tag. 53 | self.depth -= 1 54 | 55 | def data(self, data): 56 | pass # We do not need to do anything with data. 57 | 58 | def close(self): # Called when all data has been parsed. 59 | weights_list = [self.weights['red'], self.weights['green'], self.weights['blue']] 60 | return ' '.join(list(map(str, weights_list))) 61 | 62 | target = ColorWeights() 63 | parser = XMLParser(target=target) 64 | parser.feed(xml) 65 | print(parser.close()) 66 | ``` 67 | -------------------------------------------------------------------------------- /Python - основы и применение/3.4 Обзорно об интернете http-запросы, html-страницы и requests 6.md: -------------------------------------------------------------------------------- 1 | Рассмотрим два HTML-документа **A** и **B**. 2 | 3 | Из **A** можно перейти в **B** за один переход, если в **A** есть ссылка на **B**, т. е. внутри **A** есть тег ``, возможно с дополнительными параметрами внутри тега. 4 | Из **A** можно перейти в **B** за два перехода если существует такой документ **C**, что из **A** в **C** можно перейти за один переход и из **C** в **B** можно перейти за один переход. 5 | 6 | Вашей программе на вход подаются две строки, содержащие url двух документов **A** и **B**. 7 | Выведите **Yes**, если из **A** в **B** можно перейти за два перехода, иначе выведите **No**. 8 | 9 | Обратите внимание на то, что не все ссылки внутри HTML документа могут вести на существующие HTML документы. 10 | 11 | --- 12 | 13 | **Sample Input 1:** 14 | 15 | https://stepic.org/media/attachments/lesson/24472/sample0.html 16 | 17 | https://stepic.org/media/attachments/lesson/24472/sample2.html 18 | 19 | **Sample Output 1:** 20 | 21 | Yes 22 | 23 | --- 24 | 25 | **Sample Input 2:** 26 | 27 | https://stepic.org/media/attachments/lesson/24472/sample0.html 28 | 29 | https://stepic.org/media/attachments/lesson/24472/sample1.html 30 | 31 | 32 | **Sample Output 2:** 33 | 34 | No 35 | 36 | --- 37 | 38 | **Sample Input 3:** 39 | 40 | https://stepic.org/media/attachments/lesson/24472/sample1.html 41 | 42 | https://stepic.org/media/attachments/lesson/24472/sample2.html 43 | 44 | **Sample Output 3:** 45 | 46 | Yes 47 | 48 | --- 49 | 50 | # Solution / Решение 51 | 52 | ``` 53 | import re 54 | import urllib.request 55 | 56 | a = input() 57 | b = input() 58 | 59 | def get_links(url): 60 | try: 61 | fp = urllib.request.urlopen(url) 62 | mybytes = fp.read() 63 | mystr = mybytes.decode("utf8") 64 | fp.close() 65 | links = re.findall(r'<масть>, а на следующей строке указывается козырная масть. 11 | 12 | **Формат вывода**: 13 | 14 | Программа должна вывести слово **First**, если первая карта бьёт вторую, **Second**, если вторая карта бьёт первую, **Error**, если ни одна из карт не может побить другую. 15 | 16 | **Sample Input 1**: 17 | 18 | AH JH 19 | D 20 | 21 | **Sample Output 1**: 22 | 23 | First 24 | 25 | --- 26 | 27 | **Sample Input 2**: 28 | 29 | AH JS 30 | S 31 | 32 | **Sample Output 2**: 33 | 34 | Second 35 | 36 | --- 37 | 38 | **Sample Input 3**: 39 | 40 | 7C 10H 41 | S 42 | 43 | **Sample Output 3**: 44 | 45 | Error 46 | 47 | # Solution/Решение 48 | 49 | ``` 50 | c1, c2 = input().split() 51 | trump = input() 52 | suits = ('C', 'D', 'H', 'S') 53 | values = {'6': 1, 54 | '7': 2, 55 | '8': 3, 56 | '9': 4, 57 | '10': 5, 58 | 'J': 6, 59 | 'Q': 7, 60 | 'K': 8, 61 | 'A': 9} 62 | 63 | 64 | class Card: 65 | def __init__(self, c): 66 | self.suit = c[-1] 67 | self.value = values[c[:-1]] 68 | self.is_trump = self.suit == trump 69 | if self.is_trump: 70 | self.value += 10 71 | 72 | def __str__(self): 73 | return 'Value: {}, suit: {}, is trump: {}'.format(self.value, self.suit, self.is_trump) 74 | 75 | card1 = Card(c1) 76 | card2 = Card(c2) 77 | 78 | if card1.suit == card2.suit or any((card1.is_trump, card2.is_trump)): 79 | if card1.value > card2.value: 80 | print('First') 81 | else: 82 | print('Second') 83 | else: 84 | print('Error') 85 | ``` 86 | 87 | -------------------------------------------------------------------------------- /Python - основы и применение/1.5 Введение в классы 9.md: -------------------------------------------------------------------------------- 1 | Вам дается последовательность целых чисел и вам нужно ее обработать и вывести на экран сумму первой пятерки чисел из этой последовательности, затем сумму второй пятерки, и т. д. 2 | 3 | Но последовательность не дается вам сразу целиком. С течением времени к вам поступают её последовательные части. Например, сначала первые три элемента, потом следующие шесть, потом следующие два и т. д. 4 | 5 | Реализуйте класс **Buffer**, который будет накапливать в себе элементы последовательности и выводить сумму пятерок последовательных элементов по мере их накопления. 6 | 7 | Одним из требований к классу является то, что он не должен хранить в себе больше элементов, чем ему действительно необходимо, т. е. он не должен хранить элементы, которые уже вошли в пятерку, для которой была выведена сумма. 8 | 9 | Класс должен иметь следующий вид 10 | 11 | ``` 12 | class Buffer: 13 | def __init__(self): 14 | # конструктор без аргументов 15 |      16 | def add(self, *a): 17 | # добавить следующую часть последовательности 18 | 19 | def get_current_part(self): 20 | # вернуть сохраненные в текущий момент элементы последовательности в порядке, в котором они были 21 | # добавлены 22 | ``` 23 | 24 | Пример работы с классом 25 | 26 | ``` 27 | buf = Buffer() 28 | buf.add(1, 2, 3) 29 | buf.get_current_part() # вернуть [1, 2, 3] 30 | buf.add(4, 5, 6) # print(15) – вывод суммы первой пятерки элементов 31 | buf.get_current_part() # вернуть [6] 32 | buf.add(7, 8, 9, 10) # print(40) – вывод суммы второй пятерки элементов 33 | buf.get_current_part() # вернуть [] 34 | buf.add(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) # print(5), print(5) – вывод сумм третьей и четвертой пятерки 35 | buf.get_current_part() # вернуть [1] 36 | ``` 37 | 38 | Обратите внимание, что во время выполнения метода add выводить сумму пятерок может потребоваться несколько раз до тех пор, пока в буфере не останется менее пяти элементов. 39 | 40 | # Решение 41 | 42 | ``` 43 | class Buffer: 44 | 45 | def __init__(self): 46 | self.current_part = [] 47 | 48 | def add(self, *a): 49 | self.current_part.extend(a) 50 | while len(self.current_part) - 5 >= 0: 51 | print(sum(self.current_part[0:5])) 52 | self.current_part = self.current_part[5:] 53 | 54 | def get_current_part(self): 55 | return self.current_part 56 | ``` 57 | -------------------------------------------------------------------------------- /Адаптивный тренажёр Python/7.1 Minesweeper field.md: -------------------------------------------------------------------------------- 1 | Поле для игры сапёр представляет собой сетку размером *n×m* 2 | . В ячейке сетки может находиться или отсутствовать мина. 3 | 4 | Напишите программу, которая выводит "решённое" поле, т.е. для каждой ячейки, не являющейся миной, указывается число мин, находящихся в соседних ячейках (учитывая диагональные направления) 5 | 6 | **Формат ввода**: 7 | 8 | На первой строке указываются два натуральных числа *1≤n,m≤100* 9 | , после чего в *n* строках содержится описание поля в виде последовательности точек '.' и звёздочек '*', где точка означает пустую ячейку, а звёздочка − ячейку с миной. 10 | 11 | **Формат вывода**: 12 | 13 | *n* строк поля, в каждой ячейке которого будет либо число от 0 до 8, либо мина (обозначенная символом "*"), при этом число означает количество мин в соседних ячейках поля. 14 | 15 | --- 16 | 17 | **Sample Input**: 18 | 19 | ``` 20 | 4 4 21 | ..*. 22 | **.. 23 | ..*. 24 | .... 25 | ``` 26 | 27 | **Sample Output**: 28 | 29 | ``` 30 | 23*1 31 | **32 32 | 23*1 33 | 0111 34 | ``` 35 | 36 | # Solution/Решение 37 | 38 | 39 | ``` 40 | rows, columns = map(int, input().split()) 41 | 42 | 43 | class Field: 44 | def __init__(self): 45 | self.field = [] 46 | for x in range(rows): 47 | inp = input() 48 | field_row = [] 49 | for y in range(columns): 50 | cell = Cell(x, y, inp[y]) 51 | field_row.append(cell) 52 | self.field.append(field_row) 53 | self.render_mines() 54 | 55 | def render_mines(self): 56 | for x in range(rows): 57 | for y in range(columns): 58 | mines_around = 0 59 | cell_vicinity = self.field[x][y].vicinity 60 | for element in cell_vicinity: 61 | if self.field[element[0]][element[1]].status == '*': 62 | mines_around += 1 63 | if self.field[x][y].status == '.': 64 | self.field[x][y].status = str(mines_around) 65 | 66 | def __str__(self): 67 | res = '' 68 | for row in self.field: 69 | statuses = map(lambda x: x.status, row) 70 | res += ''.join(statuses) + '\n' 71 | return res.rstrip() 72 | 73 | 74 | class Cell: 75 | def __init__(self, x, y, status): 76 | self.x = x 77 | self.y = y 78 | self.status = status 79 | self.vicinity = [] 80 | self.mines_around = 0 81 | steps = range(-1, 2) 82 | for x in steps: 83 | for y in steps: 84 | if self.x + x >= 0 and self.x + x <= rows - 1: 85 | if self.y + y >= 0 and self.y + y <= columns - 1: 86 | self.vicinity.append((self.x + x, self.y + y)) 87 | self.vicinity.remove((self.x, self.y)) 88 | 89 | def __str__(self): 90 | return self.status 91 | 92 | 93 | field = Field() 94 | print(field) 95 | ``` 96 | -------------------------------------------------------------------------------- /Python - основы и применение/1.6 Наследование классов 7.md: -------------------------------------------------------------------------------- 1 | Вам дано описание наследования классов в следующем формате. 2 | 3 | **имя класса 1 : имя класса 2 имя класса 3 ... имя класса k** 4 | 5 | Это означает, что **класс 1** отнаследован от **класса 2**, **класса 3**, и т. д. 6 | 7 | Или эквивалентно записи: 8 | 9 | ``` 10 | class Class1(Class2, Class3 ... ClassK): 11 | pass 12 | ``` 13 | 14 | Класс **A** является **прямым предком** класса **B**, если **B** отнаследован от **A**: 15 | 16 | ``` 17 | class B(A): 18 | pass 19 | ``` 20 | 21 | Класс **A** является **предком** класса **B**, если 22 | 23 | - **A = B** 24 | - **A** - прямой предок **B** 25 | - существует такой класс **C**, что **C** - прямой предок **B** и **A** - предок **C** 26 | 27 | Например: 28 | 29 | ``` 30 | class B(A): 31 | pass 32 | 33 | class C(B): 34 | pass 35 | 36 | # A -- предок С 37 | ``` 38 | 39 | Вам необходимо отвечать на запросы, является ли один класс предком другого класса 40 | 41 | **Важное примечание**: 42 | 43 | Создавать классы не требуется. 44 | 45 | Мы просим вас промоделировать этот процесс, и понять существует ли путь от одного класса до другого. 46 | 47 | **Формат входных данных** 48 | 49 | В первой строке входных данных содержится целое число **n** - число классов. 50 | 51 | В следующих **n** строках содержится описание наследования классов. В **i**-й строке указано от каких классов наследуется **i**-й класс. Обратите внимание, что класс может ни от кого не наследоваться. Гарантируется, что класс не наследуется сам от себя (прямо или косвенно), что класс не наследуется явно от одного класса более одного раза. 52 | 53 | В следующей строке содержится число **q** - количество запросов. 54 | 55 | В следующих **q** строках содержится описание запросов в формате **имя класса 1 имя класса 2**. 56 | 57 | Имя класса – строка, состоящая из символов латинского алфавита, длины не более 50. 58 | 59 | **Формат выходных данных** 60 | 61 | Для каждого запроса выведите в отдельной строке слово "**Yes**", если **класс 1** является предком **класса 2**, и "**No**", если не является. 62 | 63 | --- 64 | 65 | ** Sample Input**: 66 | 67 | ``` 68 | 4 69 | A 70 | B : A 71 | C : A 72 | D : B C 73 | 4 74 | A B 75 | B D 76 | C D 77 | D A 78 | ``` 79 | 80 | **Sample Output**: 81 | 82 | ``` 83 | Yes 84 | Yes 85 | Yes 86 | No 87 | ``` 88 | 89 | # Решение 90 | 91 | ``` 92 | classes = {} 93 | 94 | def add_class(classes, class_name, parents): 95 | if class_name not in classes: 96 | classes[class_name] = [] 97 | classes[class_name].extend(parents) 98 | for parent in parents: 99 | if parent not in classes: 100 | classes[parent] = [] 101 | 102 | def found_path(classes, start, end, path=[]): 103 | path = path + [start] 104 | if start == end: 105 | return path 106 | if start not in classes: 107 | return None 108 | for node in classes[start]: 109 | if node not in path: 110 | newpath = found_path(classes, node, end, path) 111 | if newpath: return newpath 112 | return None 113 | 114 | def answer(classes, parent, child): 115 | if not(parent or child) in classes or not found_path(classes, child, parent): 116 | return 'No' 117 | return 'Yes' 118 | 119 | n = int(input()) 120 | for _ in range(n): 121 | class_description = input().split() 122 | class_name = class_description[0] 123 | class_parents = class_description[2:] 124 | add_class(classes, class_name, class_parents) 125 | 126 | q = int(input()) 127 | for _ in range(q): 128 | question = input().split() 129 | parent = question[0] 130 | child = question[1] 131 | print(answer(classes, parent, child)) 132 | ``` 133 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/ask/settings.py: -------------------------------------------------------------------------------- 1 | """ 2 | Django settings for ask project. 3 | 4 | Generated by 'django-admin startproject' using Django 1.10.4. 5 | 6 | For more information on this file, see 7 | https://docs.djangoproject.com/en/1.10/topics/settings/ 8 | 9 | For the full list of settings and their values, see 10 | https://docs.djangoproject.com/en/1.10/ref/settings/ 11 | """ 12 | 13 | import os 14 | 15 | # Build paths inside the project like this: os.path.join(BASE_DIR, ...) 16 | BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) 17 | 18 | # Quick-start development settings - unsuitable for production 19 | # See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/ 20 | 21 | # SECURITY WARNING: keep the secret key used in production secret! 22 | SECRET_KEY = 'tgtwjqxrt0%o@d0uxj-=c$e&4sph2pzjt09ndxguecga_dsfnk' 23 | 24 | # SECURITY WARNING: don't run with debug turned on in production! 25 | DEBUG = True 26 | 27 | ALLOWED_HOSTS = ['*'] 28 | 29 | 30 | # Application definition 31 | 32 | INSTALLED_APPS = [ 33 | 'django.contrib.admin', 34 | 'django.contrib.auth', 35 | 'django.contrib.contenttypes', 36 | 'django.contrib.sessions', 37 | 'django.contrib.messages', 38 | 'django.contrib.staticfiles', 39 | 'qa' 40 | ] 41 | 42 | MIDDLEWARE = [ 43 | 'django.middleware.security.SecurityMiddleware', 44 | 'django.contrib.sessions.middleware.SessionMiddleware', 45 | 'django.middleware.common.CommonMiddleware', 46 | 'django.middleware.csrf.CsrfViewMiddleware', 47 | 'django.contrib.auth.middleware.AuthenticationMiddleware', 48 | 'django.contrib.messages.middleware.MessageMiddleware', 49 | 'django.middleware.clickjacking.XFrameOptionsMiddleware', 50 | ] 51 | 52 | ROOT_URLCONF = 'ask.urls' 53 | 54 | TEMPLATES = [ 55 | { 56 | 'BACKEND': 'django.template.backends.django.DjangoTemplates', 57 | 'DIRS': [], 58 | 'APP_DIRS': True, 59 | 'OPTIONS': { 60 | 'context_processors': [ 61 | 'django.template.context_processors.debug', 62 | 'django.template.context_processors.request', 63 | 'django.contrib.auth.context_processors.auth', 64 | 'django.contrib.messages.context_processors.messages', 65 | ], 66 | }, 67 | }, 68 | ] 69 | 70 | TEMPLATE_DIRS = (os.path.join(BASE_DIR, 'templates'), ) 71 | 72 | WSGI_APPLICATION = 'ask.wsgi.application' 73 | 74 | 75 | # Database 76 | # https://docs.djangoproject.com/en/1.10/ref/settings/#databases 77 | 78 | DATABASES = { 79 | 'default': { 80 | 'ENGINE': 'django.db.backends.mysql', 81 | 'NAME': 'ask', 82 | 'USER': 'root', 83 | 'PASSWORD': '', 84 | 'HOST': 'localhost', 85 | 'PORT': '3306', 86 | } 87 | } 88 | 89 | # Password validation 90 | # https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators 91 | 92 | AUTH_PASSWORD_VALIDATORS = [ 93 | { 94 | 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', 95 | }, 96 | { 97 | 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', 98 | }, 99 | { 100 | 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', 101 | }, 102 | { 103 | 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', 104 | }, 105 | ] 106 | 107 | 108 | # Internationalization 109 | # https://docs.djangoproject.com/en/1.10/topics/i18n/ 110 | 111 | LANGUAGE_CODE = 'en-us' 112 | 113 | TIME_ZONE = 'UTC' 114 | 115 | USE_I18N = True 116 | 117 | USE_L10N = True 118 | 119 | USE_TZ = True 120 | 121 | 122 | # Static files (CSS, JavaScript, Images) 123 | # https://docs.djangoproject.com/en/1.10/howto/static-files/ 124 | 125 | STATIC_URL = '/static/' 126 | -------------------------------------------------------------------------------- /Python - основы и применение/3.6 API 4.md: -------------------------------------------------------------------------------- 1 | В этой задаче вам необходимо воспользоваться API сайта artsy.net 2 | 3 | API проекта Artsy предоставляет информацию о некоторых деятелях искусства, их работах, выставках. 4 | 5 | В рамках данной задачи вам понадобятся сведения о деятелях искусства (назовем их, условно, художники). 6 | 7 | Вам даны идентификаторы художников в базе Artsy. 8 | Для каждого идентификатора получите информацию о имени художника и годе рождения. 9 | Выведите имена художников в порядке неубывания года рождения. В случае если у художников одинаковый год рождения, выведите их имена в лексикографическом порядке. 10 | 11 | **Работа с API Artsy** 12 | 13 | Полностью открытое и свободное API предоставляют совсем немногие проекты. В большинстве случаев, для получения доступа к API необходимо зарегистрироваться в проекте, создать свое приложение, и получить уникальный ключ (или токен), и в дальнейшем все запросы к API осуществляются при помощи этого ключа. 14 | 15 | Чтобы начать работу с API проекта Artsy, вам необходимо пройти на стартовую страницу документации к API https://developers.artsy.net/start и выполнить необходимые шаги, а именно зарегистрироваться, создать приложение, и получить пару идентификаторов **Client Id** и **Client Secret**. Не публикуйте эти идентификаторы. 16 | 17 | После этого необходимо получить токен доступа к API. На стартовой странице документации есть примеры того, как можно выполнить запрос и как выглядит ответ сервера. Мы приведем пример запроса на Python. 18 | 19 | ``` 20 | import requests 21 | import json 22 | 23 | client_id = '...' 24 | client_secret = '...' 25 | 26 | # инициируем запрос на получение токена 27 | r = requests.post("https://api.artsy.net/api/tokens/xapp_token", 28 | data={ 29 | "client_id": client_id, 30 | "client_secret": client_secret 31 | }) 32 | 33 | # разбираем ответ сервера 34 | j = json.loads(r.text) 35 | 36 | # достаем токен 37 | token = j["token"] 38 | ``` 39 | 40 | Теперь все готово для получения информации о художниках. На стартовой странице документации есть пример того, как осуществляется запрос и как выглядит ответ сервера. Пример запроса на Python. 41 | 42 | ``` 43 | # создаем заголовок, содержащий наш токен 44 | headers = {"X-Xapp-Token" : token} 45 | 46 | # инициируем запрос с заголовком 47 | r = requests.get("https://api.artsy.net/api/artists/4d8b92b34eb68a1b2c0003f4", headers=headers) 48 | 49 | # разбираем ответ сервера 50 | j = json.loads(r.text) 51 | ``` 52 | 53 | Примечание: 54 | В качестве имени художника используется параметр sortable_name в кодировке UTF-8. 55 | 56 | Пример входных данных: 57 | 4d8b92b34eb68a1b2c0003f4 58 | 537def3c139b21353f0006a6 59 | 4e2ed576477cc70001006f99 60 | 61 | Пример выходных данных: 62 | Abbott Mary 63 | Warhol Andy 64 | Abbas Hamra 65 | 66 | 67 | # Solution / Решение 68 | 69 | ``` 70 | import requests 71 | import json 72 | 73 | client_id = 'db311cfe37ec4bc74a61' 74 | client_secret = 'ba1d22427d386b0b79ce4403c063b2ec' 75 | 76 | r = requests.post("https://api.artsy.net/api/tokens/xapp_token", 77 | data={ 78 | "client_id": client_id, 79 | "client_secret": client_secret 80 | }) 81 | j = json.loads(r.text) 82 | token = j["token"] 83 | 84 | artists = [] 85 | 86 | with open('dataset_24476_4.txt') as file: 87 | for artist_id in file: 88 | artist_id = artist_id.strip() 89 | url = 'https://api.artsy.net/api/artists/{}'.format(artist_id) 90 | params = {'xapp_token': token} 91 | resp = requests.get(url, params=params).text 92 | data = json.loads(resp) 93 | artists.append({'name': data['sortable_name'], 'birthday': data['birthday']}) 94 | 95 | for artist in sorted(artists, key=lambda x: (x['birthday'], x['name'])): 96 | print(artist['name']) 97 | ``` 98 | -------------------------------------------------------------------------------- /Python - основы и применение/2.1 Ошибки и исключения 7.md: -------------------------------------------------------------------------------- 1 | Вам дано описание наследования классов исключений в следующем формате. 2 | 3 | **имя исключения 1 : имя исключения 2 имя исключения 3 ... имя исключения k** 4 | 5 | Это означает, что **исключение 1** наследуется от **исключения 2**, **исключения 3**, и т. д. 6 | 7 | Или эквивалентно записи: 8 | 9 | ``` 10 | class Error1(Error2, Error3 ... ErrorK): 11 | pass 12 | ``` 13 | 14 | Антон написал код, который выглядит следующим образом. 15 | 16 | ``` 17 | try: 18 | foo() 19 | except <имя 1>: 20 | print("<имя 1>") 21 | except <имя 2>: 22 | print("<имя 2>") 23 | ... 24 | ``` 25 | 26 | Костя посмотрел на этот код и указал Антону на то, что некоторые исключения можно не ловить, так как ранее в коде будет пойман их предок. Но Антон не помнит какие исключения наследуются от каких. Помогите ему выйти из неловкого положения и напишите программу, которая будет определять обработку каких исключений можно удалить из кода. 27 | 28 | **Важное примечание**: 29 | 30 | В отличие от предыдущей задачи, типы исключений не созданы. 31 | 32 | Создавать классы исключений также не требуется 33 | 34 | Мы просим вас промоделировать этот процесс, и понять какие из исключений можно и не ловить, потому что мы уже ранее где-то поймали их предка. 35 | 36 | **Формат входных данных** 37 | 38 | В первой строке входных данных содержится целое число **n** - число классов исключений. 39 | 40 | В следующих **n** строках содержится описание наследования классов. В **i**-й строке указано от каких классов наследуется **i**-й класс. Обратите внимание, что класс может ни от кого не наследоваться. Гарантируется, что класс не наследуется сам от себя (прямо или косвенно), что класс не наследуется явно от одного класса более одного раза. 41 | 42 | В следующей строке содержится число **m** - количество обрабатываемых исключений. Следующие **m** строк содержат имена исключений в том порядке, в каком они были написаны у Антона в коде. Гарантируется, что никакое исключение не обрабатывается дважды. 43 | 44 | **Формат выходных данных** 45 | 46 | Выведите в отдельной строке имя каждого исключения, обработку которого можно удалить из кода, не изменив при этом поведение программы. Имена следует выводить в том же порядке, в котором они идут во входных данных. 47 | 48 | **Пример теста 1** 49 | 50 | Рассмотрим код 51 | 52 | ``` 53 | try: 54 | foo() 55 | except ZeroDivision : 56 | print("ZeroDivision") 57 | except OSError: 58 | print("OSError") 59 | except ArithmeticError: 60 | print("ArithmeticError") 61 | except FileNotFoundError: 62 | print("FileNotFoundError") 63 | ... 64 | ``` 65 | 66 | По условию этого теста, Костя посмотрел на этот код, и сказал Антону, что исключение **FileNotFoundError** можно не ловить, ведь мы уже ловим **OSError** -- предок **FileNotFoundError** 67 | 68 | ``` 69 | Sample Input: 70 | 4 71 | ArithmeticError 72 | ZeroDivisionError : ArithmeticError 73 | OSError 74 | FileNotFoundError : OSError 75 | 4 76 | ZeroDivisionError 77 | OSError 78 | ArithmeticError 79 | FileNotFoundError 80 | Sample Output: 81 | FileNotFoundError 82 | ``` 83 | 84 | # Решение 85 | 86 | ``` 87 | exceptions = {} 88 | throwed_exceptions = [] 89 | 90 | def found_path(exceptions, start, end, path=[]): 91 | path = path + [start] 92 | if start == end: 93 | return path 94 | if start not in exceptions: 95 | return [] 96 | for node in exceptions[start]: 97 | if node not in path: 98 | newpath = found_path(exceptions, node, end, path) 99 | if newpath: return newpath 100 | return [] 101 | 102 | n = int(input()) 103 | for _ in range(n): 104 | inpt = input().split() 105 | child = inpt[0] 106 | parents = inpt[2:] 107 | exceptions[child] = parents 108 | 109 | m = int(input()) 110 | for _ in range(m): 111 | throwing = input() 112 | for throwed_exception in throwed_exceptions: 113 | if len(found_path(exceptions, throwing, throwed_exception)) > 1: 114 | print(throwing) 115 | break 116 | throwed_exceptions.append(throwing) 117 | ``` 118 | -------------------------------------------------------------------------------- /Адаптивный тренажёр Python/5.20 Game of life.md: -------------------------------------------------------------------------------- 1 | # 5.20 Game of life 2 | 3 | Напишите программу, вычисляющую следующее состояние поля для Game of life. 4 | 5 | Поле представляет собой прямоугольник, причём для крайних клеток поля соседними являются клетки с противоположного конца (поле представляет собой тор). 6 | 7 | **Формат ввода**: 8 | 9 | На первой строке указаны два целых числа через пробел -- высота и ширина поля. В следующих строках подаётся состояние поля. Точка "." обозначает мёртвую клетку, символ "X" − живую. 10 | 11 | **Формат вывода**: 12 | 13 | Следующее состояние поля, используя те же обозначения, что использовались на вводе. 14 | 15 | **Sample Input 1**: 16 | 17 | ``` 18 | 5 5 19 | ..... 20 | ..X.. 21 | ...X. 22 | .XXX. 23 | ..... 24 | ``` 25 | 26 | **Sample Output 1**: 27 | 28 | ``` 29 | ..... 30 | ..... 31 | .X.X. 32 | ..XX. 33 | ..X.. 34 | ``` 35 | 36 | **Sample Input 2**: 37 | 38 | ``` 39 | 5 5 40 | ..... 41 | ..... 42 | .XXX. 43 | ..... 44 | ..... 45 | ``` 46 | 47 | **Sample Output 2**: 48 | 49 | ``` 50 | ..... 51 | ..X.. 52 | ..X.. 53 | ..X.. 54 | ..... 55 | ``` 56 | 57 | **Sample Input 3**: 58 | 59 | ``` 60 | 5 6 61 | ...XX. 62 | .XX... 63 | ..X... 64 | XX.... 65 | X..XX. 66 | ``` 67 | 68 | **Sample Output 3**: 69 | 70 | ``` 71 | .X..XX 72 | .XX... 73 | X.X... 74 | XXXX.X 75 | XXXXX. 76 | ``` 77 | 78 | # Решение/Solution 79 | 80 | ``` 81 | rows, columns = map(int, input().split()) 82 | inp = [] 83 | for row in range(rows): 84 | inp.append(input()) 85 | 86 | 87 | class Universe: 88 | def __init__(self, inp): 89 | self.inp = inp 90 | self.make_universe() 91 | 92 | def make_universe(self): 93 | self.universe = [] 94 | for x in range(rows): 95 | universe_row = [] 96 | for y in range(columns): 97 | cell = Cell(x, y, self.inp[x][y]) 98 | universe_row.append(cell) 99 | self.universe.append(universe_row) 100 | 101 | def make_future_universe(self): 102 | self.future_universe = [] 103 | for x in range(rows): 104 | universe_row = [] 105 | for y in range(columns): 106 | cell = Cell(x, y, '.') 107 | universe_row.append(cell) 108 | self.future_universe.append(universe_row) 109 | 110 | def make_turn(self): 111 | self.make_future_universe() 112 | for x in range(rows): 113 | for y in range(columns): 114 | cell = self.universe[x][y] 115 | future_cell = self.future_universe[x][y] 116 | if cell.status == '.': 117 | if cell.count_neighbours() == 3: 118 | future_cell.status = 'X' 119 | else: future_cell.status = '.' 120 | else: 121 | if cell.count_neighbours() < 2 or cell.count_neighbours() > 3: 122 | future_cell.status = '.' 123 | else: future_cell.status = 'X' 124 | 125 | def print_future_universe(self): 126 | for row in self.future_universe: 127 | for cell in row: 128 | print(cell, end='') 129 | print() 130 | 131 | 132 | class Cell: 133 | def __init__(self, x, y, status): 134 | self.position = x, y 135 | self.status = status 136 | 137 | def get_vicinity(self): 138 | self.vicinity_coordinates = [] 139 | increments = [-1, 0, 1] 140 | for x in increments: 141 | for y in increments: 142 | self.vicinity_coordinates.append(((self.position[0] + x) % rows, (self.position[1] + y) % columns)) 143 | self.vicinity_coordinates.remove(self.position) 144 | return self.vicinity_coordinates 145 | 146 | def count_neighbours(self): 147 | self.get_vicinity() 148 | self.num_neighbours = 0 149 | for (x, y) in self.vicinity_coordinates: 150 | if inp[x][y] == 'X': 151 | self.num_neighbours += 1 152 | return self.num_neighbours 153 | 154 | def __str__(self): 155 | return self.status 156 | 157 | u = Universe(inp) 158 | u.make_turn() 159 | u.print_future_universe() 160 | ``` 161 | -------------------------------------------------------------------------------- /Веб-технологии/web/ask/qa/views.py: -------------------------------------------------------------------------------- 1 | from django.http import HttpResponse, HttpResponseRedirect 2 | from django.core.urlresolvers import reverse 3 | from django.shortcuts import render, get_object_or_404 4 | from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger 5 | from .models import Question, Answer 6 | from .forms import AskForm, AnswerForm, SignupForm, LoginForm 7 | 8 | from django.contrib.auth.models import User 9 | 10 | from django.contrib.auth import authenticate, logout 11 | from django.contrib.auth import login as log_in 12 | 13 | import string 14 | import random 15 | 16 | 17 | def random_user(): 18 | while True: 19 | for i in range(10): 20 | name += random.choice(string.ascii_letters) 21 | try: 22 | User.objects.get(username=name) 23 | except User.DoesNotExist: 24 | user = User.objects.create_user( 25 | username=name, email='hi@there.com', password='666') 26 | break 27 | return user 28 | 29 | 30 | def test(request, *args, **kwargs): 31 | return HttpResponse('OK') 32 | 33 | 34 | def login(request): 35 | if request.method == 'POST': 36 | form = LoginForm(request.POST) 37 | if form.is_valid(): 38 | user = form.save() 39 | if user is not None: 40 | log_in(request, user) 41 | return HttpResponseRedirect(reverse('new')) 42 | form = LoginForm() 43 | return render(request, 'login.html', {'form': form}) 44 | 45 | 46 | def signup(request): 47 | if request.method == 'POST': 48 | form = SignupForm(request.POST) 49 | if form.is_valid(): 50 | user = form.save(commit=False) 51 | username = user.username 52 | email = user.email 53 | password = user.password 54 | new_user = User.objects.create_user(username, email, password) 55 | new_user.save() 56 | new_user = authenticate(username=username, password=password) 57 | log_in(request, new_user) 58 | return HttpResponseRedirect(reverse('new')) 59 | else: 60 | form = SignupForm() 61 | return render(request, 'signup.html', {'form': form}) 62 | 63 | 64 | def ask(request): 65 | 66 | if request.method == 'POST': 67 | form = AskForm(request.POST) 68 | if form.is_valid(): 69 | question = form.save(commit=False) 70 | try: 71 | question.author = request.user 72 | except ValueError: 73 | question.author = random_user() 74 | question.save() 75 | return HttpResponseRedirect(reverse('question', kwargs={'question_pk': question.pk})) 76 | else: 77 | form = AskForm() 78 | return render(request, 'ask.html', {'form': form}) 79 | 80 | 81 | def question(request, question_pk): 82 | q = get_object_or_404(Question, pk=question_pk) 83 | answers = Answer.objects.filter(question=q) 84 | 85 | if request.method == 'POST': 86 | form = AnswerForm(request.POST) 87 | if form.is_valid(): 88 | answer = form.save(commit=False) 89 | answer.author = request.user 90 | answer.question = q 91 | answer.save() 92 | return HttpResponseRedirect(request.META.get('HTTP_REFERER')) 93 | else: 94 | form = AnswerForm(initial={'question': q}) 95 | 96 | return render(request, 'question.html', {'question': q, 'answers': answers, 'form': form}) 97 | 98 | 99 | def popular(request): 100 | questions = Question.objects.popular() 101 | paginator = Paginator(questions, 10) 102 | paginator.baseurl = '/popular/?page=' 103 | page_num = request.GET.get('page') 104 | try: 105 | questions = paginator.page(page_num) 106 | except PageNotAnInteger: 107 | questions = paginator.page(1) 108 | except EmptyPage: 109 | questions = paginator.page(paginator.num_pages) 110 | 111 | return render(request, 'popular.html', {'questions': questions, 'paginator': paginator}) 112 | 113 | 114 | def new(request): 115 | questions = Question.objects.new() 116 | paginator = Paginator(questions, 10) 117 | paginator.baseurl = '/?page=' 118 | page_num = request.GET.get('page') 119 | try: 120 | questions = paginator.page(page_num) 121 | except PageNotAnInteger: 122 | questions = paginator.page(1) 123 | except EmptyPage: 124 | questions = paginator.page(paginator.num_pages) 125 | 126 | return render(request, 'index.html', {'questions': questions, 'paginator': paginator}) 127 | -------------------------------------------------------------------------------- /Адаптивный тренажёр Python/9.2 Poker hand.md: -------------------------------------------------------------------------------- 1 | A poker deck contains 52 cards. Each card has a suit of either clubs, diamonds, hearts, or spades (denoted C, D, H, S). Each card also has a value of either 2 through 10, jack, queen, king, or ace (denoted 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A). For scoring purposes card values are ordered as above, with 2 having the lowest and ace the highest value. The suit has no impact on value. 2 | 3 | A poker hand consists of five cards. Poker hands are ranked by the following partial order from lowest to highest. 4 | 5 | 6 | *High Card* 7 | 8 | Hands which do not fit any higher category are ranked by the value of their highest card. 9 | 10 | *Pair* 11 | 12 | Two of the five cards in the hand have the same value. 13 | 14 | *Two Pairs* 15 | 16 | The hand contains two different pairs. 17 | 18 | *Three of a Kind* 19 | 20 | Three of the cards in the hand have the same value. 21 | 22 | *Straight* 23 | 24 | Hand contains five cards with consecutive values. 25 | 26 | *Flush* 27 | 28 | Hand contains five cards of the same suit. 29 | 30 | *Full House* 31 | 32 | Three cards of the same value, with the remaining two cards forming a pair. 33 | 34 | *Four of a Kind* 35 | 36 | Four cards with the same value. 37 | 38 | *Straight Flush* 39 | 40 | Five cards of the same suit in numerical order. 41 | 42 | *Royal Flush* 43 | 44 | Consists of the ace, king, queen, jack and ten of a suit. 45 | 46 | 47 | Напишите программу, которая получает на вход пять карт и выводит старшую покерную комбинацию, которая образуется этими картами. 48 | 49 | **Формат ввода**: 50 | 51 | Одна строка, на которой указаны пять карт в формате , записанные через пробел. 52 | 53 | **Формат вывода**: 54 | 55 | Название старшей комбинации, сформировавшейся на пришедшем наборе. 56 | 57 | --- 58 | 59 | **Sample Input**: 60 | 61 | 10C JC QC KC AC 62 | 63 | **Sample Output**: 64 | 65 | Royal Flush 66 | 67 | --- 68 | 69 | # Решение / Solution 70 | 71 | ``` 72 | from collections import Counter, OrderedDict 73 | 74 | 75 | class Hand: 76 | def __init__(self, cards): 77 | self.cards = cards 78 | self.values = [x.value for x in self.cards] 79 | self.suits = [x.suit for x in self.cards] 80 | self.true_values = sorted([x.true_value for x in self.cards]) 81 | self.counter = Counter(self.values) 82 | self.value_amounts = self.counter.values() 83 | 84 | def pair(self): 85 | return max(self.value_amounts) == 2 86 | 87 | def two_pairs(self): 88 | return list(self.value_amounts).count(2) == 2 89 | 90 | def three_of_a_kind(self): 91 | return max(self.value_amounts) == 3 92 | 93 | def straight(self): 94 | first_value = self.true_values[0] 95 | return self.true_values == list(range(first_value, first_value + 5)) 96 | 97 | def flush(self): 98 | return len(set(self.suits)) == 1 99 | 100 | def full_house(self): 101 | return 3 in self.value_amounts and 2 in self.value_amounts 102 | 103 | def four_of_a_kind(self): 104 | return max(self.value_amounts) == 4 105 | 106 | def straight_flush(self): 107 | return self.straight() and len(set(self.suits)) == 1 108 | 109 | def royal_flush(self): 110 | return self.true_values == list(range(10, 15)) and len(set(self.suits)) == 1 111 | 112 | def __str__(self): 113 | hand = OrderedDict() 114 | hand['Royal Flush'] = self.royal_flush() 115 | hand['Straight Flush'] = self.straight_flush() 116 | hand['Four of a Kind'] = self.four_of_a_kind() 117 | hand['Full House'] = self.full_house() 118 | hand['Flush'] = self.flush() 119 | hand['Straight'] = self.straight() 120 | hand['Three of a Kind'] = self.three_of_a_kind() 121 | hand['Two Pairs'] = self.two_pairs() 122 | hand['Pair'] = self.pair() 123 | 124 | for k, fn in hand.items(): 125 | if fn: 126 | return k 127 | return 'High Card' 128 | 129 | 130 | class Card: 131 | def __init__(self, c): 132 | self.value = c[:-1] 133 | self.suit = c[-1] 134 | self.get_true_value() 135 | 136 | def get_true_value(self): 137 | elders = {'J': 11, 'Q': 12, 'K': 13, 'A': 14} 138 | self.true_value = 0 139 | try: 140 | self.true_value = int(self.value) 141 | except ValueError: 142 | self.true_value = elders[self.value] 143 | 144 | 145 | inp = input().split() 146 | cards = [] 147 | 148 | for c in inp: 149 | card = Card(c) 150 | cards.append(card) 151 | 152 | hand = Hand(cards) 153 | print(hand) 154 | ``` 155 | -------------------------------------------------------------------------------- /Python - основы и применение/2.3 Итераторы и генераторы 4.md: -------------------------------------------------------------------------------- 1 | Одним из самых часто используемых классов в Python является класс **filter**. Он принимает в конструкторе два аргумента **a** и **f** – последовательность и функцию, и позволяет проитерироваться только по таким элементам **x** из последовательности **a**, что **f(x)** равно **True**. Будем говорить, что в этом случае функция **f** допускает элемент **x**, а элемент **x** является допущенным. 2 | 3 | В данной задаче мы просим вас реализовать класс **multifilter**, который будет выполнять ту же функцию, что и стандартный класс **filter**, но будет использовать не одну функцию, а несколько. 4 | 5 | Решение о допуске элемента будет приниматься на основании того, сколько функций допускают этот элемент, и сколько не допускают. Обозначим эти количества за **pos** и **neg**. 6 | 7 | Введем понятие решающей функции – это функция, которая принимает два аргумента – количества **pos** и **neg**, и возвращает **True**, если элемент допущен, и **False** иначе. 8 | 9 | Рассмотрим процесс допуска подробнее на следующем примере. 10 | 11 | ``` 12 | a = [1, 2, 3] 13 | f2(x) = x % 2 == 0 # возвращает True, если x делится на 2 14 | f3(x) = x % 3 == 0 15 | judge_any(pos, neg) = pos >= 1 # возвращает True, если хотя бы одна функция допускает элемент 16 | ``` 17 | 18 | В этом примере мы хотим отфильтровать последовательность a и оставить только те элементы, которые делятся на два или на три. 19 | 20 | Функция **f2** допускает только элементы, делящиеся на два, а функция **f3** допускает только элементы, делящиеся на три. Решающая функция допускает элемент в случае, если он был допущен хотя бы одной из функций **f2** или **f3**, то есть элементы, которые делятся на два или на три. 21 | 22 | Возьмем первый элемент **x = 1**. 23 | 24 | **f2(x)** равно **False**, т. е. функция **f2** не допускает элемент **x**. 25 | 26 | **f3(x)** также равно **False**, т. е. функция **f3** также не допускает элемент **x**. 27 | 28 | В этом случае **pos = 0**, так как ни одна функция не допускает **x**, и соответственно **neg = 2**. 29 | 30 | **judge_any(0, 2)** равно **False**, значит мы не допускаем элемент **x = 1**. 31 | 32 | Возьмем второй элемент **x = 2**. 33 | 34 | **f2(x)** равно **True** 35 | 36 | **f3(x)** равно **False** 37 | 38 | **pos = 1, neg = 1** 39 | 40 | **judge_any(1, 1)** равно **True**, значит мы допускаем элемент **x = 2**. 41 | 42 | 43 | Аналогично для третьего элемента **x = 3**. 44 | 45 | Таким образом, получили последовательность допущенных элементов **[2, 3]**. 46 | 47 | Класс должен обладать следующей структурой: 48 | 49 | ``` 50 | class multifilter: 51 | def judge_half(pos, neg): 52 | # допускает элемент, если его допускает хотя бы половина фукнций (pos >= neg) 53 | 54 | def judge_any(pos, neg): 55 | # допускает элемент, если его допускает хотя бы одна функция (pos >= 1) 56 | 57 | def judge_all(pos, neg): 58 | # допускает элемент, если его допускают все функции (neg == 0) 59 | 60 | def __init__(self, iterable, *funcs, judge=judge_any): 61 | # iterable - исходная последовательность 62 | # funcs - допускающие функции 63 | # judge - решающая функция 64 | 65 | def __iter__(self): 66 | # возвращает итератор по результирующей последовательности 67 | ``` 68 | 69 | **Пример использования**: 70 |  71 | ``` 72 | def mul2(x): 73 | return x % 2 == 0 74 | 75 | def mul3(x): 76 | return x % 3 == 0 77 | 78 | def mul5(x): 79 | return x % 5 == 0 80 | 81 | a = [i for i in range(31)] # [0, 1, 2, ... , 30] 82 | 83 | print(list(multifilter(a, mul2, mul3, mul5))) 84 | # [0, 2, 3, 4, 5, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30] 85 | 86 | print(list(multifilter(a, mul2, mul3, mul5, judge=multifilter.judge_half))) 87 | # [0, 6, 10, 12, 15, 18, 20, 24, 30] 88 | 89 | print(list(multifilter(a, mul2, mul3, mul5, judge=multifilter.judge_all))) 90 | # [0, 30] 91 | ``` 92 | 93 | # Solution/Решение 94 | 95 | ``` 96 | def mul2(x): 97 | return x % 2 == 0 98 | 99 | def mul3(x): 100 | return x % 3 == 0 101 | 102 | def mul5(x): 103 | return x % 5 == 0 104 | 105 | 106 | a = [i for i in range(31)] # [0, 1, 2, ... , 30] 107 | 108 | class multifilter: 109 | 110 | def judge_half(pos, neg): 111 | # допускает элемент, если его допускает хотя бы половина функций (pos >= neg) 112 | return pos >= neg 113 | 114 | def judge_any(pos, neg): 115 | # допускает элемент, если его допускает хотя бы одна функция (pos >= 1) 116 | return pos >= 1 117 | 118 | def judge_all(pos, neg): 119 | # допускает элемент, если его допускают все функции (neg == 0) 120 | return neg == 0 121 | 122 | def __init__(self, iterable, *funcs, judge=judge_any): 123 | # iterable - исходная последовательность 124 | # funcs - допускающие функции 125 | # judge - решающая функция 126 | self.iterable = iterable 127 | self.funcs = funcs 128 | self.judge = judge 129 | 130 | def __iter__(self): 131 | # возвращает итератор по результирующей последовательности 132 | for element in self.iterable: 133 | pos = 0 134 | neg = 0 135 | for func in self.funcs: 136 | if func(element): 137 | pos += 1 138 | else: 139 | neg += 1 140 | if self.judge(pos, neg): 141 | yield element 142 | ``` 143 | 144 | -------------------------------------------------------------------------------- /Python - основы и применение/1.4 Пространства имён и область видимости 9.md: -------------------------------------------------------------------------------- 1 | Реализуйте программу, которая будет эмулировать работу с пространствами имен. Необходимо реализовать поддержку создания пространств имен и добавление в них переменных. 2 | 3 | В данной задаче у каждого пространства имен есть уникальный текстовый идентификатор – его имя. 4 | 5 | Вашей программе на вход подаются следующие запросы: 6 | 7 | - **create namespace parent** – создать новое пространство имен с именем **namespace** внутри пространства **parent** 8 | - **add namespace var** – добавить в пространство **namespace** переменную **var** 9 | - **get namespace var** – получить имя пространства, из которого будет взята переменная **var** при запросе из пространства **namespace**, или **None**, если такого пространства не существует 10 | 11 | Рассмотрим набор запросов 12 | 13 | - **add global a** 14 | - **create foo global** 15 | - **add foo b** 16 | - **create bar foo** 17 | - **add bar a** 18 | 19 | Структура пространств имен описанная данными запросами будет эквивалентна структуре пространств имен, созданной при выполнении данного кода 20 | 21 | ``` 22 | a = 0 23 | def foo(): 24 | b = 1 25 | def bar(): 26 | a = 2 27 | ``` 28 | 29 | В основном теле программы мы объявляем переменную **a**, тем самым добавляя ее в пространство **global**. Далее мы объявляем функцию **foo**, что влечет за собой создание локального для нее пространства имен внутри пространства **global**. В нашем случае, это описывается командой **create foo global**. Далее мы объявляем внутри функции **foo** функцию **bar**, тем самым создавая пространство **bar** внутри пространства **foo**, и добавляем в **bar** переменную **a**. 30 | 31 | Добавим запросы **get** к нашим запросам 32 | 33 | - **get foo a** 34 | - **get foo c** 35 | - **get bar a** 36 | - **get bar b** 37 | 38 | Представим как это могло бы выглядеть в коде 39 | 40 | ``` 41 | a = 0 42 | def foo(): 43 | b = 1 44 | get(a) 45 | get(c) 46 | def bar(): 47 | a = 2 48 | get(a) 49 | get(b) 50 | ``` 51 | 52 | Результатом запроса **get** будет имя пространства, из которого будет взята нужная переменная. Например, результатом запроса **get foo a** будет **global**, потому что в пространстве **foo** не объявлена переменная **a**, но в пространстве **global**, внутри которого находится пространство **foo**, она объявлена. Аналогично, результатом запроса **get bar b** будет являться **foo**, а результатом работы **get bar a** будет являться **bar**. 53 | 54 | Результатом **get foo c** будет являться **None**, потому что ни в пространстве **foo**, ни в его внешнем пространстве **global** не была объявлена переменная **с**. 55 | 56 | Более формально, результатом работы **get namespace var** является 57 | 58 | - **namespace**, если в пространстве **namespace** была объявлена переменная **var** 59 | - **get parent var** – результат запроса к пространству, внутри которого было создано пространство **namespace**, если переменная не была объявлена 60 | - **None**, если не существует parent, т. е. **namespace** – это **global** 61 | 62 | **Формат входных данных** 63 | 64 | В первой строке дано число **n (1 ≤ n ≤ 100)** – число запросов. 65 | В каждой из следующих n строк дано по одному запросу. 66 | Запросы выполняются в порядке, в котором они даны во входных данных. 67 | Имена пространства имен и имена переменных представляют из себя строки длины не более **10**, состоящие из строчных латинских букв. 68 | 69 | **Формат выходных данных** 70 | 71 | Для каждого запроса **get** выведите в отдельной строке его результат. 72 | 73 | --- 74 | 75 | **Sample Input**: 76 | 77 | ``` 78 | 9 79 | add global a 80 | create foo global 81 | add foo b 82 | get foo a 83 | get foo c 84 | create bar foo 85 | add bar a 86 | get bar a 87 | get bar b 88 | Sample Output: 89 | global 90 | None 91 | bar 92 | foo 93 | ``` 94 | 95 | --- 96 | 97 | **Sample Output**: 98 | 99 | ``` 100 | global 101 | None 102 | bar 103 | foo 104 | ``` 105 | 106 | # Решение 107 | 108 | ``` 109 | n = int(input()) 110 | scopes = {'global': {'funcs': [], 'vars': []}} 111 | 112 | def add(scopes, current_namespace, what): 113 | if current_namespace not in scopes: 114 | scopes[current_namespace] = {} 115 | scopes[current_namespace]['vars'] = [] 116 | scopes[current_namespace]['vars'].append(what) 117 | else: 118 | if 'vars' not in scopes[current_namespace]: 119 | scopes[current_namespace]['vars'] = [] 120 | scopes[current_namespace]['vars'].append(what) 121 | else: 122 | scopes[current_namespace]['vars'].append(what) 123 | 124 | def create(scopes, current_namespace, parent_namespace): 125 | if current_namespace not in scopes: 126 | scopes[current_namespace] = {} 127 | scopes[current_namespace]['funcs'] = [] 128 | scopes[current_namespace]['vars'] = [] 129 | scopes[parent_namespace]['funcs'].append(current_namespace) 130 | scopes[current_namespace]['parent'] = parent_namespace 131 | else: 132 | if 'funcs' not in scopes[current_namespace]: 133 | scopes[current_namespace]['funcs'] = [] 134 | scopes[current_namespace]['parent'] = parent_namespace 135 | scopes[parent_namespace]['funcs'].append(current_namespace) 136 | else: 137 | scopes[current_namespace]['funcs'].append(current_namespace) 138 | scopes[parent_namespace]['funcs'].append(current_namespace) 139 | 140 | def search(scopes, namespace, what): 141 | if what in scopes[namespace]['vars']: 142 | return namespace 143 | else: 144 | try: 145 | upper_namespace = scopes[namespace]['parent'] 146 | except KeyError: 147 | return None 148 | return search(scopes, upper_namespace, what) 149 | 150 | for i in range(n): 151 | command = input().split() 152 | if command[0] == 'add': 153 | add(scopes, command[1], command[2]) 154 | elif command[0] == 'create': 155 | create(scopes, command[1], command[2]) 156 | elif command[0] == 'get': 157 | print(search(scopes, command[1], command[2])) 158 | ``` 159 | --------------------------------------------------------------------------------