Lesson_1_and_2_Borisenko

Урок 1. Практическое задание/task_1.py

@@ -22,49 +22,43 @@
 #############################################################################################
 def check_1(lst_obj):
     """Функция должна создать множество из списка.
-
     Алгоритм 3:
     Создать множество из списка
-
-    Сложность: !!!.
+    Сложность: O(len...).
     """
-    lst_to_set = set(lst_obj)  # !!!
+    lst_to_set = set(lst_obj)  # O(len...)
     return lst_to_set
 
 
 #############################################################################################
 def check_2(lst_obj):
     """Функция должная вернуть True, если все элементы списка различаются.
-
     Алгоритм 1:
     Проходимся по списку и для каждого элемента проверяем,
     что такой элемент отстутствует
     в оставшихся справа элементах
-
-    Сложность: !!!.
+    Сложность: O(n**2).
     """
-    for j in range(len(lst_obj)):          # !!!
-        if lst_obj[j] in lst_obj[j+1:]:    # !!!
-            return False                   # !!!
-    return True                            # !!!
+    for j in range(len(lst_obj)):          # O(n)
+        if lst_obj[j] in lst_obj[j+1:]:    # O(n)
+            return False                   # O(1)
+    return True                            # O(1)
 
 
 #############################################################################################
 def check_3(lst_obj):
     """Функция должная вернуть True, если все элементы списка различаются.
-
     Алгоритм 2:
     Вначале выполним для списка сортировку, далее, сравниваем элементы попарно
     Если присутствуют дубли, они будут находиться рядом.
-
-    Сложность: !!!
+    Сложность: O(nlogn)
     """
-    lst_copy = list(lst_obj)                 # !!!
-    lst_copy.sort()                          # !!!
-    for i in range(len(lst_obj) - 1):        # !!!
-        if lst_copy[i] == lst_copy[i+1]:     # !!!
-            return False                     # !!!
-    return True                              # !!!
+    lst_copy = list(lst_obj)                 # O(1)
+    lst_copy.sort()                          # O(nlogn)
+    for i in range(len(lst_obj) - 1):        # O(n)
+        if lst_copy[i] == lst_copy[i+1]:     # O(1)
+            return False                     # O(1)
+    return True                              # O(1)
 
 #############################################################################################
 

Урок 1. Практическое задание/task_2.py

@@ -17,3 +17,27 @@
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
 А без столкновения со сложностями его не развить.
 """
+
+list_of_numbers = [7, 3, 8, 1, 11, 2, 37, 23]
+
+
+def find_min_number_first(input_list):
+    for item in input_list:
+        flag = True
+        for i in input_list:
+            if i < item:
+                flag = False
+        if flag:
+            return item
+
+
+def find_min_number_second(input_list):
+    minimum = input_list[0]
+    for item in input_list[1:]:
+        if item < minimum:
+            minimum = item
+    return minimum
+
+
+print(find_min_number_first(list_of_numbers))
+print(find_min_number_second(list_of_numbers))

Урок 1. Практическое задание/task_3.py

@@ -1,24 +1,41 @@
 """
 Задание 3.
-
 Для этой задачи:
 1) придумайте 1-3 решения (желательно хотя бы два)
 2) оцените сложность каждого решения в нотации О-большое
 3) сделайте вывод, какое решение эффективнее и почему
-
 Примечание:
 Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
 через строки документации в самом коде.
 Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
 а не писать "мы это не проходили)".
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
 А без столкновения со сложностями его не развить.
-
-
 Сама задача:
 Имеется хранилище с информацией о компаниях: название и годовая прибыль.
 Для реализации хранилища можно применить любой подход,
 который вы придумаете, например, реализовать словарь.
 Реализуйте поиск трех компаний с наибольшей годовой прибылью.
 Выведите результат.
 """
+
+COMPANY_DICT = {"Марвел": 23587, "ДиСиКомикс": 54754, "Амбрелла": 2545549, "ДолгостройЛТД": 3153223, "МММ": 3465987}
+
+company_dict_values = list(COMPANY_DICT.values())
+company_dict_keys = list(COMPANY_DICT.keys())
+company_dict_values_2 = company_dict_values.copy()
+
+# 1 вариант - сложность O(n log n):
+sorted_values = sorted(COMPANY_DICT.values(), reverse=True)[:3]  # O(n log n)
+for item in sorted_values:                                       # O(1)
+    find_index = company_dict_values.index(item)                 # O(n)
+    max_key = company_dict_keys[find_index]
+    print(max_key)
+
+# 2 вариант - сложность O(n):
+for i in range(3):                                               # O(1)
+    max_value = max(company_dict_values_2)                       # O(n)
+    find_index = company_dict_values.index(max_value)            # O(n)
+    max_key = company_dict_keys[find_index]                      # O(1)
+    print(max_key)
+    company_dict_values_2.remove(max_value)                      # O(n)

Урок 1. Практическое задание/task_4.py

@@ -1,29 +1,70 @@
 """
 Задание 4.
-
 Для этой задачи:
 1) придумайте 1-3 решения (желательно хотя бы два)
 2) оцените сложность каждого решения в нотации О-большое
 3) сделайте вывод, какое решение эффективнее и почему
-
 Примечание:
 Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
 через строки документации в самом коде.
 Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
 а не писать "мы это не проходили)".
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
 А без столкновения со сложностями его не развить.
-
-
 Сама задача:
 Пользователи веб-ресурса проходят аутентификацию.
 В системе хранятся логин, пароль и отметка об активации учетной записи.
-
 Нужно реализовать проверку, может ли пользователь быть допущен к ресурсу.
 При этом его учетка должна быть активирована.
 А если нет, то польз-лю нужно предложить ее пройти.
-
 Приложение должно давать ответы на эти вопросы и быть реализовано в виде функции.
 Для реализации хранилища можно применить любой подход,
 который вы придумаете, например, реализовать словарь.
 """
+
+
+USER_DB_LIST = [{"login": "Sauron", "password": "BigEye", "auth": True},
+                {"login": "Saruman", "password": "KillAllPeople", "auth": False},
+                {"login": "Gendalf", "password": "uShallNotPass", "auth": False}]
+USER_DB_DICT = {"Sauron": {"password": "BigEye", "auth": True},
+                "Saruman": {"password": "KillAllPeople", "auth": False},
+                "Gendalf": {"passw": "uShallNotPass", "auth": False}}
+
+
+# Первый вариант - сложность O(n):
+def check_user_first(user_name, user_pass):
+    for user in USER_DB_LIST:  # O(n)
+        if user["login"] == user_name:  # O(1)
+            if user["password"] == user_pass:  # O(1)
+                if user["auth"]:  # O(1)
+                    print('Welcome To Midgard!')
+                    break
+                else:
+                    print('Активируйтесь!')
+                    break
+            else:
+                print('Вы наколдовали неверный пароль!')
+                break
+    else:
+        print('Такого волшебника не существует!')
+
+
+check_user_first(input('Ваше Имя на Эльфийском:     '), input('Наколдуйте пароль:      '))
+
+
+# Второй вариант - сложность O(1):
+def check_user_second(user_name, user_pass):
+    user = USER_DB_DICT.get(user_name)           # O(1)
+    if user is not None:                  # O(1)
+        if user["password"] == user_pass:        # O(1)
+            if user["auth"]:              # O(1)
+                print('Welcome To Midgard!')
+            else:
+                print('Активируйтесь!')
+        else:
+            print('Вы наколдовали неверный пароль!')
+    else:
+        print('Такого волшебника не существует!')
+
+
+check_user_second(input('Ваше Имя на Эльфийском:     '), input('Наколдуйте пароль:      '))

Урок 1. Практическое задание/task_5.py

@@ -1,20 +1,72 @@
 """
 Задание 6.
 Задание на закрепление навыков работы со стеком
-
 Примечание: в этом задании вспомните ваши знания по работе с ООП
 и опирайтесь на пример урока
-
 Реализуйте структуру "стопка тарелок".
-
 Мы можем складывать тарелки в стопку и при превышении некоторого значения
 нужно начать складывать тарелки в новую стопку.
-
 Структура должна предусматривать наличие нескольких стеков.
 Создание нового стека происходит при достижении предыдущим стеком порогового значения.
 Реализуйте по аналогии с примером, рассмотренным на уроке, необходимые методы,
 для реализации это структуры, добавьте новые методы (не рассмотренные в примере с урока)
 для реализации этой задачи.
-
 После реализации структуры, проверьте ее работу на различных сценариях
 """
+
+
+class StackClass:
+    def __init__(self):
+        self.elements_list = []
+
+    def is_empty(self):
+        return self.elements_list == []
+
+    def push_in(self, element):
+        """Предполагаем, что верхний элемент стека находится в конце списка"""
+        self.elements_list.append(element)
+
+    def pop_out(self):
+        return self.elements_list.pop()
+
+    def get_val(self):
+        return self.elements_list[len(self.elements_list) - 1]
+
+    def stack_size(self):
+        return len(self.elements_list)
+
+
+class Plates:
+    def __init__(self):
+        self.my_stack_list = []
+        new_obj = StackClass()
+        self.my_stack_list.append(new_obj)
+
+    def add_plate(self, element):
+        if self.my_stack_list[len(self.my_stack_list) - 1].stack_size() < 4:   # 1 стопка = 4 тарелки
+            self.my_stack_list[len(self.my_stack_list) - 1].push_in(element)
+        else:
+            new_obj = StackClass()
+            self.my_stack_list.append(new_obj)
+            new_obj.push_in(element)
+
+    def stack_count(self):
+        return len(self.my_stack_list)
+
+    def plates_in_last_stack(self):
+        return self.my_stack_list[len(self.my_stack_list) - 1].stack_size()
+
+
+ExObject = Plates()
+
+while True:
+    new_element = input('Добавить тарелку?(y/n):   ')
+    if new_element == 'n':
+        print('Как хотите :)')
+        break
+    elif new_element == 'y':
+        ExObject.add_plate('Plate')
+        print(f'Всего стопок: {ExObject.stack_count()}')
+        print(f'Тарелок в последней стопке: {ExObject.plates_in_last_stack()}')
+    else:
+        print('Ответ может быть y или n')

Урок 1. Практическое задание/task_6.py

@@ -1,17 +1,89 @@
 """
 Задание 7.
 Задание на закрепление навыков работы с очередью
-
 Примечание: в этом задании вспомните ваши знания по работе с ООП
 и опирайтесь на пример урока
-
 Реализуйте структуру "доска задач".
-
-
 Структура должна предусматривать наличие несольких очередей задач, например
 1) базовой, откуда задачи берутся, решаются и отправляются в список решенных
 2) очередь на доработку, когда нерешенные задачи из первой очереди отправляются
 на корректировку решения
-
 После реализации структуры, проверьте ее работу на различных сценариях
 """
+
+
+class QueueClass:
+    def __init__(self):
+        self.elements_list = []
+
+    def is_empty(self):
+        return self.elements_list == []
+
+    def to_queue(self, item):
+        self.elements_list.insert(0, item)
+
+    def from_queue(self):
+        return self.elements_list.pop()
+
+    def get_item(self):
+        return self.elements_list[-1]
+
+    def size(self):
+        return len(self.elements_list)
+
+
+class Kanban:
+    def __init__(self):
+        self.base_tasks = QueueClass()
+        self.other_tasks = QueueClass()
+        self.closed_tasks = []
+
+    def add_task(self, task):
+        self.base_tasks.to_queue(task)
+
+    def close_task(self):
+        task = self.base_tasks.from_queue()
+        self.closed_tasks.append(task)
+        return task
+
+    def rework_task(self):
+        task = self.base_tasks.from_queue()
+        print(f'На доработку отправлена: {task}')
+        self.other_tasks.to_queue(task)
+
+    def get_task(self):
+        task = self.base_tasks.get_item()
+        return task
+
+    def count_task(self):
+        return self.base_tasks.size(), self.other_tasks.size(), len(self.closed_tasks)
+
+
+ExObject = Kanban()
+
+while 1 == 1:
+    to_base_q, to_rework_q, done_q = ExObject.count_task()
+    print(f'В базовой очереди: {to_base_q} задач\nНа доработку: {to_rework_q}\nЗадач уже выполнено: {done_q}')
+    try:
+        print(f'Что будем делать с задачей: {ExObject.get_task()}?')
+    except IndexError:
+        print('Задач пока нет')
+    option = input(f'Добавить задачу - нажмите 1, отметить как решенную - 2, на доработку - 3, выход - 4: ')
+    if len(option) == 0:
+        break
+    if option == "1":
+        ExObject.add_task(input('Введите задачу:   '))
+    elif option == "2":
+        try:
+            ExObject.close_task()
+        except IndexError:
+            print('Сначала добавь задачу')
+    elif option == "3":
+        try:
+            ExObject.rework_task()
+        except IndexError:
+            print('Сначала добавь задачу')
+    elif option == "4":
+        break
+    else:
+        print('Неверная команда!')