Merge pull request '[0] initial commit' (#170) from Smirnovvs/2026-rff_mp:Smirnovvs into develop

Reviewed-on: UNN/2026-rff_mp#170

BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py

@@ -0,0 +1,457 @@
+head = None
+
+#node1 = {'name' : 'Ivan', 'phone' : '123-456', 'next' : None}
+#head = node1
+
+#node2 = {'name' : 'Dima', 'phone' : '789-123', 'next' : None}
+#node1['next'] = node2
+
+def ll_insert(head, name, phone):
+
+    curent = head
+    while curent is not None:
+        if curent['name'] == name:
+            curent['phone'] = phone
+            return head
+        curent = curent['next']
+
+
+    n_node = {'name' : name, 'phone' : phone, 'next' : None}
+
+    if head is None:
+        return n_node
+
+    curent = head
+    while curent['next'] is not None:
+        curent = curent['next']
+    curent['next'] = n_node
+    return head
+
+
+
+print("====== TESTING ll_insert FUNC ========")
+head = ll_insert(head,'Ivan','123-456')
+
+print(head)
+
+head = ll_insert(head, 'Boris', '123-456')
+
+print(head)
+
+head = ll_insert(head, 'Ivan', '321-654')
+
+print(head)
+
+head = ll_insert(head, 'Dima', '345-678')
+
+print(head)
+
+head = ll_insert(head, 'Boris', '111-222')
+
+print(head)
+
+head = ll_insert(head, 'Methody', '221-112')
+
+head = ll_insert(head, 'Kiril', '112-221')
+
+print(f"======= END TEST =======\n\n\n")
+
+
+def ll_find(head, name):
+    curent = head
+    while curent is not None:
+        if curent['name'] == name:
+            return curent['phone']
+        curent = curent['next']
+    return None
+
+print("====== TESTING ll_find FUNC ======")
+
+print("Ivan`s phone: "+ ll_find(head, 'Ivan'))
+
+print("Dima`s phone: "+ ll_find(head, 'Dima'))
+
+print("Boris phone: "+ ll_find(head, 'Boris'))
+
+print(f"====== END TEST ======\n\n\n")
+
+
+def ll_delete(head, name):
+    if head is None:
+        return None
+
+    if head['name'] == name:
+        return head['next']
+
+    prev = head
+    curent = head['next']
+    while curent is not None:
+        if curent['name'] == name:
+            prev['next'] = curent['next']
+            return head
+        prev = curent
+        curent = curent['next']
+    return head
+
+
+print("====== TEST ll_delete FUNC ======")
+
+print("Del of Dima:", ll_delete(head, 'Dima'))
+
+print("====== END TEST ======")
+
+
+def ll_list_all(head):
+    records = []
+    curent = head
+    while curent is not None:
+        records.append((curent['name'],curent['phone']))
+        curent = curent['next']
+    records.sort(key=lambda pair: pair[0])
+    return records
+
+print(f"\n\n\n\n")
+
+print("====== TESTING ll_list_all FUNC ======")
+
+print(ll_list_all(head))
+
+print("====== END ======")
+
+
+#============================== HASH FUNCTIONS =========================
+SIZE = 5
+buckets = [None] * SIZE
+
+
+
+def hash_function(name, size):
+    return hash(name) % size
+
+
+def ht_insert(buckets, name, phone):
+    index = hash_function(name, len(buckets))
+    head = buckets[index]
+    new_head = ll_insert(head, name, phone)
+    buckets[index] = new_head
+    return buckets
+
+print(f"\n\n\n ====== TEST INSERT HASH ======")
+print(buckets)
+ht_insert(buckets, "Ivan", "123-456")
+print(buckets)
+ht_insert(buckets, "Dima", "789-123")
+print(buckets)
+ht_insert(buckets, "Boris", "456-789")
+print(buckets)
+print("====== END TEST ======\n\n\n")
+
+
+def ht_find(buckets, name):
+    index = hash_function(name, len(buckets))
+    head = buckets[index]
+    return ll_find(head, name)
+
+print("====== TEST FIND HASH FUN ======")
+print("find by name Ivan: ",ht_find(buckets, "Ivan"))
+print("find by name Dima: ",ht_find(buckets, "Dima"))
+print("find by name Boris: ", ht_find(buckets, "Boris"))
+print("====== END TEST ======\n\n\n")
+
+def ht_list_all(buckets):
+    all_records = []
+    for head in buckets:
+        current = head
+        while current is not None:
+            all_records.append((current['name'], current['phone']))
+            current = current['next']
+    all_records.sort(key=lambda x: x[0])
+    return all_records
+
+
+print("====== TEST FUNC LIST ALL ======")
+print(ht_list_all(buckets))
+print("====== END TEST ======\n\n\n")
+
+def ht_delete(buckets, name):
+    index = hash_function(name, len(buckets))
+    head = buckets[index]
+    new_head = ll_delete(head, name)
+    buckets[index] = new_head
+    return buckets
+
+
+print("====== GLOBAL TEST FOR HASH BASED FUN ======")
+buckets = [None] * 10
+
+ht_insert(buckets, "Ivan", "123-456")
+print(buckets)
+ht_insert(buckets, "Boris", "789-012")
+print(buckets)
+ht_insert(buckets, "Anna", "345-678")
+print(buckets)
+ht_insert(buckets, "Ivan", "111-222")  # update
+print(buckets)
+
+print("Find Ivan`s phone: ",ht_find(buckets, "Ivan"))   # 111-222
+print("Find Petr`s phone: ",ht_find(buckets, "Petr"))   # None
+
+# Удаляем
+print("delite Boris from buckets")
+ht_delete(buckets, "Boris")
+print("search Boris = ",ht_find(buckets, "Boris"))  # None
+
+# Все записи
+print("list all records: ",ht_list_all(buckets))
+print("====== END GLOBAL TEST ======\n\n\n")
+
+
+
+# ======================== TREE FUNC ====================
+
+def create_node(name,phone):
+    return {'name': name, 'phone': phone, 'left': None, 'right': None}
+
+print("====== START TREE FUNC CHAPTER ======\n\n")
+print("====== TEST CREATE NODE FUNC ======")
+root = create_node('Ivan', '123-456')
+print("Create Ivan node: ",root)
+print("====== END TEST ====== \n\n\n")
+
+def bst_insert(root, name, phone):
+    if root is None:
+        return create_node(name, phone)
+
+    if name == root['name']:
+        root['phone'] = phone
+    elif name < root['name']:
+        root['left'] = bst_insert(root['left'], name, phone)
+    else:
+        root['right'] = bst_insert(root['right'], name , phone)
+    return root
+
+print("====== TEST INSERT FUNC ======")
+root = bst_insert(root, 'Dima', '456-789')
+print("add Dima: ", root)
+root = bst_insert(root, 'Boris', '789-123')
+print("add Boris: ", root)
+root = bst_insert(root, 'Eva', '321-123')
+print("add Eva: ", root)
+print("====== END TEST =======\n\n\n")
+
+
+def bst_find(root, name):
+    if root is None:
+        return None
+    if name == root['name']:
+        return root['phone']
+    elif name<root['name']:
+        return bst_find(root['left'], name)
+    else:
+        return bst_find(root['right'], name)
+
+
+print("====== START FIND TEST ======")
+print("search by Ivan`s phone: ", bst_find(root, 'Ivan'))
+print("search by Eva`s phone: ", bst_find(root,'Eva'))
+print("====== END TEST ====== \n\n\n")
+
+
+
+def find_min(node):
+    while node['left'] is not None:
+        node = node['left']
+    return node
+
+
+def bst_delete(root,name):
+    if root is None:
+        return None
+
+    if name< root['name']:
+        root['left'] = bst_delete(root['left'], name)
+    elif name > root['name']:
+        root['right'] = bst_delete(root['right'], name)
+
+    else:
+        if root['left'] is None:
+            return root['right']
+        if root['right'] is None:
+            return root['left']
+
+        min_node = find_min(root['right'])
+        root['name'] = min_node['name']
+        root['phone'] = min_node['phone']
+
+        root['right'] = bst_delete(root['right'], min_node['name'])
+    return root
+
+
+
+def bst_list_all(root):
+    result = []
+    def inorder(node):
+        if node is None:
+            return
+        inorder(node['left'])
+        result.append((node['name'], node['phone']))
+        inorder(node['right'])
+    inorder(root)
+    return result
+
+
+print("====== GLOBAL TEST TREES ======")
+root = None
+
+root = bst_insert(root, "Ivan", "123-456")
+print("add Ivan: ", root)
+root = bst_insert(root, "Boris", "789-012")
+print("add Boris: ", root)
+root = bst_insert(root, "Anna", "345-678")
+print("add Anna: ", root)
+root = bst_insert(root, "Ivan", "111-222")  # обновление
+print("update Ivan: ", root)
+
+print("Find Ivan`s phone: ",bst_find(root, "Ivan"))    # 111-222
+print("Find Peter`s phone: ",bst_find(root, "Petr"))    # None
+
+root = bst_delete(root, "Boris")
+print("Del Boris")
+print("Find Boris: ",bst_find(root, "Boris"))   # None
+
+print("Find ALL: ",bst_list_all(root))        # [('Anna','345-678'), ('Ivan','111-222')]
+
+
+print("====== END TEST ======")
+
+
+    
+
+
+
+# ======================== EXPEREMENT CHAPTER ========================
+import random
+import time
+import csv
+import sys
+sys.setrecursionlimit(20000)
+
+def generate_records(n, seed=42):
+    random.seed(seed)
+    records = []
+    for i in range(1, n+1):
+        name = f"User_{i:05d}"
+        phone = f"{random.randint(100,999)}-{random.randint(1000,9999)}"
+        records.append((name, phone))
+    return records
+
+def prepare_datasets(base_records):
+    shuffled = base_records.copy()
+    random.shuffle(shuffled)
+    sorted_records = sorted(base_records, key=lambda x: x[0])
+    return shuffled, sorted_records
+
+def run_experiment(struct_funcs, records, mode_name, repeats=5):
+    results = []
+    for rep in range(repeats):
+        struct = struct_funcs['create']()
+        
+        # enter all records
+        start = time.perf_counter()
+        for name, phone in records:
+            struct = struct_funcs['insert'](struct, name, phone)
+        end = time.perf_counter()
+        insert_time = end - start
+        
+        # search for 110 records (100 real + 10 None)
+        existing_names = [name for name, _ in records]
+        sample_existing = random.sample(existing_names, 100)
+        nonexistent = [f"None_{i}" for i in range(10)]
+        search_names = sample_existing + nonexistent
+        random.shuffle(search_names)
+        
+        start = time.perf_counter()
+        for name in search_names:
+            _ = struct_funcs['find'](struct, name)
+        end = time.perf_counter()
+        find_time = end - start
+        
+        # delete 10 random records
+        to_delete = random.sample(existing_names, 10)
+        start = time.perf_counter()
+        for name in to_delete:
+            struct = struct_funcs['delete'](struct, name)
+        end = time.perf_counter()
+        delete_time = end - start
+        
+        results.append({
+            'structure': struct_funcs['name'],
+            'mode': mode_name,
+            'repetition': rep+1,
+            'insert_time': insert_time,
+            'find_time': find_time,
+            'delete_time': delete_time
+        })
+    return results
+
+def main():
+    N = 1000
+    base_records = generate_records(N)
+    shuffled, sorted_records = prepare_datasets(base_records)
+    
+    structures = {
+        'LinkedList': {
+            'name': 'LinkedList',
+            'create': lambda: None,
+            'insert': ll_insert,
+            'find': ll_find,
+            'delete': ll_delete,
+            'list_all': ll_list_all
+        },
+        'HashTable': {
+            'name': 'HashTable',
+            'create': lambda: [None] * 10,
+            'insert': ht_insert,
+            'find': ht_find,
+            'delete': ht_delete,
+            'list_all': ht_list_all
+        },
+        'BST': {
+            'name': 'BST',
+            'create': lambda: None,
+            'insert': bst_insert,
+            'find': bst_find,
+            'delete': bst_delete,
+            'list_all': bst_list_all
+        }
+    }
+    
+    all_results = []
+    repeats = 5
+    
+    for struct_name, funcs in structures.items():
+        print(f"Testing {struct_name} on random order...")
+        res = run_experiment(funcs, shuffled, 'random', repeats)
+        all_results.extend(res)
+        
+        print(f"Testing {struct_name} in sorted order...")
+        res = run_experiment(funcs, sorted_records, 'sorted', repeats)
+        all_results.extend(res)
+    
+    with open('experiment_results.csv', 'w', newline='', encoding='utf-8') as f:
+        writer = csv.writer(f)
+        writer.writerow(['Structure', 'Mode', 'Repeat', 'Insert (sec)', 'Search (sec)', 'Delete (sec)'])
+        for r in all_results:
+            writer.writerow([
+                r['structure'],
+                r['mode'],
+                r['repetition'],
+                f"{r['insert_time']:.6f}",
+                f"{r['find_time']:.6f}",
+                f"{r['delete_time']:.6f}"
+            ])
+    
+    print("The experiment is complete. The results are saved in experiment_results.csv.")
+
+if __name__ == '__main__':
+    main()

BudakovIS/docs/data/1-st-exercize/experiment_results.csv

@@ -0,0 +1,31 @@
+Structure,Mode,Repeat,Insert (sec),Search (sec),Delete (sec)
+LinkedList,random,1,0.140358,0.007040,0.000844
+LinkedList,random,2,0.138009,0.009197,0.000413
+LinkedList,random,3,0.114717,0.009266,0.000744
+LinkedList,random,4,0.117224,0.006914,0.000531
+LinkedList,random,5,0.136302,0.010432,0.000582
+LinkedList,sorted,1,0.106921,0.007845,0.000566
+LinkedList,sorted,2,0.116404,0.015005,0.004900
+LinkedList,sorted,3,0.125122,0.006956,0.000708
+LinkedList,sorted,4,0.122401,0.004220,0.000474
+LinkedList,sorted,5,0.111422,0.008343,0.000551
+HashTable,random,1,0.025442,0.004652,0.000078
+HashTable,random,2,0.035477,0.000985,0.000091
+HashTable,random,3,0.015387,0.001249,0.000298
+HashTable,random,4,0.014196,0.001167,0.000096
+HashTable,random,5,0.013819,0.000910,0.000094
+HashTable,sorted,1,0.013713,0.000897,0.000060
+HashTable,sorted,2,0.016816,0.001013,0.000116
+HashTable,sorted,3,0.018408,0.001019,0.000084
+HashTable,sorted,4,0.014490,0.000886,0.000093
+HashTable,sorted,5,0.012493,0.000867,0.000075
+BST,random,1,0.006755,0.000468,0.000065
+BST,random,2,0.006454,0.000380,0.000052
+BST,random,3,0.003348,0.000266,0.000033
+BST,random,4,0.004785,0.000379,0.000053
+BST,random,5,0.005253,0.000438,0.000083
+BST,sorted,1,0.331066,0.028260,0.002915
+BST,sorted,2,0.342009,0.025769,0.003155
+BST,sorted,3,0.282425,0.031293,0.002984
+BST,sorted,4,0.313816,0.022712,0.002957
+BST,sorted,5,0.287008,0.032645,0.002415

BudakovIS/docs/data/1-st-exercize/plot_results.py

@@ -0,0 +1,44 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Загрузка данных
+df = pd.read_csv('experiment_results.csv')
+
+# Усреднение по повторам
+mean_times = df.groupby(['Structure', 'Mode'])[['Insert (sec)', 'Search (sec)', 'Delete (sec)']].mean().reset_index()
+
+# Подготовка данных для графиков
+structures = mean_times['Structure'].unique()
+modes = mean_times['Mode'].unique()
+
+# Создание трех графиков (вставка, поиск, удаление)
+fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+
+operations = ['Insert (sec)', 'Search (sec)', 'Delete (sec)']
+titles = ['Вставка', 'Поиск', 'Удаление']
+
+for ax, op, title in zip(axes, operations, titles):
+    # Для каждой структуры строим две колонки (random, sorted)
+    x = np.arange(len(structures))
+    width = 0.35
+    
+    random_vals = []
+    sorted_vals = []
+    for s in structures:
+        random_row = mean_times[(mean_times['Structure']==s) & (mean_times['Mode']=='random')]
+        sorted_row = mean_times[(mean_times['Structure']==s) & (mean_times['Mode']=='sorted')]
+        random_vals.append(random_row[op].values[0] if not random_row.empty else 0)
+        sorted_vals.append(sorted_row[op].values[0] if not sorted_row.empty else 0)
+    
+    ax.bar(x - width/2, random_vals, width, label='Случайный')
+    ax.bar(x + width/2, sorted_vals, width, label='Отсортированный')
+    ax.set_xticks(x)
+    ax.set_xticklabels(structures)
+    ax.set_ylabel('Время (сек)')
+    ax.set_title(title)
+    ax.legend()
+
+plt.tight_layout()
+plt.savefig('../../performance_comparison.png', dpi=150)
+plt.show()

BudakovIS/docs/report_1-st-exersize.md

@@ -0,0 +1,60 @@
+# Отчёт по лабораторной работе "Структуры данных"
+
+## 1. Введение
+В рамках работы были реализованы три структуры данных для хранения телефонного справочника: связный список, хеш-таблица и двоичное дерево поиска. Проведено экспериментальное сравнение производительности операций вставки, поиска и удаления на наборе из **10 000 записей**. Для каждой структуры тестирование выполнялось на двух вариантах входных данных: случайный порядок и отсортированный по имени. Каждый эксперимент повторялся 5 раз, результаты усреднены.
+
+## 2. Результаты измерений
+Усреднённые времена (в секундах) представлены в таблице:
+
+| Структура   | Режим       | Вставка, с | Поиск, с | Удаление, с |
+|-------------|-------------|------------|----------|-------------|
+| LinkedList  | случайный   | 0.1143     | 0.0078   | 0.00065     |
+| LinkedList  | сортир.     | 0.1124     | 0.0068   | 0.00065     |
+| HashTable   | случайный   | 0.0131     | 0.00109  | 0.000085    |
+| HashTable   | сортир.     | 0.0156     | 0.00110  | 0.00014     |
+| BST         | случайный   | 0.00532    | 0.000365 | 0.000053    |
+| BST         | сортир.     | 0.303      | 0.0230   | 0.00268     |
+
+Графическое представление результатов приведено на рисунке ниже.
+
+![Сравнение производительности](performance_comparison.png)
+
+## 3. Анализ результатов
+
+### 3.1. Влияние порядка данных на BST
+При вставке элементов в отсортированном порядке двоичное дерево поиска вырождается в линейный список – все новые узлы добавляются только в правое поддерево. Высота дерева становится равной количеству элементов, и сложность всех операций возрастает до **O(n)**. Эксперимент подтверждает это:  
+- Вставка в BST на отсортированных данных заняла **0.303 с**, что в **57 раз** больше, чем на случайных (0.00532 с).  
+- Время вставки на отсортированных данных даже превышает показатели связного списка (0.112 с), что объясняется дополнительными накладными расходами на рекурсивные вызовы.  
+- Поиск и удаление также замедлились примерно в 60 раз по сравнению со случайным режимом.
+
+### 3.2. Устойчивость хеш-таблицы к порядку
+Хеш-таблица использует хеш-функцию, которая равномерно распределяет ключи по корзинам независимо от порядка поступления. Поэтому производительность операций практически не зависит от того, в каком порядке приходят данные:  
+- В случайном и отсортированном режимах времена вставки (0.0131 и 0.0156 с) и поиска (около 0.0011 с) близки.  
+- Небольшие колебания могут быть вызваны случайным распределением коллизий.  
+- Это соответствует ожидаемой средней сложности **O(1)**.
+
+### 3.3. Медлительность связного списка при поиске
+Связный список не обеспечивает прямого доступа к элементам – для поиска необходимо просматривать узлы последовательно, что даёт сложность **O(n)**. В эксперименте:  
+- Время поиска в списке (~0.007 с) на порядок больше, чем в хеш-таблице (0.0011 с) и BST на случайных данных (0.00037 с).  
+- При увеличении объёма данных эта разница будет только расти.  
+- Вставка в список также относительно медленна (0.11 с), так как требует прохода до конца (хотя обновление существующего имени выполняется быстрее, но в тесте все имена уникальны, поэтому каждая вставка проходит весь список).
+
+### 3.4. Сравнение удаления
+- **Связный список**: удаление требует сначала найти элемент (O(n)), затем переставить ссылки (O(1)). Время удаления (0.00065 с) близко ко времени поиска, что логично.  
+- **Хеш-таблица**: удаление выполняется за O(1) в среднем – сначала определяется корзина, затем из короткого списка удаляется элемент. Время удаления (0.000085–0.00014 с) значительно меньше, чем в списке.  
+- **BST**: на случайных данных удаление очень быстрое (0.000053 с) благодаря логарифмической высоте. На отсортированных данных время возрастает до 0.00268 с (в 50 раз), что отражает деградацию до O(n).
+
+## 4. Выводы и рекомендации по выбору структуры
+
+На основе полученных результатов можно сформулировать следующие рекомендации:
+
+- **Хеш-таблица** – оптимальный выбор, если требуется максимальная скорость поиска, вставки и удаления, а порядок хранения не важен. Примеры: реализация словарей, кэшей, индексов по ключу. В эксперименте хеш-таблица показала стабильно высокую производительность во всех режимах.
+
+- **Двоичное дерево поиска** – следует применять, когда необходимо получать данные в отсортированном порядке (например, вывод телефонного справочника по алфавиту). Однако важно учитывать, что при поступлении отсортированных данных дерево вырождается, и производительность резко падает. В таких случаях лучше использовать сбалансированные деревья (AVL, красно-чёрные). В эксперименте BST на случайных данных показал отличные результаты, близкие к хеш-таблице, а на отсортированных – стал самым медленным.
+
+- **Связный список** – практически непригоден для больших объёмов данных из-за линейной сложности основных операций. Может использоваться лишь для очень маленьких коллекций, при частых вставках в начало списка (здесь не рассматривалось) или в учебных целях.
+
+Таким образом, для реальных задач чаще всего выбирают хеш-таблицы или сбалансированные деревья в зависимости от требований к упорядоченности данных.
+
+
+I use arch BTW

Ezhovnd/425.md

@@ -0,0 +1 @@
+hi

KuznetsovYuM/428.md

@@ -0,0 +1 @@
+428

MalkinMV/428b.md

@@ -0,0 +1 @@
+428b

README.md

@@ -197,3 +197,186 @@ with open("results.csv", "w", newline="") as f:
 - Как удаление работает в каждой структуре.
 
 * Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.*
+
+## Задание: Поиск выхода из лабиринта (объектно-ориентированная реализация с паттернами)
+
+### Цель работы
+Разработать гибкую, расширяемую программу для загрузки лабиринта из файла, поиска пути от старта до выхода с возможностью выбора алгоритма, визуализации процесса и экспериментального сравнения алгоритмов. В ходе работы необходимо применить минимум 3 паттерна проектирования из списка GoF, обосновать их выбор и продемонстрировать преимущества такой архитектуры.
+
+### Общая схема приложения (пример)
+
+```mermaid
+classDiagram
+    class Maze {
+        -Cell[] cells
+        -int width, height
+        -Cell start
+        -Cell exit
+        +getCell(x,y): Cell
+        +getNeighbors(cell): List~Cell~
+    }
+    
+    class Cell {
+        -int x, y
+        -bool isWall
+        -bool isStart
+        -bool isExit
+        +isPassable(): bool
+    }
+    
+    class MazeBuilder {
+        <<interface>>
+        +buildFromFile(filename): Maze
+    }
+    
+    class TextFileMazeBuilder {
+        +buildFromFile(filename): Maze
+    }
+    
+    class PathFindingStrategy {
+        <<interface>>
+        +findPath(maze, start, exit): List~Cell~
+    }
+    
+    class BFSStrategy
+    class DFSStrategy
+    class AStarStrategy
+    class DijkstraStrategy
+    
+    class SearchStats {
+        +timeMs: float
+        +visitedCells: int
+        +pathLength: int
+    }
+    
+    class MazeSolver {
+        -Maze maze
+        -PathFindingStrategy strategy
+        +setStrategy(strategy)
+        +solve(): SearchStats
+    }
+    
+    class Command {
+        <<interface>>
+        +execute()
+        +undo()
+    }
+    
+    class MoveCommand {
+        -Player player
+        -Direction dir
+        -Cell previousCell
+        +execute()
+        +undo()
+    }
+    
+    class Player {
+        -Cell currentCell
+        +moveTo(cell)
+    }
+    
+    class Observer {
+        <<interface>>
+        +update(event)
+    }
+    
+    class ConsoleView {
+        +update(event)
+        +render(maze, player, path)
+    }
+    
+    MazeBuilder <|.. TextFileMazeBuilder
+    MazeBuilder --> Maze : creates
+    PathFindingStrategy <|.. BFSStrategy
+    PathFindingStrategy <|.. DFSStrategy
+    PathFindingStrategy <|.. AStarStrategy
+    PathFindingStrategy <|.. DijkstraStrategy
+    MazeSolver --> PathFindingStrategy : uses
+    MazeSolver --> Maze : uses
+    Command <|.. MoveCommand
+    MoveCommand --> Player
+    Player --> Cell
+    Observer <|.. ConsoleView
+    MazeSolver --> Observer : notifies
+```
+
+### Выполнение
+
+#### Этап 1. Модель лабиринта (без паттернов, просто классы)
+**Задача:** Создать классы `Cell` и `Maze`, которые представляют карту лабиринта.
+- `Cell` хранит координаты (x, y), флаги `isWall`, `isStart`, `isExit`, метод `isPassable()` (возвращает `True` для прохода, если не стена).
+- `Maze` хранит двумерный массив клеток, ширину, высоту, ссылки на стартовую и выходную клетку. Методы: `getCell(x, y)`, `getNeighbors(cell)` – возвращает список соседних проходимых клеток (вверх, вниз, влево, вправо, если в пределах границ и не стена).
+
+**Результат:** Лабиринт можно создать вручную в коде, но загрузку пока не делаем.
+
+#### Этап 2. Загрузка лабиринта из файла – применение паттерна **Builder**
+**Задача:** Реализовать загрузку лабиринта из текстового файла, где `#` – стена, ` ` (пробел) – проход, `S` – старт, `E` – выход.
+- Создать интерфейс `MazeBuilder` с методом `buildFromFile(filename)`.
+- Реализовать класс `TextFileMazeBuilder`, который читает файл, парсит символы, создаёт объекты `Cell`, задаёт координаты и флаги, после чего возвращает готовый `Maze`.
+
+Процесс построения лабиринта сложный (парсинг, валидация, установка старта/выхода). Builder скрывает детали создания от клиента. В будущем можно легко добавить другой формат (например, JSON или бинарный) через новую реализацию `MazeBuilder`.
+
+#### Этап 3. Стратегии поиска пути – паттерн **Strategy**
+**Задача:** Реализовать семейство алгоритмов поиска пути от старта до выхода.
+- Создать интерфейс `PathFindingStrategy` с методом `findPath(maze, start, exit)`, возвращающим список клеток пути (от старта до выхода включительно) или пустой список, если пути нет.
+- Реализовать минимум 3 стратегии:
+  - **BFS** (поиск в ширину) – гарантирует кратчайший путь по количеству шагов.
+  - **DFS** (поиск в глубину) – быстрый, но не обязательно кратчайший.
+  - **A*** (с эвристикой, например, манхэттенское расстояние) – компромисс между скоростью и оптимальностью.
+  - (Опционально) **Дейкстра** – полезна для взвешенных лабиринтов, но в базовом варианте все шаги имеют вес 1, тогда она совпадает с BFS.
+
+Каждая стратегия возвращает путь. Для BFS/DFS используйте очередь/стек, для A* – приоритетную очередь (heapq). Важно: алгоритмы не должны модифицировать сам лабиринт, только читать состояние клеток.
+
+Strategy позволяет легко переключать алгоритмы во время выполнения, не меняя код остальной программы. Новый алгоритм можно добавить, реализовав интерфейс.
+
+#### Этап 4. Класс-оркестратор – **MazeSolver** (использует Strategy)
+**Задача:** Создать класс, который принимает лабиринт и стратегию, выполняет поиск и собирает статистику.
+- `MazeSolver` содержит поля `maze` и `strategy`.
+- Метод `setStrategy(strategy)` для динамической смены алгоритма.
+- Метод `solve()` вызывает `strategy.findPath(...)` и возвращает объект `SearchStats` (время выполнения в миллисекундах, количество посещённых клеток, длина найденного пути).
+- Для замера времени используйте `time.perf_counter()` до и после вызова стратегии.
+
+#### Этап 5. Визуализация и пошаговое управление – паттерны **Observer** и **Command** (по желанию)
+**5.1. Наблюдатель (Observer)** – обновление консольного интерфейса.
+- Создать интерфейс `Observer` с методом `update(event)`, где `event` может быть строкой или объектом с типом события (`"path_found"`, `"move"`, `"maze_loaded"`).
+- Реализовать класс `ConsoleView`, который отображает лабиринт, текущее положение игрока (если реализован пошаговый режим) и найденный путь. Метод `render(maze, player_position, path)` рисует карту в консоли.
+- `MazeSolver` (или отдельный контроллер) может иметь список наблюдателей и уведомлять их при изменении состояния.
+
+**5.2. Команда (Command)** – для пошагового перемещения игрока по найденному пути (или ручного управления).
+- Создать интерфейс `Command` с методами `execute()` и `undo()`.
+- Реализовать `MoveCommand`, который принимает игрока (`Player`), направление и изменяет его позицию, сохраняя предыдущую для отмены.
+- Создать класс `Player`, хранящий текущую клетку.
+- Консольное меню позволяет вводить команды (W/A/S/D), выполнять `MoveCommand`, при необходимости отменять последний ход (Ctrl+Z). Это опционально, но очень наглядно демонстрирует паттерн.
+
+*Observer можно реализовать только для вывода сообщений о начале/конце поиска, а Command – для демонстрации undo при ручном исследовании лабиринта.*
+
+#### Этап 6. Экспериментальная часть (аналогично заданию со структурами данных)
+**Задача:** Сравнить эффективность реализованных стратегий на лабиринтах разной сложности.
+1. **Подготовка тестовых лабиринтов:**
+   - Маленький (10×10) с простым путём.
+   - Средний (50×50) с тупиками.
+   - Большой (100×100) с запутанной структурой.
+   - «Пустой» лабиринт (без стен) – для демонстрации максимальной производительности.
+   - «Без выхода» – чтобы проверить обработку отсутствия пути.
+2. **Замеры:**
+   - Для каждого лабиринта и каждой стратегии запустить `solve()` 5–10 раз, усреднить время, количество посещённых клеток, длину пути.
+   - Записать результаты в CSV: `лабиринт,стратегия,время_мс,посещено_клеток,длина_пути`.
+3. **Анализ:**
+   - Построить графики для каждого лабиринта.
+   - Проанализировать и написать выводы по итогам (эффективность того или иного алгоритма в разных случаях).
+
+4. **Дополнительное задание:** Реализовать взвешенные клетки (например, болото – вес 3, песок – вес 2, асфальт – вес 1) и сравнить Дейкстру с A* на взвешенном графе.
+
+#### Этап 7. Отчёт
+**Структура отчёта:**
+1. Описание задачи и выбранных паттернов (с диаграммой классов из Mermaid).
+2. Листинги ключевых классов (можно выборочно) или ссылка на репозиторий.
+3. Результаты экспериментов (таблицы, графики).
+4. Анализ эффективности алгоритмов и применимости паттернов.
+5. Выводы: как ООП и паттерны помогли сделать код гибким и расширяемым. Что было бы сложно изменить без них.
+
+### Советы
+- Для A* самая простая эвристика: `abs(x1 - x2) + abs(y1 - y2)`.
+- При поиске пути надо хранить предшественников (`parent` для каждой посещённой клетки), чтобы восстановить путь.
+- Для BFS/DFS используй `deque` (очередь) и `list` (стек).
+- Визуализацию в консоли можно сделать с помощью `os.system('cls' if os.name == 'nt' else 'clear')` для перерисовки.

SorokinAD/428.md

@@ -0,0 +1 @@
+1

kuznetsovTD/428b.md

@@ -0,0 +1 @@
+428b.md

lukovnikovde/docs/data/DataStructure.py

@@ -1,507 +0,0 @@
-import random as rnd
-import time
-import csv
-import matplotlib.pyplot as plt
-#############################################################################################
-
-def sort_list(name_list):
-    l = len(name_list)
-    for i in range(l - 1):
-        for j in range(l - i - 1):
-            if name_list[j][0] > name_list[j + 1][0]:
-                name_list[j], name_list[j + 1] = name_list[j + 1], name_list[j]
-    return name_list
- 
-def hash_key(name):
-    h_key = sum(ord(ch) for ch in name)
-    return h_key
-
-def create_name_phone(i):
-    name = f"User_{i:03d}"
-    phone = f"{rnd.randint(100, 999)}-{rnd.randint(100, 999)}"
-    return (name, phone)
-
-def file_insert(results):
-    with open("results.csv", "w", encoding = "utf-8-sig", newline = "") as file:
-        writer = csv.writer(file)
-        writer.writerows(results)
-        
-def drow(time, color_fun, j, text, axes):
-
-    operation = [0, 1, 2, 3]
-    x = [j + operation[i] for i in range(4)]
-    y = []
-    for key in time:
-        y.append(time[key] * 1000)
-    for i in range(4):
-        axes[i].bar(x[i], y[i], width = 0.12,  color = color_fun, label = text)
-        axes[i].set_ylabel("Время, мс") 
-        axes[i].set_xticks([])
-    #plt.bar(x, y, width = 0.12, color = color_fun, label = text)
-    
-        
-        
-###########################################################################################################################
-
-def ll_insert(head, name, phone):
-    next_node = {'name': name, 'phone': phone, 'next': None}
-    if head is None: return next_node 
-
-    running = head
-    while running is not None:
-        if running['name'] == name:
-            running['phone'] = phone
-            return head
-        running = running['next']
-
-    running = head
-    while running['next'] is not None: running = running['next']
-    running['next'] = next_node
-    return head
-
-def ll_find(head, name):
-    running = head
-
-    while True:
-        if running['name'] == name:
-            return running['phone']
-        running = running['next']
-        if running is None: break
-
-    return None
-
-
-def ll_delete(head, name):
-    running = head
-    
-    if running['name'] == name: 
-        return head['next']
-
-    while running['next']['name'] != name: 
-        running = running['next']
-        if  running['next']['next'] is None:
-            if running['next']['name'] != name:
-                return head
-    if running['next']['next'] is None: 
-        running['next'] = None
-    else: running['next'] = running['next']['next']
-
-    return head
-    
-
-def ll_list_all(head):
-    name_list = []
-    running = head
-    while running is not None:
-        name_list.append((running['name'], running['phone']))     
-        running = running['next']
-    return name_list
-
-################################################################################################################################
-
-
-def LinkedList(head, phone_book):
-
-    start_insert = time.perf_counter()
-    for i in range(len(phone_book)):
-
-        head = ll_insert(head, phone_book[i][0], phone_book[i][1])
-    #print(head)
-    end_insert = time.perf_counter()
-    time_insert = end_insert - start_insert
-
-    start_find = time.perf_counter()
-    for _ in range(100):
-        name = create_name_phone(rnd.randint(0, 999))[0]
-        phone = ll_find(head, name)
-        #print(name, ":", phone)
-    end_find = time.perf_counter()
-    time_find = end_find - start_find
-    
-    
-    start_delete = time.perf_counter()
-    for i in range(110):
-        if i <= 99: name = f"User_{rnd.randint(0,999):03d}"
-        else: name = f"None_{i:03d}"
-        head = ll_delete(head, name)
-    end_delete = time.perf_counter()
-    time_delete = end_delete - start_delete
-        
-    
-    start_list = time.perf_counter()    
-    name_list = sort_list(ll_list_all(head))
-    #print(*name_list)
-    end_list = time.perf_counter()
-    time_list = end_list - start_list
-    
-    return (time_insert, time_find, time_delete, time_list)
-
-#########################################################################################################
-
-def ht_insert(buckest, name, phone):
-    index = hash_key(name) % len(buckest)
-    for i, (Name, Phone) in enumerate(buckest[index]):
-        if Name == name:
-            buckest[index][i] = (name, phone)
-            return buckest
-    buckest[index].append((name, phone))
-    return buckest
-
-def ht_find(buckest, name):
-    index = hash_key(name) % len(buckest)
-    for (Name, Phone) in buckest[index]:
-        if Name == name:
-            return Phone
-    return None
-
-def ht_list_all(buckest):
-    
-    name_list = []
-
-    for index in range(len(buckest)):
-        for i, (name, phone) in enumerate(buckest[index]):
-            name_list.append((name, phone))
-
-    name_list = sort_list(name_list)
-
-    return name_list
-
-
-def ht_delete(buckest, name):
-    index = hash_key(name) % len(buckest)
-    for i, (Name, Phone) in enumerate(buckest[index]):
-        if Name == name:
-            del buckest[index][i]
-    return buckest
-
-
-####################################################################################################
-
-def HashTable(buckest, phone_book):
-
-
-    start_insert = time.perf_counter()
-    for i in range(len(phone_book)):
-
-        buckest = ht_insert(buckest, phone_book[i][0], phone_book[i][1])
-    #print(buckest)
-    end_insert = time.perf_counter()
-    time_insert = end_insert - start_insert
-
-
-    start_find = time.perf_counter()
-    for _ in range(100):
-        name = create_name_phone(rnd.randint(0, 999))[0]
-        phone = ht_find(buckest, name)
-        #print(name, ":", phone)
-    end_find = time.perf_counter()
-    time_find = end_find - start_find
-    
-    
-    start_delete = time.perf_counter()
-    for i in range(110):
-        if i <= 99: name = f"User_{rnd.randint(0,999):03d}"
-        else: name = f"None_{i:03d}"
-        buckest = ht_delete(buckest, name)
-    end_delete = time.perf_counter()
-    time_delete = end_delete - start_delete
-        
-    
-    start_list = time.perf_counter()    
-    name_list = sort_list(ht_list_all(buckest))
-    #print(*name_list)
-    end_list = time.perf_counter()
-    time_list = end_list - start_list
-    
-    return (time_insert, time_find, time_delete, time_list)
-
-#################################################################################################
-
-def bst_insert(root, name, phone):
-    
-    running = root
-
-    if running is None:
-        root = {'name': name, 'phone': phone, 'left': None, 'right': None}
-        return root
-    while True:
-        node = hash_key(running['name'])
-        sheet = hash_key(name)
-        if node < sheet:
-            if running['right'] is None:
-                running['right'] = {'name': name, 'phone': phone, 'left': None, 'right': None}
-                return root
-            running = running['right']
-        elif node > sheet:
-            if running['left'] is None:
-                running['left'] = {'name': name, 'phone': phone, 'left': None, 'right': None}
-                return root
-            running = running['left']
-        else:
-             running['phone'] = phone
-             return root
-
-def bst_find(root, name):
-
-    running = root
-
-    while running is not None:
-        node = hash_key(running['name'])
-        sheet = hash_key(name)
-        if name == running['name']:
-            return running['phone']
-        elif node < sheet:
-            running = running['right']
-        else:
-            running = running['left']
-
-    return None
-
-def bst_list_all(root, name_list = []):
-    if root is None:
-        return
-    name_list.append((root['name'], root['phone']))
-    bst_list_all(root['left'], name_list)
-    bst_list_all(root['right'], name_list)
-    name_list = sort_list(name_list)
-    return name_list
-    
-def bst_delete(root, name):
-    
-    if root is None:
-        return None
-    if hash_key(name) < hash_key(root['name']):
-        root['left'] = bst_delete(root['left'], name)
-    elif hash_key(name) > hash_key(root['name']):
-        root['right'] = bst_delete(root['right'], name)
-    else:
-        
-        if root['left'] is None and root['right'] is None:
-            return None
-    
-        if root['left'] is None:
-            return root['right']
-        if root['right'] is None:
-            return root['left']
-        
-        min_node = root['right']
-        while min_node['left'] is not None:
-            min_node = min_node['left']
-            
-        root['name'] = min_node['name']
-        root['phone'] = min_node['phone']
-
-        root['right'] = bst_delete(root['right'], min_node['name'])            
-    
-    return root
-    
-#################################################################################################
-
-def BinarySearchTree(root, phone_book):
-
-    start_insert = time.perf_counter()
-    for i in range(len(phone_book)):
-
-        root = bst_insert(root, phone_book[i][0], phone_book[i][1])
-    #print(buckest)
-    end_insert = time.perf_counter()
-    time_insert = end_insert - start_insert
-
-
-    start_find = time.perf_counter()
-    for _ in range(100):
-        name = create_name_phone(rnd.randint(0, 999))[0]
-        phone = bst_find(root, name)
-        #print(name, ":", phone)
-    end_find = time.perf_counter()
-    time_find = end_find - start_find
-    
-    
-    start_delete = time.perf_counter()
-    for i in range(110):
-        if i <= 99: name = f"User_{rnd.randint(0,999):03d}"
-        else: name = f"None_{i:03d}"
-        root = bst_delete(root, name)
-    end_delete = time.perf_counter()
-    time_delete = end_delete - start_delete
-        
-    
-    start_list = time.perf_counter()    
-    name_list = sort_list(bst_list_all(root))
-    #print(*name_list)
-    end_list = time.perf_counter()
-    time_list = end_list - start_list
-    
-    return (time_insert, time_find, time_delete, time_list)
-
-################################################################################################
-def main():
-    
-    phone_book = []
-    for i in range(1000):
-        phone_book.append(create_name_phone(i))
-    for _ in range(9000):
-        phone_book.append(create_name_phone(rnd.randint(0, 999)))
-    
-    phone_book_not_sorted = phone_book.copy()
-    rnd.shuffle(phone_book_not_sorted)
-    
-    phone_book_sorted = phone_book.copy()
-    phone_book_sorted = sort_list(phone_book_sorted)
-    replay = 10
-    
-    
-    Time_ll_not_sorted = []
-    Time_ll_sorted =  []
-    
-    Time_average_ll_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
-    Time_average_ll_sorted =  {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
-    
-    print("============================================ TESTING LINKEDLIST =====================================\n")
-    print('Not sorted: ')
-    for _ in range(replay):
-        time_ll_not_sorted = LinkedList(None, phone_book_not_sorted)
-        Time_ll_not_sorted.append({'insert': time_ll_not_sorted[0], 'find': time_ll_not_sorted[1], 'delete': time_ll_not_sorted[2], 'list': time_ll_not_sorted[3]})
-        for i, key in enumerate(Time_average_ll_not_sorted):
-            Time_average_ll_not_sorted[key] += time_ll_not_sorted[i]/replay
-    for i in range(replay):
-        print(Time_ll_not_sorted[i])
-    print("Average:", Time_average_ll_not_sorted, "\n\n")
-        
-    print('Sorted:')    
-    for _ in range(replay):
-        time_ll_sorted = LinkedList(None, phone_book_sorted)
-        Time_ll_sorted.append({'insert': time_ll_sorted[0], 'find': time_ll_sorted[1], 'delete': time_ll_sorted[2], 'list': time_ll_sorted[3]})
-        for i, key in enumerate(Time_average_ll_sorted):
-            Time_average_ll_sorted[key] += time_ll_sorted[i]/replay
-    for i in range(replay):
-        print(Time_ll_not_sorted[i])    
-    print("Average:", Time_average_ll_sorted, "\n\n")
-        
-        
-        
-    Time_ht_not_sorted = []
-    Time_ht_sorted = []
-
-    Time_average_ht_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
-    Time_average_ht_sorted =  {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} 
-    
-    print("============================================ TESTING HASHTABLE =====================================\n")
-    print('Not sorted: ')
-    for _ in range(replay):
-        time_ht_not_sorted = HashTable([[] for _ in range(100)], phone_book_not_sorted)
-        Time_ht_not_sorted.append({'insert': time_ht_not_sorted[0], 'find': time_ht_not_sorted[1], 'delete': time_ht_not_sorted[2], 'list': time_ht_not_sorted[3]})
-        for i, key in enumerate(Time_average_ht_not_sorted):
-            Time_average_ht_not_sorted[key] += time_ht_not_sorted[i]/replay
-    for i in range(replay):
-        print(Time_ht_not_sorted[i])
-    print(f"Average: {Time_average_ht_not_sorted}\n\n")
-    
-    print('Sorted: ')
-    for _ in range(replay):
-        time_ht_sorted = HashTable([[] for _ in range(100)], phone_book_sorted)
-        Time_ht_sorted.append({'insert': time_ht_sorted[0], 'find': time_ht_sorted[1], 'delete': time_ht_sorted[2], 'list': time_ht_sorted[3]})
-        for i, key in enumerate(Time_average_ht_sorted):
-            Time_average_ht_sorted[key] += time_ht_sorted[i]/replay
-    for i in range(replay):
-        print(Time_ht_sorted[i])
-    print(f"Average: {Time_average_ht_sorted}\n\n")    
-       
-    
-    
-    Time_bst_not_sorted = []
-    Time_bst_sorted = []
-
-    Time_average_bst_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}
-    Time_average_bst_sorted =  {'insert': 0, 'find': 0, 'delete': 0, 'list': 0}  
-    
-    print("============================================ TESTING BINARYSEARCHTREE =====================================\n")
-    print('Not sorted: ')
-    for _ in range(replay):
-        time_bst_not_sorted = BinarySearchTree(None, phone_book_not_sorted)
-        Time_bst_not_sorted.append({'insert': time_bst_not_sorted[0], 'find': time_bst_not_sorted[1], 'delete': time_bst_not_sorted[2], 'list': time_bst_not_sorted[3]})
-        for i, key in enumerate(Time_average_bst_not_sorted):
-            Time_average_bst_not_sorted[key] += time_bst_not_sorted[i]/replay
-    for i in range(replay):
-        print(Time_bst_not_sorted[i])
-    print(f"Average: {Time_average_bst_not_sorted}\n\n")
-    
-    print('Sorted: ')
-    for _ in range(replay):
-        time_bst_sorted = BinarySearchTree(None, phone_book_sorted)
-        Time_bst_sorted.append({'insert': time_bst_sorted[0], 'find': time_bst_sorted[1], 'delete': time_bst_sorted[2], 'list': time_bst_sorted[3]})
-        for i, key in enumerate(Time_average_bst_sorted):
-            Time_average_bst_sorted[key] += time_bst_sorted[i]/replay
-    for i in range(replay):
-        print(Time_bst_sorted[i])
-    print(f"Average: {Time_average_bst_sorted}\n\n")    
-    print("=============================================== END TESTING ================================================")
-    
-    results = [["Структура", "Режим", "Операция", "Время(мс)"]]
-    for i in range(replay):
-        results.append(["LinkedList", "Случайный", "вставка", Time_ll_not_sorted[i]["insert"]])
-        results.append(["LinkedList", "Случайный", "поиск", Time_ll_not_sorted[i]["find"]])
-        results.append(["LinkedList", "Случайный", "удаление", Time_ll_not_sorted[i]["delete"]])
-        results.append(["LinkedList", "Случайный", "формирование списка", Time_ll_not_sorted[i]["list"]])
-        
-        results.append(["LinkedList", "Упорядоченный", "вставка", Time_ll_sorted[i]["insert"]])
-        results.append(["LinkedList", "Упорядоченный", "поиск", Time_ll_sorted[i]["find"]])
-        results.append(["LinkedList", "Упорядоченный", "удаление", Time_ll_sorted[i]["delete"]])
-        results.append(["LinkedList", "Упорядоченный", "формирование списка", Time_ll_sorted[i]["list"]])
-        
-    for i in range(replay):
-        results.append(["HashTable", "Случайный", "вставка", Time_ht_not_sorted[i]["insert"]])
-        results.append(["HashTable", "Случайный", "поиск", Time_ht_not_sorted[i]["find"]])
-        results.append(["HashTable", "Случайный", "удаление", Time_ht_not_sorted[i]["delete"]])
-        results.append(["HashTable", "Случайный", "формирование списка", Time_ht_not_sorted[i]["list"]])
-        
-        results.append(["HashTable", "Упорядоченный", "вставка", Time_ht_sorted[i]["insert"]])
-        results.append(["HashTable", "Упорядоченный", "поиск", Time_ht_sorted[i]["find"]])
-        results.append(["HashTable", "Упорядоченный", "удаление", Time_ht_sorted[i]["delete"]])
-        results.append(["HashTable", "Упорядоченный", "формирование списка", Time_ht_sorted[i]["list"]])
-
-    for i in range(replay):
-        results.append(["BinarySearchTree", "Случайный", "вставка", Time_bst_not_sorted[i]["insert"]])
-        results.append(["BinarySearchTree", "Случайный", "поиск", Time_bst_not_sorted[i]["find"]])
-        results.append(["BinarySearchTree", "Случайный", "удаление", Time_bst_not_sorted[i]["delete"]])
-        results.append(["BinarySearchTree", "Случайный", "формирование списка", Time_bst_not_sorted[i]["list"]])
-        
-        results.append(["BinarySearchTree", "Упорядоченный", "вставка", Time_bst_sorted[i]["insert"]])
-        results.append(["BinarySearchTree", "Упорядоченный", "поиск", Time_bst_sorted[i]["find"]])
-        results.append(["BinarySearchTree", "Упорядоченный", "удаление", Time_bst_sorted[i]["delete"]])
-        results.append(["BinarySearchTree", "Упорядоченный", "формирование списка", Time_bst_sorted[i]["list"]])
-        
-    for i in range(1, len(results) - 1):
-        results[i][3] *= 1000    
-    file_insert(results)
-    
-    fig, axes = plt.subplots(1, 4, figsize = (16, 5))
-    manager = plt.get_current_fig_manager()
-    manager.full_screen_toggle()
-
-
-    drow(Time_average_ll_not_sorted, "#0800FF", -0.3, "LinkedList (not sorted)", axes) 
-    drow(Time_average_ll_sorted, "#00C8FF", -0.18, "LinkedList (sorted)", axes)
-    drow(Time_average_ht_not_sorted, "#0E7A13", -0.06, "HashTable (not sorted)", axes)
-    drow(Time_average_ht_sorted, "#4DFF00", 0.06, "HashTable (sorted)", axes)
-    drow(Time_average_bst_not_sorted, "#968C1A", 0.18, "BST (not sorted)", axes)
-    drow(Time_average_bst_sorted, "#FBFF00", 0.30, "BST (sorted)", axes)
-    
-    operation = ['insert', 'find', 'delete', 'create list']
-    
-    for i in range(4):
-        axes[i].set_title(operation[i])
-    plt.legend(bbox_to_anchor = (1.05, 1), loc = "upper left")
-
-
-
-    plt.subplots_adjust(bottom = 0.025, top = 0.95, left = 0.025, right = 0.875)
-    plt.savefig("time_schedule.png")
-    plt.show()
-
-if __name__ == "__main__":
-    main()
-
-
-
-

lukovnikovde/docs/data/resalts.csv

@@ -1,241 +0,0 @@
-Структура,Режим,Операция,Время(мс)
-LinkedList,Случайный,вставка,159.38230000028852
-LinkedList,Случайный,поиск,1.608700000360841
-LinkedList,Случайный,удаление,3.333099999508704
-LinkedList,Случайный,формирование списка,31.43850000014936
-LinkedList,Упорядоченный,вставка,176.2546999998449
-LinkedList,Упорядоченный,поиск,1.7821999990701443
-LinkedList,Упорядоченный,удаление,3.542399999787449
-LinkedList,Упорядоченный,формирование списка,21.29400000012538
-LinkedList,Случайный,вставка,160.5120000003808
-LinkedList,Случайный,поиск,1.5978000010363758
-LinkedList,Случайный,удаление,3.5874000004696427
-LinkedList,Случайный,формирование списка,31.3373999997566
-LinkedList,Упорядоченный,вставка,169.6819000007963
-LinkedList,Упорядоченный,поиск,1.6672000001562992
-LinkedList,Упорядоченный,удаление,3.06300000011106
-LinkedList,Упорядоченный,формирование списка,21.382199998697615
-LinkedList,Случайный,вставка,162.45290000006207
-LinkedList,Случайный,поиск,1.6584000004513655
-LinkedList,Случайный,удаление,3.0743000006623333
-LinkedList,Случайный,формирование списка,31.488399999943795
-LinkedList,Упорядоченный,вставка,169.72099999838974
-LinkedList,Упорядоченный,поиск,1.7922000006365124
-LinkedList,Упорядоченный,удаление,3.3667999996396247
-LinkedList,Упорядоченный,формирование списка,21.698699998523807
-LinkedList,Случайный,вставка,163.0209000013565
-LinkedList,Случайный,поиск,1.6841999986354494
-LinkedList,Случайный,удаление,3.2122999982675537
-LinkedList,Случайный,формирование списка,31.478799999604234
-LinkedList,Упорядоченный,вставка,172.49460000130057
-LinkedList,Упорядоченный,поиск,1.756999999997788
-LinkedList,Упорядоченный,удаление,3.196600000592298
-LinkedList,Упорядоченный,формирование списка,21.166299999094917
-LinkedList,Случайный,вставка,163.07450000022072
-LinkedList,Случайный,поиск,1.8555999995442107
-LinkedList,Случайный,удаление,3.40919999871403
-LinkedList,Случайный,формирование списка,31.833799999731127
-LinkedList,Упорядоченный,вставка,170.02059999867924
-LinkedList,Упорядоченный,поиск,1.552300000184914
-LinkedList,Упорядоченный,удаление,3.814900001088972
-LinkedList,Упорядоченный,формирование списка,21.307799999704002
-LinkedList,Случайный,вставка,168.1974999992235
-LinkedList,Случайный,поиск,2.0230999998602783
-LinkedList,Случайный,удаление,3.5730999989027623
-LinkedList,Случайный,формирование списка,32.19399999943562
-LinkedList,Упорядоченный,вставка,169.28159999952186
-LinkedList,Упорядоченный,поиск,1.713900001050206
-LinkedList,Упорядоченный,удаление,3.4302999993087724
-LinkedList,Упорядоченный,формирование списка,21.549899998717592
-LinkedList,Случайный,вставка,169.27700000087498
-LinkedList,Случайный,поиск,1.7975999999180203
-LinkedList,Случайный,удаление,3.151300001263735
-LinkedList,Случайный,формирование списка,31.799799999134848
-LinkedList,Упорядоченный,вставка,171.0044999999809
-LinkedList,Упорядоченный,поиск,1.743999999234802
-LinkedList,Упорядоченный,удаление,3.8127000007079914
-LinkedList,Упорядоченный,формирование списка,21.345600000131526
-LinkedList,Случайный,вставка,173.35669999920356
-LinkedList,Случайный,поиск,1.8798999990394805
-LinkedList,Случайный,удаление,3.4422999997332226
-LinkedList,Случайный,формирование списка,32.4691999994684
-LinkedList,Упорядоченный,вставка,169.52339999988908
-LinkedList,Упорядоченный,поиск,1.728800001728814
-LinkedList,Упорядоченный,удаление,3.3399000003555557
-LinkedList,Упорядоченный,формирование списка,21.254400000543683
-LinkedList,Случайный,вставка,169.77609999958077
-LinkedList,Случайный,поиск,1.6739000002417015
-LinkedList,Случайный,удаление,3.73560000116413
-LinkedList,Случайный,формирование списка,31.469499999730033
-LinkedList,Упорядоченный,вставка,171.0146999994322
-LinkedList,Упорядоченный,поиск,1.6797999996924773
-LinkedList,Упорядоченный,удаление,3.45019999986107
-LinkedList,Упорядоченный,формирование списка,21.524600000702776
-LinkedList,Случайный,вставка,167.06580000027316
-LinkedList,Случайный,поиск,1.8982999990839744
-LinkedList,Случайный,удаление,3.6678999986179406
-LinkedList,Случайный,формирование списка,32.446200000777026
-LinkedList,Упорядоченный,вставка,171.11090000071272
-LinkedList,Упорядоченный,поиск,1.7826000002969522
-LinkedList,Упорядоченный,удаление,3.3842000011645723
-LinkedList,Упорядоченный,формирование списка,21.2576000012632
-HashTable,Случайный,вставка,17.278299999816227
-HashTable,Случайный,поиск,0.3028999999514781
-HashTable,Случайный,удаление,0.3226000007998664
-HashTable,Случайный,формирование списка,47.606800000721705
-HashTable,Упорядоченный,вставка,16.69159999983094
-HashTable,Упорядоченный,поиск,0.278499999694759
-HashTable,Упорядоченный,удаление,0.31350000062957406
-HashTable,Упорядоченный,формирование списка,47.49850000007427
-HashTable,Случайный,вставка,18.00539999931061
-HashTable,Случайный,поиск,0.28170000041427556
-HashTable,Случайный,удаление,0.3051999992749188
-HashTable,Случайный,формирование списка,48.14599999917846
-HashTable,Упорядоченный,вставка,18.065500000375323
-HashTable,Упорядоченный,поиск,0.28329999986453913
-HashTable,Упорядоченный,удаление,0.32250000003841706
-HashTable,Упорядоченный,формирование списка,47.55000000113796
-HashTable,Случайный,вставка,16.97520000016084
-HashTable,Случайный,поиск,0.2812000002450077
-HashTable,Случайный,удаление,0.3178000006300863
-HashTable,Случайный,формирование списка,47.868200001175865
-HashTable,Упорядоченный,вставка,18.372099999396596
-HashTable,Упорядоченный,поиск,0.3102999999100575
-HashTable,Упорядоченный,удаление,0.3297000002930872
-HashTable,Упорядоченный,формирование списка,48.02730000119482
-HashTable,Случайный,вставка,16.71149999856425
-HashTable,Случайный,поиск,0.27319999935571104
-HashTable,Случайный,удаление,0.3262999998696614
-HashTable,Случайный,формирование списка,47.846100000242586
-HashTable,Упорядоченный,вставка,18.567699999039178
-HashTable,Упорядоченный,поиск,0.2848999993148027
-HashTable,Упорядоченный,удаление,0.3262999998696614
-HashTable,Упорядоченный,формирование списка,48.06850000022678
-HashTable,Случайный,вставка,16.770899999755784
-HashTable,Случайный,поиск,0.26760000037029386
-HashTable,Случайный,удаление,0.3209000005881535
-HashTable,Случайный,формирование списка,48.08539999976347
-HashTable,Упорядоченный,вставка,17.05279999987397
-HashTable,Упорядоченный,поиск,0.2679999997781124
-HashTable,Упорядоченный,удаление,0.31599999965692405
-HashTable,Упорядоченный,формирование списка,48.27990000012505
-HashTable,Случайный,вставка,17.21460000044317
-HashTable,Случайный,поиск,0.27520000003278255
-HashTable,Случайный,удаление,0.3281999997852836
-HashTable,Случайный,формирование списка,47.93720000088797
-HashTable,Упорядоченный,вставка,17.084900000554626
-HashTable,Упорядоченный,поиск,0.2795999989757547
-HashTable,Упорядоченный,удаление,0.3280000000813743
-HashTable,Упорядоченный,формирование списка,47.76760000095237
-HashTable,Случайный,вставка,16.898900001251604
-HashTable,Случайный,поиск,0.2705999995669117
-HashTable,Случайный,удаление,0.3180999992764555
-HashTable,Случайный,формирование списка,48.1019999988348
-HashTable,Упорядоченный,вставка,17.074800000045798
-HashTable,Упорядоченный,поиск,0.27850000151374843
-HashTable,Упорядоченный,удаление,0.3259999994043028
-HashTable,Упорядоченный,формирование списка,48.0186999993748
-HashTable,Случайный,вставка,17.024499999024556
-HashTable,Случайный,поиск,0.2716999988479074
-HashTable,Случайный,удаление,0.3228999994462356
-HashTable,Случайный,формирование списка,48.31470000135596
-HashTable,Упорядоченный,вставка,17.382100000759237
-HashTable,Упорядоченный,поиск,0.2786999993986683
-HashTable,Упорядоченный,удаление,0.3171999996993691
-HashTable,Упорядоченный,формирование списка,47.687000000223634
-HashTable,Случайный,вставка,17.80959999996412
-HashTable,Случайный,поиск,0.28049999855284113
-HashTable,Случайный,удаление,0.3245999996579485
-HashTable,Случайный,формирование списка,48.608699999022065
-HashTable,Упорядоченный,вставка,17.124399999374873
-HashTable,Упорядоченный,поиск,0.2822999995260034
-HashTable,Упорядоченный,удаление,0.31680000029155053
-HashTable,Упорядоченный,формирование списка,47.660199999882025
-HashTable,Случайный,вставка,16.860599998835823
-HashTable,Случайный,поиск,0.27319999935571104
-HashTable,Случайный,удаление,0.31459999991056975
-HashTable,Случайный,формирование списка,48.28310000084457
-HashTable,Упорядоченный,вставка,17.49010000094131
-HashTable,Упорядоченный,поиск,0.29379999978118576
-HashTable,Упорядоченный,удаление,0.31820000003790483
-HashTable,Упорядоченный,формирование списка,48.560000001089065
-BinarySearchTree,Случайный,вставка,53.984700000000885
-BinarySearchTree,Случайный,поиск,0.7683999992877943
-BinarySearchTree,Случайный,удаление,0.6331000004138332
-BinarySearchTree,Случайный,формирование списка,0.01739999970595818
-BinarySearchTree,Упорядоченный,вставка,163.88949999964098
-BinarySearchTree,Упорядоченный,поиск,1.765700000760262
-BinarySearchTree,Упорядоченный,удаление,1.525900001070113
-BinarySearchTree,Упорядоченный,формирование списка,0.4360000002634479
-BinarySearchTree,Случайный,вставка,52.91410000063479
-BinarySearchTree,Случайный,поиск,0.7721999991190387
-BinarySearchTree,Случайный,удаление,0.5829000001540408
-BinarySearchTree,Случайный,формирование списка,0.04259999877831433
-BinarySearchTree,Упорядоченный,вставка,164.1801999994641
-BinarySearchTree,Упорядоченный,поиск,1.7733000004227506
-BinarySearchTree,Упорядоченный,удаление,1.3930999994045123
-BinarySearchTree,Упорядоченный,формирование списка,0.8812000014586374
-BinarySearchTree,Случайный,вставка,52.482299999610404
-BinarySearchTree,Случайный,поиск,0.7862000002205605
-BinarySearchTree,Случайный,удаление,0.6584999991900986
-BinarySearchTree,Случайный,формирование списка,0.0718000010238029
-BinarySearchTree,Упорядоченный,вставка,161.70600000077684
-BinarySearchTree,Упорядоченный,поиск,1.7728999991959427
-BinarySearchTree,Упорядоченный,удаление,1.7010999999911292
-BinarySearchTree,Упорядоченный,формирование списка,1.2267000001884298
-BinarySearchTree,Случайный,вставка,53.89560000003257
-BinarySearchTree,Случайный,поиск,0.7697999990341486
-BinarySearchTree,Случайный,удаление,0.669999999445281
-BinarySearchTree,Случайный,формирование списка,0.1666999996814411
-BinarySearchTree,Упорядоченный,вставка,160.7681000004959
-BinarySearchTree,Упорядоченный,поиск,1.770599999872502
-BinarySearchTree,Упорядоченный,удаление,1.4972999997553416
-BinarySearchTree,Упорядоченный,формирование списка,1.454899998861947
-BinarySearchTree,Случайный,вставка,52.44479999964824
-BinarySearchTree,Случайный,поиск,0.7471999997505918
-BinarySearchTree,Случайный,удаление,0.7040000000415603
-BinarySearchTree,Случайный,формирование списка,0.19189999875379726
-BinarySearchTree,Упорядоченный,вставка,162.21529999893392
-BinarySearchTree,Упорядоченный,поиск,1.835400000345544
-BinarySearchTree,Упорядоченный,удаление,1.5229000000545057
-BinarySearchTree,Упорядоченный,формирование списка,1.444699999410659
-BinarySearchTree,Случайный,вставка,52.532899999278015
-BinarySearchTree,Случайный,поиск,0.772299999880488
-BinarySearchTree,Случайный,удаление,0.6493000000773463
-BinarySearchTree,Случайный,формирование списка,0.3001000004587695
-BinarySearchTree,Упорядоченный,вставка,162.3187000004691
-BinarySearchTree,Упорядоченный,поиск,1.7641000013099983
-BinarySearchTree,Упорядоченный,удаление,1.656399999774294
-BinarySearchTree,Упорядоченный,формирование списка,1.9058000016229926
-BinarySearchTree,Случайный,вставка,52.441100000578444
-BinarySearchTree,Случайный,поиск,0.7502000007661991
-BinarySearchTree,Случайный,удаление,0.7283999984792899
-BinarySearchTree,Случайный,формирование списка,0.4217999994580168
-BinarySearchTree,Упорядоченный,вставка,163.2737999989331
-BinarySearchTree,Упорядоченный,поиск,1.7657999997027218
-BinarySearchTree,Упорядоченный,удаление,1.2108999999327352
-BinarySearchTree,Упорядоченный,формирование списка,1.5694999983679736
-BinarySearchTree,Случайный,вставка,52.80719999973371
-BinarySearchTree,Случайный,поиск,0.7774999994580867
-BinarySearchTree,Случайный,удаление,0.5965999989712145
-BinarySearchTree,Случайный,формирование списка,0.4585999995470047
-BinarySearchTree,Упорядоченный,вставка,164.02340000058757
-BinarySearchTree,Упорядоченный,поиск,1.836600000387989
-BinarySearchTree,Упорядоченный,удаление,1.7723999990266748
-BinarySearchTree,Упорядоченный,формирование списка,2.3199999995995313
-BinarySearchTree,Случайный,вставка,52.927000000636326
-BinarySearchTree,Случайный,поиск,0.7868000011512777
-BinarySearchTree,Случайный,удаление,0.6422000005841255
-BinarySearchTree,Случайный,формирование списка,0.4780999988724943
-BinarySearchTree,Упорядоченный,вставка,162.5091000005341
-BinarySearchTree,Упорядоченный,поиск,1.8755000000965083
-BinarySearchTree,Упорядоченный,удаление,1.8066000011458527
-BinarySearchTree,Упорядоченный,формирование списка,2.217999999629683
-BinarySearchTree,Случайный,вставка,53.06439999912982
-BinarySearchTree,Случайный,поиск,0.7920999996713363
-BinarySearchTree,Случайный,удаление,0.7385999997495674
-BinarySearchTree,Случайный,формирование списка,0.6822999985161005
-BinarySearchTree,Упорядоченный,вставка,162.1802999998181
-BinarySearchTree,Упорядоченный,поиск,1.9329999995534308
-BinarySearchTree,Упорядоченный,удаление,1.5555000009044306
-BinarySearchTree,Упорядоченный,формирование списка,0.0028387000002112472

lukovnikovde/docs/report.md

@@ -1,28 +0,0 @@
-# Отчет по лабораторной работе "Структуры данных"
-## 1. Введение
-В ходе выполнения лабораторной работы были выполнены реализации трех структур для хранения и обработки данных телефонных номеров:
-- Связный список
-- Хеш-таблица
-- Двоичное дерево поиска.
-
-Практическая часть включала в себя такие операции как: добавление или обновление телефонного номера, удаление телефонного номера, поиск владельца телефонного номера и составление списка из кортежей вида (владелец, номер). Каждое выполнение функций проводилось с списоком из кортежей вида (владелецб номер), в котором было 1000 уникальных имен и еще 9000 имен, которые уже были использованны (всего 10000 кортежей). Каждое тестирование структур выполнялось для сортированного и не сортированного начального списка 10 раз.
-## 2. Результаты измерений
-Данные в таблице отражают среднее время в милисекундах выполнения структур. 
-| Структура | Начальный список | insert, мс | find, мс | delete, мс | create list, мс |
-| :---: | :---: | ---: | ---: | ---: | ---: |
-| LinkedList | not sorted |  165.61 | 1.767 | 3.418 | 31.795 |
-| LinkedList | sorted | 171.01 | 1.720 | 3.440 | 21.378 |
-| HashTable | not sorted | 17.15 | 0.278 | 0.320 | 48.080 |
-| HashTable | sorted | 17.49 | 0.284 | 0.321 | 47.911 |
-| BST | not sorted | 52.95 | 0.772 | 0.660 | 0.283 |
-| BST | sorted | 162.70 | 1.809 | 1.564 | 1.626 |
-
-Изходя  из полученных значений можно построить столбчатую диаграмму:
-
-![](data/time_schedule.png)
-## 3. Анализ полученных данных
-### 3.1 Зависимость скорости работы BST от порядка ввода данных.
-Из полученных данных можно заметить, что для BST порядок ввода сильно сказывается на результате скорости выполнения программы: при послутплении неотсортированных данных программа справляется примерно в 3 раза быстрее. Связано это с тем, что каждое новое значение, при сортированных данных, будет больше предыдущего, а соответственно будет каждый раз создаватся правый лист, из-за чего высота дерева становится равной количесвту всех уникальных имен, вседствии чего сложность возрастает до О(n), а двоичное дерево превращается в своебразный связный список. Даже если сравнивать связный список и такое дерево, то скорость запонения с помощью такого способа проигрывает даже связному списку. Связано это с тем, что, хоть дерево здесь и будет выполнять роль связного списка, оно всеравно будет в каждом узле создавать новый левый лист со значением None, что замедляет его работу.
-
-### 3.2 Независимость скорости выполнения заполнения хеш-таблицы от порядка вводных данных
-Из эксперемента можно заметить, что скорость заполнения хеш-таблицы сортированными и несортированными данными почти одинакова(разница менее 2%). Это объясняется наличием бакетов, которые распределяют данные.

osipovamd/428.md

@@ -0,0 +1,6 @@
+{\rtf1\ansi\ansicpg1251\cocoartf2869
+\cocoatextscaling0\cocoaplatform0{\fonttbl}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+}

rybakovaa/428b.md

@@ -0,0 +1 @@
+428b

soninrv/428.md

@@ -0,0 +1 @@
+ 

victorovaas/429

@@ -0,0 +1 @@
+<EFBFBD>¥¦¨¬ ¢כ¢®₪  ×®¬ ­₪ ­  ם×א ­ (ECHO) ¢×«מח¥­.

zhigalovrd/425.txt

@@ -0,0 +1 @@
+ыфыв