first commit

task_1.py

@@ -0,0 +1,81 @@
+"""
+Задание 1.
+
+Для каждой из трех задач выполнить следующее:
+
+1) для каждой инструкции рядом в комментарии определите сложность этой инструкции
+2) определите сложность алгоритма в целом
+
+укажите сложность непосредственно в этом файле
+точки, где нужно поработать вам, отмечены знаком '!!!'
+Не забудтье оценить итоговую сложность каждого из трех алгоритмов.
+
+Примечание:
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+"""
+
+import random
+
+
+#############################################################################################
+def check_1(lst_obj):
+    """Функция должна создать множество из списка.
+
+    Алгоритм 3:
+    Создать множество из списка
+
+    Сложность: n + с => O(n) - линейная.
+    """
+    lst_to_set = set(lst_obj)  # O(n) - линейная
+    return lst_to_set  # O(1) - константная
+
+
+#############################################################################################
+def check_2(lst_obj):
+    """Функция должная вернуть True, если все элементы списка различаются.
+
+    Алгоритм 1:
+    Проходимся по списку и для каждого элемента проверяем,
+    что такой элемент отстутствует
+    в оставшихся справа элементах
+
+    Сложность: n * n + с => O(n^2) - квадратичная.
+    """
+    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:
+    Вначале выполним для списка сортировку, далее, сравниваем элементы попарно
+    Если присутствуют дубли, они будут находиться рядом.
+
+    Сложность: n + nlogn + n * c + c => O(n log n) -линейно-логарифмическая
+                (хотя если там не сравнение констант, то сложность квадратичная)
+    """
+    lst_copy = list(lst_obj)                 # O(n) - линейная
+    lst_copy.sort()                          # O(n log 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))

task_2.py

@@ -0,0 +1,44 @@
+"""
+Задание 2.
+
+Реализуйте два алгоритма.
+
+Первый, в виде функции, должен обеспечивать поиск минимального значения для списка.
+В основе алгоритма должно быть сравнение каждого числа со всеми другими элементами списка.
+Сложность такого алгоритма: O(n^2) - квадратичная.
+
+Второй, в виде функции, должен обеспечивать поиск минимального значения для списка.
+Сложность такого алгоритма: O(n) - линейная.
+
+Не забудьте указать где какая сложность.
+
+Примечание:
+Построить список можно через списковое включение.
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+"""
+
+
+def min_n2(lst):  # O(n^2) <= n * (n + c) + c
+    for i in lst:
+        for j in lst:
+            if i > j:
+                break
+            elif i < j and j == lst[-1]:
+                return i
+
+
+def min_n(lst):  # O(n) <= n + n * c + c
+    result = lst[0]
+    for i in lst:
+        if result > i:
+            result = i
+    return result
+
+
+user_list = [2, 3, 4, 10, 1, 8]
+
+print(min_n2(user_list))
+print(min_n(user_list))

task_3.py

@@ -0,0 +1,71 @@
+"""
+Задание 3.
+
+Для этой задачи:
+1) придумайте 2-3 решения (не менее двух)
+2) оцените сложность каждого решения в нотации О-большое
+3) сделайте вывод, какое решение эффективнее и почему
+
+Примечание:
+Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
+через строки документации в самом коде.
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+
+Сама задача:
+Имеется хранилище с информацией о компаниях: название и годовая прибыль.
+Для реализации хранилища можно применить любой подход,
+который вы придумаете, например, реализовать словарь.
+Реализуйте поиск трех компаний с наибольшей годовой прибылью.
+Выведите результат.
+"""
+
+# В задании не указано, что делать, если у двух компаний одинаковая годовая прибыль и это влияет на результат.
+# Поэтому в этом случае в результат попадает случайная(ые) компания(ии) из подобных, если все попасть не могут.
+
+def max3_1(dct):  # O(n log n) <= nlogn + 3
+    return sorted(dct, key=dct.get)[-3:]
+
+
+def max3_2(dct):  # O(n log n) <= c + n + nlogn + 3
+    lst = list(dct.items())
+    lst.sort(key=lambda i: i[1])
+    return lst[-3:]
+
+
+def max3_3(dct):  # O(n) - много кода, но только в одном месте линейная сложность, а в остальных константные
+    result = []  # O(1)
+    min_result = []  # O(1)
+
+    def min_res_func(mr):
+        for i in result:  # O(1) ибо длина result всегда 3
+            if i[1] < mr[1]:   # O(1)
+                mr = i  # O(1)
+        return mr  # O(1)
+
+    for key, value in dct.items():  # O(n)
+        if len(result) < 3:  # O(1)
+            result.append([key, value])   # O(1)
+            if len(result) == 3:   # O(1)
+                min_result = result[0]  # O(1)
+                min_result = min_res_func(min_result)  # O(1) - ибо длина result всегда 3
+        else:   # O(1)
+            if value > min_result[1]:   # O(1)
+                result.remove(min_result)  # O(1) - ибо длина result всегда 3
+                result.append([key, value])  # O(1)
+                min_result = min_res_func(result[0])  # O(1) - ибо длина result всегда 3
+    return result  # O(1)
+
+
+'''
+Вывод - третий вариант имеет наименьшую сложность, однако наибольший размер кода.
+Так что я бы сказал, что первые два варианта эффективнее при небольшом количестве компаний, а третий - при большом.
+'''
+
+companies = {'A': 12000, 'B': 1000, 'C': 2600, 'D': 15000, 'E': 10000}
+
+print(max3_1(companies))
+print(max3_2(companies))
+print(max3_3(companies))

task_4.py

@@ -0,0 +1,83 @@
+"""
+Задание 4.
+
+Для этой задачи:
+1) придумайте 2-3 решения (не менее двух)
+2) оцените сложность каждого решения в нотации О-большое
+3) сделайте вывод, какое решение эффективнее и почему
+
+Примечание:
+Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
+через строки документации в самом коде.
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+
+Сама задача:
+Пользователи веб-ресурса проходят аутентификацию.
+В системе хранятся логин, пароль и отметка об активации учетной записи.
+
+Нужно реализовать проверку, может ли пользователь быть допущен к ресурсу.
+При этом его учетка должна быть активирована.
+А если нет, то польз-лю нужно предложить ее пройти.
+
+Приложение должно давать ответы на эти вопросы и быть реализовано в виде функции.
+Для реализации хранилища можно применить любой подход,
+который вы придумаете, например, реализовать словарь.
+"""
+
+
+def check_1(dct):  # O(1) - всё постоянное
+    while True:
+        user = input('Введите логин: ')
+        try:
+            user = dct[user]
+            break
+        except KeyError:
+            pass
+    if user['activation']:
+        for _ in range(5):
+            password = input('Введите пароль: ')
+            if user['password'] == password:
+                print('Вы вошли')
+                break
+    else:
+        answer = input('Хотите активировать учётную запись?: ')
+        if answer.lower() == 'да':
+            user['activation'] = True
+            print('Ваша учётная запись активирована')
+
+
+def check_2(dct):  # O(n) - линейный только цикл по перебору ключей словаря, остальное всё постоянное
+
+    def login_check():
+        for _ in range(5):
+            user = input('Введите логин: ')
+            for key in dct:
+                if key == user:
+                    return user
+        print("Превышено количество попыток")
+
+    user = login_check()
+    if dct[user]['activation']:
+        for _ in range(5):
+            password = input('Введите пароль: ')
+            if dct[user]['password'] == password:
+                print('Вы вошли')
+                break
+    else:
+        answer = input('Хотите активировать учётную запись?: ')
+        if answer.lower() == 'да':
+            dct[user]['activation'] = True
+            print('Ваша учётная запись активирована')
+
+
+# Задание сложнее предыдущего по вариативности на мой взгляд, поэтому варианты весьма похожи.
+# Засчёт цикла while True первый вариант может выполняться бесконечно, поэтому второй вариант предпочтительней.
+# Хотя по сути лучший решением была бы комбинация, где во втором варианте при вводе логина, используются не два цикла for, а цикл for и try/except
+
+
+users = {'login1': {'password': 'pass1', 'activation': True}, 'login2': {'password': 'pass2', 'activation': False}}
+check_1(users)
+print(users)