Lesson7

task1.py

@@ -0,0 +1,69 @@
+"""
+1. Отсортируйте по убыванию методом "пузырька" одномерный целочисленный массив,
+заданный случайными числами на промежутке [-100; 100). Выведите на экран
+исходный и отсортированный массивы.
+Сортировка должна быть реализована в виде функции.
+Обязательно доработайте алгоритм (сделайте его умнее).
+Идея доработки: если за проход по списку не совершается ни одной сортировки,
+то завершение. Обязательно сделайте замеры времени обеих реализаций
+и обосновать дала ли оптимизация эффективность
+Подсказка: обратите внимание, сортируем не по возрастанию, как в примере,
+а по убыванию.
+Сделайте выводы!!!
+Опишите в чем была ваша доработка и помогла ли вам доработка??
+"""
+
+# Сделал доработку из подсказки. Сделал три пары замеров:
+# - С уже отсортированным списком
+# - С относительно большими случайными списками
+# - С очень маленькими случайными спискоми
+# В первом случае улучшенный алгоритм работает на порядок быстрее, в третьем улучшенный работает чуть быстрее,
+# а во втором разницы почти нет. Связанно это с тем, что маленькие списки с гораздо большей вероятностью
+# генерируются полностью или частично отсортированными, чем большие, а доработка расчитана как раз на такие случаи.
+# Замеры с уже отсортированным списком показывают, что доработка действует.
+
+
+from random import randint
+from timeit import timeit
+
+
+def create_rand_lst(num):
+    return [randint(-100, 100) for _ in range(num)]
+
+
+def sort_bubble(lst):
+    n = 1
+    while n < len(lst):
+        for i in range(len(lst) - n):
+            if lst[i] < lst[i + 1]:
+                lst[i], lst[i + 1] = lst[i + 1], lst[i]
+        n += 1
+    return lst
+
+
+def better_sort_bubble(lst):
+    n = 1
+    while n < len(lst):
+        sort_count = 0
+        for i in range(len(lst) - n):
+            if lst[i] < lst[i + 1]:
+                sort_count = 1
+                lst[i], lst[i + 1] = lst[i + 1], lst[i]
+        if sort_count == 0:
+            break
+        n += 1
+    return lst
+
+
+lst1 = create_rand_lst(100)
+print(lst1)
+print(sort_bubble(lst1))
+print(timeit('sort_bubble(lst1)', number=1000, globals=globals()))
+print(timeit('better_sort_bubble(lst1)', number=1000, globals=globals()))
+
+print(timeit('sort_bubble(create_rand_lst(100))', number=10000, globals=globals()))
+print(timeit('better_sort_bubble(create_rand_lst(100))', number=10000, globals=globals()))
+
+print(timeit('sort_bubble(create_rand_lst(5))', number=1000000, globals=globals()))
+print(timeit('better_sort_bubble(create_rand_lst(5))', number=1000000, globals=globals()))
+

task2.py

@@ -0,0 +1,71 @@
+"""
+2. Отсортируйте по возрастанию методом слияния одномерный вещественный массив,
+заданный случайными числами на промежутке [0; 50). Выведите на экран исходный
+и отсортированный массивы.
+Хотя в примерах к уроку уже есть вариант реализации слияния,
+попробуйте предложить другой (придумать или найти).
+И попытаться сделать замеры на массивах разной длины: 10, 100, 1000, ...
+Пример:
+Введите число элементов: 5
+Исходный - [46.11436617832828, 41.62921998361278, 18.45859540989644, 12.128870723745806, 8.025098788570562]
+Отсортированный - [8.025098788570562, 12.128870723745806, 18.45859540989644, 41.62921998361278, 46.11436617832828]
+"""
+
+
+# Замеры показали, что пузырьковый метод работает быстрее на списках размером меньше 20 элементов,
+# после этого слияние работает быстрее и чем больше размер списка, тем существеннее разница в скорости.
+
+
+from random import uniform
+from timeit import timeit
+
+
+def create_rand_lst(num):
+    return [uniform(0, 50) for _ in range(num)]
+
+
+def merge_sort(lst):
+    if len(lst) < 2:
+        return lst
+    result = []
+    mid = len(lst) // 2
+    left = merge_sort(lst[:mid])
+    right = merge_sort(lst[mid:])
+    i = 0
+    j = 0
+    while i < len(left) and j < len(right):
+        if left[i] > right[j]:
+            result.append(right[j])
+            j += 1
+        else:
+            result.append(left[i])
+            i += 1
+    result += left[i:]
+    result += right[j:]
+    return result
+
+
+# Пузырьковая сортировка из первого задания для сравнения
+def better_sort_bubble(lst):
+    n = 1
+    while n < len(lst):
+        sort_count = 0
+        for i in range(len(lst) - n):
+            if lst[i] < lst[i + 1]:
+                sort_count = 1
+                lst[i], lst[i + 1] = lst[i + 1], lst[i]
+        if sort_count == 0:
+            break
+        n += 1
+    return lst
+
+
+lst1 = create_rand_lst(10)
+print(lst1)
+print(merge_sort(lst1))
+print(timeit('merge_sort(create_rand_lst(10))', number=10000, globals=globals()))
+print(timeit('better_sort_bubble(create_rand_lst(10))', number=10000, globals=globals()))
+print(timeit('merge_sort(create_rand_lst(100))', number=10000, globals=globals()))
+print(timeit('better_sort_bubble(create_rand_lst(100))', number=10000, globals=globals()))
+print(timeit('merge_sort(create_rand_lst(1000))', number=10000, globals=globals()))
+print(timeit('better_sort_bubble(create_rand_lst(1000))', number=10000, globals=globals()))

task3.py

@@ -0,0 +1,48 @@
+"""
+3. Массив размером 2m + 1, где m – натуральное число, заполнен случайным образом.
+Найдите в массиве медиану. Медианой называется элемент ряда, делящий его на
+две равные по длине части: в одной находятся элементы, которые не меньше медианы,
+в другой – не больше медианы.
+Задачу можно решить без сортировки исходного массива.
+Но если это слишком сложно, то используйте метод сортировки,
+который не рассматривался на уроках: Шелла, Гномья, Кучей...
+[5, 3, 4, 3, 3, 3, 3]
+[3, 3, 3, 3, 3, 4, 5]
+my_lst
+new_lts
+arr[m]
+from statistics import median
+[3, 4, 3, 3, 5, 3, 3]
+left = []
+right = []
+left == right and
+for i in
+    for
+    left == right
+    left.clear()
+    right.clear()
+"""
+
+
+def median(lst):
+    half = len(lst)//2
+    smaller = []
+    bigger = []
+    m = lst[0]
+    for i in lst:
+        if i > m:
+            bigger.append(i)
+            if len(bigger) >= half:
+                smaller.append(m)
+                m = min(bigger)
+                bigger.remove(m)
+        elif i < m:
+            smaller.append(i)
+            if len(smaller) >= half:
+                bigger.append(m)
+                m = max(smaller)
+                smaller.remove(m)
+    return m
+
+
+print(median([3, 3, 3, 3, 3, 4, 5]))