LABS : 1, 2

labs/lab_01/37/Var_5/Vec_matrix.py

@@ -0,0 +1,80 @@
+import timeit
+import random
+import matplotlib.pyplot as plt
+
+def get_element_by_index(vector, index):
+    return vector[index]
+
+def product_of_elements(vector):
+    product = 1
+    for element in vector:
+        product *= element
+    return product
+
+def find_min_element(vector):
+    min_element = vector[0]
+    for element in vector[1:]:
+        if element < min_element:
+            min_element = element
+    return min_element
+
+def harmonic_mean(vector):
+    sum_of_inverses = 0.0
+    for x in vector:
+        sum_of_inverses += 1.0 / x
+
+    # Вычисляем длину вектора вручную
+    vector_length = 0
+    for _ in vector:
+        vector_length += 1
+
+    # Вычисляем среднее гармоническое
+    harmonic_mean_value = vector_length / sum_of_inverses
+
+    return harmonic_mean_value
+
+def measure_time(func, vector):
+    times = []
+    for _ in range(5):
+        start_time = timeit.default_timer()
+        func(vector)
+        end_time = timeit.default_timer()
+        times.append(end_time - start_time)
+    return sum(times) / len(times)
+
+def main():
+    N = 5
+    max_n = 10**2 * N
+    step = 100 * N
+
+    sizes = []
+    times_get_element_by_index = []
+    times_product_of_elements = []
+    times_find_min_element = []
+    times_harmonic_mean = []
+
+    for n in range(1, max_n + 1, step):
+        vector = [random.randint(1, 100) for _ in range(n)]
+
+        sizes.append(n)
+        times_get_element_by_index.append(measure_time(lambda v: get_element_by_index(v, 0), vector))
+        times_product_of_elements.append(measure_time(product_of_elements, vector))
+        times_find_min_element.append(measure_time(find_min_element, vector))
+        times_harmonic_mean.append(measure_time(harmonic_mean, vector))
+
+    # Построение графика
+    plt.figure(figsize=(10, 6))
+    plt.plot(sizes, times_get_element_by_index, label='get_element_by_index')
+    plt.plot(sizes, times_product_of_elements, label='product_of_elements')
+    plt.plot(sizes, times_find_min_element, label='find_min_element')
+    plt.plot(sizes, times_harmonic_mean, label='harmonic_mean')
+
+    plt.xlabel('Количество элементов (n)')
+    plt.ylabel('Среднее время выполнения (секунды)')
+    plt.title('Зависимость времени выполнения от количества элементов')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+if __name__ == "__main__":
+    main()

labs/lab_01/37/Var_5/matrix.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+# Генерация случайного размера матрицы
+n = np.random.randint(0, 10)
+
+# Генерация случайных матриц A и B размером n x n с неотрицательными элементами
+A = np.random.randint(0, 10, size=(n, n))
+B = np.random.randint(0, 10, size=(n, n))
+
+# Инициализация результирующей матрицы C
+C = np.zeros((n, n))
+
+# Вычисление матричного произведения
+for i in range(n):
+    for j in range(n):
+        for k in range(n):
+            C[i, j] += A[i, k] * B[k, j]
+
+
+print("Результат матричного произведения C:")
+print(C)

labs/lab_01/37/Var_5/q.py

@@ -0,0 +1,78 @@
+import time
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+# Функции, которые мы будем тестировать
+def get_element_by_index(vector, index):
+    return vector[index]
+
+
+def product_of_elements(vector):
+    product = 1
+    for element in vector:
+        product *= element
+    return product
+
+
+def find_min_element(vector):
+    min_element = vector[0]
+    for element in vector[1:]:
+        if element < min_element:
+            min_element = element
+    return min_element
+
+
+def harmonic_mean(vector):
+    sum_of_inverses = 0.0
+    for x in vector:
+        sum_of_inverses += 1.0 / x
+
+    vector_length = 0
+    for _ in vector:
+        vector_length += 1
+
+    harmonic_mean_value = vector_length / sum_of_inverses
+    return harmonic_mean_value
+
+
+# Функция для измерения времени работы функции
+def measure_time(func, vector):
+    start_time = time.time()
+    func(vector)
+    end_time = time.time()
+    return end_time - start_time
+
+
+# Генерация векторов разного размера
+N = 5
+max_n = 10**4 * N
+step = 100 * N
+vector_sizes = np.arange(1, max_n, step)
+times_get_element = []
+times_product = []
+times_min_element = []
+times_harmonic_mean = []
+
+for size in vector_sizes:
+    vector = np.random.rand(size)
+
+    # Измеряем время для каждой функции
+    times_get_element.append(measure_time(lambda v: get_element_by_index(v, 0), vector))
+    times_product.append(measure_time(product_of_elements, vector))
+    times_min_element.append(measure_time(find_min_element, vector))
+    times_harmonic_mean.append(measure_time(harmonic_mean, vector))
+
+# Построение графика
+plt.figure(figsize=(10, 6))
+plt.plot(vector_sizes, times_get_element, label='get_element_by_index')
+plt.plot(vector_sizes, times_product, label='product_of_elements')
+plt.plot(vector_sizes, times_min_element, label='find_min_element')
+plt.plot(vector_sizes, times_harmonic_mean, label='harmonic_mean')
+
+plt.xlabel('Размер вектора')
+plt.ylabel('Время (секунды)')
+plt.title('Зависимость времени работы функций от размера вектора')
+plt.legend()
+plt.grid(True)
+plt.show()

labs/lab_02/37/Var_5/example.py

@@ -0,0 +1,62 @@
+import timeit
+import matplotlib.pyplot as plt
+import random
+
+class TreeNode:
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+def insert(root, key):
+    if root is None:
+        return TreeNode(key)
+    else:
+        if root.val < key:
+            root.right = insert(root.right, key)
+        else:
+            root.left = insert(root.left, key)
+    return root
+
+def inorder_traversal(root, result):
+    if root:
+        inorder_traversal(root.left, result)
+        result.append(root.val)
+        inorder_traversal(root.right, result)
+
+def tree_sort(A):
+    root = None
+    for key in A:
+        root = insert(root, key)
+    result = []
+    inorder_traversal(root, result)
+    return result
+
+# Функция для генерации случайного массива заданной длины
+def generate_random_array(length):
+    return [random.randint(0, 1000) for _ in range(length)]
+
+# Функция для замера времени выполнения сортировки
+def measure_time(array):
+    return timeit.timeit(lambda: tree_sort(array), number=1)
+
+# Длины массивов для тестирования
+lengths = [1000, 5000, 10000]
+
+# Списки для хранения результатов
+times = []
+
+# Замер времени для каждой длины массива
+for length in lengths:
+    array = generate_random_array(length)
+    time_taken = measure_time(array)
+    times.append(time_taken)
+    print(f"Length: {length}, Time: {time_taken:.6f} seconds")
+
+# Построение графика
+plt.plot(lengths, times, marker='o')
+plt.xlabel('Array Length')
+plt.ylabel('Time (seconds)')
+plt.title('Tree Sort Performance')
+plt.grid(True)
+plt.show()

labs/lab_02/37/Var_5/main.py

@@ -0,0 +1,54 @@
+import timeit
+import matplotlib.pyplot as plt
+import random
+
+def cocktail_sort(A):
+    left = 0
+    right = len(A) - 1
+    swapped = True
+    while swapped:
+        swapped = False
+        for i in range(left, right):
+            if A[i] > A[i + 1]:
+                A[i], A[i + 1] = A[i + 1], A[i]
+                swapped = True
+        if not swapped:
+            break
+        swapped = False
+        right -= 1
+        for i in range(right, left, -1):
+            if A[i] < A[i - 1]:
+                A[i], A[i - 1] = A[i - 1], A[i]
+                swapped = True
+        left += 1
+
+# Функция для генерации случайного массива заданной длины
+def generate_random_array(length):
+    return [random.randint(0, 1000) for _ in range(length)]
+
+# Функция для замера времени выполнения сортировки
+def measure_time(array):
+    return timeit.timeit(lambda: cocktail_sort(array), number=1)
+
+# Длины массивов для тестирования
+lengths = [ 1000,  5000,10000,100000]
+
+# Списки для хранения результатов
+times = []
+
+# Замер времени для каждой длины массива
+for length in lengths:
+    array = generate_random_array(length)
+    time_taken = measure_time(array)
+    times.append(time_taken)
+    print(f"Length: {length}, Time: {time_taken:.6f} seconds")
+
+# Построение графика
+plt.plot(lengths, times, marker='o')
+plt.xlabel('Array Length')
+plt.ylabel('Time (seconds)')
+plt.title('Cocktail Sort Performance')
+plt.grid(True)
+plt.show()
+
+