HomeWorks

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

@@ -0,0 +1,80 @@
+"""
+Задание 1.
+
+Для каждой из трех задач выполнить следующее:
+
+1) для каждой инструкции рядом в комментарии определите сложность этой инструкции
+2) определите сложность алгоритма в целом
+
+укажите сложность непосредственно в этом файле
+точки, где нужно поработать вам, отмечены знаком '!!!'
+Не забудтье оценить итоговую сложность каждого из трех алгоритмов.
+
+Примечание:
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+"""
+
+import random
+
+
+#############################################################################################
+def check_1(lst_obj):
+    """Функция должна создать множество из списка.
+
+    Алгоритм 3:
+    Создать множество из списка
+
+    Сложность: !!!. O(n) -- из-за количества элементов массива
+    """
+    lst_to_set = set(lst_obj)  # !!! O(n)
+    return lst_to_set  # !!! O(1)
+
+
+#############################################################################################
+def check_2(lst_obj):
+    """Функция должная вернуть True, если все элементы списка различаются.
+
+    Алгоритм 1:
+    Проходимся по списку и для каждого элемента проверяем,
+    что такой элемент отстутствует
+    в оставшихся справа элементах
+
+    Сложность: !!!. O(n)
+    """
+    for j in range(len(lst_obj)):          # !!! O(n)
+        if lst_obj[j] in lst_obj[j+1:]:    # !!! O(1)
+            return False                   # !!! O(1)
+    return True                            # !!! o(1)
+
+
+#############################################################################################
+def check_3(lst_obj):
+    """Функция должная вернуть True, если все элементы списка различаются.
+
+    Алгоритм 2:
+    Вначале выполним для списка сортировку, далее, сравниваем элементы попарно
+    Если присутствуют дубли, они будут находиться рядом.
+
+    Сложность: !!! O(n)
+    """
+    lst_copy = list(lst_obj)                 # !!! O(n)
+    lst_copy.sort()                          # !!! O(n)
+    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)
+
+#############################################################################################
+
+
+for j in (50, 500, 1000, 5000, 1000):
+    # Из 100000 чисел возьмем 'j' случайно выбранных
+    # Всего 10 тыс. чисел
+    lst = random.sample(range(-100000, 100000), j)
+
+print(check_1(lst))
+print(check_2(lst))
+print(check_3(lst))

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

@@ -0,0 +1,41 @@
+"""
+Задание 2.
+
+Реализуйте два алгоритма.
+
+Первый, в виде функции, должен обеспечивать поиск минимального значения для списка.
+В основе алгоритма должно быть сравнение каждого числа со всеми другими элементами списка.
+Сложность такого алгоритма: O(n^2) - квадратичная.
+
+Второй, в виде функции, должен обеспечивать поиск минимального значения для списка.
+Сложность такого алгоритма: O(n) - линейная.
+
+Не забудьте указать где какая сложность.
+
+Примечание:
+Построить список можно через списковое включение.
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+"""
+# Квадратичная сложность
+def alg_1 (lst_obj):
+
+    l_list_obj = list(lst_obj)
+    l_first = l_list_obj[1]
+    for idx in range(len(l_list_obj)):
+        for idx1 in idx:
+            if l_first < l_list_obj[idx]:
+               l_first = l_list_obj[idx]
+    return l_first
+
+# Линейная сложность
+def alg_2 (lst_obj):
+
+    l_list_obj = list(lst_obj)
+    l_first = l_list_obj[1]
+    for idx in range(len(l_list_obj)):
+        if l_first < l_list_obj[idx]:
+            l_first = l_list_obj[idx]
+    return l_first

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

@@ -0,0 +1,66 @@
+"""
+Задание 3.
+
+Для этой задачи:
+1) придумайте 2-3 решения (не менее двух)
+2) оцените сложность каждого решения в нотации О-большое
+3) сделайте вывод, какое решение эффективнее и почему
+
+Примечание:
+Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
+через строки документации в самом коде.
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+
+Сама задача:
+Имеется хранилище с информацией о компаниях: название и годовая прибыль.
+Для реализации хранилища можно применить любой подход,
+который вы придумаете, например, реализовать словарь.
+Реализуйте поиск трех компаний с наибольшей годовой прибылью.
+Выведите результат.
+"""
+"""
+
+import operator
+
+dict1 = {"one": 10000, "two": 30000, "three": 15000, "four": 25000, "five": 20000}
+sorted_values = sorted(dict1.values()) # Sort the values
+sorted_dict = {}
+
+for i in sorted_values:
+    for k in dict1.keys():
+        if dict1[k] == i:
+            sorted_dict[k] = dict1[k]
+            break
+a =  sorted_dict
+print(sorted(a))
+b = sorted(a, reverse = True)
+
+print(b)
+"""
+
+"""
+import operator
+
+dict1 = {"one": 10000, "two": 30000, "three": 15000, "four": 25000, "five": 20000}
+sorted_tuples = sorted(dict1.items(), key=operator.itemgetter(1))
+print(sorted_tuples)  # [(1, 1), (3, 4), (2, 9)]
+sorted_dict = {k: v for k, v in sorted_tuples}
+
+print(sorted_dict) # {1: 1, 3: 4, 2: 9}
+a = sorted(dict1, reverse=True)
+print(a) #
+"""
+
+D = {"one": 10000, "two": 30000, "three": 15000, "four": 25000, "five": 20000}
+my_max_val = 0
+for k,v in D.items():
+    if v > my_max_val:
+        my_max_val=v
+        my_max_key=k
+
+print(my_max_key)
+#  Сложность О(n)
+#  Задание выполнил насколько смог. Много время потратил. Видимо, для меня пока не под силу решать подобные задачи.

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

@@ -1,15 +1,12 @@
 """
 Задание 1.
-
 Для каждой из трех задач выполнить следующее:
-
 1) для каждой инструкции рядом в комментарии определите сложность этой инструкции
 2) определите сложность алгоритма в целом
-
 укажите сложность непосредственно в этом файле
 точки, где нужно поработать вам, отмечены знаком '!!!'
-
-Примечание:
+Не забудтье оценить итоговую сложность каждого из трех алгоритмов.
+Примечание
 Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
 а не писать "мы это не проходили)".
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
@@ -22,49 +19,45 @@
 #############################################################################################
 def check_1(lst_obj):
     """Функция должна создать множество из списка.
-
     Алгоритм 3:
     Создать множество из списка
-
-    Сложность: !!!.
+    Сложность: !!!. O(n) -- из-за количества элементов массива
     """
-    lst_to_set = set(lst_obj)  # !!!
-    return lst_to_set
+    lst_to_set = set(lst_obj)  # !!! O(n)
+    return lst_to_set  # !!! O(1)
 
 
 #############################################################################################
 def check_2(lst_obj):
     """Функция должная вернуть True, если все элементы списка различаются.
-
     Алгоритм 1:
     Проходимся по списку и для каждого элемента проверяем,
     что такой элемент отстутствует
     в оставшихся справа элементах
-
-    Сложность: !!!.
+    Сложность: !!!. O(n)
     """
-    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) - срез + in:
+                                           #  O(n) + O(n) = O(n)
+            return False                   # !!! O(1)
+    return True                            # !!! o(1)
 
 
 #############################################################################################
 def check_3(lst_obj):
     """Функция должная вернуть True, если все элементы списка различаются.
-
     Алгоритм 2:
     Вначале выполним для списка сортировку, далее, сравниваем элементы попарно
     Если присутствуют дубли, они будут находиться рядом.
-
-    Сложность: !!!
+    Сложность: !!! O(n log n)
     """
-    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(n)
+    lst_copy.sort()                          # !!! O(n log n) - встроенная
+                                                 #  сортировка (алгоритм Timsort)
+    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

@@ -1,19 +1,36 @@
 """
 Задание 2.
-
 Реализуйте два алгоритма.
-
 Первый, в виде функции, должен обеспечивать поиск минимального значения для списка.
 В основе алгоритма должно быть сравнение каждого числа со всеми другими элементами списка.
 Сложность такого алгоритма: O(n^2) - квадратичная.
-
 Второй, в виде функции, должен обеспечивать поиск минимального значения для списка.
 Сложность такого алгоритма: O(n) - линейная.
-
+Не забудьте указать где какая сложность.
 Примечание:
-Построить список можно через генератор списка.
+Построить список можно через списковое включение.
 Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
 а не писать "мы это не проходили)".
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
 А без столкновения со сложностями его не развить.
 """
+# Квадратичная сложность
+def alg_1 (lst_obj):
+
+    l_list_obj = list(lst_obj)
+    l_first = l_list_obj[1]
+    for idx in range(len(l_list_obj)):
+        for idx1 in idx:
+            if l_first < l_list_obj[idx]:
+               l_first = l_list_obj[idx]
+    return l_first
+
+# Линейная сложность
+def alg_2 (lst_obj):
+
+    l_list_obj = list(lst_obj)
+    l_first = l_list_obj[1]
+    for idx in range(len(l_list_obj)):
+        if l_first < l_list_obj[idx]:
+            l_first = l_list_obj[idx]
+    return l_first

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

@@ -1,24 +1,77 @@
 """
 Задание 3.
-
 Для этой задачи:
-1) придумайте 1-3 решения (желательно хотя бы два)
+1) придумайте 2-3 решения (не менее двух)
 2) оцените сложность каждого решения в нотации О-большое
 3) сделайте вывод, какое решение эффективнее и почему
-
 Примечание:
 Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
 через строки документации в самом коде.
 Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
 а не писать "мы это не проходили)".
 Алгоритмизатор должен развивать мышление, а это прежде всего практика.
 А без столкновения со сложностями его не развить.
-
-
 Сама задача:
 Имеется хранилище с информацией о компаниях: название и годовая прибыль.
 Для реализации хранилища можно применить любой подход,
 который вы придумаете, например, реализовать словарь.
 Реализуйте поиск трех компаний с наибольшей годовой прибылью.
 Выведите результат.
 """
+
+# Линейная сложность — O(n)
+# Функция схожа с линейной сложностью, так как идет перебор массива для поиска 3 максимальных значений. Количество шагов = количеству элементов в массиве.
+# O(n) - в нотации О-большое
+def var_1 (dict_obj):
+    l_result_dict = {'Первая кампания': 0, 'Вторая кампания': 0, 'Третья кампания': 0}
+
+    for idx in dict_obj:                                           #O(n)
+          if l_result_dict.get('Первая кампания') == 0 :
+              l_result_dict.update({'Первая кампания': idx})
+              continue
+          if  l_result_dict.get('Вторая кампания') == 0 :
+              l_result_dict.update({'Вторая кампания': idx})
+              continue
+          if  l_result_dict.get('Третья кампания') == 0 :
+              l_result_dict.update({'Третья кампания': idx})
+              continue
+
+          if dict_obj.get(idx) > dict_obj.get(l_result_dict.get('Первая кампания')):
+              l_result_dict.update({'Третья кампания': l_result_dict.get('Вторая кампания')})
+              l_result_dict.update({'Вторая кампания': l_result_dict.get('Первая кампания')})
+              l_result_dict.update({'Первая кампания': idx})
+              continue
+          elif dict_obj.get(idx) > dict_obj.get(l_result_dict.get('Вторая кампания')):
+              l_result_dict.update({'Третья кампания': l_result_dict.get('Вторая кампания')})
+              l_result_dict.update({'Вторая кампания': idx})
+              continue
+          elif dict_obj.get(idx) > dict_obj.get(l_result_dict.get('Третья кампания')):
+              l_result_dict.update({'Третья кампания': idx})
+              continue
+
+    return l_result_dict
+# Квадратичная сложность — O(n2)
+# Функция схожа с Квадратичной сложностью, так как идет цикл в цикле, из-за этого O(n2)
+# O(n2) - в нотации О-большое
+def var_2 (dict_obj):
+    l_result_dict = {'Первая кампания': 0, 'Вторая кампания': 0, 'Третья кампания': 0}
+
+    for idx in dict_obj:                                     #Один Цикл
+      for idx1 in reversed(l_result_dict):                   #Второй цикл внутри первого
+         if l_result_dict.get(idx1) == 0:
+             l_result_dict.update({idx1: dict_obj.get(idx)})
+
+         if l_result_dict.get(idx1) < dict_obj.get(idx):
+             continue
+         else:
+             l_result_dict.update({idx1: dict_obj.get(idx)})
+
+    return l_result_dict
+
+d = {'NKP1': 1000000000, 'NKP2': 2000000, 'NKP3': 123456778, 'NKP4': 6789034546}
+
+print(var_1(d))
+print(var_2(d))
+
+# Как итог, две функции возвращают одинаковое значение кампаний.
+# Эффективным решением считаю 2, оно более гибкое, и не настроена на перебор как в первом случае.