Tomina s lesson 1

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

@@ -26,9 +26,10 @@ def check_1(lst_obj):
     Алгоритм 3:
     Создать множество из списка
 
-    Сложность: !!!.
+    Сложность: !!! - O(n) - линейная сложность, тк set() - встроенная ф-ция и ее сложность 
+        зависит от длинны списка lst_obj.
     """
-    lst_to_set = set(lst_obj)  # !!!
+    lst_to_set = set(lst_obj)  # !!! O(len(lsr_obj)) = O(n), где n - длина списка lst_obj
     return lst_to_set
 
 
@@ -41,12 +42,13 @@ def check_2(lst_obj):
     что такой элемент отстутствует
     в оставшихся справа элементах
 
-    Сложность: !!!.
+    Сложность: !!! if lst_obj[j] in lst_obj[j+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) - линейная, n - длина списка
+        if lst_obj[j] in lst_obj[j+1:]:    # !!! - поиск в списке - линеная
+            return False                   # !!! - константная сложность
+    return True                            # !!! - константая сложность
 
 
 #############################################################################################
@@ -57,14 +59,14 @@ def check_3(lst_obj):
     Вначале выполним для списка сортировку, далее, сравниваем элементы попарно
     Если присутствуют дубли, они будут находиться рядом.
 
-    Сложность: !!!
+    Сложность: !!! по доминанте - сложность O(N*logN) - линейно-логарифмическая
     """
-    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)                 # !!! линейная - зависит от длины аргумента
+    lst_copy.sort()                          # !!! N*logN - линейно-логарифмическая сложность
+    for i in range(len(lst_obj) - 1):        # !!! линейная = O(n)? где n=len(lst_obj) - 1
+        if lst_copy[i] == lst_copy[i+1]:     # !!! константа
+            return False                     # !!! константа
+    return True                              # !!! константа
 
 #############################################################################################
 

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

@@ -17,3 +17,24 @@
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
 А без столкновения со сложностями его не развить.
 """
+def find_min_1(lst):  # сложность алгорима - квадратичная, ибо вложенность  
+    elem_min = lst[0]
+    for index in range(len(lst)): # O(n)
+        for elem_second in lst[index + 1 : ]: # O(n-1)
+            if lst[index] > elem_second:
+                elem_min = elem_second
+    return elem_min
+
+def find_min_2(lst):  # сложность алгоритма - линейная
+    elem_min = lst[0]
+    for index in range(len(lst)-1): # O(n)
+        if lst[index] > lst[index+1]: # коснтанта
+                elem_min = lst[index+1] 
+    return elem_min
+
+N = 20
+lst = [i for i in range(N)]
+# print(lst)
+
+print('ф-ция 1, min =', find_min_1(lst))
+print('ф-ция 2, min =', find_min_2(lst))

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

@@ -22,3 +22,100 @@
 Реализуйте поиск трех компаний с наибольшей годовой прибылью.
 Выведите результат.
 """
+# companies_info = {'name': , ammount}
+companies_info = {'Ford': 900, 'Tesla': 800, 'Mercedes': 900, 'Nokia': 800, \
+            'Yandex': 520, 'Mil.ru Group': 800}
+
+# оба решения учитывают, что годовая прибыль может быть равная - тогда в топ 3 попадает компания,
+     # которая идет первая в хранилище (хранилище не отсортированное - поэтому мб выведена разная 
+     # последовтальность названий компани у решений)
+
+
+def find_top_profit_1(comp_info_dict):  # сложность алгоритма - O(n) - линейная
+    max1 = 0
+    max2 = 0
+    max3 = 0
+    comp_max_amount = [i for i in range(3)]  # O(1)
+    for name, amount in comp_info_dict.items():  # O(n) 
+        #  comp_info_dict.items() -  O(1)
+        if amount > max1:
+            max1 = amount
+            comp_max_amount[0] = name
+        elif amount > max2:
+            max2 = amount
+            comp_max_amount[1] = name
+        elif amount > max3:
+            max3 = amount
+            comp_max_amount[2] = name
+    return comp_max_amount
+
+
+def find_top_profit_2(comp_info_dict):  # сложность алгоритма - # O(n) 
+    comp_max_amount = []  # O(1)
+
+    list_amount = list(comp_info_dict.values())  # O(n) 
+
+    max1 = max(list_amount)  # O(n) 
+    list_amount.remove(max1)  # O(n) 
+    max2 = max(list_amount)  # O(n) 
+    list_amount.remove(max2)  # O(n)    
+    max3 = max(list_amount)  # O(n) 
+    list_amount.remove(max3)  # O(n)
+
+    for name, amount in comp_info_dict.items():  # O(n) # comp_info_dict.items() - сложность O(1)
+        # print(name, amount)
+        if len(comp_max_amount) == 3:  # O(1)
+            break
+        elif amount == max1 or amount == max2 or amount ==max3:
+            comp_max_amount.append(name)  # O(1)
+        # else:
+        #   print('smth wrong')
+    return comp_max_amount
+
+
+# решение похоже на 2ое, но чуть инетересней
+def find_top_profit_3(comp_info_dict):  # сложность алгоритма - O(n)
+    list_max_amount = []
+    comp_name_max_amount = []   
+    list_amount = list(comp_info_dict.values())  # O(n), n - длина словаря
+
+    for i in range(3):  # O(n=3) = O(1) - константа
+        list_max_amount.append(max(list_amount))  # O(n) 
+        val_remove = list_max_amount[i]
+        list_amount.remove(val_remove)  # O(n) 
+    for name, amount in comp_info_dict.items():  # O(n) 
+        if len(comp_name_max_amount) == 3:
+            break
+        elif amount in list_max_amount:  # O(n)= O(1) - тк n=3, по задани нужно найти топ 3 
+            comp_name_max_amount.append(name)  # O(1)
+        # else:
+        #   print('smth wrong')
+    return comp_name_max_amount
+
+def find_top_profit_4(comp_info_dict): # вариант 4: O(n ^ 2)
+
+    list_dict = list(comp_info_dict.items())  # O(n)
+
+    for i in range(len(list_dict)):
+        low_value = i
+        for j in range(i + 1, len(list_dict)):
+            if list_dict[j][1] > list_dict[low_value][1]:
+                low_value = j
+        list_dict[i], list_dict[low_value] = list_dict[low_value], list_dict[i]
+    # print(list_dict[0:3])
+    # for elem in list_dict[0:3]:
+    #     print(elem[0], ':', elem[1], ' ')
+    return list_dict[0:3]
+
+
+# если считала правильно, то первые три решения имееют сложностью O(n), а 4ое O(n ^ 2), что является 
+# более сложным алгоритмом, особенно при увеличении n
+# считаю, что первое решение эффективне из-за отсутствия большого применения встроенных ф-ций, 
+    # имеющих сложность O(n) и наглядности кода
+    # на маленьких n, большое число встроенных операций, имеющих сложность O(n), будет давать большое кол-во операций
+
+print('1 решение - Список компаний с наибольшей годовой прибылью:', find_top_profit_1(companies_info), '\n')
+print('2 решение - Список компаний с наибольшей годовой прибылью:', find_top_profit_2(companies_info), '\n')
+print('3 решение - Список компаний с наибольшей годовой прибылью:', find_top_profit_3(companies_info), '\n')
+print('4 решение - Список компаний с наибольшей годовой прибылью:', find_top_profit_4(companies_info), '\n')
+

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

@@ -27,3 +27,57 @@
 Для реализации хранилища можно применить любой подход,
 который вы придумаете, например, реализовать словарь.
 """
+
+# system_info_dict = {'login': [password, activ_boolean]}
+system_info_dict = {'Alex': ['qwerty', 1],
+                'Sam': ['q', 0],
+                'Sveta': ['qw', 1]
+                }
+
+
+def authorization(system_info, login, password):  # O(1) - константная сложность
+    try:
+        value_list = system_info.get(login)  # O(1) 
+        # print(value_list)
+        print('Проверка...\n')
+        if password == value_list[0]:
+            print('Авторизация пройдена')
+            if value_list[1]:
+                print('Вы допущены к ресурсу\n')
+            else:
+                print('Выша учетка не активирована. \nПожалуйста, пройдите активацию вашей учетной записи.\n')
+        else:
+            print('Неверный пароль\n')
+    # except:
+    #   print("Логина нету в базе")
+    except Exception as e:
+        print(f"Логина нету в базе, ошибка: {e}")
+
+
+def authorization_2(system_info, login, password):  # O(n) - линейная
+    print('Проверка...')
+    for key, value in system_info.items():  # O(n)
+        if key == login:
+            if password == value[0]:
+                print('Авторизация пройдена')
+                if value[1]:
+                    print('Вы допущены к ресурсу\n')
+                else:
+                    print('Выша учетка не активирована. \nПожалуйста, пройдите активацию вашей учетной записи.\n')
+                break
+            else:
+                print('Неверный пароль\n')
+    else:
+        print('Вы не зарегестрированы\n')
+
+
+user_login = 'Sveta'
+user_password = 'qw'
+print(f"Введен логин: {user_login} и пароль: {user_password}\n")
+authorization(system_info_dict, user_login, user_password)
+
+authorization_2(system_info_dict, user_login, user_password)
+
+# 3) сделайте вывод, какое решение эффективнее и почему
+# первое решение эффективнее, тк его сложность - константная, что меньше чем у 2ого решения, где сложность линейная
+# этого удалось добиться, используя встроенный ф-ции работы со словарем

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

@@ -17,4 +17,82 @@
 для реализации этой задачи.
 
 После реализации структуры, проверьте ее работу на различных сценариях
+
+класс PlateStackClass - описывает необходимую структуру данных
 """
+
+class PlateStackClass:
+    def __init__(self, max_size):
+        self.elems = []
+        self.max_size = max_size    # размер стопки
+
+    def __str__(self):
+        return str(self.elems)
+
+    def is_empty(self):
+        return self.elems == []
+
+    def push_in(self, el):
+        """Предполагаем, что верхний элемент стека находится в конце списка
+        если размер стопки равен пороговому значению то создается новая стопка и туда кладется значние"""
+        if len(self.elems) == 0:
+            self.elems.append([el])
+        elif len(self.elems[len(self.elems) - 1]) < self.max_size:
+            self.elems[len(self.elems) - 1].append(el)
+        else:
+            self.elems.append([])
+            self.elems[len(self.elems) - 1].append(el)
+
+    def pop_out(self):
+        """Берем тарелку из крайней стопки, если она пустая удаляем ее"""
+        if len(self.elems) == 0:
+            result = False
+        else:
+            result = self.elems[len(self.elems) - 1].pop()
+            if len(self.elems[len(self.elems) - 1]) == 0:
+                self.elems.pop()
+        return result
+
+    def get_val(self):
+        return False if len(self.elems)==0 else self.elems[len(self.elems) - 1][len(self.elems[len(self.elems) - 1])-1]
+
+    def stack_size(self):
+        """Общее количество тарелок"""
+        elem_sum = 0
+        for stack in self.elems:
+            elem_sum += len(stack)
+        return elem_sum
+
+    def stack_count(self):
+        """Количество стоек"""
+        return len(self.elems)
+
+
+if __name__ == '__main__':
+
+    kitchen = PlateStackClass(3)
+    print('Стопка тарелок:', kitchen.elems)
+
+    print('Проверка на пустую стопку:', kitchen.is_empty(), '\n')
+
+    kitchen.push_in('plate1')
+    kitchen.push_in('plate2')
+
+    kitchen.push_in('plate3')
+    kitchen.push_in('plate4')
+    kitchen.push_in('plate5')
+    kitchen.push_in('plate6')
+    kitchen.push_in('plate7')
+
+    print('Проверка на пустую стопку:', kitchen.is_empty(), '\n')
+
+    # получаем значение первого элемента с вершины стека, но не удаляем сам элемент из стека
+    print(kitchen.get_val())
+    print('Стопка тарелок:', kitchen.elems, '\n')
+    # убираем элемент с вершины стека и возвращаем его значение
+    print(kitchen.pop_out())
+
+    print('Стопка тарелок:', kitchen.elems, '\n')
+    print('Колличество тарелок:', kitchen.stack_size() )
+    print('Колличество стопок тарелок:', kitchen.stack_count())
+