Как пишется циклический алгоритм - Правописание и грамматика

План урока:

Понятие циклического алгоритма

Программирование циклического алгоритма

Операторы цикла

Решение задач с использованием операторов while, repeat, for

Понятие циклического алгоритма

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

Циклические алгоритмы – это алгоритмы, в которых некоторая часть операций повторяется многократно.

Цикл – конструкция с оператором, который повторяется определённое или неопределённое заранее количество раз. Действия, выполняющиеся последовательно внутри цикла, называют телом цикла.

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

Циклы разделяют на три типа в зависимости от метода организации повторений:

Цикл, в котором задано условие окончания работы;
Когда известно условие продолжения работы цикла;
Когда известно число повторений цикла.

Программирование циклического алгоритма

Выбрав среду программирования Паскаль необходимо познакомиться с операторами, с помощью которых можно разработать программу с циклом. Ими являются while, repeat, for. Оператор while был разобран ещё на прошлом уроке, однако забывать о нём нельзя.

Цикл с предусловием

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

Цикл с постусловием

Цикл с постусловием – это алгоритм циклической структуры, в котором проверка условия продолжения осуществляется после выполнения тела цикла.

Тело цикла с постусловием всегда выполняется как минимум один раз, независимо от истинности или ложности условия. Это его ключевое отличие от цикла с предусловием.

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

Цикл с заданным числом повторений

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

Операторы цикла

Для программирования циклических алгоритмов и корректного выполнения программ с их использованием, необходимо знать операторы цикла. Чаще всего, в языке Паскаль используют операторы цикла: for, repeat и while. Разберем их подробнее.

Оператор while

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

Если переводить его дословно, то можно сказать, что он работает по принципу «пока <условие> выполнять действие <оператор 1>», а заканчивается при переходе программы на слово end. Перед выполнением операторов внутри цикла условие обязательно проверяется и уже дальше, в зависимости от его истинности, программа либо выполняет тело цикла, либо переходит к последующим операторам.

Решение задач с использованием оператора while

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

Задача 1. На вход подаются целые числа. До тех пор, пока не будет введено число, которое больше 17, программа должна вывести сумму полученного числа и числа 8. Когда вводимое число будет больше 17, то после выполнения программы цикл завершается.

Решение.

Шаг 1. Для начала необходимо дать программе название.

Шаг 2. Учитывая, что на вход подаётся целое число, указать тип данных, в данном случае – integer.

Шаг 3. Запись командного блока. Нужно написать слово, обозначающее начало, begin.

Шаг 4. Нужно дать переменной a значение 1, чтобы цикл начался автоматически.

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

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

Шаг 7. Запись необходимых операторов. Используя оператор readln программа считывает данные и переводит курсор на новую строку. Далее она производит операции над поступившими данными.

Шаг 8. Запись суммы. Исходя из условия задачи необходимо сделать так, чтобы программа выводила сумму входящего числа и числа 8. Осуществить это можно используя оператор writeln.

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

Шаг 10. Проверка правильности записи алгоритма. В конце программного блока, после слова end нельзя забывать точку, её обязательно нужно поставить.

Оператор repeat

Оператор цикла repeat until используется для создания циклического алгоритма с постусловием. Его схема выглядит так:

Дословно оператор Паскаля repeat можно перевести как «повторяй <оператор 1>, до <условие>». В зависимости от истинности условия, либо происходит переход на повторение «оператора 1», либо осуществляется выход из цикла к последующим операторам.

Оператор repeat имеет два важных отличия от оператора while:

в операторе repeat сначала выполняется тело, а затем проверяется условие;
в операторе repeat прописывается условие завершения цикла, тогда как в операторе while – условие его продолжения.

Решение задач с использованием оператора repeat

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

Решение.

Шаг 1. Название программы. В данном случае — «задача 1».

Шаг 2. Учитывая, что на вход подаются целые числа, требуется указать тип данных – integer.

Шаг 3. Командный блок. Запись начального слова begin.

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

Шаг 5. Необходимо присвоить переменной i значение 1 для того, чтобы последовательность начиналась с натурального числа.

Шаг 6. Запись цикла. Учитывая, что используется цикл с постусловием, необходимо сначала записать оператор, который будет повторяться, затем увеличить i на 1, чтобы образовывалась последовательность, и уже после этого прописать условие повторения. В данной задаче цикл перестаёт повторяться тогда, когда переменная i принимает значение больше введённого числа, которое является последним членом последовательности.

Шаг 7. Проверка программы на правильность в выводе. В результате своей работы программа должна вывести последовательность натуральных чисел от 1 до n, через пробел.

Оператор for

Используя оператор for можно задать нужное количество повторений одних и тех же действий. По-другому его называют оператором циклов с известным числом повторений. Он имеет два соединительных слова – это to и downto. Различие между ними в том, что при использовании первого к предыдущему значению переменной цикла прибавляется единица, а при написании второго – вычитается единица. Схемы оператора имеют следующий вид:

Дословно его можно перевести как «для переменной в значении от начального к конечному выполнять <оператор 1> ».

Решение задач с использованием оператора for

Рассмотреть пример с оператором for можно при написании короткого алгоритма для следующей задачи.

Задача 1. Напишите на одном из языков программирование алгоритм, который выводит квадраты чисел от 1 до 10.

Решение.

Шаг 1. Необходимо дать программе название.

Шаг 2. Поскольку на вход числа не подаются, тип указывается в зависимости от данных, которые изначально находятся в программе. В данном случае – это целые числа.

Шаг 3. Запись блока с командами алгоритма.

Шаг 4. Перебор последовательности чисел осуществляется в цикле for, в котором счетчик i пробегает значения от 1 до 10, а расчет и вывод квадратов осуществляется в процедуре write.

Решение задач с использованием операторов while, repeat, for

Задача 1 Разработать алгоритм программы, которая выведет таблицу умножения чисел от 1 до 10 на 9.

Решение

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

Шаг 1. Нужно назвать программу.

Шаг 2. Так как пользователь не вводит никаких данных, то их можно ввести в сам код программы. Тип используемых данных в данном случае – это integer.

Шаг 3. Написание команд. Изначально нужно сделать так, чтобы программа вывела название того, для чего она предназначена. В данной задаче это «Таблица умножения на 9».

Шаг 4. Запись цикла for. С помощью него программа будет последовательно умножать числа от 1 до 10 на 9 и составлять таблицу умножения путём вывода каждого значения по схеме «9x, i, =, p», где i – умножаемое на 9 число, p – результат произведения 9 и i.

Шаг 6. Программа завершает свою работу. Необходимо проверить правильность выведенных данных и, если это необходимо, поправить код для более корректной работы.

Источник

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

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

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

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

Многие языки программирования предоставляют разработчику средства, обеспечивающие досрочное завершение цикла (выход из него вне зависимости от истинности условия выхода).

Виды циклических алгоритмов

Безусловные циклы

В некоторых программах и линейных алгоритмах на компьютерах выход из циклов не предусмотрен логикой. Эти циклы называются безусловными (другое название — бесконечные). При написании таких алгоритмов для решения поставленных задач специальных синтаксических средств не используют (они часто и не предусмотрены). На практике вполне достаточно конструкций, которые предназначены для формирования обычных (условных) циклов. Чтобы обеспечить бесконечное повторение, проверка условия или исключается (LOOP…END LOOP, язык программирования Ада), или заменяется константным значением (while true do …, Pascal).

Теперь следует рассмотреть группу циклов с условием.

Циклический алгоритм с предусловием

При наличии предусловия цикл выполняется до тех пор, пока истинно определённое условие, которое указано перед началом. Данное условие проверяется ещё до выполнения тела, в результате чего тело алгоритма может вообще ни разу не выполнится (пример такой ситуации с нулевым количеством итераций — условие изначально ложно). Что касается применения и реализации, то во многих процедурных языках программирования такой алгоритм реализуется с помощью оператора while.

Циклический алгоритм с постусловием

В данном случае проверка условия происходит уже после выполнения тела. Это означает, что тело цикла хотя бы раз, да выполнится. В Pascal такой алгоритм реализуется посредством оператора repeat..until, в языке программирования Си — с помощью do…while.

В зависимости от языка, трактовка условий бывает разной. В том же Pascal речь идёт об условии выхода (работа линейного алгоритма завершится, когда условие истинно; «цикл до»), а в вышеупомянутом Си можно говорить об условии продолжения (цикл завершится, когда условие ложно; «цикл пока»).

Циклический алгоритм с выходом из середины

Это самая общая форма условного линейного алгоритма. Синтаксически оформляется посредством 3-х конструкций:
— начало цикла,
— конец,
— команда выхода.

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

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

Чтобы организовать выход из середины, в некоторых языках программирования необходимо использовать специальные конструкции. В Ада это LOOP…END LOOP и команда EXIT либо EXIT WHEN:

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

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

Циклический алгоритм cо счётчиком

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

Хотите знать про алгоритмы больше? Записывайтесь на специализированные курсы в OTUS!

Источник — https://dic.academic.ru/dic.nsf/ruwiki/1188296.

Источник

Алгоритм циклической структуры

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

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

Разновидности циклической структуры

Задается количество повторений

Цикл с параметром

Задается условие продолжения/окончания повторений

блок-схема

фрагмент программы

for i:=1 to 10 do

write(i, ‘ ‘);

Результат:

1 2 3 4 5 6 7 8 9 10

for k:=8 downto 1 do

write(k*k, ‘ ‘);

n:=1;

while n < 100 do

begin

write(n, ‘ ‘);

n:=n*2;

end;

Результат:

1 2 4 8 16 32 64

m:=1;

repeat

write(m, ‘ ‘);

m:=m*3;

until m > 500;

Результат:

1 3 9 27 81 243

Результат:

64 49 36 25 16 9 4 1

(В примерах фрагментов программ ключевые слова операторов цикла выделены полужирным шрифтом).

Если тело цикла состоит более чем из одной команды, в операторах for…to…do и while…do ее необходимо, как и в условном операторе, заключать в операторные скобки begin…end (см. пример цикла с предусловием).

При составлении циклического алгоритма, нужно…

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

Источник

ЛЕКЦИЯ
№ 2. Алгоритмы циклической структуры.

Цель лекции:
Приобретение навыков
построения алгоритмов циклической
структуры.

Базовая
структура цикл. Обеспечивает
многократное выполнение некоторой
совокупности действий, которая называется
телом цикла. Используется при решении
задач табулирования и построения
графиков функций, вычисления сумм и
произведений (конечных и бесконечных),
решения уравнений и т.п. Алгоритмы,
реализующие такие вычисления, называют
циклическими, а повторяющиеся участки
вычислений — циклами. Использование
циклов позволяет выполнять большие
объемы вычислений при помощи компактных
программ. Структура цикл существует в
трех вариантах: цикл с предусловием
(цикл ПОКА), цикл с постусловием (цикл
ДО) и цикл с параметром. На рисунке 10
изображен цикл с предусловием, а на
рисунке 11 – цикл с постусловием, которые
называют условными циклическими
алгоритмами

Рисунок
2.1-Цикл—ПОКА

Рисунок
2.2- Цикл-ДО

Эти циклы
взаимозаменяемы и обладают некоторыми
отличиями.

в цикле с предусловием условие проверяется
до тела цикла, в цикле с постусловием
– после тела цикла;
в цикле с постусловием тело цикла
выполняется хотя бы один раз, в цикле
с предусловием тело цикла может не
выполниться ни разу;
в цикле с предусловием проверяется
условие продолжения цикла, в цикле с
постусловием – условие выхода из цикла.

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

Кроме того, существует безусловный
циклический алгоритм (рисунок 2.3),
который удобно использовать, если
известно, сколько раз необходимо
выполнить тело цикла.

Рисунок
2.3- Цикл с параметром

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

Пример. Вычислить значения функции
у = f(x) некоторой переменной х,
изменяющейся от начального значения
х_о до конечного x_k
с постоянным шагом h. Эта задача
реализуется с помощью цикла с заданным
количеством повторений, которое
определяется как n
=mod((x_k—x_o)/h)+1.
Процедура вычислений сводится к
следующему: вычисляется значение у
для начального значения x,
равного x₀.
Затем х увеличивается на значение
шага h, и для него вычисляется значение
у. Последний этап повторяется до
тех пор, пока х не превысит конечного
значения x_k.
(Схема алгоритма решения задачи приведена
на рисунке 2.4). Переменная х
называется параметром цикла. Назначение
блоков 1, 2 и 8 ясно из схемы алгоритма.
В блоке 3 осуществляется подготовка
цикла -присвоение начального значения
х_о параметру цикла
х. Блоки 4 и 5 представляют собой тело
цикла, т. е. участок вычислений,
повторяющихся при различных значениях
параметра цикла. В блоке 6 текущее
значение параметра цикла x
увеличивается на значение шага h.
Результат операции х+h присваивается
переменной x, предыдущее
значение х при этом стирается. В
блоке 7 проверяется условие продолжения
цикла. При выполнении условия х<=x_k
цикл повторяется, при невыполнении —
повторение цикла прекращается, т. е.
осуществляется выход из цикла.

Рисунок
2.4- Цикл с заданным числом повторений
с использованием блока условия

Рисунок
2.5- Цикл с заданным числом повторений
с использованием блока модификации

C использованием блока
модификации схема алгоритма имеет
вид, приведенный на рисунке 2.5. Блок
модификации 3 помещается в начале цикла
и выполняет те же функции, что и блоки
3, 6, 7 в схеме на рисунке 2.4. Запись х
= x_о, x_k,
h, помещенная в блоке модификации,
представляет собой заголовок цикла
и предписывает следующие действия:
«Для x, изменяющегося
от x₀ до
x_k
с шагом h, выполнить операции,
указанные в блоках, следующих за блоком
модификации, и ограниченные линией,
входящей слева в блок модификации».
Выход из цикла обозначается линией
связи, выходящей справа из блока
модификации. Если величины x₀,
x_k,
h представлены в блоке модификации
константами, например x
= 0,50,1, то при значении шага, равном
единице, его запись можно опустить:
х=0, 50

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

Рассмотрим использование алгоритмов
циклической структуры на конкретных
примерах.

Пример 1. Найти наибольший общий
делитель (НОД) двух натуральных чисел
А и В. Входные данные: А и В. Выходные
данные: А – НОД.

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

В блок–схеме решения задачи, представленной
на рис. 2.6, для решения поставленной
задачи используется цикл с предусловием,
то есть тело цикла повторяется до тех
пор, пока А не равно В.

Рисунок
2.6-Поиск наибольшего общего делителя
двух чисел

Рисунок
2.6 — Поиск наибольшего общего делителя
двух чисел

Пример 2. Вводится последовательность
чисел, 0 – конец последовательности.
Определить, содержит ли последовательность
хотя бы два равных соседних числа.

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

Входные данные: X₀ – текущий
член последовательности, X₁ –
следующий член последовательности.

Выходные данные: сообщение о наличии
в последовательности двух равных
соседних элементов.

Вспомогательные переменные: F_l
– логическая переменная, сохраняет
значение «истина», если в последовательности
есть равные рядом стоящие члены и «ложь»
— иначе.

Блок–схема решения задачи приведена
на рисунке. 2.7. Применение здесь цикла
с постусловием обосновано тем, что
необходимо вначале сравнить два
элемента последовательности, а затем
принять решение об окончании цикла.

Пример 3.Вычислить факториал числа
N (N!=1*2*3 …*N).

Входные данные: N– целое число, факториал
которого необходимо вычислить.

Выходные данные: factorial– значение
факториала числа N, произведение чисел
от 1 до N, целое число.

Промежуточные данные: i– целочисленная
переменная, принимающая значения от 2
до N с шагом 1, параметр цикла. Блок-схема
приведена на рисунке 2.8.

Рисунок
2.8 — Вычисление факториала

Итак, вводится число N. Переменной
factorial, предназначенной для хранения
значения произведения последовательности
чисел, присваивается начальное значение,
равное единице. Затем организуется
цикл, параметром которого выступает
переменная i. Если значение параметра
цикла меньше или равно N, то выполняется
оператор тела цикла, в котором из участка
памяти с именем factorial считывается
предыдущее значение произведения,
умножается на текущее значение параметра
цикла, а результат снова помещается
участок памяти с именем factorial. Когда
параметр i становится больше N, цикл
заканчивается, и на печать выводится
значение переменой factorial, которая была
вычислена в теле цикла.

Пример 4.
Вычислить aⁿ(n>0).

Входные данные: a – вещественное
число, которое необходимо возвести в
целую положительную степень n.

Выходные данные: p (вещественное
число) – результат возведения вещественного
числа a в целую положительную степень
n.

Рисунок
2.9 — Возведение вещественного числа в
целую степень

Промежуточные данные: i–
целочисленная переменная, принимающая
значения от 1 до n с шагом 1, параметр
цикла. Известно, что для того, чтобы
получить целую степень n числа
a, нужно умножить его само на себя
n раз. Результат этого умножения
будет храниться в участке памяти с
именем p. При выполнении очередного
цикла из этого участка предыдущее
значение будет считываться, умножаться
на основание степени a и снова
записываться в участок памяти p.
Цикл выполняется n раз.

Пример
5.Вычислить
сумму натуральных четных чисел, не
превышающих N.

Входные данные: N – целое число.

Выходные данные: S – сумма четных чисел.

Промежуточные данные: i – переменная,
принимающая значения от 2 до N с шагом
2, следовательно, также имеет целочисленное
значение.

Рисунок
2.10 — Вычисление суммы четных, натуральных
чисел

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

Пример 6. Дано натуральное число
N. Определить К – количество делителей

этого числа, не превышающих его (N=12, его
делители 1, 2, 3, 4, 6, K=5).

Входные данные: N – целое число.

Выходные данные: целое число K – количество
делителей N.

Промежуточные данные: i – параметр
цикла, возможные делители числа N.

Рисунок
2.11 — Определение количества делителей
натурального числа

В блок-схеме, изображенной на
рисунке 2.11, реализован следующий
алгоритм: в переменную K, предназначенную
для подсчета количества делителей
заданного числа, помещается значение,
которое не влияло бы на результат, т.е.
нуль. Далее организовывается цикл, в
котором изменяющийся параметр i
выполняет роль возможных делителей
числа N. Если заданное число делится
нацело на параметр цикла, это означает,
что i является делителем N, и значение
переменной K следует увеличить на
единицу. Цикл необходимо повторить N/2
раз.

Пример 7.Дано натуральное число N.
Определить, является ли оно простым.
Натуральное число N называется простым,
если оно делится нацело без остатка
только на единицу и N. Число 13 – простое,
так как делится только на 1 и 13, N=12 не
является простым, так как делится на 1,
2, 3, 4, 6 и 12.

Входные данные: N – целое число. Выходные
данные: сообщение.

Промежуточные данные: i – параметр
цикла, возможные делители числа N.

Рисунок 2.12 —
Определение простого числа

Алгоритм решения этой задачи (рисунок
2.12) заключается в том, что число N делится
на параметр цикла i, изменяющийся
в диапазоне от 2 до N/2. Если среди
значений параметра не найдется ни
одного числа, делящего заданное
число нацело, то N – простое число, иначе
оно таковым не является. Обратите
внимание на то, что в алгоритме
предусмотрено два выхода из цикла.
Первый естественный, при исчерпании
всех значений параметра, а второй —
досрочный. Нет смысла продолжать
цикл, если будет найден хотя бы один
делитель из указанной области изменения
параметра.

Пример 8. Вычислить значения
функции

используя рекуррентную
(k=1,2,3,…) формулу. Вычисления
прекратить при выполнении условия

Определить количество итераций.
Начальные значения параметров равны
U₁=1; x=5.5; точность ε принять
равной 10^-4.

Входные данные: U – начальное приближение,
х, E – точность (ε).

Выходные данные: y — значение вычисленной
функции, k — количество итераций.

Рисунок
2.13 — Вычисление суммы значений функции
с заданной точностью

Пример 9. Дано натуральное число N.
Определить самую большую цифру и ее
позицию в числе (N=573863, наибольшей
является цифра 8, ее позиция –
четвертая слева).

Входные данные: N – целое число.

Выходные данные: max – значение наибольшей
цифры в числе, pos – позиция этой цифры
в числе.

Рисунок 2.14 —
Определение количества цифр в числе

Промежуточные данные: i – параметр
цикла, kol – количество цифр в числе, M –
переменная для временного хранения
значения N.

Рисунок2.15
— Определение максимальной цифры в
числе и ее позиции

Разобьем решение этой задачи на два
этапа. Вначале найдем количество цифр
в заданном числе (рисунок 2.14), а затем
определим наибольшую цифру и ее позицию
(рисунок 2.15). Для того, чтобы подсчитать
количество цифр в числе, необходимо
определить, сколько раз заданное
число можно разделить на десять
нацело. Если цифры числа известны,
определить наибольшую из них не
составит труда. Алгоритм поиска
максимального значения в некоторой
последовательности цифр заключается
в следующем. В ячейку, в которой будет
храниться максимальный элемент (max),
записывают значение, меньшее любого из
элементов последовательности (в нашем
случае max=-1, так как цифры числа находятся
в диапазоне от 0 до 9). Затем сравнивают
элементы последовательности со
значением ячейки max, если найдется
элемент, превышающий значение
предполагаемого максимума, то ячейке
max необходимо присвоить значение
этого элемента и, соответственно,
запомнить его номер в последовательности
(в нашем случае переменной pos присваивается
значение параметра цикла i).

В алгоритме поиска минимума вначале
в переменную min записываем значение,
заранее большее любого элемента
последовательности. Затем все элементы
последовательности сравниваем с
min, если встретится значение меньшее,
чем min, переписываем его в переменную
min

Задания по циклическим алгоритмам

Вариант 1

1.
Hе используя стандаpтные функции (за
исключением abs), вычислить сумму
следующего pяда с заданной точностью
Е>0 (Е вводится с клавиатуры):

2.
Даны целые числа K и N (N >
0). Вывести N раз число K.

3. Даны положительные
числа A и B (A > B). На
отрезке длины A размещено максимально
возможное количество отрезков длины B
(без наложений). Не используя операции
умножения и деления, найти длину незанятой
части отрезка A.

Вариант 2

1.
Hе используя стандаpтные функции,
вычислить сумму n первых членов следующего
pяда (n вводится с клавиатуры):
.

2. Даны два целых числа
A и B (A < B). Вывести в
порядке возрастания все целые числа,
расположенные между A и B (включая
сами числа A и B), а также количество
N этих чисел.

3. Даны положительные
числа A и B (A > B). На
отрезке длины A размещено максимально
возможное количество отрезков длины B
(без наложений). Не используя операции
умножения и деления, найти количество
отрезков B, размещенных на отрезке
A.

Вариант 3

1
Дано действительное число х. Hе
используя стандаpтные функции (за
исключением abs),вычислить сумму следующего
pяда с заданной точностью Е>0 (Е, x
вводятся с клавиатуры):
.

2.
Даны два целых числа A и B (A
< B). Вывести в порядке убывания все
целые числа, расположенные между A
и B (не включая числа A и B), а
также количество N этих чисел.

3. Даны целые положительные
числа N и K. Используя только
операции сложения и вычитания, найти
частное от деления нацело N на K,
а также остаток от этого деления.

Вариант 4

1.
Дано действительное число х. Hе
используя стандаpтные функции, вычислить
сумму n первых членов следующего pяда
(n, х вводятся с клавиатуры):
.

2. Дано вещественное
число — цена 1 кг конфет. Вывести стоимость
1, 2, … , 10 кг конфет.

3. Дано целое число N
(> 0). Если оно является степенью числа
3, то вывести True, если не является —
вывести False.

Вариант 5

1
Дано действительное число х. Hе
используя стандаpтные функции (за
исключением abs), вычислить сумму следующего
pяда с заданной точностью Е>0 (Е, x
вводятся с клавиатуры):
.

2.
Дано вещественное число — цена 1 кг
конфет. Вывести стоимость 0.1, 0.2, … , 1 кг
конфет.

3. Дано целое число N
(> 0), являющееся некоторой степенью
числа 2: N = 2^K. Найти целое
число K — показатель этой степени.

Вариант 6

2. Дано вещественное
число — цена 1 кг конфет. Вывести стоимость
1.2, 1.4, … , 2 кг конфет.

3. Дано целое число N
(> 0). Найти наименьшее целое положительное
число K, квадрат которого превосходит
N: K² > N. Функцию
извлечения квадратного корня не
использовать.

Вариант 7

1
Дано действительное число х. Hе
используя стандаpтные функции (за
исключением abs), вычислить сумму следующего
pяда с заданной точностью Е>0 (Е, x
вводятся с клавиатуры):
.

.2.
Даны два целых числа A и B (A
< B). Найти сумму всех целых чисел
от A до B включительно.

3. Дано целое число N
(> 0). Найти наибольшее целое число K,
квадрат которого не превосходит N:
K²  N.
Функцию извлечения квадратного корня
не использовать.

Вариант 8

2. Даны два целых числа
A и B (A < B). Найти
произведение всех целых чисел от A
до B включительно.

3. Дано целое число N
(> 1). Найти наименьшее целое число K,
при котором выполняется неравенство
3^K > N.

Вариант 9

1.
Hе используя стандаpтные функции,
вычислить сумму n первых членов следующего
pяда (n вводится с клавиатуры):
.

2. Даны два целых числа
A и B (A < B). Найти сумму
квадратов всех целых чисел от A до
B включительно.

3. Дано целое число N
(> 1). Найти наибольшее целое число K,
при котором выполняется неравенство
3^K < N.

Вариант 10

1.
Дано натуральное число. Получить число,
получаемое при прочтении его цифр справа
налево.

2.
Дано натуральное число n и
действительное число а. Вычислить n
первых членов следующего pяда (n, a вводится
с клавиатуры):

3. Начальный вклад в
банке равен 1000 руб. Через каждый месяц
размер вклада увеличивается на P
процентов от имеющейся суммы (P —
вещественное число, 0 < P < 25). По
данному P определить, через сколько
месяцев размер вклада превысит 1100 руб.,
и вывести найденное количество месяцев
K (целое число) и итоговый размер
вклада S (вещественное число).

Вариант 11

1.
Дано действительное число a.
Вычислить сумму следующего pяда с
заданной точностью Е>0 (Е, a вводятся
с клавиатуры):

2. Дано целое число N
(> 0). Найти сумму

N² + (N + 1)² + (N + 2)²
+ … + (2·N)²

(целое число).

3. Даны положительные
числа A, B, C. На прямоугольнике
размера A  B
размещено максимально возможное
количество квадратов со стороной C
(без наложений). Найти количество
квадратов, размещенных на прямоугольнике.

Вариант 12

Hе используя стандаpтные функции (за
исключением abs), вычислить сумму
следующего pяда с заданной точностью
Е>0 (Е вводится с клавиатуры):.

2. Дано целое число N
(> 0). Найти квадрат данного числа,
используя для его вычисления следующую
формулу:

N² = 1 + 3 + 5 + … + (2·N – 1).

После добавления к сумме каждого
слагаемого выводить текущее значение
суммы (в результате будут выведены
квадраты всех целых чисел от 1 до N).

3.
Найти 10 первых натуральных чисел,
оканчивающихся на цифру «7», кратных
числу 9 и больших 100.

Вариант 13

1.
Hе используя стандаpтные функции,
вычислить сумму n первых членов следующего
pяда (n вводится с клавиатуры):.

2. Дано вещественное
число A и целое число N (> 0).
Используя один цикл, вывести все целые
степени числа A от 1 до N.

3. Дано целое число N
(> 0). С помощью операций деления нацело
и взятия остатка от деления определить,
имеются ли в записи числа N нечетные
цифры. Если имеются, то вывести True, если
нет — вывести False.

Вариант 14

1.
Hе используя стандаpтные функции
(за исключением abs), вычислить сумму
следующего pяда с заданной точностью
Е>0 (Е вводится с клавиатуры):.

2. Дано вещественное
число A и целое число N (> 0).
Используя один цикл, найти сумму

1 + A + A² + A³ + … +
A^N.

3. Дано целое число N
(> 0). Используя операции деления нацело
и взятия остатка от деления, вывести
все его цифры, начиная с самой правой
(разряда единиц).

Вариант 15

Hе используя стандаpтные функции,
вычислить сумму n первых членов следующего
pяда (n вводится с клавиатуры):.

2.
Дано вещественное число A и целое
число N (> 0). Найти A в степени
N:

A^N = A·A· … ·A

(числа A перемножаются N раз).

3. Дано целое число N
(> 1). Если оно является простым, то
есть не имеет положительных делителей,
кроме 1 и самого себя, то вывести True,
иначе вывести False.

Вариант 16

1.
Дано действительное число x. Hе
используя стандаpтные функции (за
исключением abs и sin), вычислить сумму
следующего pяда с заданной точностью
Е>0 (Е,x вводятся с клавиатуры):.

2. Дано вещественное
число A и целое число N (> 0).
Используя один цикл, найти значение
выражения

1 – A + A² – A³ + …
+ (–1)^N·A^N.

Условный оператор не использовать.

3. Спортсмен-лыжник
начал тренировки, пробежав в первый
день 10 км. Каждый следующий день он
увеличивал длину пробега на P
процентов от пробега предыдущего дня
(P — вещественное, 0 < P < 50). По
данному P определить, после какого
дня суммарный пробег лыжника за все дни
превысит 200 км, и вывести найденное
количество дней K (целое) и суммарный
пробег S (вещественное число).

Вариант 17

1.
Дано действительное число x. Hе
используя стандаpтные функции (за
исключением abs и sin), вычислить сумму n
первых слагаемых следующего pяда (x
вводятся с клавиатуры): .

2. Дана последовательность целых чисел,
оканчивающаяся числом 9999. Количество
чисел в последовательности не меньше
двух. Определить, есть ли в ней хотя бы
одна пара «соседних» четных чисел. В
случае положительного ответа определить
их порядковые номера.
3.
Дано целое число N (> 0). С помощью
операций деления нацело и взятия остатка
от деления определить, имеется ли в
записи числа N цифра «2». Если имеется,
то вывести True, если нет — вывести False.

Вариант 18

1. Дано действительное число x. Hе используя
стандаpтные функции (за исключением abs
и cos), вычислить сумму следующего pяда с
заданной точностью Е>0 (Е,x вводятся с
клавиатуры):.

2. Дано целое число N
(> 1) и две вещественные точки на числовой
оси: A, B (A < B). Отрезок
[A, B] разбит на N равных
отрезков. Вывести H — длину каждого
отрезка, а также набор точек

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

Вариант 19

1. Дано действительное число x. Hе используя
стандаpтные функции (за исключением abs
и cos), вычислить сумму n первых слагаемых
следующего pяда (x вводятся с клавиатуры):

2. Дано целое число N
(> 0). Используя операции деления нацело
и взятия остатка от деления, найти
количество и сумму его цифр.

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

Вариант 20

1.
Дано натуральное число. Выяснить,
является ли оно палиндромом («перевертышем»),
т.е. числом, десятичная запись которого
читается одинаково слева направо и
справа налево

2. Hе используя
cтандаpтные функции, вычислить сумму n
первых членов следующего pяда (n вводится
с клавиатуры):
.

3. Дана последовательность ненулевых
целых чисел, оканчивающаяся нулем.
Определить, сколько раз в этой
последовательности меняется знак.
(Например, в последовательности 10, –4,
12, 56, –4 знак меняется 3 раза.)

Источник

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

Содержание

1 Определения
2 Виды циклов
- 2.1 Безусловные циклы
- 2.2 Цикл с предусловием
- 2.3 Цикл с постусловием
- 2.4 Цикл с выходом из середины
- 2.5 Цикл cо счётчиком
- 2.6 Вложенные циклы
- 2.7 Совместный цикл
3 Циклы с несколькими охраняемыми ветвями
- 3.1 Цикл Дейкстры
- 3.2 Цикл-‘паук’
4 Интересные факты
5 См. также
6 Методы оптимизации циклов
7 Ссылки

Определения

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

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

Виды циклов

Безусловные циклы

Иногда в программах используются циклы, выход из которых не предусмотрен логикой программы. Такие циклы называются безусловными, или бесконечными. Специальных синтаксических средств для создания бесконечных циклов, ввиду их нетипичности, языки программирования не предусматривают, поэтому такие циклы создаются с помощью конструкций, предназначенных для создания обычных (или условных) циклов. Для обеспечения бесконечного повторения проверка условия в таком цикле либо отсутствует (если позволяет синтаксис, как, например, в цикле LOOP…END LOOP языка Ада), либо заменяется константным значением (while true do … в Паскале).

Цикл с предусловием

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

Цикл с постусловием

Цикл с постусловием — цикл, в котором условие проверяется после выполнения тела цикла. Отсюда следует, что тело всегда выполняется хотя бы один раз. В языке Паскаль этот цикл реализует оператор repeat..until; в Си — do…while.

В трактовке условия цикла с постусловием в разных языках есть различия. В Паскале и языках, произошедших от него, условие такого цикла трактуется как условие выхода (цикл завершается, когда условие истинно, в русской терминологии такие циклы называют ещё «цикл до»), а в Си и его потомках — как условие продолжения (цикл завершается, когда условие ложно, такие циклы иногда называют «цикл пока»)…..

Цикл с выходом из середины

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

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

Легко видеть, что с помощью цикла с выходом из середины можно легко смоделировать и цикл с предусловием (разместив команду выхода в начале тела цикла), и цикл с постусловием (разместив команду выхода в конце тела цикла).

Часть языков программирования содержат специальные конструкции для организации цикла с выходом из середины. Так, в языке Ада для этого используется конструкция LOOP…END LOOP и команда выхода EXIT или EXIT WHEN:

LOOP
  ... Часть тела цикла
  EXIT WHEN <условие выхода>;
  ... Часть тела цикла
  IF <условие выхода> THEN 
    EXIT; 
  END;
  ... Часть тела цикла
END LOOP:

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

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

Цикл cо счётчиком

Цикл со счётчиком — цикл, в котором некоторая переменная изменяет своё значение от заданного начального значения до конечного значения с некоторым шагом, и для каждого значения этой переменной тело цикла выполняется один раз. В большинстве процедурных языков программирования реализуется оператором for, в котором указывается счётчик (так называемая «переменная цикла»), требуемое количество проходов (или граничное значение счётчика) и, возможно, шаг, с которым изменяется счётчик. Например, в языке Оберон-2 такой цикл имеет вид:

 FOR v := b TO e BY s DO
   ... тело цикла
 END

(здесь v — счётчик, b — начальное значение счётчика, e — граничное значение счётчика, s — шаг).

Неоднозначен вопрос о значении переменной по завершении цикла, в котором эта переменная использовалась как счётчик. Например, если в программе на языке Паскаль встретится конструкция вида:

i := 100;
for i := 0 to 9 do begin
  ... тело цикла
end;
k := i;

возникает вопрос: какое значение будет в итоге присвоено переменной k: 9, 10, 100, может быть, какое-то другое? А если цикл завершится досрочно? Ответы зависят от того, увеличивается ли значение счётчика после последней итерации и не изменяет ли транслятор это значение дополнительно. Ещё один вопрос: что будет, если внутри цикла счётчику будет явно присвоено новое значение? Различные языки программирования решают данные вопросы по-разному. В некоторых поведение счётчика чётко регламентировано. В других, например, в том же Паскале, стандарт языка не определяет ни конечного значения счётчика, ни последствий его явного изменения в цикле, но не рекомендует изменять счётчик явно и использовать его по завершении цикла без повторной инициализации. Программа на Паскале, игнорирующая эту рекомендацию, может давать разные результаты при выполнении на разных системах и использовании разных трансляторов.

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

i := 100;
for i in (0..9) loop
  ... тело цикла
end loop;
k := i;

внешне аналогичная вышеприведённому циклу на Паскале, трактуется однозначно: переменной k будет присвоено значение 100, поскольку переменная i, используемая вне данного цикла, не имеет никакого отношения к счётчику i, который создаётся и изменяется внутри цикла. Считается, что подобное обособление счётчика наиболее удобно и безопасно: не требуется отдельное описание для него и минимальна вероятность случайных ошибок, связанных со случайным разрушением внешних по отношению к циклу переменных. Если программисту требуется включить в готовый код цикл со счётчиком, то он может не проверять, существует ли переменная с именем, которое он выбрал в качестве счётчика, не добавлять описание нового счётчика в заголовок соответствующей процедуры, не пытаться использовать один из имеющихся, но в данный момент «свободных» счётчиков. Он просто пишет цикл с переменной-счётчиком, имя которой ему удобно, и может быть уверен, что никакой коллизии имён не произойдёт.

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

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

for (i = 0; i < 10; ++i)
{
  ... тело цикла 
}

фактически представляет собой другую форму записи конструкции:

i = 0;
while (i < 10)
{
  ... тело цикла 
  ++i;
}

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

Вложенные циклы

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

Полное число исполнений тела внутреннего цикла не превышает произведения числа итераций внутреннего и всех внешних циклов. Например взяв три вложенных друг в друга цикла, каждый по 10 итераций, получим 10 исполнений тела для внешнего цикла, 100 для цикла второго уровня и 1000 в самом внутреннем цикле.

Одна из проблем, связанных с вложенными циклами — организация досрочного выхода из них. Во многих языках программирования есть оператор досрочного завершения цикла (break в Си, exit в Турбо Паскале, last в Perl и т. п.), но он, как правило, обеспечивает выход только из цикла того уровня, откуда вызван. Вызов его из вложенного цикла приведёт к завершению только этого внутреннего цикла, объемлющий же цикл продолжит выполняться. Проблема может показаться надуманной, но она действительно иногда возникает при программировании сложной обработки данных, когда алгоритм требует немедленного прерывания в определённых условиях, наличие которых можно проверить только в глубоко вложенном цикле.

Решений проблемы выхода из вложенных циклов несколько.

Простейший — использовать оператор безусловного перехода goto для выхода в точку программы, непосредственно следующую за вложенным циклом. Этот вариант критикуется сторонниками структурного программирования, как и все конструкции, требующие использования goto. Некоторые языки программирования, например Modula-2, просто не имеют оператора безусловного перехода, и в них подобная конструкция невозможна.
Альтернатива — использовать штатные средства завершения циклов, в случае необходимости устанавливая специальные флаги, требующие немедленного завершения обработки. Недостаток — усложнение кода, снижение производительности без каких-либо преимуществ, кроме теоретической «правильности» из-за отказа от goto.
Размещение вложенного цикла в процедуре. Идея состоит в том, чтобы всё действие, которое может потребоваться прервать досрочно, оформить в виде отдельной процедуры, и для досрочного завершения использовать оператор выхода из процедуры (если такой есть в языке программирования). В Си, например, можно построить функцию с вложенным циклом, а выход из неё организовать с помощью оператора return. Недостаток — выделение фрагмента кода в процедуру не всегда логически обосновано, и не все языки имеют штатные средства досрочного завершения процедур.
Воспользоваться механизмом генерации и обработки исключений (исключительных ситуаций), который имеется сейчас в большинстве ЯВУ. В этом случае в нештатной ситуации код во вложенном цикле возбуждает исключение, а блок обработки исключений, в который помещён весь вложенный цикл, перехватывает и обрабатывает его. Недостаток — реализация механизма обработки исключений в большинстве случаев такова, что скорость работы программы уменьшается. Правда, в современных условиях это не особенно важно: практически потеря производительности столь мала, что имеет значение лишь для очень немногих приложений.
Наконец, существуют специальные языковые средства для выхода из вложенных циклов. Так, в языке Ада программист может пометить цикл (верхний уровень вложенного цикла) меткой, и в команде досрочного завершения цикла указать эту метку. Выход произойдёт не из текущего цикла, а из всех вложенных циклов до помеченного, включительно.

Совместный цикл

Ещё одним вариантом цикла является цикл, задающий выполнение некоторой операции для объектов из заданного множества, без явного указания порядка перечисления этих объектов. Такие циклы называются совместными (а также циклами по коллекции, циклами просмотра) и представляют собой формальную запись инструкции вида: «Выполнить операцию X для всех элементов, входящих в множество M». Совместный цикл, теоретически, никак не определяет, в каком порядке операция будет применяться к элементам множества, хотя конкретные языки программирования, разумеется, могут задавать конкретный порядок перебора элементов. Произвольность даёт возможность оптимизации исполнения цикла за счёт организации доступа не в заданном программистом, а в наиболее выгодном порядке. При наличии возможности параллельного выполнения нескольких операций возможно даже распараллеливание выполнения совместного цикла, когда одна и та же операция одновременно выполняется на разных вычислительных модулях для разных объектов, при том что логически программа остаётся последовательной.

Совместные циклы имеются в некоторых языках программирования (C#, JavaScript, Python, LISP, коллекции объектов. В определении такого цикла требуется указать только коллекцию объектов и переменную, которой в теле цикла будет присвоено значение обрабатываемого в данный момент объекта (или ссылка на него). Синтаксис в различных языках программирования синтаксис оператора различен:

C#:

foreach (type item in set) 
{
    //использование item
}

foreach (@set) 
{
    #использование $_
}

Источник

Основные алгоритмические конструкции

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

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

Линейный алгоритм — набор команд (указаний), выполняемых последовательно друг за другом.

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

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

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

В алгебраической форме это выглядит следующим образом:

Построим алгоритм деления дробей для ЭВМ. В этом алгоритме сохраним те же обозначения для переменных, которые использованы в записанной выше формуле. Исходными данными являются целочисленные переменные а, Ь, с, d. Результатом — также целые величины m и n. Блок-схема и текст алгоритма на языке программирования (ЯП) Kotlin приведены ниже.

namespace oap
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter a, b, c, d: ");
            var a = int.Parse(Console.ReadLine());
            var b = int.Parse(Console.ReadLine());
            var c = int.Parse(Console.ReadLine());
            var d = int.Parse(Console.ReadLine());
            var m = a * d;
            var n = b * c;
            Console.WriteLine($"m={m}, n={n}");
        }
    }
}

Формат команды присваивания следующий:

Знак «=» нужно читать как «присвоить».

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

Вычисляется выражение.
Полученное значение присваивается переменной.

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

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

В приведенном алгоритме присутствуют команды ввода:

var a = int.Parse(Console.ReadLine());
var b = int.Parse(Console.ReadLine());
var c = int.Parse(Console.ReadLine());
var d = int.Parse(Console.ReadLine());

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

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

Console.WriteLine($"m={m}, n={n}");

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

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

Рассмотрим последовательное выполнение четырех команд присваивания, в которых участвуют две переменные величины a и b.

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

Команда	a	b
a=1	1	—
b=a*2	1	2
a=b	2	2
b=a+b	2	4

Этот пример иллюстрирует три основных свойства команды присваивания:

пока переменной не присвоено значение, она остается неопределенной;
значение, присвоенное переменной, сохраняется в ней вплоть до выполнения следующей команды присваивания этой переменной;
новое значение, присваиваемое переменной, заменяет ее предыдущее значение.

Рассмотрим один очень полезный алгоритм, который приходится часто использовать при программировании. Даны две величины: Х и Y. Требуется произвести между ними обмен значениями. Например, если первоначально было Х=1, Y=2, то после обмена должно стать: Х=2, Y=1.

Хорошей моделью для решения этой задачи является следующая ситуация: имеются два стакана — один с молоком, другой с водой. Требуется произвести обмен их содержимым. Всякому ясно, что в этом случае нужен дополнительный третий пустой стакан. Последовательность действий будет следующей: 1) перелить из первого стакана в третий; 2) перелить из второго в первый;
3) перелить из третьего во второй. Цель достигнута!

По аналогии для обмена значениями двух переменных нужна третья дополнительная переменная. Назовем ее Z. Тогда задача обмена решается последовательным выполнением трех команд присваивания:

Команда	X	Y	Z
ввод X, Y	1	2	—
Z = X	1	2	1
X = Y	2	2	1
Y = Z	2	1	1

Аналогия со стаканами не совсем точна в том смысле, что при переливании из одного стакана в другой первый становится пустым. В результате же присваивания (Х = Y) переменная, стоящая справа (Y), сохраняет свое значение.

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

При описании алгоритмов в блок-схемах типы, как правило, не указываются (но подразумеваются). В алгоритмах для всех переменных типы указываются явно. В них используются следующие обозначения типов: Int — целый тип, Float — вещественный тип, String — символьный (литерный) тип, Boolean — логический тип. В алгоритме для деления дробей для всех переменных указан тип Int.

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

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

Составим алгоритм решения квадратного уравнения: ax²+bx+c=0

Задача хорошо знакома из математики. Исходными данными здесь являются коэффициенты а, b, с. Решением в общем случае будут два корня х1 и х2, которые вычисляются по формуле:

namespace oap
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Введите a, b, c: ");
            var a = int.Parse(Console.ReadLine());
            var b = int.Parse(Console.ReadLine());
            var c = int.Parse(Console.ReadLine());
            var d = b * b - 4 * a * c;
            var x1 = (-b + Math.Sqrt(d)) / (2 * a);
            var x2 = (-b - Math.Sqrt(d)) / (2 * a);
            Console.WriteLine($"x1={x1}, x2={x2}");
        }
    }
}

Введите a, b, c:
3
2
1
x1=NaN, x2=NaN

Слабость такого алгоритма видна невооруженным глазом. Он не обладает важнейшим свойством, предъявляемым к качественным алгоритмам, — универсальностью по отношению к исходным данным. Какими бы ни были значения исходных данных, алгоритм должен приводить к определенному результату и завершать работу. Результатом может быть число, но может быть и сообщение о том, что при определенных данных задача решения не имеет. Недопустимы остановки в середине алгоритма из-за невозможности выполнить какую-то операцию. Упомянутое свойство называют результативностью алгоритма (в любом случае должен быть получен какой-то результат).

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

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

если а = 0, b = 0, с = 0, то любое х — решение уравнения;
если а = 0, b = 0, с <> О, то уравнение действительных решений не имеет;
если а = 0, b <> О, то это линейное уравнение, которое имеет одно решение х = -c/b;
если а<>0 и d=b²-4ac >= 0, то уравнение имеет два вещественных корня (формулы приведены выше);
если a<>0 и d<0, то уравнение не имеет вещественных корней.

Этот же алгоритм на Kotlin:

fun main(){
    println("Введите a, b, c:")
    val a = readLine()!!.toInt()
    val b = readLine()!!.toInt()
    val c = readLine()!!.toInt()

    var x1: Float

    if(a==0){
        if(b==0){
            if(c==0) println("любое X")
            else println("нет решений")
        } else {
            x1 = -c.toFloat()/b
            println("X=$x1")
        }
    } else {
        val d = b*b-4*a*c
        if(d<0) println("нет вещественных корней")
        else{
            x1 = (-b+sqrt(d.toFloat()))/(2*a)
            val x2 = (-b-sqrt(d.toFloat()))/(2*a)
            println("x1=$x1, x2=$x2")
        }
    }
}

В этом алгоритме многократно использована структурная команда ветвления. Общий вид команды ветвления в блок-схемах и на ЯП следующий:

if (условие) {серия1}
else {серия2}

Вначале проверяется условие (вычисляется отношение, логическое выражение). Если условие истинно, то выполняется серия 1 — последовательность команд, на которую указывает стрелка с надписью «да» (положительная ветвь). В противном случае выполняется серия 2 (отрицательная ветвь). В языке Kotlin условие записывается после служебного слова if, положительная ветвь — сразу после условия, отрицательная — после слова else.

Если на ветвях одного ветвления содержатся другие ветвления, то такой алгоритм имеет структуру вложенных ветвлений. Именно такую структуру имеет алгоритм «Корни квадратного уравнения».

Рассмотрим следующую задачу: дано целое положительное число n. Требуется вычислить n! (n-факториал). Вспомним определение факториала:

Ниже приведена блок-схема алгоритма. В нем используются три переменные целого типа: n — аргумент; i — промежуточная переменная; F — результат. Для проверки правильности алгоритма построена трассировочная таблица. В такой таблице для конкретных значений исходных данных по шагам прослеживается изменение переменных, входящих в алгоритм. Данная таблица составлена для случая п = 3.

Шаг	n	F	i	Условие
1	3
2		1
3			1
4				1<=3, да
5		1
6			2
7				2<=3, да
8		2
9			3
10				3<=3, да
11		6
12			4
13				4<=3, нет
14		вывод

Трассировка доказывает правильность алгоритма. Теперь запишем этот алгоритм на ЯП.

fun main(){
    println("Введите n:")
    val n = readLine()!!.toInt()
    var F = 1
    var i = 1
    while (i<=n){
        F *= i  // F = F*i
        i++     // i = i+1
    }
    println("F=$F")
}

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

while (условие) {
  //серия
}

Выполнение серии команд (тела цикла) повторяется, пока условие цикла истинно. Когда условие становится ложным, цикл заканчивает выполнение.

Цикл с предусловием — это основная, но не единственная форма организации циклических алгоритмов. Другим вариантом является цикл с постусловием. Вернемся к алгоритму решения квадратного уравнения. К нему можно подойти с такой позиции:

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

fun main(){
    var a: Int
    do {
        println("Введите a:")
        a = readLine()!!.toInt()
    } while(a!=0)

    val d = b*b-4*a*c
    if(d<0) println("нет вещественных корней")
    else{
        val x1 = (-b+sqrt(d.toFloat()))/(2*a)
        val x2 = (-b-sqrt(d.toFloat()))/(2*a)
        println("x1=$x1, x2=$x2")
    }
}

В общем виде структурная команда цикл с постусловием или цикл — до представляется так:

do {
  //серия
} while (условие)

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

Составим алгоритм решения следующей задачи: даны два натуральных числа М и N. Требуется вычислить их наибольший общий делитель — НОД(M, N).

Эта задача решается с помощью метода, известного под названием алгоритма Евклида. Его идея основана на том свойстве, что если M>N, то НОД(М, N) = НОД(М-N,N). Другой факт, лежащий в основе алгоритма, тривиален — НОД(М, М) = М. Для «ручного» выполнения этот алгоритм можно описать в форме следующей инструкции:

Если числа равны, то взять их общее значение в качестве ответа; в противном случае продолжить выполнение алгоритма
Определить большее из чисел
Заменить большее число разностью большего и меньшего значений
Вернуться к выполнению пункта 1

fun main(){
    println("Введите m, n: ")
    var m = readLine()!!.toInt()
    var n = readLine()!!.toInt()
    while (m!=n){
        if(m>n) m = m-n
        else n = n-m
    }
    println("НОД = $m")
}

Алгоритм имеет структуру цикла с вложенным ветвлением. Проделайте самостоятельно трассировку этого алгоритма для случая М = 18, N = 12. В результате получится НОД = 6, что, очевидно, верно.

Вспомогательные алгоритмы и процедуры

В теории алгоритмов известно понятие вспомогательного алгоритма. Вспомогательным называется алгоритм решения некоторой подзадачи из основной решаемой задачи. В таком случае алгоритм решения исходной задачи называется основным алгоритмом.

В качестве примера рассмотрим следующую задачу: требуется составить алгоритм вычисления степенной функции с целым показателем у = х^к, где к — целое число, х<>0. В алгебре такая функция определена следующим образом:

Для данной задачи в качестве подзадачи можно рассматривать возведение числа в целую положительную степень.

Учитывая, что 1/х^-n = (1/х)^-n, запишем основной алгоритм решения этой задачи.

fun main(){
    println("Введите x, n: ")
    var x = readLine()!!.toFloat()
    var n = readLine()!!.toInt()
    var y: Float

    if(n==0) y = 1F
    else {
        if(n>0) y = stepen(x, n)
        else y = stepen(1/x, -n)
    }
   
    println("y = $y")
}

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

В котлине вспомогательные алгоритмы оформляются в виде функций. Запишем функцию stepen.

fun stepen(x: Float, n: Int): Float {
    var res = 1F
    var i = 1
    while(i<=n){
        res = res * x
        i++
    }
    return res
}

Заголовок вспомогательного алгоритма начинается с ключевого слова fun, после которого следует имя функции, в скобках — список формальных параметров и после скобок тип результата (не обязателен). В списке параметров перечисляются переменные-аргументы с указанием их типов. Здесь x и n — формальные параметры-аргументы. Следовательно, процедура stepen производит вычисления по формуле а^к. В основном алгоритме «Степенная функция» обращение к процедуре производится путем указания ее имени с последующим в скобках списком фактических параметров. Между формальными и фактическими параметрами процедуры должны выполняться следующие правила соответствия:

по количеству (сколько формальных, столько и фактических параметров)
по последовательности (первому формальному соответствует первый фактический параметр, второму — второй и т.д.)
по типам (типы соответствующих формальных и фактических параметров должны совпадать)

Фактические параметры-аргументы могут быть выражениями соответствующего типа.

Обращение к процедуре инициирует следующие действия:

Значения параметров-аргументов присваиваются соответствующим формальным параметрам.
Выполняется тело процедуры (команды внутри процедуры).
Значение результата возвращается командой return, и происходит переход к выполнению следующей команды основного алгоритма.

В функции stepen нет команд ввода исходных данных и вывода результатов. Здесь присваивание начальных значений аргументам (x, n) производится через передачу параметров-аргументов. А получение результата происходит командой return. Таким образом, передача значений параметров процедур — это третий способ присваивания (наряду с командой присваивания и командой ввода).

Использование процедур позволяет строить сложные алгоритмы методом последовательной детализации.

Программы для графического отображения алгоритмов

https://draw.io (онлайн)
Microsoft Visio
Dia (бесплатная)

КОНТРОЛЬНЫЕ ВОПРОСЫ

Линейный алгоритм
Разветвляющийся алгоритм
Циклический алгоритм
Вспомогательные алгоритмы и процедуры

Источник

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

Ход урока

I. Актуализация знаний

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

II. Теоретический материал урока

Большинство практических задач требует многократного повторения одних и тех же действий, т. е. повторного использования одного или нескольких операторов. (Презентация)

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

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

Циклом называется многократно исполняемый участок алгоритма (программы). Соответственно циклический алгоритм — это алгоритм, содержащий циклы.

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

Существует 3 типа циклических структур:

Цикл с предусловием;
Цикл с послеусловием;
Цикл с параметром;

Иначе данные структуры называют циклами типа «Пока», «До», «Для».

Графическая форма записи данных алгоритмических структур:

Цикл с предусловием (иначе цикл пока) имеет вид:

Форматы записи операторов алгоритма	Блок-схема	Форматы записи операторов на Паскале
Пока (условие) нц серия команд кц		while условие do begin серия команд; end;

где

условие – выражение логического типа.

Цикл может не выполняться ни разу, если значение логического выражения сразу же оказывается ложь.

Серия команд, находящихся между begin и end, выполняются до тех пор, пока условие истинно.

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

Цикл с постусловием (иначе цикл до) имеет вид:

Форматы записи операторов алгоритма	Блок-схема	Форматы записи операторов на Паскале
В алгоритмическом языке нет команды которая могла бы описать данную структуру, но ее можно выразить с помощью других команд (Например, ветвления).		*repeat* серия команд *until* условие

где

условие – выражение логического типа.

Обратите внимание:

Последовательность инструкций между repeat и until всегда будет выполнено хотя бы один раз;

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

Инструкция repeat, как и инструкция while, используется в программе, если надо провести некоторые повторяющиеся вычисления (цикл), однако число повторов заранее не известно и определяется самим ходом вычисления.

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

Форматы записи операторов алгоритма	Блок-схема	Форматы записи операторов на Паскале
Для i от а до b шаг h делай Нц Серия команд кц		h = +1 for i:= a to b do begin серия команд end; h = -1 for i:= b downto a do begin Cерия команд; end;

где

i – параметр цикла;
a – начальное значение цикла;
b – конечное значение цикла;
h – шаг изменения параметра.

Структура данного цикла иначе называют циклом i раз.

Эта команда выполняется таким образом: параметру i присваивается начальное значение а, сравнивается с конечным значением b и, если оно меньше или равно конечному значению b, выполняется серия команд. Параметру присваивается значение предыдущего, увеличенного на величину h – шага изменения параметра и вновь сравнивается с конечным значением b.

На языке программирования Паскаль шаг изменения параметра может быть равным одному или минус одному.

Если между begin и end находится только один оператор, то операторные скобки можно не писать. Это правило работает для цикла типа «Пока» и «Для».

Рассмотрим пример решения задач с использованием данных структур

Пример.

Вычислить произведение чисел от 1 до 5 используя различные варианты цикла

Математическая модель:

Р= 1· 2· 3· 4· 5=120

Составим алгоритм в виде блок-схемы.

Для проверки правильности алгоритма заполним трассировочную таблицу.

Шаг	Операция	Р	i	Проверка условия
1	P:=1	1
2	i:=1;	1	1
3	i<=5 P:=P*I i:=i+1	1	1	1<=5, да (истина)
4	i<=5 P:=P*I i:=i+1	2	2	2<=5, да (истина)
5	i<=5 P:=P*I i:=i+1	6	3	3<=5, да (истина)
6	i<=5 P:=P*I i:=i+1	24	4	4<=5, да (истина)
7	i<=5 P:=P*I i:=i+1	120	5	5<=5, да (истина)
8	i<=5 P:=P*I i:=i+1			6<=5, нет (ложь)

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

Шаг первый: Р присваивается значение один.

Шаг второй: i присваивается значение один.

Шаг третий: при i равном единице проверяем условие один меньше или равен пяти, да, условие истинно, значит Р присваивается значение один умноженное на один, будет два. Для i: один плюс один, будет два.

Шаг четвертый: при i равном двум проверяем условие два меньше или равен пяти, да, условие истинно, значит Р присваивается значение 2 умноженное на один, будет 2. Для i: два плюс один, будет три.

Шаг пятый: при i равном трем проверяем условие три меньше или равен пяти, да, условие истинно, значит Р присваивается значение два умноженное на три, будет шесть. Для i: три плюс один, будет четыре.

Шаг шестой: при i равном четырем проверяем условие четыре меньше или равен пяти, да, условие истинно, значит Р присваивается значение шесть умноженное на четыре, будет двадцать четыре. Для i: четыре плюс один, будет пять.

Шаг седьмой: при i равном пяти проверяем условие пять меньше или равен пяти, да ,условие истинно, значит Р присваивается значение двадцать четыре умноженное на пять, будет сто двадцать. Для i: пять плюс один, будет шесть.

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

Program Pr1;
Var i: integer;
Begin
P:=1;
i:=1;
While i<=5 do
       begin
           P:=P*i;
           i:=i+1;
       end;
Write (‘P=’, P);
end.

Для цикла с постусловием построим блок-схему и трассировочную таблицу. (слайд16)

В результате получаем последнее значение равное сто двадцати на седьмом шаге

И для Цикла с параметром построим блок-схему и трассировочную таблицу. (слайд17)

В результате получаем последнее значение равное сто двадцати на шестом шаге

Задача:

Вывести на экран числа от 1 до 5 в:

прямом порядке;
обратном порядке.

Математическая модель:

1 2 3 4 5;
5 4 3 2 1.

Блок-схема и программа решения задачи представлена для чисел в прямом порядке и обратном порядке.

(слайд 21)

Запишем рассмотренные алгоритмы на языке программирования Паскаль.

(слайд 22)

III. Подведение итогов урока

И так мы рассмотрели следующие вопросы:

Алгоритмическая структура цикл;
Виды алгоритмических структур:
1. Цикл с предусловием;
2. Цикл с послеусловием;
3. Цикл с параметром;
Рассмотрели способы записи данных структур;
Разобрали примеры решения задач с помощью этих структур.

Источник