2026-MP

Практика по курсам "Методы программирования" и "Программная инженерия" РФФ ННГУ

Презентация по курсу (обновляемая)

Для работы необходим python 3.11 и выше. Библиотеки: numpy, pandas, matplotlib, tensorflow, Pillow. Редактор любой. Из неплохих: IDLE (родной, идёт вместе с установщиком), Visual Studio Code, notepad++, PyCharm, vim (для любителей сначала страдать, потом наслаждаться).

Работа с блокнотами онлайн, с возможностью подключения удалённых мощностей гугла (GPU, TPU): https://colab.research.google.com/

Мой контакт: nsmorozov@rf.unn.ru

Внутри папки группы создать папку имени себя (фамилия и имя). В своей папке можете делать все что угодно, в чужие не залезать, в корневую тоже. Я буду ориентироваться на файлы, где в названии будет номер лабораторной.

Название пулл-реквеста должно начинаться с квадратных скобок, в которых перечислены номера сдаваемых лабораторных работ. Не больше одного активного реквеста, если надо довнести -- надо обновить текущий.

Крайний срок приема работ 25.05.2026 до 14:00

Задание 0 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026]

0. Создай пользователя (логин — фамилия+инициалы слитно транслитом, как в терминал-классе).

1. Зайди в этот репозиторий на Gitea, нажми кнопку Форкнуть, чтобы создать копию в своем аккаунте.

2. Клонирование: Скопируй ссылку на свой форк и выполни:

   git clone <ссылка_на_ваш_форк>
   cd <название_репозитория>
   

3. Создай ветку (название — фамилия+инициалы слитно транслитом, буква в букву как логин):

   git checkout -b IvanovII
   

4. Создай папку с таким же названием (IvanovII) и внутри неё — текстовый файл, названный номером вашей группы (например, 101.md).

5. Сохрани изменения:

   git add -A
   git commit -m "[0] initial commit"
   

6. Отправь ветку в свой форк на Gitea:

   git push origin
   

если просит, перед этим сделать git push --set-upstream origin

7. Создай запрос на слияние (Pull Request): На Gitea перейди в свой форк, выбери ветку IvanovII, нажмите Запрос на слияние. Убедитесь, что:

   • Базовый репозиторий: учебный (преподавателя)
   • Базовая ветка: develop
   • Сравниваемая ветка: свой форк / IvanovII

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:

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-файл:

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, обосновать их выбор и продемонстрировать преимущества такой архитектуры.

Общая схема приложения (пример)

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') для перерисовки.