DZ7

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

@@ -9,3 +9,50 @@
 Подсказка: обратите внимание, сортируем не по возрастанию, как в примере,
 а по убыванию
 """
+from random import randint
+from timeit import timeit
+
+LST = [randint(-100, 100) for _ in range(30)]
+print(LST)
+
+
+def bubble_1(old_lst, cnt=0):
+    lst = old_lst[:]
+    for _ in range(len(lst) - 1):
+        for i in range(len(lst)):
+            if lst[i] > lst[i - 1] and i > 0:
+                lst[i], lst[i - 1] = lst[i - 1], lst[i]
+    return lst
+
+
+print(timeit("bubble_1(LST)", \
+             setup="from __main__ import bubble_1, LST", number=100))
+print(bubble_1(LST))
+
+
+def bubble_2(old_lst, sort=1):
+    lst = old_lst[:]
+    while sort > 0:
+        sort = 0
+        for i in range(len(lst)):
+            if lst[i] > lst[i - 1] and i > 0:
+                lst[i], lst[i - 1] = lst[i - 1], lst[i]
+                sort += 1
+    return lst
+
+
+print(timeit("bubble_2(LST)", \
+             setup="from __main__ import bubble_2, LST", number=100))
+
+print(bubble_2(LST))
+
+print(LST)
+
+"""
+Доработка скрипта привела к тому что в большинстве случаев скорость выполнения увеличилась
+один из вариантов
+0.015818744000000003 - старый вариант
+0.009746643000000013 - новый
+Я пробовал ставить счетчики на циклы, вышло что в наилучшем случае при списке длиной в 10 элементов
+улучшеный скрипт справлялся за 5 проходов вместо 9. Но чаще это 8 или 7.
+"""

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

@@ -8,3 +8,91 @@
 Исходный - [46.11436617832828, 41.62921998361278, 18.45859540989644, 12.128870723745806, 8.025098788570562]
 Отсортированный - [8.025098788570562, 12.128870723745806, 18.45859540989644, 41.62921998361278, 46.11436617832828]
 """
+
+from random import uniform
+from timeit import timeit
+
+element = int(input('Введите число элементов:'))
+LST = [uniform(0, 50) for _ in range(element)]
+LST1 = LST[:]
+print(LST)
+
+'''
+Это первая версия. Ее я решил написать не заглядывая в ваш пример.
+Она оказалась рабочая, но работала медленнее чем ваша.
+Чем больше был массив, тем больше разница. При массиве
+в 100 тыс она была уже в 3 раз, на 200 в 5, и дальше увеличивалась в разы
+миллион было уже не дождаться.
+Тогда я посмотрел вашу версию и перелелал часть своей.
+Стала летать.
+
+Возможно моя работала медленнее из-за того что использовал  extend и pop
+
+
+'''
+
+
+def merger_sort_1(lst):
+    center = len(lst) // 2
+    tmp = []
+    left_list = lst[:center]
+    right_list = lst[center:]
+    if len(left_list) > 1:
+        left_list = merger_sort_1(left_list)
+    if len(right_list) > 1:
+        right_list = merger_sort_1(right_list)
+
+    while True:
+        if len(left_list) == 0:
+            tmp.extend(right_list)
+            break
+        elif len(right_list) == 0:
+            tmp.extend(left_list)
+            break
+        if left_list[0] < right_list[0]:
+            tmp.append(left_list.pop(0))
+        else:
+            tmp.append(right_list.pop(0))
+    return tmp
+
+
+def merger_sort_2(lst):
+    center = len(lst) // 2
+    left_list = lst[:center]
+    right_list = lst[center:]
+    if len(left_list) > 1:
+        left_list = merger_sort_2(left_list)
+    if len(right_list) > 1:
+        right_list = merger_sort_2(right_list)
+
+    i, j, k = 0, 0, 0
+    while i < len(left_list) and j < len(right_list):
+        if left_list[i] < right_list[j]:
+            lst[k] = left_list[i]
+            i += 1
+        else:
+            lst[k] = right_list[j]
+            j += 1
+        k += 1
+
+    while i < len(left_list):
+        lst[k] = left_list[i]
+        i += 1
+        k += 1
+
+    while j < len(right_list):
+        lst[k] = right_list[j]
+        j += 1
+        k += 1
+    return lst
+
+
+print(timeit("merger_sort_1(LST1)", \
+             setup="from __main__ import merger_sort_1, LST1", number=1))
+
+print(merger_sort_1(LST1))
+
+print(timeit("merger_sort_2(LST)", \
+             setup="from __main__ import merger_sort_2, LST", number=1))
+
+print(merger_sort_2(LST))

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

@@ -6,3 +6,45 @@
 массива. Но если это слишком сложно, то используйте метод сортировки,
 который не рассматривался на уроках
 """
+from random import randint
+
+M = 5
+LST = [randint(0, 50) for _ in range(2 * M + 1)]
+
+
+def median(lst, old_lst):
+    left_lst_old = [i for i in old_lst if i < lst[0]]
+    right_lst_old = [i for i in old_lst if i > lst[0]]
+    cnt = lst.count(lst[0])
+    if cnt > 1:
+        for i in range(cnt - 1):
+            if len(left_lst_old) > len(right_lst_old):
+                right_lst_old.append(lst[0])
+            else:
+                left_lst_old.append(lst[0])
+
+    left_lst = [i for i in lst if i < lst[0]]
+    right_lst = [i for i in lst if i > lst[0]]
+
+    if len(left_lst_old) == len(right_lst_old):
+        return lst[0]
+
+    elif len(left_lst_old) > len(right_lst_old):
+        return median(left_lst, old_lst)
+    else:
+        return median(right_lst, old_lst)
+
+
+print(f'В массиве {LST} медианой является число {median(LST, LST)}')
+
+
+"""
+Вычисление происходит с помошью рекурсии. Берется 0-й элемент массива. Находятся все элементы меньше него
+и больше него. Если элемент присутствует несколько раз, то элементы раскидываются по левому и правому списку
+для уравновешивания. Если списки равны по длинне, то медиана найдена. Если нет, то надо брать следующий элемент,
+но тогда пришлось бы перебирать все, пока не попадется нужный. Что бы ускорить процесс, мы паралельно создаем еще
+правый и левый список, без повторов опорного элемента и тех значений которые мы уже отсекли, и если правый список 
+длиннее левого, то значит что медиана находится там, именно его мы и отправляем рекурсивно в функцию, которая снова
+делит список и ищет медиану, сверяясь с старым, полным списком. Так как мы каждый раз отсекаем диапазон чисел, 
+поиск происходит быстро.
+"""