Текст выступления:

Кодирование основных типов алгоритмических структур на языках объектно-ориентированного и процедурного программирования
1. Кодирование основных типов алгоритмических структур

Алгоритм — это способ договориться с компьютером: что делать, в каком порядке и почему.

2. Один алгоритм — разные записи

У алгоритма есть смысл и есть форма. Смысл — одна и та же последовательность действий для решения задачи. В школе и дома один и тот же алгоритм можно оформлять словами, блок-схемами, псевдокодом и затем уже программным кодом. А в программировании важна ещё и «точность» записи: процедурный подход описывает шаги и функции, а объектно-ориентированный — данные и действия внутри объектов. Логика остаётся общей, но выражается разными инструментами.

3. Три базовые алгоритмические структуры

Сначала разберём три «кирпича», из которых складывается большинство программ. Первый кирпич — следование. Команды выполняются одна за другой в заданном порядке: сначала ввод, потом вычисление, затем вывод. Если изменить порядок — меняется и результат.

Второй кирпич — ветвление. Исполнение зависит от условия: программа проверяет факт и выбирает нужную ветку — «да» или «нет», положительное или отрицательное число, чётное или нечётное.

Третий кирпич — цикл. Группа команд повторяется несколько раз. Повторение необходимо, когда действий много, а также когда данные приходят списком. Часто структуры комбинируются: внутри цикла может быть ветвление, а после следования — новое повторение.

4. Структура следования в блок-схеме и коде

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

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

5. Ветвление: выбор по условию

Когда появляется «если… то… иначе…», начинается ветвление. Ветвление позволяет выбрать одну из нескольких возможностей, опираясь на результат проверки.

В простых случаях обычно достаточно одной проверки: в Python чаще используют конструкции if, else, elif, а в C++ — if, else if, else. Важно понимать не столько слова языка, сколько смысл: проверка условия определяет, какая команда будет выполнена дальше. Так программа реагирует на разные входные данные.

Если вариантов больше, запись становится «ступенчатой»: сначала проверяется первое условие, затем — возможные альтернативы. Это удобно для диапазонов и правил. Например: при делении на ноль выводится предупреждение; по баллам выбирается оценка; определяется знак числа; проверяется возраст. Во всех этих задачах смысл одинаков: условие управляет выбором ветки.

6. Когда нужен if, а когда несколько вариантов выбора

Есть простое правило выбора инструмента. Если условия проверяется один раз, обычно хватает простого if: «сделать действие только при одном условии». Когда исходов два — удобнее if else: «если условие верно, то одно, иначе — другое».

Когда же вариантов больше, приходится расширять логику: в Python — это цепочка elif, а в C++ подобные конструкции часто используют через последовательность условий или case-подобные решения (в зависимости от задачи). Идея остаётся понятной: каждый следующий вариант проверяется только тогда, когда предыдущие не подошли.

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

7. Циклы: повторение действий без лишнего кода

После ветвления обычно приходит вопрос: «а что если повторяется снова и снова?» Тогда нужен цикл. Цикл помогает добиться результата без копирования одних и тех же строк.

Цикл экономит силы и уменьшает ошибки: вместо многократного повторения одинакового фрагмента задаётся правило, сколько раз или до какого момента выполнять действия.

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

8. Одна задача — разные стили программирования

Теперь посмотрим на тот же смысл в разных стилях программирования. Одна и та же задача может быть организована по-разному: через функции и последовательность вызовов или через классы и методы.

В процедурном стиле обычно удобно «разложить» задачу на шаги: функция вычисляет, функция проверяет, функция обрабатывает ввод. В итоге программа выглядит как цепочка вызовов.

В объектно-ориентированном подходе важнее другое: логика привязывается к данным. Класс задаёт, что хранится и какие действия доступны, а конкретные объекты уже несут конкретные значения. Ключевое отличие — не в логике вычислений, а в организации: где хранится «каркас» программы — в наборе функций или в структуре классов.

9. Процедурное программирование: функции и шаги решения

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

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

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

10. Процедурная схема решения простой задачи

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

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

11. ОOП: класс, объект, метод

Переходим к объектно-ориентированному подходу. Его «термины-ориентиры» — класс, объект и метод.

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

Объект — это конкретный экземпляр класса с собственными значениями свойств. Например: ученик хранит имя и класс, книга — название и автора, счёт игры — очки и состояние команд.

Метод — действие, которое объект выполняет. Он использует данные объекта и меняет его состояние или возвращает результат. Например: увеличить очки, сбросить счёт, получить текущее значение для вывода на экран.

12. Инкапсуляция и защита данных объекта

Один из ключевых принципов ООП — инкапсуляция. Она означает: внутренние данные объекта меняются через его собственные методы.

Снаружи программист видит понятные действия — «вызвать метод увеличить», «вызвать метод получить значение». А то, как именно устроено внутри — скрыто. Такой подход уменьшает вероятность ошибок: если данные изменяются только правильным способом, то меньше шансов случайно «сломать» объект.

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

13. Где чаще удобен процедурный подход, а где ООП

Теперь соберём картину целиком: где обычно удобнее процедурный подход, а где — объектно-ориентированный.

Большинство школьных задач допускают разные решения. Но структура помогает выбрать стиль. Если задача больше похожа на «цепочку шагов» — когда важно последовательно выполнить операции, удобнее процедурный код. Если же важнее «объекты и их действия» — когда нужно представить сущности и поведение, — чаще выигрывает ООП.

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

14. Ветвление на Python и C++: одинаковый смысл, разный синтаксис

Ветвление одинаково по смыслу, но записывается по-разному. Это важная часть обучения: не нужно менять логику — меняется только синтаксис.

В Python выбор ветки часто оформляется через отступы и двоеточие. В C++ используются фигурные скобки и точка с запятой. На первый взгляд внешний вид кажется совершенно разным, но смысл условия сохраняется: сначала проверяется условие, затем выполняется нужная ветка.

Поэтому главное умение — читать условие и понимать логику, а не пытаться запомнить форму скобок. Когда смысл понятен, синтаксис осваивается быстрее: он становится переводом мысли на язык конкретной среды.

15. Цикл for в Python и C++

И наконец — цикл for. Это один из самых понятных способов повторения.

В Python for часто перебирает элементы последовательности или значения, полученные из range. Это удобно, когда заранее известно, какие значения нужны и сколько их будет: например, вывести числа от 1 до 10 или пройтись по списку оценок.

В C++ конструкция for обычно содержит счётчик, условие продолжения и шаг изменения счётчика. Такая форма помогает увидеть, как именно меняется перебор на каждом шаге: и старт, и ограничение, и шаг задаются явно.

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

Различается только запись: где в одном языке удобно задать перечисление или range, там в другом управляют счётчиком и условием. Но идея остаётся та же — и её легко переносить между языками программирования.

16. Цикл while и защита от бесконечного повторения

Алгоритмы редко обходятся без повторений: одна и та же идея применяется к данным снова и снова. Один из самых “прямых” инструментов для этого — цикл while, в котором тело выполняется, пока условие остаётся истинным.

Такой цикл легко представить как проверку дверного замка: пока условие «открыто» — действие продолжается; когда условие меняется на «закрыто» — выполнение останавливается. Именно поэтому главная задача при while — добиться того, чтобы условие в какой-то момент стало ложным.

На практике цикл while часто описывают простой мыслью: «повторяй действие, а внутри обязательно меняй то, что влияет на условие». Если этого не сделать — условие никогда не перестанет быть истинным, и программа начнёт повторять одни и те же шаги бесконечно.

Исторически циклы и понятие “условия остановки” развивались вместе с математикой вычислений. Ещё в работах А. М. Тьюринга обсуждалась идея вычислительной машины и то, почему некоторые процессы могут не завершаться. Хотя речь там не только о циклах в школьном коде, в основе — один и тот же риск: выполнение может никогда не дойти до состояния остановки.

Чтобы защититься от бесконечного повторения, полезно проверять несколько вещей:

Во-первых, условие в while должно зависеть от переменных, которые действительно изменяются внутри тела цикла.
Во-вторых, нужно продумать «точку выхода»: какой шаг гарантирует, что условие станет ложным.
В-третьих, стоит контролировать счётчики и условия окончания: например, проверка «пока i меньше N» работает только тогда, когда i увеличивается.

Иногда помогает правило: если внутри while не происходит изменения хотя бы одного параметра, от которого зависит условие, значит, почти наверняка цикл потенциально опасен.

Переходя дальше, важно помнить: выбор структуры алгоритма определяет, как именно будут приниматься решения, где будет происходить повторение и как соединятся оба подхода — последовательность, ветвление и цикл.

17. Выбор структуры алгоритма

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

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

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

Теперь о том, как выбирать структуру осознанно:

Если задача описывает «сначала сделать А, потом Б, затем В» — применяется следование.
Если в условии есть слова вроде «если… то… иначе…» или «в зависимости от…» — нужна структура выбора, то есть ветвление.
Если в условии сказано «пока…», «повторять, пока…», «для каждого элемента…» — почти всегда требуется цикл.

Но в реальных задачах структуры редко встречаются по одной. Обычно алгоритм выглядит как сочетание: ветвление внутри цикла или цикл внутри ветвления.

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

Поэтому при выборе структуры стоит мысленно отвечать на вопросы: «Где именно происходит решение? Что должно повторяться? Как гарантируется завершение?»

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

18. Типичные ошибки при записи алгоритмов

Даже когда идея алгоритма понятна, ошибки часто появляются не в математике, а в логике записи. Именно это и делает тему особенно важной: программист может «почти правильно» описать задачу, но одна мелочь ломает результат.

Одна из частых проблем — условие может не сработать. Например, написано условие «меньше», а в задаче подразумевается «не больше», или перепутан знак. Такое легко заметить, если внимательно сравнить условие из задачи с тем, что оказалось в коде.

Вторая группа ошибок связана с завершением цикла. Цикл может не завершиться, если условие остановки не выполняется: счётчик не изменяется, направление изменения неверное, либо условие построено так, что оно всегда остаётся истинным.

Третья причина — нарушенный смысл из‑за порядка шагов. Бывает, что команды записаны в правильной последовательности буквально, но логически переставлены: например, сначала выводится значение, а потом оно меняется; или обновление переменной происходит слишком поздно.

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

Ниже — практический вывод, который стоит запомнить:

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

Особенно внимательным нужно быть там, где одновременно есть ветвление и повторение: именно такие места чаще всего содержат ошибки, потому что в них легко «потерять» момент остановки или забыть обновить переменную.

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

19. Учебные задачи для закрепления темы

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

С этой целью полезны учебные задачи следующего типа.

Практика «условие и выбор»: придумать два разных пути выполнения и проверить, что алгоритм выбирает правильный вариант для разных входных данных. Здесь особенно важны знаки сравнения и корректные условия.

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

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

Практика «сочетание структур»: внутри цикла встречается ветвление, а внутри ветвления — продолжение цикла или вывод результата. Эти задания учат не только писать конструкции, но и связывать их в цельный алгоритм.

Практика «поиск и исправление ошибок»: дать алгоритм с логической проблемой и попросить найти её. Такой формат развивает навык диагностики: как понять, почему условие не срабатывает или цикл “застревает”.

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

И завершить работу стоит общим ориентиром, который объединяет все предыдущие идеи.

20. Главный вывод: важна логика алгоритма и точность записи

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

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

А ещё появляется спокойствие: становится ясно, что проверять в первую очередь — условия, счётчики и порядок команд. Именно в этих местах рождается качество алгоритма, а не случайное “вроде работает”.

Источники

А. П. Ершов, В. М. Монахов. Основы программирования. — М.: Просвещение, 1992.

Дж. Макконнелл. Код: управление программными проектами. — М.: Вильямс, 2005.

Б. Керниган, Д. Ритчи. Язык программирования C. — М.: Финансы и статистика, 1992.

З. Г. Гасанов. Теория алгоритмов и основы программирования. — М.: Академия, 2010.

Тьюринг А. М. О вычислимых числах и проблеме разрешимости // В: Работы по основаниям математики. М.: Наука, 1984.

Кнут Д. Искусство программирования. Том 1: Основные алгоритмы. М.: Вильямс, 2010.

Николаев С. А., Филиппов А. А. Программирование и основы алгоритмизации: учебное пособие. М.: Просвещение, 2016.

Скотт Л. Программирование: концепции и практика (управляющие структуры). М.: ДМК Пресс, 2018.