├── Python основы и применение ├── 1.2_1.md ├── 1.3_15.md ├── 1.3_9.md ├── 1.5_8.md ├── 1.5_9.md ├── 1.6_7.md ├── 1.6_8.md ├── 1.6_9.md ├── 2.1_6.md ├── 2.1_9.md ├── 2.2_5.md └── 2.5.md └── Добрый, добрый Python - обучающий курс от Сергея Балакирева ├── 4.2_7.md ├── 5.3_10.md ├── 5.4_2.md ├── 5.4_4..md ├── 5.4_5.md ├── 5.4_6.md ├── 5.4_7.md ├── 5.4_8.md ├── 5.5_3.md ├── 5.5_4.md ├── 5.6_2.md ├── 5.6_3.md ├── 5.6_4.md ├── 5.6_5.md ├── 5.6_6.md ├── 5.6_7.md ├── 5.6_8.md ├── 5.6_9.md └── img ├── 1.png └── 2.png /Python основы и применение/1.2_1.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 | print(ans) 13 | ``` 14 | 15 | **Примечание**: 16 | 17 | Количеством различных объектов называется максимальный размер множества объектов, в котором любые два объекта являются различными. 18 | 19 | Рассмотрим пример: 20 | 21 | `objects = [1, 2, 1, 2, 3]` # будем считать, что одинаковые числа соответствуют одинаковым объектам, а различные – различным 22 | 23 | Тогда все различные объекты являют собой множество **{1, 2, 3}**. Таким образом, количество различных объектов равно трём. 24 | 25 | # Решение 26 | 27 | ``` 28 | answ = [] 29 | for i in objects: 30 | if not i in answ: 31 | answ.append(i) 32 | print(len(answ)) 33 | ``` 34 | -------------------------------------------------------------------------------- /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 | def c(n, k): 56 | if k == 0: 57 | return 1 58 | elif k > n: 59 | return 0 60 | else: 61 | return c(n - 1, k) + c(n - 1, k - 1) 62 | print(c(n, k)) 63 | ``` -------------------------------------------------------------------------------- /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 | if x % 5 == 0: 20 | return x 21 | return closest_mod_5(x+1) 22 | ``` -------------------------------------------------------------------------------- /Python основы и применение/1.5_8.md: -------------------------------------------------------------------------------- 1 | Реализуйте класс **MoneyBox**, для работы с виртуальной копилкой. 2 | 3 | Каждая копилка имеет ограниченную вместимость, которая выражается целым числом – количеством монет, которые можно положить в копилку. Класс должен поддерживать информацию о количестве монет в копилке, предоставлять возможность добавлять монеты в копилку и узнавать, можно ли добавить в копилку ещё какое-то количество монет, не превышая ее вместимость. 4 | 5 | Класс должен иметь следующий вид 6 | 7 | ``` 8 | class MoneyBox: 9 | def __init__(self, capacity): 10 |      # конструктор с аргументом – вместимость копилки 11 | def can_add(self, v): 12 | # True, если можно добавить v монет, False иначе 13 | def add(self, v): 14 | # положить v монет в копилку 15 | ``` 16 | 17 | При создании копилки, число монет в ней равно **0**. 18 | 19 | **Примечание**: 20 | 21 | Гарантируется, что метод **add(self, v)** будет вызываться только если **can_add(self, v) – True**. 22 | 23 | # Решение 24 | 25 | ``` 26 | class MoneyBox: 27 | def __init__(self, capacity): 28 | self.capacity = capacity 29 | self.nowCount = 0 30 | def can_add(self,v): 31 | if self.nowCount+v<=self.capacity: 32 | return True 33 | return False 34 | def add(self, v): 35 | if (self.can_add(v)): 36 | self.nowCount += v 37 | ``` -------------------------------------------------------------------------------- /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 | def get_current_part(self): 19 | # вернуть сохраненные в текущий момент элементы последовательности в порядке, в котором они были 20 | # добавлены 21 | ``` 22 | 23 | Пример работы с классом 24 | 25 | ``` 26 | buf = Buffer() 27 | buf.add(1, 2, 3) 28 | buf.get_current_part() # вернуть [1, 2, 3] 29 | buf.add(4, 5, 6) # print(15) – вывод суммы первой пятерки элементов 30 | buf.get_current_part() # вернуть [6] 31 | buf.add(7, 8, 9, 10) # print(40) – вывод суммы второй пятерки элементов 32 | buf.get_current_part() # вернуть [] 33 | buf.add(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) # print(5), print(5) – вывод сумм третьей и четвертой пятерки 34 | buf.get_current_part() # вернуть [1] 35 | ``` 36 | 37 | Обратите внимание, что во время выполнения метода add выводить сумму пятерок может потребоваться несколько раз до тех пор, пока в буфере не останется менее пяти элементов. 38 | 39 | # Решение 40 | 41 | ``` 42 | class Buffer: 43 | def __init__(self): 44 | self.arr = [] 45 | 46 | def add(self, *a): 47 | self.arr += a 48 | while (len(self.arr)>=5): 49 | print(sum(self.arr[:5])) 50 | self.arr = self.arr[5:] 51 | 52 | def get_current_part(self): 53 | return self.arr 54 | ``` -------------------------------------------------------------------------------- /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 | class C(B): 33 | pass 34 | # A -- предок С 35 | ``` 36 | 37 | Вам необходимо отвечать на запросы, является ли один класс предком другого класса 38 | 39 | **Важное примечание**: 40 | 41 | Создавать классы не требуется. 42 | 43 | Мы просим вас промоделировать этот процесс, и понять существует ли путь от одного класса до другого. 44 | 45 | **Формат входных данных** 46 | 47 | В первой строке входных данных содержится целое число **n** - число классов. 48 | 49 | В следующих **n** строках содержится описание наследования классов. В **i**-й строке указано от каких классов наследуется **i**-й класс. Обратите внимание, что класс может ни от кого не наследоваться. Гарантируется, что класс не наследуется сам от себя (прямо или косвенно), что класс не наследуется явно от одного класса более одного раза. 50 | 51 | В следующей строке содержится число **q** - количество запросов. 52 | 53 | В следующих **q** строках содержится описание запросов в формате **имя класса 1 имя класса 2**. 54 | 55 | Имя класса – строка, состоящая из символов латинского алфавита, длины не более 50. 56 | 57 | **Формат выходных данных** 58 | 59 | Для каждого запроса выведите в отдельной строке слово "**Yes**", если **класс 1** является предком **класса 2**, и "**No**", если не является. 60 | 61 | --- 62 | 63 | ** Sample Input**: 64 | 65 | ``` 66 | 4 67 | A 68 | B : A 69 | C : A 70 | D : B C 71 | 4 72 | A B 73 | B D 74 | C D 75 | D A 76 | ``` 77 | 78 | **Sample Output**: 79 | 80 | ``` 81 | Yes 82 | Yes 83 | Yes 84 | No 85 | ``` 86 | 87 | # Решение 88 | 89 | ``` 90 | classes = {} 91 | 92 | def add_class(classes, class_name, parents): 93 | if class_name not in classes: 94 | classes[class_name] = [] 95 | classes[class_name].extend(parents) 96 | for parent in parents: 97 | if parent not in classes: 98 | classes[parent] = [] 99 | 100 | def found_path(classes, start, end, path=[]): 101 | path = path + [start] 102 | if start == end: 103 | return path 104 | if start not in classes: 105 | return None 106 | for node in classes[start]: 107 | if node not in path: 108 | newpath = found_path(classes, node, end, path) 109 | if newpath: return newpath 110 | return None 111 | 112 | def answer(classes, parent, child): 113 | if not(parent or child) in classes or not found_path(classes, child, parent): 114 | return 'No' 115 | return 'Yes' 116 | 117 | n = int(input()) 118 | for _ in range(n): 119 | class_description = input().split() 120 | class_name = class_description[0] 121 | class_parents = class_description[2:] 122 | add_class(classes, class_name, class_parents) 123 | 124 | q = int(input()) 125 | for _ in range(q): 126 | question = input().split() 127 | parent = question[0] 128 | child = question[1] 129 | print(answer(classes, parent, child)) 130 | ``` 131 | -------------------------------------------------------------------------------- /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 | def sub(self): 16 | # операция вычитания 17 | def mul(self): 18 | # операция умножения 19 | def div(self): 20 | # операция целочисленного деления 21 | ``` 22 | 23 | **Примечание** 24 | 25 | Для добавления элемента на стек используется метод **`append`**, а для снятия со стека – метод **`pop`**. 26 | 27 | Гарантируется, что операции будут совершаться только когда в стеке есть хотя бы два элемента. 28 | 29 | # Решение 30 | 31 | ``` 32 | class ExtendedStack(list): 33 | def sum(self): 34 | self.append(self.pop() + self.pop()) 35 | 36 | def sub(self): 37 | self.append(self.pop() - self.pop()) 38 | 39 | def mul(self): 40 | self.append(self.pop() * self.pop()) 41 | 42 | def div(self): 43 | self.append(self.pop() // self.pop()) 44 | ``` -------------------------------------------------------------------------------- /Python основы и применение/1.6_9.md: -------------------------------------------------------------------------------- 1 | Одно из применений множественного наследование – расширение функциональности класса каким-то заранее определенным способом. Например, если нам понадобится логировать какую-то информацию при обращении к методам класса. 2 | 3 | Рассмотрим класс **Loggable**: 4 | 5 | ``` 6 | import time 7 | class Loggable: 8 | def log(self, msg): 9 | print(str(time.ctime()) + ": " + str(msg)) 10 | ``` 11 | 12 | У него есть ровно один метод **log**, который позволяет выводить в лог (в данном случае в stdout) какое-то сообщение, добавляя при этом текущее время. 13 | 14 | Реализуйте класс **LoggableList**, отнаследовав его от классов **list** и **Loggable** таким образом, чтобы при добавлении элемента в список посредством метода **append** в лог отправлялось сообщение, состоящее из только что добавленного элемента. 15 | 16 | **Примечание** 17 | 18 | Ваша программа не должна содержать класс **Loggable**. При проверке вашей программе будет доступен этот класс, и он будет содержать метод **log**, описанный выше. 19 | 20 | # Решение 21 | 22 | ``` 23 | class LoggableList(list, Loggable): 24 | def append(self, msg): 25 | self.log(msg) 26 | super().append(msg) 27 | ``` -------------------------------------------------------------------------------- /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 | ``` -------------------------------------------------------------------------------- /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().append(x) 23 | else: 24 | raise NonPositiveError() 25 | ``` -------------------------------------------------------------------------------- /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 | import datetime 62 | date = input().split() 63 | delta = datetime.timedelta(int(input())) 64 | new_date = datetime.date(int(date[0]), int(date[1]), int(date[2])) 65 | out_date = new_date + delta 66 | print(out_date.year, out_date.month, out_date.day) 67 | ``` -------------------------------------------------------------------------------- /Python основы и применение/2.5.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 | mod_3_1 = mod_checker(3, 1) 12 | print(mod_3_1(4)) # True 13 | ``` 14 | 15 | # Solution / Решение 16 | 17 | ``` 18 | def mod_checker(x,mod=0): 19 | return lambda y:y%x==mod 20 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/4.2_7.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Дата некоторого дня характеризуется двумя натуральными числами: m (порядковый номер месяца) и n (число). По введенным m и n (в одну строку через пробел) определить: 3 | 4 | а) дату предыдущего дня (принять, что m и n не характеризуют 1 января); 5 | б) дату следующего дня (принять, что m и n не характеризуют 31 декабря). 6 | 7 | В задаче принять, что год не является високосным. Вывести предыдущую дату и следующую дату (в формате: mm.dd, где m - число месяца; d - номер дня) в одну строчку через пробел. 8 | 9 | P.S. Число дней в месяцах не високосного года, начиная с января: 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 10 | 11 | # Sample Input 12 | 8 31 13 | # Sample Output 14 | 08.30 09.01 15 | 16 | # Solution 17 | ``` 18 | import datetime as dt 19 | m,d = map(int, input().split()) 20 | date = dt.date(2021,m,d) 21 | date1 = date-dt.timedelta(days=1) 22 | date2 = date+dt.timedelta(days=1) 23 | print(f"{date1.strftime('%m.%d')} {date2.strftime('%m.%d')}") 24 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.3_10.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится список названий городов в одну строчку через пробел. Перебрать все эти названия с помощью цикла for и определить, начинается ли название следующего города на последнюю букву предыдущего города в списке. Если последними встречаются буквы 'ь', 'ъ', 'ы', то берется следующая с конца буква. Вывести на экран ДА, если последовательность удовлетворяет этому правилу и НЕТ - в противном случае. 3 | 4 | # Sample Input 5 | Москва Астрахань Новгород Димитровград Душанбе 6 | 7 | # Sample Output 8 | ДА 9 | 10 | # Solution 11 | ``` 12 | lst = list(map(str, input().lower().split())) 13 | mark = ['ь', 'ъ', 'ы'] 14 | out = "ДА" 15 | for i in range(len(lst)-1): 16 | if lst[i][-1] in mark: 17 | if lst[i+1][0] != lst[i][-2]: 18 | out = "НЕТ" 19 | break 20 | else: 21 | if lst[i+1][0] != lst[i][-1]: 22 | out = "НЕТ" 23 | break 24 | print(out) 25 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.4_2.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится строка. Необходимо найти все индексы фрагмента "ра" во введенной строке. Вывести в строку через пробелы найденные индексы. Если этот фрагмент ни разу не будет найден, то вывести значение -1. 3 | # Sample Input 4 | Барабанщик бил бой в барабан 5 | # Sample Output 6 | 2 23 7 | 8 | # Solution 9 | ``` 10 | str = input() 11 | if 'ра' not in str: 12 | print(-1) 13 | else: 14 | for i, d in enumerate(str): 15 | if d == 'а' and str[i-1] == 'р': 16 | print(i-1, end=' ') 17 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.4_4..md: -------------------------------------------------------------------------------- 1 | # Task 2 | В виде строки записано арифметическое выражение, например: 3 | 4 | "10 + 25 - 12" 5 | 6 | или 7 | 8 | "10 + 25 - 12 + 20 - 1 + 3" 9 | 10 | и т. д. То есть, количество действий может быть разным. 11 | 12 | Необходимо выполнить вычисление и результат отобразить на экране. Полагается, что в качестве арифметических операций здесь используется только сложение (+) и вычитание (-), а в качестве операндов - целые неотрицательные числа. Следует учесть, что эти операторы могут быть записаны как с пробелами, так и без них. 13 | # Sample Input 14 | 10+25 - 12 15 | # Sample Output 16 | 23 17 | 18 | # Solution 19 | ``` 20 | str = input().replace(" ", "").replace("-", "+-").split("+") 21 | print(sum(map(int, str))) 22 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.4_5.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится список в виде целых чисел в одну строку через пробел. Необходимо сначала сформировать список на основе введенной строки, а затем, каждое значение этого списка изменить, возведя в квадрат. Отобразить результат на экране в виде строки полученных чисел, записанных через пробел. Программу следует реализовать с использованием функции enumerate. 3 | # Sample Input 4 | 8 -11 4 3 6 5 | # Sample Output 6 | 64 121 16 9 36 7 | 8 | # Solution 9 | 10 | ``` 11 | str = input().split() 12 | for i,d in enumerate(str): 13 | str[i] = int(d)**2 14 | print(*str) 15 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.4_6.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится список в виде целых чисел в одну строку через пробел. Сначала нужно сформировать список из введенной строки. Затем, каждый элемент этого списка продублировать один раз. Результат отобразить на экране в виде строки полученных чисел, записанных через пробел. 3 | # Sample Input 4 | 8 11 2 5 | # Sample Output 6 | 8 8 11 11 2 2 7 | 8 | # Solution 9 | 10 | ``` 11 | str = input().split() 12 | for i,d in enumerate(str): 13 | print(d,d,end=" ") 14 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.4_7.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится список в виде вещественных чисел в одну строку через пробел. С помощью цикла for необходимо найти наименьшее значение в этом списке. Полученный результат вывести на экран. Реализовать программу без использования функции min, max и сортировки. 3 | # Sample Input 4 | 8.6 9.11 -4.567 -10.0 1.45 5 | # Sample Output 6 | -10.0 7 | 8 | # Solution 9 | 10 | ``` 11 | str = input().split() 12 | min_res = float(str[0]) 13 | for i,d in enumerate(str): 14 | if float(d) 1: 30 | res = 'НЕТ' 31 | break 32 | print(res) 33 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.6_6.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится двумерный список размерностью 5 х 5 элементов, состоящий из целых чисел (пример ввода см. ниже). Проверьте, является ли этот двумерный список симметричным относительно главной диагонали. Главная диагональ — та, которая идёт из левого верхнего угла двумерного массива в правый нижний. Выведите на экран ДА, если матрица симметрична и НЕТ - в противном случае. 3 | 4 | P. S. Для считывания списка целиком в программе уже записаны начальные строчки 5 | 6 | # Sample Input 7 | ``` 8 | 2 3 4 5 6 9 | 3 2 7 8 9 10 | 4 7 2 0 4 11 | 5 8 0 2 1 12 | 6 9 4 1 2 13 | ``` 14 | # Sample Output 15 | ДА 16 | 17 | # Solution 18 | 19 | ``` 20 | import sys 21 | 22 | # считывание списка из входного потока 23 | s = sys.stdin.readlines() 24 | lst_in = [list(map(int, x.strip().split())) for x in s] 25 | res = 'ДА' 26 | # здесь продолжайте программу (используйте список lst_in) 27 | for i in range(len(lst_in)): 28 | if res == 'НЕТ': 29 | break 30 | for j in range(len(lst_in)): 31 | if lst_in[i][j] != lst_in[j][i]: 32 | res = 'НЕТ' 33 | break 34 | print(res) 35 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.6_7.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится список целых чисел в одну строку через пробел. Необходимо выполнить его сортировку выбором по возрастанию (неубыванию). Идея алгоритма очень проста и проиллюстрирована на рисунке ниже. 3 | 4 | 5 | 6 | Вначале мы рассматриваем первый элемент списка и ищем второй минимальный относительно первого элемента (включая и его). На рисунке - это последний элемент со значением -1. Затем, меняем местами первый и последний элементы. Переходим ко второму элементу списка и повторяем эту же процедуру, но относительно второго элемента (то есть, первый уже не рассматриваем). На рисунке минимальный элемент - это 2, поэтому менять местами здесь ничего не нужно. Переходим к 3-му элементы со значением 6. Относительно него находим минимальный элемент - это 3. Меняем их местами. 7 | 8 | Вот идея алгоритма сортировки выбором. Реализуйте его для вводимого списка целых чисел. Результат выведите в виде списка чисел одну строку через пробел. 9 | 10 | # Sample Input 11 | 8 11 -53 2 10 11 12 | 13 | # Sample Output 14 | -53 2 8 10 11 11 15 | 16 | # Solution 1 17 | 18 | ``` 19 | arr = list(map(int, input().split())) 20 | for i in range(len(arr)): 21 | min_v = arr[i] 22 | k = i 23 | for j in range(i, len(arr)): 24 | if arr[j] < min_v: 25 | min_v = arr[j] 26 | k = j 27 | arr[i], arr[k] = arr[k], arr[i] 28 | print(*arr) 29 | ``` 30 | # Solution 2 31 | ``` 32 | arr = list(map(int, input().split())) 33 | for i in range(len(arr)): 34 | k = i 35 | for j in range(i, len(arr)): 36 | if arr[j] < arr[k]: 37 | k = j 38 | arr[i], arr[k] = arr[k], arr[i] 39 | print(*arr) 40 | ``` 41 | -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.6_8.md: -------------------------------------------------------------------------------- 1 | # Task 2 | Вводится список целых чисел в одну строку через пробел. Необходимо выполнить его сортировку по возрастанию (неубыванию) методом всплывающего пузырька. Идея алгоритма проста и показана на рисунке ниже. 3 | 4 | 5 | 6 | При первом проходе перебираем все соседние пары элементов и если значение предыдущего элемента (слева) больше значения следующего (справа), то они меняются местами. (На рисунке 3 и 2 меняются местами). Следующая пара - это 3 и 6. Они уже выстроены по возрастанию, поэтому ничего не делаем и переходим к следующей паре 6 и -1. Меняем значения местами и видим, что на последнем месте находится максимальное значение 6, что нам и нужно. 7 | 8 | При втором проходе делаем все то же самое, но доходим до предпоследнего элемента, так как последнее значение 6 уже отсортировано. На третьем проходе исключаем уже последние два элемента и так далее. То есть, в этом алгоритме достаточно сделать N-1 проходов, где N - длина списка. 9 | 10 | Вот идея алгоритма сортировки всплывающего пузырька. Реализуйте его для вводимого списка целых чисел. Результат выведите в виде списка чисел одну строку через пробел. 11 | 12 | # Sample Input 13 | 4 5 2 0 6 3 -56 3 -1 14 | 15 | # Sample Output 16 | -56 -1 0 2 3 3 4 5 6 17 | 18 | # Solution 19 | 20 | ``` 21 | arr = list(map(int, input().split())) 22 | for i in range(len(arr)-1): 23 | for j in range(len(arr)-i-1): 24 | if arr[j] > arr[j+1]: 25 | arr[j], arr[j+1] = arr[j+1], arr[j] 26 | print(*arr) 27 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/5.6_9.md: -------------------------------------------------------------------------------- 1 | # Task 2 | В некоторой стране используются денежные купюры достоинством в 1, 2, 4, 8, 16, 32 и 64. Вводится натуральное число n. Как наименьшим количеством таких денежных купюр можно выплатить сумму n? Вывести на экран список купюр для формирования суммы n (в одну строчку через пробел, начиная с наибольшей и заканчивая наименьшей). Предполагается, что имеется достаточно большое количество купюр всех достоинств. 3 | 4 | # Sample Input 5 | 221 6 | 7 | # Sample Output 8 | 64 64 64 16 8 4 1 9 | 10 | # Solution 11 | ``` 12 | n = int(input()) 13 | lst = [64, 32, 16, 8, 4, 2, 1] 14 | ans = [] 15 | while n>0: 16 | for i in lst: 17 | if n >= i: 18 | n -= i 19 | ans.append(i) 20 | break 21 | print(*ans) 22 | ``` -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/img/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/paveldat/Stepik/bd907d3faee811c7e18873e35a75719efe593458/Добрый, добрый Python - обучающий курс от Сергея Балакирева/img/1.png -------------------------------------------------------------------------------- /Добрый, добрый Python - обучающий курс от Сергея Балакирева/img/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/paveldat/Stepik/bd907d3faee811c7e18873e35a75719efe593458/Добрый, добрый Python - обучающий курс от Сергея Балакирева/img/2.png --------------------------------------------------------------------------------