From 890447d696b7b58e5bb476ff0cf09735b121f386 Mon Sep 17 00:00:00 2001 From: Tatyana <> Date: Sun, 20 Jan 2019 18:00:58 +0300 Subject: [PATCH 1/5] up --- task_1.py | 109 ++++++++++++++++++++++++++++++++++++++++++++++++ task_2.py | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 231 insertions(+) create mode 100644 task_1.py create mode 100644 task_2.py diff --git a/task_1.py b/task_1.py new file mode 100644 index 0000000..dee0f20 --- /dev/null +++ b/task_1.py @@ -0,0 +1,109 @@ +# 1. Проанализировать скорость и сложность одного любого алгоритма, разработанных в рамках домашнего задания первых трех уроков. +# +# В диапазоне натуральных чисел от 2 до 99 определить, сколько из них кратны любому из чисел в диапазоне от 2 до 9. +import cProfile + +RANGE_START = 2 + + +# Способ 1. Перебор +def func1(range_stop): + nums_data = dict() + for i in range(2, 10): + nums_data[i] = 0 + + for num in range(RANGE_START, range_stop + 1): + for i in nums_data.keys(): + if num % i == 0: + nums_data[i] += 1 + + return nums_data + + +# 100 loops, best of 5: 53.6 usec per loop - 99 +# 100 loops, best of 5: 551 usec per loop - 999 +# 100 loops, best of 5: 5.75 msec per loop - 9999 + +# cProfile.run('func1(99)') +# +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.000 0.000 :1() +# 1 0.000 0.000 0.000 0.000 task_1.py:7(func1) +# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} +# 98 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} + +# cProfile.run('func1(999)') +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.001 0.001 :1() +# 1 0.001 0.001 0.001 0.001 task_1.py:7(func1) +# 1 0.000 0.000 0.001 0.001 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} +# 998 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} + +# print(func1(99)) + +# Способ 2. Целочисленное деление +def func2(range_stop): + nums_data = dict() + for i in range(2, 10): + nums_data[i] = range_stop // i + + return nums_data + + +# 100 loops, best of 5: 901 nsec per loop - 99 +# 100 loops, best of 5: 950 nsec per loop - 999 +# 100 loops, best of 5: 965 nsec per loop - 9999 +# 100 loops, best of 5: 966 nsec per loop - 99999 + +# cProfile.run('func2(99)') +# +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.000 0.000 :1() +# 1 0.000 0.000 0.000 0.000 task_1.py:45(func2) +# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + +# cProfile.run('func2(999)') +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.000 0.000 :1() +# 1 0.000 0.000 0.000 0.000 task_1.py:45(func2) +# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + + +# Способ 3. Пройти диапазон для каждого числа 2-9 +def func3(range_stop): + nums_data = dict() + for i in range(2, 10): + nn = 0 + for num in range(RANGE_START, range_stop + 1): + if num % i == 0: + nn += 1 + nums_data[i] = nn + + return nums_data + +#100 loops, best of 5: 34.8 usec per loop - 99 +#100 loops, best of 5: 397 usec per loop - 999 +#100 loops, best of 5: 4.27 msec per loop - 9999 + +# cProfile.run('func3(99)') +# +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.000 0.000 :1() +# 1 0.000 0.000 0.000 0.000 task_1.py:77(func3) +# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + + +# print(func1(99)) +# print(func2(99)) +# print(func3(99)) + + +# Вывод +# Ранее задача была решена самым ресурсоемким способом. Способ 3 быстрее способа 1 за счет отсутствия обращения к ключам словаря. +# Самый быстрый способ - Способ 2. + diff --git a/task_2.py b/task_2.py new file mode 100644 index 0000000..f0ab633 --- /dev/null +++ b/task_2.py @@ -0,0 +1,122 @@ +# 2. Написать два алгоритма нахождения i-го по счёту простого числа. + + +import cProfile + +# Без использования «Решета Эратосфена»; + +def func1(n): + snums = [2] + last_num = 3 + while len(snums) < n: + for snum in snums: + if last_num % snum == 0: + break + else: + snums.append(last_num) + + last_num += 1 + return snums[len(snums) - 1] + + +# 100 loops, best of 5: 6.7 usec per loop - 10 +# 100 loops, best of 5: 19.1 usec per loop - 20 +# 100 loops, best of 5: 273 usec per loop - 100 + +# cProfile.run('func1(10)') + +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.000 0.000 :1() +# 1 0.000 0.000 0.000 0.000 task_2.py:7(func1) +# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} +# 29 0.000 0.000 0.000 0.000 {built-in method builtins.len} +# 9 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + +# cProfile.run('func1(1000)') +# +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.027 0.027 :1() +# 1 0.026 0.026 0.027 0.027 task_2.py:7(func1) +# 1 0.000 0.000 0.027 0.027 {built-in method builtins.exec} +# 7919 0.001 0.000 0.001 0.000 {built-in method builtins.len} +# 999 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + +# print(func1(10)) + +# Используя алгоритм «Решето Эратосфена» + +def func2(n): + pi_func = { + 4: 10, + 25: 10 ** 2, + 168: 10 ** 3, + 1229: 10 ** 4, + 9592: 10 ** 5, + 78498: 10 ** 6, + 664579: 10 ** 7, + 5761455: 10 ** 8 + } + + for num in pi_func.keys(): + if n <= num: + size = pi_func[num] + break + else: + return 'Ошибка! Сликом большое число' + + a = [0] * size + for i in range(size): + a[i] = i + + a[1] = 0 + + m = 2 + nnum = 0 + while m < size: + if a[m] != 0: + + nnum += 1 + if nnum == n: + return m + + j = m * 2 + while j < size: + a[j] = 0 + j = j + m + + m += 1 + + # 100 loops, best of 5: 13.4 usec per loop - 10 + # 100 loops, best of 5: 17.4 usec per loop - 20 + # 100 loops, best of 5: 204 usec per loop - 100 + + +# cProfile.run('func2(10)') +# +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.000 0.000 :1() +# 1 0.000 0.000 0.000 0.000 task_2.py:49(func2) +# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} +# 1 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} + + +# cProfile.run('func2(1000)') + +# ncalls tottime percall cumtime percall filename:lineno(function) +# 1 0.000 0.000 0.003 0.003 :1() +# 1 0.003 0.003 0.003 0.003 task_2.py:49(func2) +# 1 0.000 0.000 0.003 0.003 {built-in method builtins.exec} +# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} +# 1 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} + + +#Вывод: +#1. Использование решета Эратосфена более долгий метод на маленьких значениях n, но существенно более выигрышний с ростом n +#2. Функцию func1 можно облегчить за счет отказа от использования метода len - хранить длину в отдельной переменной, +# но в целом это сильно скажется на производительности алгоритма + +# print(func1(1000)) +# print(func2(1000)) From 17854137d7819bc5e99317383bef2468aa592bea Mon Sep 17 00:00:00 2001 From: Tatyana <> Date: Fri, 1 Feb 2019 14:14:53 +0300 Subject: [PATCH 2/5] hw6 --- task_2.py | 122 ------------------------------------------------------ 1 file changed, 122 deletions(-) delete mode 100644 task_2.py diff --git a/task_2.py b/task_2.py deleted file mode 100644 index f0ab633..0000000 --- a/task_2.py +++ /dev/null @@ -1,122 +0,0 @@ -# 2. Написать два алгоритма нахождения i-го по счёту простого числа. - - -import cProfile - -# Без использования «Решета Эратосфена»; - -def func1(n): - snums = [2] - last_num = 3 - while len(snums) < n: - for snum in snums: - if last_num % snum == 0: - break - else: - snums.append(last_num) - - last_num += 1 - return snums[len(snums) - 1] - - -# 100 loops, best of 5: 6.7 usec per loop - 10 -# 100 loops, best of 5: 19.1 usec per loop - 20 -# 100 loops, best of 5: 273 usec per loop - 100 - -# cProfile.run('func1(10)') - -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.000 0.000 :1() -# 1 0.000 0.000 0.000 0.000 task_2.py:7(func1) -# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} -# 29 0.000 0.000 0.000 0.000 {built-in method builtins.len} -# 9 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} - -# cProfile.run('func1(1000)') -# -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.027 0.027 :1() -# 1 0.026 0.026 0.027 0.027 task_2.py:7(func1) -# 1 0.000 0.000 0.027 0.027 {built-in method builtins.exec} -# 7919 0.001 0.000 0.001 0.000 {built-in method builtins.len} -# 999 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} - -# print(func1(10)) - -# Используя алгоритм «Решето Эратосфена» - -def func2(n): - pi_func = { - 4: 10, - 25: 10 ** 2, - 168: 10 ** 3, - 1229: 10 ** 4, - 9592: 10 ** 5, - 78498: 10 ** 6, - 664579: 10 ** 7, - 5761455: 10 ** 8 - } - - for num in pi_func.keys(): - if n <= num: - size = pi_func[num] - break - else: - return 'Ошибка! Сликом большое число' - - a = [0] * size - for i in range(size): - a[i] = i - - a[1] = 0 - - m = 2 - nnum = 0 - while m < size: - if a[m] != 0: - - nnum += 1 - if nnum == n: - return m - - j = m * 2 - while j < size: - a[j] = 0 - j = j + m - - m += 1 - - # 100 loops, best of 5: 13.4 usec per loop - 10 - # 100 loops, best of 5: 17.4 usec per loop - 20 - # 100 loops, best of 5: 204 usec per loop - 100 - - -# cProfile.run('func2(10)') -# -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.000 0.000 :1() -# 1 0.000 0.000 0.000 0.000 task_2.py:49(func2) -# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} -# 1 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} - - -# cProfile.run('func2(1000)') - -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.003 0.003 :1() -# 1 0.003 0.003 0.003 0.003 task_2.py:49(func2) -# 1 0.000 0.000 0.003 0.003 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} -# 1 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} - - -#Вывод: -#1. Использование решета Эратосфена более долгий метод на маленьких значениях n, но существенно более выигрышний с ростом n -#2. Функцию func1 можно облегчить за счет отказа от использования метода len - хранить длину в отдельной переменной, -# но в целом это сильно скажется на производительности алгоритма - -# print(func1(1000)) -# print(func2(1000)) From 2224b9ec4e3e71c37a238cea413c6c4f9dd1e227 Mon Sep 17 00:00:00 2001 From: Tatyana <> Date: Fri, 1 Feb 2019 22:17:17 +0300 Subject: [PATCH 3/5] up --- task_1.py | 108 +++++++++++++++++++++++------------------------------- 1 file changed, 46 insertions(+), 62 deletions(-) diff --git a/task_1.py b/task_1.py index dee0f20..bbe32d7 100644 --- a/task_1.py +++ b/task_1.py @@ -1,7 +1,30 @@ -# 1. Проанализировать скорость и сложность одного любого алгоритма, разработанных в рамках домашнего задания первых трех уроков. +# 1. Подсчитать, сколько было выделено памяти под переменные в ранее разработанных программах +# в рамках первых трех уроков. +# Проанализировать результат и определить программы с наиболее эффективным использованием памяти.. # # В диапазоне натуральных чисел от 2 до 99 определить, сколько из них кратны любому из чисел в диапазоне от 2 до 9. -import cProfile +import platform +import sys + +memory_size = 0 + + +def add_to_memory_size(var): + global memory_size + + if isinstance(var, dict): + memory_size += sys.getsizeof(var) + for i in var: + memory_size += sys.getsizeof(i) + elif isinstance(var, list): # только для приема списка переменных, в фукнциях не используется + for i in var: + add_to_memory_size(i) + else: + memory_size += sys.getsizeof(var) + + +# ********* + RANGE_START = 2 @@ -17,31 +40,10 @@ def func1(range_stop): if num % i == 0: nums_data[i] += 1 - return nums_data - + add_to_memory_size([RANGE_START, range_stop, nums_data, nums_data.keys(), i, num]) -# 100 loops, best of 5: 53.6 usec per loop - 99 -# 100 loops, best of 5: 551 usec per loop - 999 -# 100 loops, best of 5: 5.75 msec per loop - 9999 + return nums_data -# cProfile.run('func1(99)') -# -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.000 0.000 :1() -# 1 0.000 0.000 0.000 0.000 task_1.py:7(func1) -# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} -# 98 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} - -# cProfile.run('func1(999)') -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.001 0.001 :1() -# 1 0.001 0.001 0.001 0.001 task_1.py:7(func1) -# 1 0.000 0.000 0.001 0.001 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} -# 998 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects} - -# print(func1(99)) # Способ 2. Целочисленное деление def func2(range_stop): @@ -49,28 +51,9 @@ def func2(range_stop): for i in range(2, 10): nums_data[i] = range_stop // i - return nums_data - - -# 100 loops, best of 5: 901 nsec per loop - 99 -# 100 loops, best of 5: 950 nsec per loop - 999 -# 100 loops, best of 5: 965 nsec per loop - 9999 -# 100 loops, best of 5: 966 nsec per loop - 99999 - -# cProfile.run('func2(99)') -# -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.000 0.000 :1() -# 1 0.000 0.000 0.000 0.000 task_1.py:45(func2) -# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + add_to_memory_size([range_stop, nums_data, i]) -# cProfile.run('func2(999)') -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.000 0.000 :1() -# 1 0.000 0.000 0.000 0.000 task_1.py:45(func2) -# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} + return nums_data # Способ 3. Пройти диапазон для каждого числа 2-9 @@ -83,27 +66,28 @@ def func3(range_stop): nn += 1 nums_data[i] = nn + add_to_memory_size([RANGE_START, range_stop, nums_data, i, nn, num]) + return nums_data -#100 loops, best of 5: 34.8 usec per loop - 99 -#100 loops, best of 5: 397 usec per loop - 999 -#100 loops, best of 5: 4.27 msec per loop - 9999 -# cProfile.run('func3(99)') -# -# ncalls tottime percall cumtime percall filename:lineno(function) -# 1 0.000 0.000 0.000 0.000 :1() -# 1 0.000 0.000 0.000 0.000 task_1.py:77(func3) -# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} -# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} +# print(func1(99)) # Память: 752 +# print(func2(99)) # Память: 648 +# print(func3(99)) # Память: 732 +# print(func1(999999)) # Память: 752 +# print(func2(999999)) # Память: 648 +# print(func3(999999)) # Память: 732 -# print(func1(99)) -# print(func2(99)) -# print(func3(99)) +# print(sys.version) # 3.7.0 +# print(platform.architecture()) # ('64bit', '') +print(f'Память: {memory_size}') # Вывод -# Ранее задача была решена самым ресурсоемким способом. Способ 3 быстрее способа 1 за счет отсутствия обращения к ключам словаря. -# Самый быстрый способ - Способ 2. - +# Отдельно на каждую функцию можно посчитать - 136 байт, но тк функции использованы для +# оформления решения и к алгоритму отношения не имеют в общую сумму их не включаю +# +# Память не растет при переборе тк использована range, которая генерирует не список а итерируемый объект, +# Все перечисленные алгоритмы не потребляют значительного количества памяти +# и использование памяти не увеличивается при увеличении рассматриваемого интервала From 68fdce3afdfb71eede05bff12e9d944946cd7995 Mon Sep 17 00:00:00 2001 From: Tatyana <> Date: Fri, 1 Feb 2019 22:28:56 +0300 Subject: [PATCH 4/5] master --- task_1.py | 93 ------------------------------------------------------- 1 file changed, 93 deletions(-) delete mode 100644 task_1.py diff --git a/task_1.py b/task_1.py deleted file mode 100644 index bbe32d7..0000000 --- a/task_1.py +++ /dev/null @@ -1,93 +0,0 @@ -# 1. Подсчитать, сколько было выделено памяти под переменные в ранее разработанных программах -# в рамках первых трех уроков. -# Проанализировать результат и определить программы с наиболее эффективным использованием памяти.. -# -# В диапазоне натуральных чисел от 2 до 99 определить, сколько из них кратны любому из чисел в диапазоне от 2 до 9. -import platform -import sys - -memory_size = 0 - - -def add_to_memory_size(var): - global memory_size - - if isinstance(var, dict): - memory_size += sys.getsizeof(var) - for i in var: - memory_size += sys.getsizeof(i) - elif isinstance(var, list): # только для приема списка переменных, в фукнциях не используется - for i in var: - add_to_memory_size(i) - else: - memory_size += sys.getsizeof(var) - - -# ********* - - -RANGE_START = 2 - - -# Способ 1. Перебор -def func1(range_stop): - nums_data = dict() - for i in range(2, 10): - nums_data[i] = 0 - - for num in range(RANGE_START, range_stop + 1): - for i in nums_data.keys(): - if num % i == 0: - nums_data[i] += 1 - - add_to_memory_size([RANGE_START, range_stop, nums_data, nums_data.keys(), i, num]) - - return nums_data - - -# Способ 2. Целочисленное деление -def func2(range_stop): - nums_data = dict() - for i in range(2, 10): - nums_data[i] = range_stop // i - - add_to_memory_size([range_stop, nums_data, i]) - - return nums_data - - -# Способ 3. Пройти диапазон для каждого числа 2-9 -def func3(range_stop): - nums_data = dict() - for i in range(2, 10): - nn = 0 - for num in range(RANGE_START, range_stop + 1): - if num % i == 0: - nn += 1 - nums_data[i] = nn - - add_to_memory_size([RANGE_START, range_stop, nums_data, i, nn, num]) - - return nums_data - - -# print(func1(99)) # Память: 752 -# print(func2(99)) # Память: 648 -# print(func3(99)) # Память: 732 - -# print(func1(999999)) # Память: 752 -# print(func2(999999)) # Память: 648 -# print(func3(999999)) # Память: 732 - -# print(sys.version) # 3.7.0 -# print(platform.architecture()) # ('64bit', '') - -print(f'Память: {memory_size}') - -# Вывод -# Отдельно на каждую функцию можно посчитать - 136 байт, но тк функции использованы для -# оформления решения и к алгоритму отношения не имеют в общую сумму их не включаю -# -# Память не растет при переборе тк использована range, которая генерирует не список а итерируемый объект, -# Все перечисленные алгоритмы не потребляют значительного количества памяти -# и использование памяти не увеличивается при увеличении рассматриваемого интервала From 4366774732baf5a66b5e16e0460240e832748e1c Mon Sep 17 00:00:00 2001 From: Tatyana <> Date: Sun, 3 Feb 2019 20:01:31 +0300 Subject: [PATCH 5/5] up --- task_1.py | 27 ++++++++++++++++++++ task_2.py | 59 ++++++++++++++++++++++++++++++++++++++++++ task_3.py | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 162 insertions(+) create mode 100644 task_1.py create mode 100644 task_2.py create mode 100644 task_3.py diff --git a/task_1.py b/task_1.py new file mode 100644 index 0000000..62d995d --- /dev/null +++ b/task_1.py @@ -0,0 +1,27 @@ +# 1. Отсортируйте по убыванию методом "пузырька" одномерный целочисленный массив, заданный +# случайными числами на промежутке [-100; 100). Выведите на экран исходный и отсортированный массивы. +# Сортировка должна быть реализована в виде функции. +# По возможности доработайте алгоритм (сделайте его умнее). + +import random + +LEFT_EDGE = -100 +RIGHT_EDGE = 100 +SIZE = 20 + + +def sort_bubble(array): + for ii in range(0, len(array) - 1): + for i in range(0, len(array) - ii - 1): + if array[i] < array[i + 1]: + array[i], array[i + 1] = array[i + 1], array[i] + # print(array) + + +array_rand = [random.randrange(LEFT_EDGE, RIGHT_EDGE) for _ in range(SIZE)] +array_sort = array_rand.copy() +sort_bubble(array_sort) + +# print('*' * 10) +print(array_rand) +print(array_sort) diff --git a/task_2.py b/task_2.py new file mode 100644 index 0000000..c7d2eb6 --- /dev/null +++ b/task_2.py @@ -0,0 +1,59 @@ +# 2. Отсортируйте по возрастанию методом слияния одномерный вещественный массив, +# заданный случайными числами на промежутке [0; 50). +# Выведите на экран исходный и отсортированный массивы. + +import random + +LEFT_EDGE = 0 +RIGHT_EDGE = 50 +SIZE = 11 + + +def get_rand_val(left, right): + rand = random.uniform(left, right) + while rand == right: + rand = random.uniform(left, right) + return rand + + +def sort_merge(array): + if len(array) <= 1: + return + + middle = len(array) // 2 + array_1 = array[0:middle] + array_2 = array[middle:] + + sort_merge(array_1) + sort_merge(array_2) + + i = 0 + a1 = 0 + a2 = 0 + + while len(array_1) > a1 and len(array_2) > a2: + if array_1[a1] < array_2[a2]: + array[i] = array_1[a1] + a1 += 1 + else: + array[i] = array_2[a2] + a2 += 1 + + i += 1 + + while len(array_1) > a1: + array[i] = array_1[a1] + a1 += 1 + i += 1 + while len(array_2) > a2: + array[i] = array_2[a2] + a2 += 1 + i += 1 + + +array_rand = [get_rand_val(LEFT_EDGE, RIGHT_EDGE) for _ in range(SIZE)] +array_sort = array_rand[:] +sort_merge(array_sort) + +print(array_rand) +print(array_sort) diff --git a/task_3.py b/task_3.py new file mode 100644 index 0000000..6795b6f --- /dev/null +++ b/task_3.py @@ -0,0 +1,76 @@ +# 3. Массив размером 2m + 1, где m – натуральное число, заполнен случайным образом. +# Найдите в массиве медиану. Медианой называется элемент ряда, делящий его на две равные части: +# в одной находятся элементы, которые не меньше медианы, в другой – не больше медианы. +# Задачу можно решить без сортировки исходного массива. +# Но если это слишком сложно, то используйте метод сортировки, который не рассматривался на уроках + +import random +from collections import deque + +LEFT_EDGE = 0 +RIGHT_EDGE = 200 + + +def get_median(array): + sum_ = 0 + for num in array: + sum_ += num + + middle = sum_ // len(array) + + deq_left = deque() + deq_right = deque() + + # print(middle) + + for num in array: + if num > middle: + if len(deq_right) == 0 or deq_right[0] > num: + deq_right.appendleft(num) + else: + deq_right.append(num) + else: + if len(deq_left) == 0 or deq_left[-1] > num: + deq_left.appendleft(num) + else: + deq_left.append(num) + + # print(deq_left, deq_right) + if len(deq_left) > len(deq_right): + while len(deq_left) - 1 != len(deq_right): + deq_right.appendleft(deq_left[-1]) + deq_left.pop() + max_left_ind = 0 + + for i, num in enumerate(deq_left): + if num > deq_left[max_left_ind]: + max_left_ind = i + + deq_left[max_left_ind], deq_left[-1] = deq_left[-1], deq_left[max_left_ind] + # print(deq_left, deq_right) + + return deq_left[-1] + else: + while len(deq_right) - 1 != len(deq_left): + deq_left.append(deq_right[0]) + deq_right.popleft() + min_right_ind = 0 + + for i, num in enumerate(deq_right): + if num < deq_right[min_right_ind]: + min_right_ind = i + + deq_right[min_right_ind], deq_right[0] = deq_right[0], deq_right[min_right_ind] + # print(deq_left, deq_right) + + return deq_right[0] + + +m = int(input('Введите m: ')) + +array = [random.randrange(LEFT_EDGE, RIGHT_EDGE) for _ in range(2 * m + 1)] + +print(array) +print(f'Медиана: {get_median(array)}') + +# print(sorted(array))