diff --git a/BoriskovaDV/428.md b/BoriskovaDV/428.md new file mode 100644 index 0000000..e69de29 diff --git a/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py b/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py new file mode 100644 index 0000000..3a30714 --- /dev/null +++ b/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']: + 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() diff --git a/BudakovIS/docs/data/1-st-exercize/experiment_results.csv b/BudakovIS/docs/data/1-st-exercize/experiment_results.csv new file mode 100644 index 0000000..e754dc6 --- /dev/null +++ b/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 diff --git a/BudakovIS/docs/data/1-st-exercize/plot_results.py b/BudakovIS/docs/data/1-st-exercize/plot_results.py new file mode 100644 index 0000000..8eb2e7a --- /dev/null +++ b/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() diff --git a/BudakovIS/docs/performance_comparison.png b/BudakovIS/docs/performance_comparison.png new file mode 100644 index 0000000..ef3e2e0 Binary files /dev/null and b/BudakovIS/docs/performance_comparison.png differ diff --git a/BudakovIS/docs/report_1-st-exersize.md b/BudakovIS/docs/report_1-st-exersize.md new file mode 100644 index 0000000..f478c8a --- /dev/null +++ b/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 diff --git a/Ezhovnd/425.md b/Ezhovnd/425.md new file mode 100644 index 0000000..45b983b --- /dev/null +++ b/Ezhovnd/425.md @@ -0,0 +1 @@ +hi diff --git a/KislyuninED/428.md b/KislyuninED/428.md new file mode 100644 index 0000000..e69de29 diff --git a/MalkinMV/428b.md b/MalkinMV/428b.md new file mode 100644 index 0000000..225a97e --- /dev/null +++ b/MalkinMV/428b.md @@ -0,0 +1 @@ +428b diff --git a/MochalovAE/426.txt b/MochalovAE/426.txt new file mode 100644 index 0000000..e69de29 diff --git a/README.md b/README.md index 5952cd5..69bb887 100644 --- a/README.md +++ b/README.md @@ -196,4 +196,187 @@ with open("results.csv", "w", newline="") as f: - Как удаление работает в каждой структуре. -* Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.* \ No newline at end of file +* Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.* + +## Задание: Поиск выхода из лабиринта (объектно-ориентированная реализация с паттернами) + +### Цель работы +Разработать гибкую, расширяемую программу для загрузки лабиринта из файла, поиска пути от старта до выхода с возможностью выбора алгоритма, визуализации процесса и экспериментального сравнения алгоритмов. В ходе работы необходимо применить минимум 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 { + <> + +buildFromFile(filename): Maze + } + + class TextFileMazeBuilder { + +buildFromFile(filename): Maze + } + + class PathFindingStrategy { + <> + +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 { + <> + +execute() + +undo() + } + + class MoveCommand { + -Player player + -Direction dir + -Cell previousCell + +execute() + +undo() + } + + class Player { + -Cell currentCell + +moveTo(cell) + } + + class Observer { + <> + +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')` для перерисовки. diff --git a/SavelevMI/428.md b/SavelevMI/428.md new file mode 100644 index 0000000..e69de29 diff --git a/Smirnovvs/428.txt b/Smirnovvs/428.txt new file mode 100644 index 0000000..e69de29 diff --git a/SokolovNE/428b.md.txt b/SokolovNE/428b.md.txt new file mode 100644 index 0000000..e69de29 diff --git a/SorokinAD/428.md b/SorokinAD/428.md new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/SorokinAD/428.md @@ -0,0 +1 @@ +1 diff --git a/VarnakovAA/429.md b/VarnakovAA/429.md new file mode 100644 index 0000000..e69de29 diff --git a/dyachenkoas/428 b/dyachenkoas/428 new file mode 100644 index 0000000..e69de29 diff --git a/famutdinovmd/428b.md b/famutdinovmd/428b.md new file mode 100644 index 0000000..e69de29 diff --git a/kalinovskiymi/428 b/kalinovskiymi/428 new file mode 100644 index 0000000..e69de29 diff --git a/nikitovie/425.txt b/nikitovie/425.txt new file mode 100644 index 0000000..e69de29 diff --git a/osipovamd/428.md b/osipovamd/428.md new file mode 100644 index 0000000..71b0a00 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/starikovta/426.md b/starikovta/426.md new file mode 100644 index 0000000..e69de29 diff --git a/victorovaas/429 b/victorovaas/429 new file mode 100644 index 0000000..cf53638 --- /dev/null +++ b/victorovaas/429 @@ -0,0 +1 @@ + 뢮 ࠭ (ECHO) 祭.