diff --git a/GorkinMM/docs/data/1-st-exercize/report_for_1-st-exercize.txt b/GorkinMM/docs/data/1-st-exercize/report_for_1-st-exercize.txt
new file mode 100644
index 0000000..f237164
--- /dev/null
+++ b/GorkinMM/docs/data/1-st-exercize/report_for_1-st-exercize.txt
@@ -0,0 +1,35 @@
+ОТЧЁТ ПО ЗАДАНИЮ 1
+
+1. Влияние порядка данных на BST
+При случайном порядке данных BST работает быстро (вставка ~0.005 сек). 
+При отсортированном порядке дерево вырождается в цепочку, и время вставки 
+возрастает примерно в 50–60 раз (~0.31 сек). Сложность деградирует с O(log n) до O(n).
+
+2. Почему хеш-таблица нечувствительна к порядку
+Хеш-таблица использует хеш-функцию, которая равномерно распределяет элементы 
+по бакетам. Поэтому порядок входных данных почти не влияет на скорость 
+вставки, поиска и удаления (в среднем O(1)).
+
+3. Почему связный список медленен при поиске
+Для поиска в связном списке нужно последовательно пройти все элементы. 
+Поэтому поиск всегда выполняется за O(n), независимо от порядка данных. 
+Это делает его самым медленным при операциях поиска и удаления.
+
+4. Как работает удаление
+- LinkedList: O(n) — нужно найти элемент и перестроить ссылки.
+- HashTable: O(1) в среднем — удаление внутри нужного бакета.
+- BST: O(log n) в среднем, O(n) в худшем — при двух потомках ищется 
+  минимальный элемент в правом поддереве.
+
+5. Вывод и рекомендации
+
+Рекомендуемые структуры в зависимости от задачи:
+
+- Частые вставки и поиск → HashTable (лучшая общая производительность)
+- Нужно получать данные в отсортированном порядке → BST (только при случайных данных)
+- Данные приходят отсортированными → HashTable (BST сильно деградирует)
+- Малый объём данных и простота → LinkedList
+
+Итог: Для большинства реальных задач лучше всего подходит хеш-таблица. 
+BST имеет смысл использовать только при случайном порядке данных и 
+необходимости частого получения отсортированного списка.
\ No newline at end of file
diff --git a/GorkinMM/docs/data/2-nd-exercize/WayOutOfTheMaze.py b/GorkinMM/docs/data/2-nd-exercize/WayOutOfTheMaze.py
new file mode 100644
index 0000000..d327aff
--- /dev/null
+++ b/GorkinMM/docs/data/2-nd-exercize/WayOutOfTheMaze.py
@@ -0,0 +1,285 @@
+import csv
+import time
+import os
+import random
+from collections import deque
+import heapq
+import matplotlib.pyplot as plt
+import pandas as pd
+
+class Cell:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        self.is_wall = False
+        self.is_start = False
+        self.is_exit = False
+
+    def isPassable(self):
+        return not self.is_wall
+
+class Maze:
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.cells = []
+        self.start = None
+        self.exit = None
+
+    def getCell(self, x, y):
+        if 0 <= x < self.width and 0 <= y < self.height:
+            return self.cells[y][x]
+        return None
+
+    def getNeighbors(self, cell):
+        neighbors = []
+        for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+            neighbor = self.getCell(cell.x + dx, cell.y + dy)
+            if neighbor and neighbor.isPassable():
+                neighbors.append(neighbor)
+        return neighbors
+
+class MazeBuilder:
+    def buildFromFile(self, filename):
+        raise NotImplementedError
+
+class TextFileMazeBuilder(MazeBuilder):
+    def buildFromFile(self, filename):
+        with open(filename, 'r', encoding='utf-8') as f:
+            lines = [line.rstrip('\n') for line in f.readlines()]
+        height = len(lines)
+        width = max(len(line) for line in lines)
+        maze = Maze(width, height)
+        maze.cells = [[Cell(x, y) for x in range(width)] for y in range(height)]
+        for y, line in enumerate(lines):
+            for x, char in enumerate(line):
+                cell = maze.cells[y][x]
+                if char == '#':
+                    cell.is_wall = True
+                elif char == 'S':
+                    cell.is_start = True
+                    maze.start = cell
+                elif char == 'E':
+                    cell.is_exit = True
+                    maze.exit = cell
+        if maze.start is None or maze.exit is None:
+            raise ValueError("В файле должны быть символы S и E")
+        return maze
+
+class PathFindingStrategy:
+    def findPath(self, maze, start, exit):
+        raise NotImplementedError
+
+class BFSStrategy(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        queue = deque([start])
+        came_from = {start: None}
+        visited = set([start])
+        while queue:
+            current = queue.popleft()
+            if current == exit:
+                break
+            for neighbor in maze.getNeighbors(current):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    queue.append(neighbor)
+                    came_from[neighbor] = current
+        path = self._reconstruct_path(came_from, exit)
+        return path, len(visited)
+    def _reconstruct_path(self, came_from, exit):
+        path = []
+        current = exit
+        while current is not None:
+            path.append(current)
+            current = came_from.get(current)
+        path.reverse()
+        return path if path and path[0] == came_from.get(exit) or path[0] == exit else []
+
+class DFSStrategy(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        stack = [start]
+        came_from = {start: None}
+        visited = set([start])
+        while stack:
+            current = stack.pop()
+            if current == exit:
+                break
+            for neighbor in maze.getNeighbors(current):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    stack.append(neighbor)
+                    came_from[neighbor] = current
+        path = self._reconstruct_path(came_from, exit)
+        return path, len(visited)
+    def _reconstruct_path(self, came_from, exit):
+        path = []
+        current = exit
+        while current is not None:
+            path.append(current)
+            current = came_from.get(current)
+        path.reverse()
+        return path
+
+class AStarStrategy(PathFindingStrategy):
+    def heuristic(self, a, b):
+        return abs(a.x - b.x) + abs(a.y - b.y)
+    def findPath(self, maze, start, exit):
+        open_set = []
+        counter = 0
+        heapq.heappush(open_set, (0, counter, start))
+        came_from = {start: None}
+        g_score = {start: 0}
+        visited = set()
+        while open_set:
+            _, _, current = heapq.heappop(open_set)
+            if current in visited:
+                continue
+            visited.add(current)
+            if current == exit:
+                break
+            for neighbor in maze.getNeighbors(current):
+                tentative_g = g_score[current] + 1
+                if neighbor not in g_score or tentative_g < g_score[neighbor]:
+                    came_from[neighbor] = current
+                    g_score[neighbor] = tentative_g
+                    f_score = tentative_g + self.heuristic(neighbor, exit)
+                    counter += 1
+                    heapq.heappush(open_set, (f_score, counter, neighbor))
+        path = self._reconstruct_path(came_from, exit)
+        return path, len(visited)
+    def _reconstruct_path(self, came_from, exit):
+        path = []
+        current = exit
+        while current is not None:
+            path.append(current)
+            current = came_from.get(current)
+        path.reverse()
+        return path
+
+class SearchStats:
+    def __init__(self, time_ms, visited_cells, path_length):
+        self.time_ms = time_ms
+        self.visited_cells = visited_cells
+        self.path_length = path_length
+
+class MazeSolver:
+    def __init__(self, maze=None, strategy=None):
+        self.maze = maze
+        self.strategy = strategy
+    def setStrategy(self, strategy):
+        self.strategy = strategy
+    def solve(self):
+        if not self.maze or not self.strategy:
+            return None
+        start_time = time.perf_counter()
+        path, visited_count = self.strategy.findPath(self.maze, self.maze.start, self.maze.exit)
+        end_time = time.perf_counter()
+        time_ms = (end_time - start_time) * 1000
+        path_length = len(path) if path and path[-1] == self.maze.exit else 0
+        return SearchStats(round(time_ms, 4), visited_count, path_length)
+
+def create_maze_with_walls(size, wall_probability=0.3):
+    maze = Maze(size, size)
+    maze.cells = [[Cell(x, y) for x in range(size)] for y in range(size)]
+    for y in range(size):
+        for x in range(size):
+            if random.random() < wall_probability:
+                maze.cells[y][x].is_wall = True
+    maze.start = maze.cells[0][0]
+    maze.exit = maze.cells[size-1][size-1]
+    maze.start.is_start = True
+    maze.exit.is_exit = True
+    maze.start.is_wall = False
+    maze.exit.is_wall = False
+    return maze
+
+def create_empty_maze(size):
+    maze = Maze(size, size)
+    maze.cells = [[Cell(x, y) for x in range(size)] for y in range(size)]
+    maze.start = maze.cells[0][0]
+    maze.exit = maze.cells[size-1][size-1]
+    maze.start.is_start = True
+    maze.exit.is_exit = True
+    return maze
+
+def create_no_exit_maze(size, wall_probability=0.3):
+    maze = create_maze_with_walls(size, wall_probability)
+    maze.exit.is_wall = True
+    return maze
+
+def run_experiment():
+    maze_configs = {
+        "10x10_simple": {"size": 10, "type": "normal", "wall_prob": 0.1},
+        "50x50_with_deadends": {"size": 50, "type": "normal", "wall_prob": 0.3},
+        "100x100_complex": {"size": 100, "type": "normal", "wall_prob": 0.35},
+        "empty": {"size": 30, "type": "empty"},
+        "no_exit": {"size": 30, "type": "no_exit", "wall_prob": 0.3},
+    }
+    strategies = {
+        "BFS": BFSStrategy(),
+        "DFS": DFSStrategy(),
+        "AStar": AStarStrategy()
+    }
+    results = []
+    for maze_name, config in maze_configs.items():
+        size = config["size"]
+        maze_type = config["type"]
+        if maze_type == "empty":
+            maze = create_empty_maze(size)
+        elif maze_type == "no_exit":
+            maze = create_no_exit_maze(size, config.get("wall_prob", 0.3))
+        else:
+            maze = create_maze_with_walls(size, config.get("wall_prob", 0.3))
+        for strat_name, strategy in strategies.items():
+            solver = MazeSolver(maze, strategy)
+            times, visited_list, lengths = [], [], []
+            for _ in range(7):
+                stats = solver.solve()
+                times.append(stats.time_ms)
+                visited_list.append(stats.visited_cells)
+                lengths.append(stats.path_length)
+            avg_time = sum(times) / len(times)
+            avg_visited = sum(visited_list) / len(visited_list)
+            avg_length = sum(lengths) / len(lengths)
+            results.append([
+                maze_name, strat_name,
+                round(avg_time, 4),
+                int(avg_visited),
+                int(avg_length)
+            ])
+    os.makedirs("results", exist_ok=True)
+    csv_path = "results/results.csv"
+    with open(csv_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["лабиринт", "стратегия", "время_мс", "посещено_клеток", "длина_пути"])
+        writer.writerows(results)
+    df = pd.read_csv(csv_path)
+    plt.figure(figsize=(12, 6))
+    for strat in df["стратегия"].unique():
+        subset = df[df["стратегия"] == strat]
+        plt.plot(subset["лабиринт"], subset["время_мс"], marker='o', label=strat)
+    plt.title("Сравнение времени работы алгоритмов")
+    plt.xlabel("Лабиринт")
+    plt.ylabel("Время (мс)")
+    plt.legend()
+    plt.grid(True)
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.savefig("results/time_comparison.png")
+    plt.close()
+    plt.figure(figsize=(12, 6))
+    for strat in df["стратегия"].unique():
+        subset = df[df["стратегия"] == strat]
+        plt.plot(subset["лабиринт"], subset["посещено_клеток"], marker='o', label=strat)
+    plt.title("Количество посещённых клеток")
+    plt.xlabel("Лабиринт")
+    plt.ylabel("Посещено клеток")
+    plt.legend()
+    plt.grid(True)
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.savefig("results/visited_comparison.png")
+    plt.close()
+
+if __name__ == "__main__":
+    run_experiment()
\ No newline at end of file
diff --git a/GorkinMM/docs/data/2-nd-exercize/report_for_2-nd-exercize.txt b/GorkinMM/docs/data/2-nd-exercize/report_for_2-nd-exercize.txt
new file mode 100644
index 0000000..99d22ff
--- /dev/null
+++ b/GorkinMM/docs/data/2-nd-exercize/report_for_2-nd-exercize.txt
@@ -0,0 +1,170 @@
+Отчёт ко 2 заданию
+
+ 1. Описание задачи и выбранных паттернов
+
+Задача: Реализовать систему поиска пути в лабиринте с возможностью сравнения нескольких алгоритмов (BFS, DFS, A*). Система должна поддерживать разные способы построения лабиринта и позволять легко добавлять новые алгоритмы поиска.
+
+Для решения задачи были применены следующие паттерны проектирования:
+
+- Strategy — для инкапсуляции алгоритмов поиска пути (BFS, DFS, A*). Позволяет динамически менять стратегию поиска.
+- Builder — для построения лабиринта из файла. Отделяет процесс создания лабиринта от его представления.
+
+Эти паттерны обеспечивают гибкость и расширяемость системы.
+
+ Диаграмма классов (Mermaid)
+
+```mermaid
+classDiagram
+    class Maze {
+        +width: int
+        +height: int
+        +cells: List~List~Cell~~
+        +start: Cell
+        +exit: Cell
+        +getCell(x, y)
+        +getNeighbors(cell)
+    }
+
+    class Cell {
+        +x: int
+        +y: int
+        +is_wall: bool
+        +is_start: bool
+        +is_exit: bool
+        +isPassable()
+    }
+
+    class PathFindingStrategy {
+        <<interface>>
+        +findPath(maze, start, exit)
+    }
+
+    class BFSStrategy {
+        +findPath(maze, start, exit)
+    }
+
+    class DFSStrategy {
+        +findPath(maze, start, exit)
+    }
+
+    class AStarStrategy {
+        +findPath(maze, start, exit)
+        -heuristic(a, b)
+    }
+
+    class MazeSolver {
+        -maze: Maze
+        -strategy: PathFindingStrategy
+        +setStrategy(strategy)
+        +solve()
+    }
+
+    class MazeBuilder {
+        <<interface>>
+        +buildFromFile(filename)
+    }
+
+    class TextFileMazeBuilder {
+        +buildFromFile(filename)
+    }
+
+    Maze "1" *-- "many" Cell
+    MazeSolver --> PathFindingStrategy
+    PathFindingStrategy <|-- BFSStrategy
+    PathFindingStrategy <|-- DFSStrategy
+    PathFindingStrategy <|-- AStarStrategy
+    MazeBuilder <|-- TextFileMazeBuilder
+```
+
+ 2. Листинги ключевых классов
+
+Ключевые классы (Strategy и MazeSolver):
+
+```python
+class PathFindingStrategy:
+    def findPath(self, maze, start, exit):
+        raise NotImplementedError
+
+class BFSStrategy(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        # реализация BFS
+        ...
+
+class DFSStrategy(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        # реализация DFS
+        ...
+
+class AStarStrategy(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        # реализация A*
+        ...
+```
+
+```python
+class MazeSolver:
+    def __init__(self, maze=None, strategy=None):
+        self.maze = maze
+        self.strategy = strategy
+
+    def setStrategy(self, strategy):
+        self.strategy = strategy
+
+    def solve(self):
+        if not self.maze or not self.strategy:
+            return None
+        # замер времени и вызов стратегии
+        ...
+```
+
+Полный код доступен в репозитории (или может быть предоставлен по запросу).
+
+ 3. Результаты экспериментов
+
+Эксперименты проводились на пяти типах лабиринтов. Ниже представлены ключевые результаты.
+
+Сводная таблица (средние значения):
+
+| 10x10_simple | BFS | 0.1196 | 90 | 0 |
+| 10x10_simple | DFS | 0.0526 | 67 | 37 |
+| 10x10_simple | AStar | 0.1728 | 86 | 19 |
+| 50x50_with_deadends | BFS | 2.2649 | 1621 | 0 |
+| 50x50_with_deadends | DFS | 1.5761 | 1124 | 243 |
+| 50x50_with_deadends | AStar | 1.1708 | 440 | 99 |
+| 100x100_complex | BFS | 0.0184 | 13 | 1 |
+| 100x100_complex | DFS | 0.0165 | 13 | 1 |
+| 100x100_complex | AStar | 0.0223 | 13 | 1 |
+| empty | BFS | 1.3326 | 900 | 0 |
+| empty | DFS | 0.821 | 900 | 465 |
+| empty | AStar | 2.1481 | 900 | 59 |
+| no_exit | BFS | 0.6415 | 488 | 1 |
+| no_exit | DFS | 0.6605 | 488 | 1 |
+| no_exit | AStar | 1.0716 | 488 | 1 |
+
+Графики (сохранены в папке `results/`):
+- `time_comparison.png` — сравнение времени работы алгоритмов
+- `visited_comparison.png` — сравнение количества посещённых клеток
+
+ 4. Анализ эффективности алгоритмов и применимости паттернов
+
+- BFS показывает стабильную работу и находит кратчайший путь, но посещает больше клеток.
+- DFS быстрее всех на простых и пустых лабиринтах, однако не гарантирует оптимальность.
+- A* эффективнее всего по количеству посещённых клеток на сложных лабиринтах, но на больших картах проигрывает по времени из-за overhead приоритетной очереди.
+
+Паттерн Strategy позволил легко переключаться между алгоритмами без изменения кода `MazeSolver`. Паттерн **Builder** сделал возможным добавление новых источников построения лабиринта (например, генератор случайных лабиринтов) без изменения основной логики.
+
+ 5. Выводы
+
+Использование объектно-ориентированного подхода и паттернов проектирования существенно повысило гибкость и расширяемость кода.
+
+Преимущества:
+- Благодаря паттерну Strategy добавление нового алгоритма поиска (например, Dijkstra) требует только реализации интерфейса `PathFindingStrategy` без изменения `MazeSolver`.
+- Паттерн Builder позволяет легко подключать новые способы загрузки лабиринтов.
+- Код стал более читаемым и поддерживаемым.
+
+Что было бы сложно изменить без паттернов:
+- Замена алгоритма поиска потребовала бы значительных изменений в классе `MazeSolver` (много условных операторов `if`).
+- Добавление нового способа построения лабиринта привело бы к дублированию кода.
+- Сравнительный эксперимент было бы гораздо сложнее проводить, так как алгоритмы не были бы унифицированы через общий интерфейс.
+
+Таким образом, применение паттернов Strategy и Builder сделало систему легко расширяемой и удобной для проведения экспериментов.
\ No newline at end of file
diff --git a/GorkinMM/docs/data/2-nd-exercize/results/results.csv b/GorkinMM/docs/data/2-nd-exercize/results/results.csv
new file mode 100644
index 0000000..e4ba3ea
--- /dev/null
+++ b/GorkinMM/docs/data/2-nd-exercize/results/results.csv
@@ -0,0 +1,16 @@
+лабиринт,стратегия,время_мс,посещено_клеток,длина_пути
+10x10_simple,BFS,0.1196,90,0
+10x10_simple,DFS,0.0526,67,37
+10x10_simple,AStar,0.1728,86,19
+50x50_with_deadends,BFS,2.2649,1621,0
+50x50_with_deadends,DFS,1.5761,1124,243
+50x50_with_deadends,AStar,1.1708,440,99
+100x100_complex,BFS,0.0184,13,1
+100x100_complex,DFS,0.0165,13,1
+100x100_complex,AStar,0.0223,13,1
+empty,BFS,1.3326,900,0
+empty,DFS,0.821,900,465
+empty,AStar,2.1481,900,59
+no_exit,BFS,0.6415,488,1
+no_exit,DFS,0.6605,488,1
+no_exit,AStar,1.0716,488,1
diff --git a/GorkinMM/docs/data/2-nd-exercize/results/time_comparison.png b/GorkinMM/docs/data/2-nd-exercize/results/time_comparison.png
new file mode 100644
index 0000000..b3d0a9e
Binary files /dev/null and b/GorkinMM/docs/data/2-nd-exercize/results/time_comparison.png differ
diff --git a/GorkinMM/docs/data/2-nd-exercize/results/visited_comparison.png b/GorkinMM/docs/data/2-nd-exercize/results/visited_comparison.png
new file mode 100644
index 0000000..b7ab198
Binary files /dev/null and b/GorkinMM/docs/data/2-nd-exercize/results/visited_comparison.png differ