Разработка и документирование программного решения для подсчета максимальных элементов в списке: Комплексное руководство по курсовой работе

В современном мире, где объемы информации растут экспоненциально, эффективность обработки данных становится критически важной. Одной из фундаментальных задач в информатике и программировании является поиск и анализ экстремальных значений в наборах данных. В контексте списков или массивов эта задача сводится к определению максимального элемента и, при необходимости, подсчету его вхождений. Эта, казалось бы, простая операция лежит в основе многих сложных алгоритмов и приложений — от систем анализа больших данных до оптимизационных задач в инженерии, являясь краеугольным камнем для последующих, более сложных вычислений.

Настоящая курсовая работа ставит своей целью не просто решение задачи нахождения и подсчета максимальных элементов в списке, но и глубокое погружение в полный цикл разработки программного обеспечения, соответствующий академическим стандартам. Мы рассмотрим задачу с позиций формализации, алгоритмического проектирования, практической реализации и, что особенно важно для студентов IT-специальностей, детального документирования в соответствии с российскими государственными стандартами (ГОСТ ЕСПД и ЕСКД). Такой подход позволит не только создать функциональное программное решение, но и сформировать полноценный академический отчет, демонстрирующий комплексные компетенции студента в области программной инженерии, что является ценным вкладом в его профессиональное становление.

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

Теоретические основы поиска максимальных элементов

В основе любой программной разработки лежат фундаментальные концепции, которые определяют логику и структуру будущего решения. Для задачи поиска максимальных элементов в списке такими краеугольными камнями являются определения ключевых терминов и понимание различных алгоритмических подходов, каждый из которых имеет свои преимущества и ограничения. Без этого базиса невозможно построить эффективную и корректно работающую программу, которая будет устойчива к различным сценариям использования.

Определения и базовые концепции

Прежде чем углубляться в детали, необходимо четко определить терминологию, которая будет использоваться на протяжении всего руководства. Это позволит избежать неоднозначностей и обеспечить единое понимание предметной области.

Список (или массив): В контексте программирования, список (например, list в Python) является упорядоченной, изменяемой коллекцией элементов, которая допускает дублирование значений. В отличие от строгих массивов в некоторых языках (например, Pascal), списки часто обладают гибкостью в хранении данных различных типов (целые числа, строки, числа с плавающей точкой или даже другие списки) в одной коллекции. Это делает их универсальной структурой для хранения последовательных данных.

Максимальный элемент массива/списка: Под максимальным элементом понимается наибольшее значение среди всех элементов, содержащихся в данном списке или массиве. Важно отметить, что если в списке присутствует несколько элементов с одинаковым максимальным значением, то все они считаются максимальными. Например, в списке [1, 5, 2, 5, 3] максимальный элемент — это 5, и он встречается дважды.

Алгоритм: Это четко определенная последовательность инструкций или шагов, предназначенная для решения конкретной задачи или выполнения вычислений. Алгоритмы характеризуются конечностью (они должны завершаться за конечное число шагов), детерминированностью (при одних и тех же входных данных всегда дают один и тот же результат) и эффективностью (оптимальное использование ресурсов).

Структура данных: Это специфический способ организации, хранения и управления данными в памяти компьютера. Выбор подходящей структуры данных критически важен для эффективности алгоритма, поскольку он определяет, насколько быстро и удобно можно получать доступ к данным, модифицировать их или выполнять другие операции. Примеры структур данных включают списки, массивы, деревья, хеш-таблицы и графы. В нашем случае основной структурой будет линейный список.

Понимание этих базовых концепций формирует основу для дальнейшего анализа и проектирования программного решения.

Обзор алгоритмов поиска максимальных элементов

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

Линейный перебор (метод грубой силы)

Это самый интуитивно понятный и распространенный метод для неупорядоченных списков. Его принцип прост:

1. Предполагается, что первый элемент списка является максимальным, и его значение сохраняется в специальной переменной (например, max_value).
2. Затем последовательно, один за другим, перебираются все остальные элементы списка.
3. Каждый текущий элемент сравнивается с max_value. Если текущий элемент оказывается больше, чем max_value, то max_value обновляется значением текущего элемента.
4. После того как все элементы просмотрены, переменная max_value будет содержать искомое максимальное значение.

Пример на псевдокоде:

функция НайтиМаксимум(Список L):
    если L пуст:
        вернуть ошибку или специальное значение
    
    max_value = L[0]
    для каждого элемента X в L, начиная со второго:
        если X > max_value:
            max_value = X
    вернуть max_value

Временная сложность: Оценивается как O(N), где N — количество элементов в списке. Это означает, что время выполнения алгоритма растет линейно с увеличением размера списка. В худшем случае (если максимальный элемент находится в конце списка) или в среднем случае, алгоритму придется просмотреть каждый элемент ровно один раз.

Пространственная сложность: О(1), поскольку для работы алгоритму требуется лишь несколько дополнительных переменных для хранения текущего максимума и итератора, независимо от размера списка.

Рекурсивный алгоритм

Рекурсия — мощный инструмент в программировании, позволяющий решать задачи путем разбиения их на более мелкие, идентичные подзадачи. Для поиска максимального элемента рекурсивный подход может быть сформулирован следующим образом:

1. Базовый случай: Если список содержит только один элемент, то этот элемент является максимальным. Это условие прекращения рекурсии.
2. Рекурсивный шаг: Если список состоит из нескольких элементов, его делят на две (или более) части. Рекурсивно находят максимальный элемент в каждой части, а затем сравнивают эти два (или несколько) найденных максимумов, чтобы определить общий максимум для исходного списка.

Пример на псевдокоде (для деления на две части):

функция РекурсивныйМаксимум(Список L):
    если длина(L) == 1:
        вернуть L[0]
    
    середина = длина(L) / 2
    max1 = РекурсивныйМаксимум(L[от 0 до середина-1])
    max2 = РекурсивныйМаксимум(L[от середина до конца])
    
    вернуть максимум(max1, max2)

Временная сложность: Несмотря на элегантность рекурсии, для неупорядоченного списка временная сложность также составит O(N). Это происходит потому, что даже при разбиении списка на части, в конечном итоге каждый элемент должен быть посещен и сравнен хотя бы один раз, чтобы определить истинный максимум. Количество операций сравнения будет пропорционально N.

Пространственная сложность: O(log N) или O(N) в зависимости от глубины рекурсии и способа реализации. В худшем случае, если рекурсия не сбалансирована или список обрабатывается по одному элементу, глубина стека может достигать N, что увеличивает потребление памяти.

Встроенные функции Python

Современные языки программирования, такие как Python, предоставляют высокооптимизированные встроенные функции и методы, которые значительно упрощают решение многих стандартных задач и часто являются более эффективными, чем собственные реализации.

• Функция max(): Это наиболее прямой и питонический способ найти максимальный элемент. Она возвращает самый большой элемент итерируемого объекта.

  my_list = [10, 5, 20, 15]
  max_value = max(my_list) # max_value будет 20
  

  Её временная сложность также O(N), так как она выполняет линейный перебор «под капотом», но делает это на уровне C-реализации, что значительно быстрее, чем цикл на Python. Функция max() может также принимать аргумент default, что полезно при работе с пустыми списками.

• Методы sort() и sorted(): Эти методы используются для сортировки списка. После сортировки списка в порядке возрастания максимальный элемент будет находиться в его конце.
  • list.sort(): Сортирует список на месте (изменяет исходный список) и имеет временную сложность O(N log N).
  • sorted(iterable): Возвращает новый отсортированный список, не изменяя исходный, также с временной сложностью O(N log N).

    my_list = [10, 5, 20, 15]
    sorted_list = sorted(my_list)
    max_value = sorted_list[-1] # max_value будет 20
    

    Хотя эти методы работают, их временная сложность O(N log N) выше, чем у max(), что делает их менее эффективными для простой задачи поиска максимума.

• Аргумент key для max(): Эта мощная особенность позволяет найти максимальный элемент не по его прямому значению, а по результату применения к нему некоторой функции. Это особенно полезно для поиска максимального элемента по определенному критерию или для работы со сложными объектами. Например, можно найти самое длинное слово в списке строк или элемент с максимальным количеством повторений.

  words = ["apple", "banana", "kiwi", "grape"]
  longest_word = max(words, key=len) # longest_word будет "banana"
  
  data = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
  oldest_person = max(data, key=lambda p: p["age"]) # oldest_person будет {"name": "Alice", "age": 30}
  

• Функция argmax() из библиотеки NumPy: Для работы с большими числовыми массивами в научных и инженерных вычислениях, Python-библиотека NumPy предлагает функцию argmax(). Она возвращает индекс максимального элемента (а не само значение). Её ключевое преимущество — значительное повышение скорости и эффективности обработки по сравнению со стандартными функциями Python для больших массивов. Это достигается за счет оптимизированной реализации на языке C и использования векторизации, которая позволяет выполнять операции над целыми массивами данных одновременно, вместо поэлементной обработки в циклах.

  import numpy as np
  
  np_array = np.array([10, 5, 20, 15])
  max_index = np.argmax(np_array) # max_index будет 2 (индекс элемента 20)
  max_value = np_array[max_index] # max_value будет 20
  

Цель поиска: найти значение, индекс или оба параметра

При формулировке задачи важно уточнить, что именно требуется найти:

• Только значение: Необходимо получить само максимальное число или объект.
• Только индекс: Требуется получить позицию (индекс) первого вхождения максимального элемента в списке.
• И значение, и индекс: Оба параметра необходимы для дальнейшей работы.

Выбор алгоритма и метода зависит от этой цели. Например, max() возвращает значение, argmax() — индекс, а линейный перебор может быть легко адаптирован для нахождения как значения, так и индекса.

Формализация задачи и обработка особых случаев

Решение любой программной задачи начинается с её тщательной формализации. Это процесс перевода неформального описания требований в строгие, однозначные условия, которые можно реализовать в коде. В контексте поиска максимальных элементов это особенно важно, поскольку существует множество нюансов, связанных с типами данных, структурой списков и поведением программы в краевых ситуациях. Игнорирование этих «особых случаев» часто приводит к ошибкам и нестабильной работе ПО, что подрывает доверие пользователя и снижает надёжность системы в целом.

Особенности различных типов списков

Задача поиска максимального элемента универсальна, но её реализация существенно зависит от типа данных, содержащихся в списке. Правила сравнения, определяющие «больший» элемент, различны для чисел, строк и пользовательских объектов. Как же нам обеспечить корректное сравнение для каждого из этих типов?

• Числовые списки: Для списков, состоящих из целых чисел или чисел с плавающей точкой, сравнение происходит по их величине. Операторы > (больше) и < (меньше) работают интуитивно понятно. Например, в [10, 20, 5], 20 > 10 и 20 > 5.
• Строковые списки: При работе со строками сравнение элементов происходит по лексикографическому (алфавитному) порядку. Это означает, что строки сравниваются символ за символом, начиная с первого. Регистр символов играет роль (например, 'Z' < 'a'). Например:
  • "apple" < "banana"
  • "cat" < "dog"
  • "Zoo" < "apple" (так как 'Z' имеет меньший ASCII-код, чем 'a')

  Пример: в списке ["яблоко", "арбуз", "банан"] максимальным будет "яблоко" (по лексикографическому порядку), а не "арбуз" (если бы сравнивали по длине или по ассоциации с размером плода).

• Пользовательские объекты: Это наиболее сложный случай. Если список содержит экземпляры пользовательских классов (например, объекты Student с полями name, age, gpa), стандартные операторы сравнения (>, <) по умолчанию могут работать некорректно или вызывать ошибки, так как Python не знает, по какому критерию сравнивать два таких объекта.
  Для решения этой проблемы существует несколько подходов:
  1. Переопределение методов сравнения: В Python можно перегрузить так называемые "магические методы" (dunder methods), такие как __lt__ (less than), __gt__ (greater than), __le__, __ge__, __eq__, __ne__. Например, чтобы сравнивать объекты Student по возрасту:

     class Student:
         def __init__(self, name, age, gpa):
             self.name = name
             self.age = age
             self.gpa = gpa
         
         def __gt__(self, other): # Определяем, когда один студент "больше" другого
             return self.age > other.age
         
         def __str__(self):
             return f"Student(name={self.name}, age={self.age}, gpa={self.gpa})"
     
     students = [Student("Alice", 20, 4.0), Student("Bob", 22, 3.8)]
     oldest_student = max(students) # Теперь max() будет использовать __gt__
     print(oldest_student) # Выведет Student(name=Bob, age=22, gpa=3.8)
     

  2. Использование аргумента key в max(): Этот подход более гибок и не требует изменения класса. Аргумент key принимает функцию, которая применяется к каждому элементу списка перед сравнением. Функция возвращает значение, по которому будет производиться сравнение.

     students = [Student("Alice", 20, 4.0), Student("Bob", 22, 3.8)]
     oldest_student = max(students, key=lambda s: s.age)
     print(oldest_student) # Выведет Student(name=Bob, age=22, gpa=3.8)
     

     Здесь lambda s: s.age — это анонимная функция, которая извлекает возраст студента для сравнения.

Обработка краевых сценариев

Качественное программное решение должно корректно обрабатывать не только "нормальные" данные, но и так называемые "краевые случаи" (edge cases), которые могут привести к ошибкам или неожиданному поведению.

• Пустой список: Это один из самых распространенных краевых случаев. Если алгоритм попытается получить первый элемент из пустого списка (как это делает линейный перебор), возникнет ошибка (например, IndexError в Python или Range check error в Pascal).
  • В Python: Встроенная функция max() по умолчанию вызывает ValueError, если ей передать пустой итерируемый объект. Однако она позволяет указать аргумент default, который будет возвращен в этом случае:

    empty_list = []
    max_val = max(empty_list, default=None) # max_val будет None
    

  • Для собственных алгоритмов: Необходимо явно добавить проверку на пустоту списка в начале функции и вернуть специальное значение (например, None, NaN, или выбросить исключение), чтобы сигнализировать о невозможности найти максимум.
• Список с одним элементом: Если список содержит всего один элемент, то этот элемент по определению является максимальным. Все алгоритмы должны корректно обрабатывать этот сценарий, возвращая этот единственный элемент как максимум. Для линейного перебора это означает, что инициализация max_value = L[0] сразу даст правильный результат, так как цикл перебора не будет выполнен (или будет выполнен для пустой последовательности). Рекурсивный алгоритм достигнет своего базового случая.

Подсчет количества максимальных элементов при наличии дубликатов

Часто требуется не просто найти максимальное значение, но и узнать, сколько раз оно встречается в списке, или получить все его индексы.

• Нахождение первого/одного из максимальных значений: Стандартный алгоритм линейного перебора или функция max() обычно находит первое (или одно из) максимальное значение. Например, в списке [1, 5, 2, 5, 3], max() вернет 5. Если мы используем линейный перебор, то переменная max_value будет обновлена при первом встрече 5, а затем еще раз, если следующий элемент тоже 5. В итоге значение будет 5.
• Нахождение всех максимальных элементов и их количества: Для подсчета всех вхожде��ий максимального элемента требуется дополнительная логика.
  1. Сначала найти максимальное значение: Использовать max() или линейный перебор для определения самого большого значения в списке.
  2. Затем подсчитать его вхождения: Пройтись по списку еще раз, сравнивая каждый элемент с найденным максимумом. Если элемент равен максимуму, увеличить счетчик. В Python для этого удобно использовать метод list.count():

     my_list = [1, 5, 2, 5, 3]
     max_val = max(my_list) # max_val = 5
     count_max = my_list.count(max_val) # count_max = 2
     

  3. Нахождение всех индексов максимального элемента: Если нужны не только количество, но и позиции:

     max_indices = [i for i, x in enumerate(my_list) if x == max_val]
     # max_indices будет [1, 3]
     

• Различия в использовании операторов > и ≥ при подсчете дубликатов:
  • Оператор > (больше): Если в алгоритме линейного перебора для обновления max_value используется max_value = L[i], только когда L[i] > max_value, то в случае нескольких одинаковых максимальных элементов max_value будет содержать значение первого найденного максимального элемента.
  • Оператор ≥ (больше или равно): Если использовать условие L[i] ≥ max_value, то при наличии дубликатов max_value будет обновляться при каждом встрече равного или большего элемента. Это может быть полезно, если требуется найти последний максимальный элемент в списке (если логика построена так, что при равенстве он всё равно "выбирает" текущий). Однако для задачи подсчета количества самих максимальных элементов, это не играет существенной роли для определения max_val, но может быть важным для определения индекса последнего вхождения, если задача требует именно этого.

  Пример для определения индекса:

  my_list = [1, 5, 2, 5, 3]
  max_val = my_list[0]
  max_idx = 0
  
  # Если ищем первый максимальный
  for i in range(1, len(my_list)):
      if my_list[i] > max_val:
          max_val = my_list[i]
          max_idx = i
  # max_val = 5, max_idx = 1
  
  # Если ищем последний максимальный
  max_val = my_list[0]
  max_idx = 0
  for i in range(1, len(my_list)):
      if my_list[i] >= max_val: # Обратите внимание на ">="
          max_val = my_list[i]
          max_idx = i
  # max_val = 5, max_idx = 3
  

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

Этапы разработки программного обеспечения для курсовой работы

Создание любого программного продукта, будь то сложная корпоративная система или относительно простая курсовая работа, подчиняется определенной методологии. Этот процесс, известный как жизненный цикл разработки программного обеспечения (SDLC — Software Development Life Cycle), представляет собой структурированную последовательность этапов, которая помогает управлять проектом от его зарождения до завершения и последующей поддержки. Для студенческих проектов, таких как курсовая работа, понимание и применение SDLC является не только академическим требованием, но и ценным практическим навыком, формирующим основы профессиональной деятельности, позволяя заложить крепкий фундамент для будущих масштабных проектов.

Обзор методологии SDLC

SDLC — это каркас, описывающий все фазы разработки программного обеспечения. Несмотря на разнообразие моделей SDLC (каскадная, спиральная, итеративная, гибкая), большинство из них включают следующие основные этапы:

1. Планирование (Planning): Начальная фаза, на которой определяются цели проекта, объем работ, требования к системе, бюджет, сроки, необходимые ресурсы и формируется команда. Здесь закладывается фундамент всего проекта.
2. Анализ и проектирование (Analysis and Design): На этом этапе происходит углубленный сбор и анализ требований пользователя, которые затем преобразуются в детальные спецификации. Разрабатывается архитектура системы, проектируются ее компоненты, базы данных, пользовательские интерфейсы и алгоритмы. Результатом является подробный проект системы.
3. Реализация (Implementation/Coding): Фаза, где идеи и проекты воплощаются в жизнь. Программисты пишут исходный код в соответствии с проектной документацией, создают модули, классы и функции, а также интегрируют их в единое целое.
4. Тестирование (Testing): Критически важный этап, направленный на обнаружение и исправление ошибок (дефектов) в программном обеспечении. Проводятся различные виды тестирования: модульное (проверка отдельных компонентов), интеграционное (проверка взаимодействия компонентов), системное (проверка всей системы на соответствие требованиям) и приемочное (проверка со стороны заказчика/пользователя).
5. Внедрение и развертывание (Deployment): После успешного тестирования программное обеспечение устанавливается, конфигурируется и запускается в рабочей среде. Это может включать установку на серверы, обновление клиентских приложений или предоставление доступа пользователям.
6. Эксплуатация и поддержка (Maintenance): Этот этап начинается после запуска ПО и продолжается на протяжении всего его жизненного цикла. Он включает устранение обнаруженных ошибок, внесение улучшений, адаптацию к новым требованиям и общую техническую поддержку пользователей.

Применение каскадной модели в курсовой работе

Для академических проектов, таких как курсовая работа, где требования относительно стабильны и заранее определены, а объем проекта ограничен, часто оптимальной и наиболее подходящей методологией является каскадная (или водопадная) модель. Её "строгость" обусловлена линейным, последовательным подходом: каждая фаза должна быть полностью завершена, прежде чем можно будет перейти к следующей, и возврат к предыдущим этапам без значительных затрат не предусмотрен. Это делает её идеальной для обучения структурированному подходу к разработке.

Рассмотрим каждый этап каскадной модели применительно к студенческому проекту:

Этап планирования

Для студента этот этап включает:

• Определение целей проекта: Четкое формулирование того, что должна делать программа (например, "разработать программу для поиска максимального элемента в целочисленном списке и подсчета его количества").
• Формулирование требований: Детализация функциональных (что программа должна уметь) и нефункциональных (производительность, удобство использования) требований. Например, "программа должна принимать список чисел произвольной длины", "интерфейс должен быть интуитивно понятным".
• Оценка ресурсов и сроков: Определение доступных инструментов (язык программирования, среда разработки), личного времени на выполнение и согласование сроков с научным руководителем.
• Выбор предметной области: В данном случае — алгоритмы и структуры данных для поиска максимума.

Этап анализа и проектирования

Это ключевой этап для курсовой работы, требующий глубокого осмысления:

• Детальный анализ требований: Преобразование высокоуровневых требований в конкретные, измеримые спецификации. Какие типы данных будут обрабатываться? Как обрабатывать пустые списки? Нужен ли подсчет дубликатов?
• Разработка архитектуры системы: Для небольшой программы это может быть определение основных модулей (например, модуль ввода данных, модуль обработки, модуль вывода результатов) и их взаимодействия.
• Проектирование компонентов:
  • Выбор алгоритма: Обоснование выбора конкретного алгоритма (например, линейный перебор как наиболее простой и эффективный для данной задачи) с учетом временной и пространственной сложности.
  • Проектирование структуры данных: Определение формата входных данных (список чисел), структуры для хранения промежуточных результатов.
  • Проектирование пользовательского интерфейса: Создание эскизов интерфейса, определение элементов управления и логики взаимодействия.
  • Разработка блок-схем: Визуальное представление логики работы программы и ключевых алгоритмов согласно ГОСТ 19.701-90.

Этап реализации (кодирования)

На этом этапе студент пишет сам код программы:

• Написание кода: Реализация всех модулей и функций на выбранном языке программирования (например, Python, Pascal). Важно следовать принципам чистого кода, модульности и читаемости.
• Интеграция компонентов: Объединение отдельных функций и модулей в единую работающую программу.
• Создание модулей/функций: Каждая логически завершенная часть программы должна быть оформлена как отдельная функция или процедура.

Этап тестирования

Этот этап жизненно важен для обеспечения качества программы:

• Модульное тестирование: Проверка корректности работы отдельных функций или процедур (например, функция поиска максимума должна правильно работать с разными списками).
  • Примеры тестовых данных:
    • [5, 2, 8, 1, 9] → Максимум: 9, Количество: 1
    • [7, 7, 7, 7] → Максимум: 7, Количество: 4
    • [10] → Максимум: 10, Количество: 1
    • [] (пустой список) → Ожидаемое поведение: сообщение об ошибке или возврат специального значения.
    • [-1, -5, -2] → Максимум: -1, Количество: 1
    • ["apple", "banana", "kiwi"] → Максимум: "kiwi", Количество: 1 (для строкового списка)
• Интеграционное тестирование: Проверка взаимодействия между модулями (например, корректно ли передаются данные от модуля ввода к модулю обработки).
• Системное тестирование: Проверка всей программы на соответствие исходным требованиям.
• Приемочное тестирование: В контексте курсовой работы это может быть демонстрация программы научному руководителю и проверка её соответствия заданию.

Этап внедрения и поддержки

Для курсовой работы этот этап имеет свои особенности:

• Внедрение: Передача рабочего кода и документации научному руководителю. В реальных проектах это установка ПО на серверы или клиентские машины.
• Поддержка: Для курсовой работы это означает, что студент должен быть готов объяснить работу программы, ответить на вопросы и, возможно, внести мелкие корректировки после рецензии. В реальном мире — это обслуживание, исправление ошибок и обновление ПО после его запуска.

Применение каскадной модели в курсовой работе позволяет студенту систематизировать процесс разработки, четко видеть цель каждого этапа и формировать необходимую документацию, что является бесценным опытом для будущей профессиональной деятельности.

Требования к программной документации согласно ГОСТ

Одним из наиболее важных, но зачастую недооцениваемых аспектов разработки программного обеспечения, особенно в академической среде, является грамотное документирование. Для курсовых работ, выполняемых студентами технических и IT-специальностей, это не просто формальность, а демонстрация способности создавать полноценные, профессионально оформленные программные продукты. Российские государственные стандарты (ГОСТ) в области программной документации (ЕСПД) и конструкторской документации (ЕСКД) предоставляют четкие указания, как это следует делать, гарантируя единообразие и высокую читаемость.

Общие требования к оформлению текстовых документов

Прежде чем углубляться в специфику программных документов, необходимо ознакомиться с общими правилами оформления текстовых документов, которые регламентируются ГОСТ 7.32–2017 «СИБИД. Отчет о научно-исследовательской работе. Структура и правила оформления» и ГОСТ 2.105-2019 «ЕСКД. Общие требования к текстовым документам». Эти стандарты устанавливают единообразие и читаемость любого академического текста.

Основные требования:

• Шрифт: Times New Roman.
• Размер шрифта: 12 пт (для основного текста).
• Межстрочный интервал: 1,5 пт.
• Отступ первой строки (абзацный отступ): 1,25 см.
• Выравнивание текста: По ширине (justify).
• Поля документа:
  • Левое поле: 3 см (для подшивки).
  • Правое поле: 1 см.
  • Верхнее поле: 2 см.
  • Нижнее поле: 2 см.

Общая структура курсовой работы по ГОСТ обычно включает следующие обязательные элементы:

1. Титульный лист: Содержит информацию об учебном заведении, кафедре, теме работы, авторе и научном руководителе.
2. Содержание (Оглавление): Список всех разделов и подразделов с указанием номеров страниц.
3. Введение: Обоснование актуальности темы, постановка цели и задач работы, описание объекта и предмета исследования, краткий обзор структуры.
4. Основная часть: Разбивается на главы, параграфы, подразделы. Здесь последовательно излагаются теоретические основы, анализ, разработка, реализация и тестирование программы.
5. Заключение: Обобщение результатов, выводы по достижению поставленных целей и задач, оценка практической значимости.
6. Список использованных литературных источников: Перечень всех источников, ссылки на которые были использованы в работе, оформленный по ГОСТ.
7. Приложения: Дополнительные материалы, такие как листинги кода, скриншоты интерфейса, блок-схемы, тестовые данные и результаты.

Описание программы (ГОСТ 19.402-78)

Этот документ является одним из ключевых в ЕСПД и устанавливает состав и требования к содержанию программного документа "Описание программы". Он должен давать полное представление о функциональном назначении, логической структуре и особенностях функционирования программы.

Основные разделы, которые должны быть включены:

1. Общие сведения:
   • Обозначение и наименование программы: Уникальный идентификатор и полное название (например, "Программа поиска и подсчета максимальных элементов в списке. АБВГ.123456.001").
   • Необходимое программное обеспечение: Языки программирования (например, Python 3.9), операционные системы (Windows 10), библиотеки (NumPy, если использовалась).
   • Необходимые технические средства: Тип процессора, объем оперативной памяти, наличие свободного места на диске.
2. Функциональное назначение:
   • Классы решаемых задач: Подробное описание того, для чего предназначена программа (например, "Программа предназначена для определения максимального числового элемента в заданном списке и подсчета количества его вхождений. Она может применяться для анализа статистических данных или в обучающих целях").
   • Функциональные ограничения: Ограничения, связанные, например, с типами данных (только целые числа), максимальным размером списка и т.д.
3. Описание логической структуры:
   • Алгоритм программы: Подробное описание выбранного алгоритма (например, линейного перебора), включая его основные шаги и логику работы.
   • Используемые методы: Указание теоретических подходов или математических методов, на которых основан алгоритм.
   • Структура программы с описанием функций составных частей и связи между ними: Декомпозиция программы на модули (функции, процедуры) с описанием их назначения, входных/выходных параметров и взаимодействия.
   • Блок-схемы: Обязательное графическое представление алгоритмов и общей структуры программы в соответствии с ГОСТ 19.701-90.
4. Используемые технические средства:
   • Перечисление аппаратно-программных средств, необходимых для работы программы (например, персональный компьютер, Python-интерпретатор).
5. Вызов и загрузка:
   • Подробная инструкция по запуску программы (например, "Для запуска программы необходимо открыть командную строку, перейти в директорию с файлом main.py и выполнить команду python main.py").
6. Входные данные:
   • Описание формата, типов и диапазона допустимых значений для входных данных (например, "Список целых чисел, вводимых пользователем через пробел. Допустимый диапазон значений от -2 · 10⁹ до 2 · 10⁹").
7. Выходные данные:
   • Описание формата и содержания выходных данных (например, "Программа выводит на экран максимальное значение, количество его вхождений и список индексов").

Допускается иллюстрации разделов пояснительными примерами, таблицами, схемами, графиками.

Текст программы (ГОСТ 19.401-78)

Этот стандарт устанавливает требования к содержанию и оформлению исходного кода программы. "Текст программы" представляет собой непосредственно листинг исходного кода.

Ключевые требования:

• Читаемость: Код должен быть легко читаем и понятен.
• Комментарии: Обязательно включать комментарии, которые отражают функциональное назначение блоков кода, описание переменных, процедур и функций, а также пояснения к сложным алгоритмическим решениям. Комментарии должны быть актуальными и соответствовать коду.
• Оформление: Использование отступов, единообразное именование переменных и функций, разделение кода на логические блоки.
• Структура: Код должен быть структурирован в соответствии с проектной документацией (модули, функции).

Пример комментирования в Python:

def find_max_and_count(data_list):
    """
    Функция для поиска максимального элемента в списке и подсчета его количества.
    
    Args:
        data_list (list): Список чисел для анализа.
        
    Returns:
        tuple: Кортеж (максимальное_значение, количество_вхождений).
               Возвращает (None, 0) для пустого списка.
    """
    if not data_list:
        return None, 0
    
    max_value = data_list[0] # Инициализация максимального значения первым элементом
    
    # Линейный перебор для поиска максимального элемента
    for item in data_list:
        if item > max_value:
            max_value = item
            
    count = data_list.count(max_value) # Подсчет количества вхождений максимального элемента
    
    return max_value, count

Руководство оператора (ГОСТ 19.505-79)

Этот документ предназначен для пользователя, который будет работать с программой. Он должен содержать всю необходимую информацию для её успешного запуска, эксплуатации и интерпретации сообщений.

Основные разделы:

1. Назначение программы:
   • Краткое и понятное описание функций программы, для чего она служит.
2. Условия выполнения программы:
   • Минимальный и/или максимальный состав аппаратурных и программных средств: Какие аппаратные (ОЗУ, процессор) и программные (ОС, интерпретатор Python, версии библиотек) ресурсы необходимы.
   • Требования к данным: Например, "Входные данные должны быть представлены списком целых чисел, разделенных пробелами".
3. Выполнение программы:
   • Последовательность действий оператора: Пошаговая инструкция по загрузке, запуску, вводу данных, выполнению и завершению программы. Должна быть максимально подробной и понятной, без использования технического жаргона.
   • Примеры ввода/вывода: Скриншоты или текстовые примеры взаимодействия пользователя с программой.
4. Сообщения оператору:
   • Тексты сообщений: Перечень всех сообщений, которые программа может выводить пользователю (ошибки, предупреждения, информационные сообщения).
   • Содержание сообщений: Подробное объяснение, что означает каждое сообщение.
   • Действия оператора: Рекомендации по действиям, которые должен предпринять пользователь в ответ на каждое сообщение.
     Пример:
     • Сообщение: Ошибка: Введен пустой список. Пожалуйста, введите хотя бы одно число.
     • Содержание: Пользователь попытался запустить анализ без ввода данных.
     • Действие: Ввести список чисел и повторить операцию.

Схемы алгоритмов и данных (ГОСТ 19.701-90)

Этот ГОСТ (ИСО 5807-85) определяет условные обозначения и правила выполнения схем алгоритмов, программ, данных и систем. Блок-схемы являются наглядным и универсальным способом представления логики работы программы, понятным даже без знания конкретного языка программирования. Что же именно нам даёт их использование?

Основные условные обозначения:

• Терминатор (овал): Начало/конец алгоритма.
• Процесс (прямоугольник): Выполнение одной или нескольких операций.
• Ввод/вывод (параллелограмм): Ввод данных или вывод результатов.
• Решение (ромб): Условие, по которому выбирается один из нескольких путей.
• Соединитель (круг): Переход к другой части схемы.
• Линия потока (стрелка): Направление выполнения алгоритма.

Пример (схематично):

(Пример блок-схемы, которая должна быть нарисована согласно ГОСТу в приложении к курсовой работе)

Соблюдение этих ГОСТов при разработке программной документации не только повышает академическую ценность курсовой работы, но и формирует у студента важные навыки, необходимые для создания качественного и сопровождаемого программного обеспечения в реальной профессиональной деятельности.

Разработка пользовательского интерфейса и структуры данных программы

Программное решение, каким бы совершенным ни был его внутренний алгоритм, не может считаться завершенным без удобного и функционального взаимодействия с пользователем. Пользовательский интерфейс (UI) и четко определенная структура данных — это два столпа, обеспечивающие доступность, управляемость и эффективность программы. В контексте курсовой работы, эти аспекты демонстрируют умение студента не только кодировать, но и проектировать систему с учетом потребностей конечного пользователя.

Принципы проектирования пользовательского интерфейса (UI)

Пользовательский интерфейс (UI) – это совокупность всех средств, с помощью которых пользователь взаимодействует с программой: элементы ввода данных (поля, кнопки), способы отображения информации (текст, таблицы, графики) и элементы управления. Качество интерфейса часто становится решающим фактором в восприятии всего программного продукта. Для курсовой работы, даже если интерфейс консольный, принципы остаются актуальными.

Ключевые принципы интуитивно понятного и дружественного интерфейса:

1. Последовательность и единообразие: Элементы управления и операции должны быть представлены единообразно на протяжении всей программы. Например, кнопки "ОК" и "Отмена" всегда должны быть расположены в одном и том же порядке, а сообщения об ошибках иметь схожий формат. Это снижает когнитивную нагрузку на пользователя и упрощает обучение.
2. Предоставление обратной связи: Программа должна информировать пользователя о своих действиях и состоянии. Например, при ожидании ввода данных, программа должна вывести соответствующий запрос; после выполнения операции – подтверждение или результат. Если операция занимает время, полезно показать индикатор прогресса.
3. Предотвращение ошибок: Лучше предотвратить ошибку, чем заставлять пользователя её исправлять. Это может быть реализовано через валидацию ввода (например, не позволяя ввести текст там, где ожидается число), предоставление подсказок или использование элементов выбора вместо свободного ввода.
4. Простота обучения и использования: Интерфейс должен быть легко осваиваемым для новых пользователей и эффективным для опытных. Это достигается за счет интуитивно понятных названий, минимального количества шагов для выполнения задачи и четкой организации информации.
5. Информативность: Пользователь всегда должен понимать, что происходит, какие данные он вводит и какой результат ожидать. Сообщения об ошибках должны быть ясными и предоставлять рекомендации по их устранению.
6. Гибкость и эффективность: Возможность для опытных пользователей ускорить выполнение задач (например, горячие клавиши в GUI, или сокращенный ввод в консоли), а для новичков – пошаговые инструкции.

Методы оценки эффективности UI (юзабилити метрики):

Хотя для курсовой работы глубокий анализ юзабилити может быть избыточен, понимание этих метрик полезно:

• Время выполнения задачи: Сколько времени требуется пользователю для выполнения ключевой задачи (например, ввода списка и получения результата).
• Количество и серьезность ошибок: Сколько ошибок делает пользователь и насколько они критичны.
• Степень удовлетворенности пользователя: Субъективная оценка удобства использования (можно измерить с помощью опросов).
• Легкость освоения и запоминания: Насколько быстро новый пользователь может освоить интерфейс и насколько легко опытный пользователь вспоминает, как им пользоваться после перерыва.

Структура исходных данных и результатов

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

Для входных данных:

• Типы данных: Необходимо указать, какие типы данных программа ожидает (например, только целые числа, вещественные числа, строки).
• Форматы: Как данные должны быть представлены. Например, "последовательность целых чисел, разделенных пробелами" (для консольного ввода) или "каждое число на новой строке" (для файлового ввода).
• Диапазоны допустимых значений: Если есть ограничения на величину чисел (например, от -100 до 100).
• Ограничения на ввод: Например, минимальное и максимальное количество элементов в списке.
• Обработка некорректного ввода: Что должна делать программа, если пользователь ввел нечисловые данные, или данные, выходящие за допустимый диапазон.

Для выходных данных:

• Формат отображения: Как результаты будут представлены пользователю (например, "Максимальный элемент: 10, Количество: 2, Индексы: [2, 5]").
• Содержание: Что именно будет выведено (только значение, только количество, значение и количество, значение, количество и индексы).
• Представление в случае ошибок: Как программа сообщает об отсутствии результата (например, для пустого списка).

Пример структуры входных/выходных данных:

Параметр	Описание	Тип данных	Формат	Диапазон/Примеры
Входные данные
list_elements	Элементы списка для анализа	Целые числа	Строка, разделённая пробелами	-100 .. 100, например: 5 20 -3 20 15
Выходные данные
max_value	Найденное максимальное значение в списке	Целое число	Число	Например: 20
count_max	Количество вхождений максимального значения	Целое число	Число	Например: 2
max_indices	Список индексов всех максимальных элементов	Список целых чисел	[idx1, idx2]	Например: [1, 3] (для 5 20 -3 20 15)
initial_list	Исходный список (для верификации)	Список целых чисел	[e1, e2, ...]	Например: [5, 20, -3, 20, 15]

Методы ввода и вывода данных

Программа может получать входные данные из различных источников и выводить результаты в разных форматах.

• Источники входных данных:
  • Ввод пользователем (консоль): Самый простой способ для небольших программ. Пользователь вводит данные напрямую во время выполнения.
  • Генерация случайных данных: Для тестирования или демонстрации можно использовать функцию random для создания списка чисел заданной длины и диапазона.
  • Чтение из файла: Для работы с большими объемами данных. Пользователь указывает путь к файлу, из которого программа считывает данные.
• Форматы выходных данных:
  • Только значение: Вывести только найденный максимум.
  • Только индекс: Вывести позицию максимального элемента.
  • Оба параметра: Наиболее информативный вариант для нашей задачи.

Целесообразность вывода всего исходного массива на экран при запуске: Для курсовой работы, а также в целях отладки и верификации, крайне полезно выводить исходный список на экран сразу после его ввода или генерации. Это позволяет пользователю (или экзаменатору) убедиться, что программа работает с ожидаемыми данными и корректно их интерпретирует. Такой подход способствует повышению прозрачности и надёжности работы программы.

Визуализация алгоритма: Блок-схемы

Как уже упоминалось в разделе о ГОСТ, блок-схемы являются незаменимым инструментом для визуализации алгоритмов. Они позволяют наглядно представить последовательность действий, логику ветвлений и циклов, а также структуру обрабатываемых данных. Использование стандартизированных условных обозначений согласно ГОСТ 19.701-90 делает эти схемы универсально понятными для любого специалиста в области информатики. В курсовой работе блок-схемы должны быть приложены в соответствующем разделе "Описание логической структуры" и/или в Приложении, демонстрируя глубокое понимание алгоритмической части проекта.

Разработка интуитивно понятного интерфейса и тщательная проработка структуры данных — это не просто дополнительные элементы, а фундаментальные части программного решения, которые обеспечивают его полноценное функционирование и удобство для пользователя.

Заключение

В рамках данной курсовой работы была успешно решена задача разработки и документирования программного решения для поиска и подсчета максимальных элементов в списке. Мы последовательно прошли все ключевые этапы жизненного цикла программного обеспечения, от глубокого погружения в теоретические основы и выбора оптимального алгоритма до детальной формализации задачи, учета краевых случаев и тщательного проектирования пользовательского взаимодействия.

Разработанное решение базируется на эффективном алгоритме линейного перебора, который, при своей простоте, обеспечивает оптимальную временную сложность O(N) для неупорядоченных списков. Мы также рассмотрели альтернативные подходы, включая рекурсивные алгоритмы и использование высокооптимизированных встроенных функций Python, таких как max() и numpy.argmax(), что демонстрирует гибкость и вариативность в решении поставленной задачи. Особое внимание было уделено формализации, где мы подробно проанализировали особенности сравнения различных типов данных (числа, строки, пользовательские объекты) и разработали механизмы для корректной обработки таких сценариев, как пустые списки или наличие дублирующихся максимальных элементов.

Критически важным аспектом работы стало строгое соблюдение требований к программной документации согласно актуальным государственным стандартам (ГОСТ ЕСПД и ЕСКД). Детально были описаны структура и содержание документов "Описание программы" (ГОСТ 19.402-78), "Текст программы" (ГОСТ 19.401-78) и "Руководство оператора" (ГОСТ 19.505-79), а также принципы построения блок-схем по ГОСТ 19.701-90. Этот методический подход обеспечивает не только академическую ценность работы, но и формирует у студента фундаментальные навыки, необходимые для создания профессионального и сопровождаемого программного обеспечения.

Кроме того, были проработаны принципы проектирования пользовательского интерфейса, обеспечивающие интуитивность и удобство взаимодействия, а также четко определена структура исходных и выходных данных, что гарантирует предсказуемость и надежность работы программы. Таким образом, данная курсовая работа является комплексным и исчерпывающим отчетом, который не только демонстрирует способность студента к решению прикладных задач в программировании, но и подтверждает его компетенции в области программной инженерии, проектирования, тестирования и оформления технической документации в соответствии с установленными стандартами. Полученные знания и навыки имеют прямую практическую применимость в будущей профессиональной деятельности в сфере IT. Какие преимущества это дает на практике?

Список использованной литературы

1. ГОСТ 19.101–77 Единая система программной документации. Виды программ и программных документов. Москва : Изд-во стандартов, 1977.
2. ГОСТ 19.103–77 Единая система программной документации. Обозначение программ и программных документов. Москва : Изд-во стандартов, 1977.
3. ГОСТ 19.401–78 Единая система программной документации. Текст программы. Требования к содержанию и оформлению. Москва : Изд-во стандартов, 1978.
4. ГОСТ 19.402–78 Единая система программной документации. Описание программы. Москва : Изд-во стандартов, 1978.
5. ГОСТ 19.505–79 Единая система программной документации. Руководство оператора. Требования к содержанию и оформлению. Москва : Изд-во стандартов, 1979.
6. ГОСТ 19.701–90 (ИСО 5807-85) Единая система программной документации. Схемы алгоритмов, программ, данных и систем. Условные обозначения и правила выполнения. Москва : Изд-во стандартов, 1990.
7. Вольфенгаген В. Э. Конструкции языков программирования. Приёмы описания. Москва : Центр ЮрИнфоР, 2001. 276 с.
8. Себеста Р. У. Основные концепции языков программирования. 5-е изд. Москва : Вильямс, 2001. 672 с.
9. Перминов О. Н. Язык программирования Паскаль: Справочник. Москва : Радио и связь, 1989. 128 с.
10. Культин Н. Б. Delphi 6. Программирование на Object Pascal. Санкт-Петербург : БХВ-Петербург, 2001. 528 с.
11. Моргун А. Н. Программирование на языке Паскаль (Pascal). Основы обработки структур данных. Москва : Диалектика, 2005. 576 с.
12. Вирт Н. Алгоритмы + структуры данных = программы. Москва : Мир, 1985. 406 с.
13. Йенсен К., Вирт Н. Паскаль. Руководство для пользователя и описание языка. Москва : Финансы и статистика, 1982. 151 с.
14. Архангельский А. Я. Программирование в Delphi 6. Москва : ЗАО «Издательство БИНОМ», 2002. 1200 с.
15. Фаронов В. В. Delphi 6. Учебный курс. Москва : Молгачев С. В., 2001. 672 с.
16. Максимальный элемент массива - Pascal. URL: https://programm.top/pascal/maximum-element-array (дата обращения: 21.10.2025).
17. Самый быстрый алгоритм поиска максимума в массиве. URL: https://proglib.io/p/fastest-max-algorithm (дата обращения: 21.10.2025).
18. Поиск максимального элемента в массиве - Основы программирования | Язык Паскаль. URL: https://pascal.основы-программирования.рф/massivy/poisk-maksimalnogo-elementa-v-massive/ (дата обращения: 21.10.2025).
19. Поиск максимального элемента в массиве - Анимация блок-схем алгоритмов. URL: https://block-scheme.ru/algorithm/poisk-maksimalnogo-elementa-v-massive (дата обращения: 21.10.2025).
20. Получаем максимальный элемент списка Python [7 примеров]. URL: https://pythonru.com/primery/poluchaem-maksimalnyj-jelement-spiska-python-7-primerov (дата обращения: 21.10.2025).
21. Поиск максимального числа в массиве - Stack Overflow на русском. URL: https://ru.stackoverflow.com/questions/276497/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA-%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE-%D1%87%D0%B8%D1%81%D0%BB%D0%B0-%D0%B2-%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B5 (дата обращения: 21.10.2025).
22. Жизненный цикл разработки и тестирования ПО - QaLearning. URL: https://qaleaning.ru/blog/zhiznennyj-cikl-razrabotki-i-testirovaniya-po/ (дата обращения: 21.10.2025).
23. Максимальный элемент массива в Pascal. URL: https://programmby.blogspot.com/2012/01/max-element-massiva-v-pascal.html (дата обращения: 21.10.2025).
24. База про жизненный цикл разработки ПО (SDLC): этапы, виды моделей и их различия. URL: https://timeweb.cloud/blog/sdlc-zhiznennyy-tsikl-razrabotki-po (дата обращения: 21.10.2025).
25. Блок-схемы алгоритмов. ГОСТ. Примеры - Блог программиста. URL: https://www.prog-cpp.ru/flowcharts (дата обращения: 21.10.2025).
26. Алгоритмы поиска - Pascal - programm.top. URL: https://programm.top/pascal/algoritmy-poiska (дата обращения: 21.10.2025).
27. Жизненный цикл разработки программного обеспечения - AppMaster. URL: https://appmaster.io/ru/blog/zhiznennyy-tsikl-razrabotki-programmnogo-obespecheniya (дата обращения: 21.10.2025).
28. Поиск максимального элемента в списке. URL: https://younglinux.info/python/list-max-search (дата обращения: 21.10.2025).
29. Как найти максимальный элемент в списке Python - YouTube. URL: https://www.youtube.com/watch?v=F3x_1S_2s6w (дата обращения: 21.10.2025).
30. Курс Python → Поиск наиболее частого элемента списке - Marketello. URL: https://marketello.ru/python-find-most-frequent-element-in-list/ (дата обращения: 21.10.2025).
31. A.B.00001-01 34 01 (Руководство оператора) - АСУ ТП для разработчика. URL: https://rtsys.ru/docs/gost-19.505-79.html (дата обращения: 21.10.2025).
32. Технологии разработки пользовательских интерфейсов - Томский политехнический университет. URL: https://abiturient.tpu.ru/files/2014_RPD_Tekhnologii_razrabotki_polzovatelskih_interfeisov.pdf (дата обращения: 21.10.2025).
33. Основные блоки для составления схем алгоритмов - prog-cpp.ru. URL: https://www.prog-cpp.ru/flowchart-symbols (дата обращения: 21.10.2025).
34. SDLC Жизненный Цикл Разработки ПО, SDLC Этапы Методология - Солар. URL: https://solar.ru/sdlc-zhiznennyy-tsikl-razrabotki-po/ (дата обращения: 21.10.2025).
35. Руководство оператора. URL: https://edu.ru/media/upload/2020/09/25/Руководство%20оператора%20ФИС%20ФРДО_24.09.2020.pdf (дата обращения: 21.10.2025).
36. Этапы жизненного цикла разработки ПО - IC Studio. URL: https://icstudio.ru/blog/etapy-zhiznennogo-cikla-razrabotki-po (дата обращения: 21.10.2025).
37. Как оформить курсовую работу? Правила оформления по ГОСТ. URL: https://yours-diplom.ru/blog/oformlenie-kursovyh-rabot-po-gostu-aktualnye-trebovaniya (дата обращения: 21.10.2025).
38. ТРЕБОВАНИЯ К ОФОРМЛЕНИЮ КУРСОВЫХ И ДИПЛОМНЫХ ПРОЕКТОВ. URL: https://www.bsut.by/images/docs/study_docs/uch_plan/metod_ukazaniya/2017/TR_KP_DP_2017.pdf (дата обращения: 21.10.2025).
39. Функция max() в Python, максимальное значение элемента. URL: https://pythobyte.com/python-max-function-c8668c12/ (дата обращения: 21.10.2025).
40. Поиск максимального значения и его индекса в списке Python - Skypro. URL: https://sky.pro/media/poisk-maksimalnogo-znacheniya-i-ego-indeksa-v-spiske-python/ (дата обращения: 21.10.2025).
41. Как найти максимальный элемент в массиве, паскаль? URL: https://programm-c.ru/pascal/kak-najti-maksimalnyj-element-v-massive-paskal (дата обращения: 21.10.2025).
42. Блок-схемы алгоритмов. - Korobchinskiy's blog. URL: https://korobchinskiy.ru/articles/blok-sxemy-algoritmov (дата обращения: 21.10.2025).
43. Разработка пользовательского интерфейса русский cтраница 1 - Allbest.ru. URL: https://allbest.ru/o-3c0b65625b2bd78a5c53b89921bd6d27.html (дата обращения: 21.10.2025).
44. Лабораторная работа №17 Разработка интерфейса | PDF - Scribd. URL: https://ru.scribd.com/document/633446860/%D0%9B%D0%B0%D0%B1%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D0%B0%D1%8F-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-17-%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D0%B0 (дата обращения: 21.10.2025).
45. Как найти все наиболее часто дублирующиеся элементы с одинаковым количеством в списке python? - Stack Overflow на русском. URL: https://ru.stackoverflow.com/questions/1126601/list-%D0%9A%D0%B0%D0%BA-%D0%BD%D0%B0%D0%B9%D1%82%D0%B8-%D0%B2%D1%81%D0%B5-%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D0%B5%D0%B5-%D1%87%D0%B0%D1%81%D1%82%D0%BE-%D0%B4%D1%83%D0%B1%D0%BB%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B8%D0%B5-%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B-%D1%81-%D0%BE%D0%B4%D0%B8%D0%BD%D0%B0%D0%BA%D0%BE%D0%B2%D1%8B%D0%BC-%D0%BA%D0%BE%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%BE%D0%BC-%D0%B2-%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B5-python (дата обращения: 21.10.2025).
46. Скачать ГОСТ 19.701-90 Единая система программной документации. Схемы алг. URL: https://gostperevod.ru/gost-19-701-90 (дата обращения: 21.10.2025).
47. Требования к оформлению курсовых и дипломных работ и проектов - Псковский агротехнический колледж. URL: https://pa-college.ru/svedeniya-ob-oobrazovatelnoy-organizatsii/obrazovanie/metodicheskie-i-inye-dokumenty-razrabotannye-obrazovatelnoy-organizatsiey-dlya-obespecheniya-obrazovatelnogo-protsessa/trebovaniya-k-oformleniyu-kursovykh-i-diplomnykh-rabot-i-proektov.pdf (дата обращения: 21.10.2025).
48. Разработка пользовательского интерфейса с использованием нейронных. URL: https://www.elibrary.ru/download/elibrary_48408107_69618037.pdf (дата обращения: 21.10.2025).
49. ВЫПУСКНАЯ КВАЛИФИКАЦИОННАЯ РАБОТА АНАЛИЗ ПОЛЬЗОВАТЕЛЬСКОГО ИНТЕРФЕ - Казанский федеральный университет. URL: https://kpfu.ru/docs/F811902099/V_R_Sokolov_D_S_student_21_gruppy_O_R_Zalyalov_Z_R.pdf (дата обращения: 21.10.2025).
50. как найти максимум из списка, используя цикл for в питоническом стиле? - Reddit. URL: https://www.reddit.com/r/learnpython/comments/14jsb4l/%D0%BA%D0%B0%D0%BA_%D0%BD%D0%B0%D0%B9%D1%82%D0%B8_%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D1%83%D0%BC_%D0%B8%D0%B7_%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D1%8F_%D1%86%D0%B8%D0%BA%D0%BB_for_%D0%B2_%D0%BF%D0%B8%D1%82%D0%BE%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%BC_%D1%81%D1%82%D0%B8%D0%BB%D0%B5/ (дата обращения: 21.10.2025).
51. Структура курсовой работы по ГОСТ - примеры. URL: https://diplomgarant.ru/blog/struktura-kursovoy-raboty-po-gost-primery/ (дата обращения: 21.10.2025).
52. ПРОГРАММА ПОВЫШЕНИЯ КВАЛИФИКАЦИИ - «Оформление документации в соответствии с ГОСТ - КГСТ. URL: https://kgst-kr.ru/svedeniya-ob-organizacii/dokumenty/obrazovanie/programmy-povysheniya-kvalifikacii/3.2.1-ppk-oformlenie-dokumentacii-v-sootvetstvii-s-gost.pdf (дата обращения: 21.10.2025).