110 changed files with 4 additions and 971 deletions
--- a/.gitignore
+++ b/.gitignore
@ -7,7 +7,6 @@ __pycache__/
 # C extensions
 *.so
 .DS_Store
 # Distribution / packaging
 .Python
 build/
--- a/BolonkinNM/426.md
+++ b/BolonkinNM/426.md
--- a/BoriskovaDV/428.md
+++ b/BoriskovaDV/428.md
--- a/BorisovMI/429.md
+++ b/BorisovMI/429.md
--- a/BudakovIS/428.md
+++ b/BudakovIS/428.md
--- a/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py
+++ b/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py
@ -1,457 +0,0 @@
 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()
--- a/BudakovIS/docs/data/1-st-exercize/experiment_results.csv
+++ b/BudakovIS/docs/data/1-st-exercize/experiment_results.csv
@ -1,31 +0,0 @@
 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
--- a/BudakovIS/docs/data/1-st-exercize/plot_results.py
+++ b/BudakovIS/docs/data/1-st-exercize/plot_results.py
@ -1,44 +0,0 @@
 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()
--- a/BudakovIS/docs/performance_comparison.png
+++ b/BudakovIS/docs/performance_comparison.png
--- a/BudakovIS/docs/report_1-st-exersize.md
+++ b/BudakovIS/docs/report_1-st-exersize.md
@ -1,60 +0,0 @@
 # Отчёт по лабораторной работе "Структуры данных"
 ## 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
--- a/DerbenevRY/428.md
+++ b/DerbenevRY/428.md
--- a/Ezhovnd/425.md
+++ b/Ezhovnd/425.md
@ -1 +0,0 @@
 hi
--- a/GorkinMM/425.md
+++ b/GorkinMM/425.md
--- a/GutovVM/428b.md
+++ b/GutovVM/428b.md
--- a/KislyuninED/428.md
+++ b/KislyuninED/428.md
--- a/KolbasovPD/425.md
+++ b/KolbasovPD/425.md
--- a/KorotkinSE/428b.md
+++ b/KorotkinSE/428b.md
--- a/KuzminskiyAA/427.md
+++ b/KuzminskiyAA/427.md
@ -1 +0,0 @@
--- a/KuznetsovAS/427.md
+++ b/KuznetsovAS/427.md
--- a/KuznetsovMA/429.txt
+++ b/KuznetsovMA/429.txt
--- a/KuznetsovYuM/428.md
+++ b/KuznetsovYuM/428.md
@ -1 +0,0 @@
 428
--- a/LarikovaAA/428b.md
+++ b/LarikovaAA/428b.md
--- a/LukovnikovDE/428.md
+++ b/LukovnikovDE/428.md
--- a/MalkinMV/428b.md
+++ b/MalkinMV/428b.md
@ -1 +0,0 @@
 428b
--- a/MarkinAM/428b.md
+++ b/MarkinAM/428b.md
--- a/MashinDD/429.txt
+++ b/MashinDD/429.txt
--- a/MininaVD/427.txt
+++ b/MininaVD/427.txt
@ -1 +0,0 @@
 427.txt 
--- a/MininaVD/MininaVD
+++ b/MininaVD/MininaVD
@ -1 +0,0 @@
 427.txt 
--- a/MochalovAE/426.txt
+++ b/MochalovAE/426.txt
--- a/MusinAA/428b.md
+++ b/MusinAA/428b.md
--- a/MylnikovAS/427.md
+++ b/MylnikovAS/427.md
@ -1 +0,0 @@
--- a/ProninVV/427.md
+++ b/ProninVV/427.md
--- a/ProninVV/file.txt
+++ b/ProninVV/file.txt
--- a/README.md
+++ b/README.md
@ -16,7 +16,7 @@
 ### Крайний срок приема работ 25.05.2026 до 14:00
-## Задание 0 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026]
+## Задание 1 -- репозиторий
 0. Создай пользователя (логин — фамилия+инициалы слитно транслитом, как в терминал-классе).
@ -38,345 +38,17 @@
 5.  **Сохрани изменения:**
    ```bash
    git add -A
-    git commit -m "[0] initial commit"
+    git commit -m "Добавлен файл группы [номер] для [Фамилия]"
    ```
 6.  Отправь ветку **в свой форк** на Gitea:
    ```bash
-    git push origin
+    git push origin IvanovII
    ```
 если просит, перед этим сделать git push --set-upstream origin
 7.  **Создай запрос на слияние (Pull Request):** На Gitea перейди в свой форк, выбери ветку `IvanovII`, нажмите **Запрос на слияние**. Убедитесь, что:
    - Базовый репозиторий: **учебный** (преподавателя)
    - Базовая ветка: **develop**
    - Сравниваемая ветка: **свой форк / IvanovII**
-8.  Отправь PR.
+8.  Отправь PR.
 ## Задание 1 -- структуры данных
 ***Напоминание: под каждое задание вы создаете отдельную ветку***
 >Для оформления результатов заведи папку **docs** в своей папке и сохраняй туда отчет (в любом формате от .doc до .md, а то и .jpnb). Вспомогательные файлы клади в подпапку **data** внутри **docs**
 **Цель работы**
 Реализовать три различные структуры данных «с нуля», применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций. Вы должны собственными руками написать код, чтобы понять внутреннее устройство связного списка, хеш-таблицы и двоичного дерева поиска, а также осознать их сильные и слабые стороны на практике.
 **!! Задание  выполнять в структурной (процедурной) парадигме, не используя классы. Главное реализовать структуры данных «руками» и сравнить их производительность.**
 ### Базовые операции (обязательны для всех):
 `insert(name, phone)` -- добавить или обновить запись.
 `find(name)` -- phone или None.
 `delete(name)` -- удалить запись, игнорировать отсутствие.
 `list_all()` -- список всех записей, отсортированный по имени (для BST in‑order обход; для списка и хеш‑таблицы — собрать и отсортировать явно).
 #### 1. Связный список (LinkedListPhoneBook)
 Узел представляется словарём: `{'name': 'Имя', 'phone': '123', 'next': None}.`
 **Функции:**
 `def ll_insert(head, name, phone)` — проходит до конца (или сразу добавляет в конец) и возвращает новую голову (если вставка в начало) или изменяет список по ссылке. Удобнее возвращать новую голову, если вставка может быть в начало.
 `def ll_find(head, name)` — ищет узел, возвращает телефон или None.
 `def ll_delete(head, name)` — удаляет узел, возвращает новую голову.
 `def ll_list_all(head)` — собирает все записи в список и сортирует (сортировка вынесена отдельно).
 #### 2. Хеш-таблица
 Хранится как список buckets фиксированной длины, каждый элемент — голова связного списка (или None).
 **Функции:**
 `def ht_insert(buckets, name, phone)` — вычисляет индекс, вызывает ll_insert для соответствующего бакета.
 Аналогично `ht_find, ht_delete, ht_list_all` (последняя собирает все записи из всех бакетов и сортирует).
 #### 3. Двоичное дерево поиска
 Узел — словарь: `{'name': 'Имя', 'phone': '123', 'left': None, 'right': None}.`
 **Функции:**
 `def bst_insert(root, name, phone)` — рекурсивно или итеративно вставляет, возвращает новый корень (если корень меняется).
 `def bst_find(root, name)` — поиск.
 `def bst_delete(root, name)` — удаление, возвращает новый корень.
 `def bst_list_all(root)` — центрированный обход (рекурсивно собирает записи в отсортированном порядке).
 ### Экспериментальная часть (подробно об измерении времени)
 #### 1. Генерация тестовых данных
 Создайте список records из N элементов (например, N = 10000). Каждый элемент — кортеж (name, phone).
 Имена генерируйте как `f"User_{i:05d}"` (равномерное распределение) или случайные слова из небольшого набора (чтобы были повторения и коллизии). Для проверки влияния порядка подготовьте два варианта одного и того же набора:
 `records_shuffled` — случайный порядок.
 `records_sorted` — отсортированный по имени (по алфавиту).
 #### 2. Инструменты замера времени
 Используйте модуль **time**:
 ```python
 import time
 start = time.perf_counter()
 # ... операции ...
 end = time.perf_counter()
 elapsed = end - start  # время в секундах
 ```
 Для многократных замеров удобен `timeit`, но в этой задаче достаточно просто обернуть код в цикл и усреднить.
 #### 3. Проведение замеров
 Для каждой структуры данных и для каждого режима входных данных (случайный / отсортированный) выполните:
 - А. Вставка всех записей
 Создайте пустую структуру.
 Засеките время, выполните insert для каждой записи из входного списка.
 Зафиксируйте общее время вставки.
 - Б. Поиск 100 случайных записей
 Возьмите 100 случайных имён из того же набора (гарантированно существующих) и 10 имён, которых нет (например, "None_{i}").
 Засеките время на выполнение всех 110 вызовов find.
 - В. Удаление 50 случайных записей
 Выберите 50 случайных имён из набора.
 Засеките время на выполнение delete для каждого.
 **!! Важно: после вставки структура остаётся заполненной, поиск и удаление выполняются на ней же. Если нужно повторить замер для другого порядка данных — создавайте новую структуру и заполняйте заново.**
 #### 4. Сохранение результатов
 **!! Каждый эксперимент повторить минимум 5 раз и записывать и среднее время, и все замеры.**
 Соберите все замеры в словарь или список, затем сохраните в CSV-файл:
 ```python
 import csv
 results = [
    ["Структура", "Режим", "Операция", "Время (сек)"],
    ["LinkedList", "случайный", "вставка", 0.123],
    ...
 ]
 with open("results.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(results)
 ```
 #### 5. Анализ результатов
 Постройте график (столбчатая диаграмма или линейный график) — можно в Excel, Google Sheets или с помощью matplotlib в Python.
 Сравните:
 - Как порядок входных данных влияет на скорость вставки в BST (деградация до O(n) на отсортированных данных).
 - Почему хеш-таблица почти не чувствительна к порядку.
 - Почему связный список всегда медленен при поиске.
 - Как удаление работает в каждой структуре.
 * Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.*
 ## Задание: Поиск выхода из лабиринта (объектно-ориентированная реализация с паттернами)
 ### Цель работы
 Разработать гибкую, расширяемую программу для загрузки лабиринта из файла, поиска пути от старта до выхода с возможностью выбора алгоритма, визуализации процесса и экспериментального сравнения алгоритмов. В ходе работы необходимо применить минимум 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')` для перерисовки.
--- a/SavelevMI/428.md
+++ b/SavelevMI/428.md
--- a/ShulpinIN/428.md
+++ b/ShulpinIN/428.md
--- a/SimonovaMS/428.md
+++ b/SimonovaMS/428.md
--- a/SimonovaMS/428.txt
+++ b/SimonovaMS/428.txt
--- a/Smirnovvs/428.txt
+++ b/Smirnovvs/428.txt
--- a/SobolevNS/426
+++ b/SobolevNS/426
--- a/SokolovEN/426
+++ b/SokolovEN/426
--- a/SokolovNE/428b.md.txt
+++ b/SokolovNE/428b.md.txt
--- a/SolovevDD/425.md
+++ b/SolovevDD/425.md
--- a/SolovevDS/428b.md
+++ b/SolovevDS/428b.md
--- a/SorokinAD/428.md
+++ b/SorokinAD/428.md
@ -1 +0,0 @@
 1
--- a/VaravinVV/428b
+++ b/VaravinVV/428b
@ -1 +0,0 @@
 428b 
--- a/VarnakovAA/429.md
+++ b/VarnakovAA/429.md
--- a/VildyaevAV/426
+++ b/VildyaevAV/426
--- a/VolkovVA/428b.md
+++ b/VolkovVA/428b.md
--- a/YanyaevAA/428b.md
+++ b/YanyaevAA/428b.md
--- a/YaroslavtsevAS/428.md
+++ b/YaroslavtsevAS/428.md
@ -1 +0,0 @@
 428
--- a/ZelentsovAV/428b.md
+++ b/ZelentsovAV/428b.md
--- a/ZhuravlevDV/425.txt
+++ b/ZhuravlevDV/425.txt
--- a/agafonovdm/425.txt
+++ b/agafonovdm/425.txt
--- a/anikinvd/428.md
+++ b/anikinvd/428.md
--- a/chizhikovaSM/428.md
+++ b/chizhikovaSM/428.md
--- a/duznb/429.md.txt
+++ b/duznb/429.md.txt
--- a/dyachenkoas/428
+++ b/dyachenkoas/428
--- a/famutdinovmd/428b.md
+++ b/famutdinovmd/428b.md
--- a/filippovavm/427
+++ b/filippovavm/427
@ -1 +0,0 @@
 427
--- a/fomichevks/426.md.txt
+++ b/fomichevks/426.md.txt
--- a/groshevava/426.md.txt
+++ b/groshevava/426.md.txt
--- a/ivanchenkoam/427.txt
+++ b/ivanchenkoam/427.txt
@ -1 +0,0 @@
 856
--- a/ivantsovma/428.txt
+++ b/ivantsovma/428.txt
--- a/kalinovskiymi/428
+++ b/kalinovskiymi/428
--- a/kolesovve/427.md
+++ b/kolesovve/427.md
--- a/komissarovgo/427.md
+++ b/komissarovgo/427.md
--- a/konnovaea/429
+++ b/konnovaea/429
@ -1 +0,0 @@
 429 
--- a/kornevma/426.md
+++ b/kornevma/426.md
--- a/krasnovia/429.txt
+++ b/krasnovia/429.txt
--- a/kuznetsovTD/428b.md
+++ b/kuznetsovTD/428b.md
@ -1 +0,0 @@
 428b.md
--- a/lomakinae/426
+++ b/lomakinae/426
--- a/meosyam/428.md.txt
+++ b/meosyam/428.md.txt
--- a/morozovns/1.py
+++ b/morozovns/1.py
@ -1,2 +0,0 @@
 print("Zadanie adin!!11!adin!11!")
 print("patch")
--- a/morozovns/429
+++ b/morozovns/429
@ -1 +0,0 @@
 429 
--- a/nehoroshevaa/428b.md
+++ b/nehoroshevaa/428b.md
@ -1 +0,0 @@
 428b
--- a/nikitovie/425.txt
+++ b/nikitovie/425.txt
--- a/nikolaevda/427.md
+++ b/nikolaevda/427.md
--- a/novikovsd/428
+++ b/novikovsd/428
--- a/osininyai/427.md
+++ b/osininyai/427.md
--- a/osipovamd/428.md
+++ b/osipovamd/428.md
@ -1,6 +0,0 @@
 {\rtf1\ansi\ansicpg1251\cocoartf2869
 \cocoatextscaling0\cocoaplatform0{\fonttbl}
 {\colortbl;\red255\green255\blue255;}
 {\*\expandedcolortbl;;}
 \paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
 }
--- a/petryaninyas/426.md
+++ b/petryaninyas/426.md
--- a/pogodinda/427.md.txt
+++ b/pogodinda/427.md.txt
--- a/pomelovsd/427
+++ b/pomelovsd/427
@ -1 +0,0 @@
 427 
--- a/raskatovia/429.md
+++ b/raskatovia/429.md
--- a/romanovpv/427.md
+++ b/romanovpv/427.md
--- a/rybakovaa/428b.md
+++ b/rybakovaa/428b.md
@ -1 +0,0 @@
 428b
--- a/semyanovra/426.md
+++ b/semyanovra/426.md
--- a/shahovaa/429.md
+++ b/shahovaa/429.md
--- a/shalovsa/429.txt
+++ b/shalovsa/429.txt
--- a/shapovalovka/425.txt
+++ b/shapovalovka/425.txt
--- a/shekurovaa/429.md
+++ b/shekurovaa/429.md
--- a/skorohodovsa/427
+++ b/skorohodovsa/427
@ -1 +0,0 @@
 427 
--- a/skorohodovsa/main.py
+++ b/skorohodovsa/main.py
@ -1,4 +0,0 @@
 from math import sin
 for i in range(10000):
    print(" " * round(50 * (1 + sin(i/100))), "Hello World!")
--- a/smirnovad/429.md
+++ b/smirnovad/429.md
--- a/sobininaas/429.rtf
+++ b/sobininaas/429.rtf
@ -1,6 +0,0 @@
 {\rtf1\ansi\ansicpg1251\cocoartf2761
 \cocoatextscaling0\cocoaplatform0{\fonttbl}
 {\colortbl;\red255\green255\blue255;}
 {\*\expandedcolortbl;;}
 \paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
 }
--- a/soldatkinao/428б.md
+++ b/soldatkinao/428б.md
@ -1 +0,0 @@
 <EFBFBD>¥¦¨¬ ¢כ¢®₪  ×®¬ ₪   ם×א  (ECHO) ¢×«מח¥.
--- a/soninrv/428.md
+++ b/soninrv/428.md
@ -1 +0,0 @@
--- a/sorokinfi/427.md
+++ b/sorokinfi/427.md
--- a/starikovta/426.md
+++ b/starikovta/426.md
--- a/Show More
+++ b/Show More
		`@ -1,2 +0,0 @@`
			`print("Zadanie adin!!11!adin!11!")`
			`print("patch")`
		`@ -1 +0,0 @@`
			`<EFBFBD>¥¦¨¬ ¢כ¢®₪ ×®¬ ₪ ם×א (ECHO) ¢×«מח¥.`