Здравствуйте, дорогие читатели! Вот мы с вами и подошли к изучению циклов. Циклы в Паскаль. Что это такое? Как этим пользоваться? Для чего они нужны? Именно на эти вопросы я сегодня и отвечу.
Если вы читали , то знаете, что существует три вида алгоритмов: линейный, разветвляющийся и циклический. Мы с вами уже знаем, как реализовывать и алгоритмы на Паскале. Приступим к изучению последнего типа алгоритмов.
В языке Pascal, как и в большинстве языков программирования, существует три типа циклических конструкций.

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

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

Задача 1. Вывести все числа от 1 до числа, введенного с клавиатуры.

While, или цикл с предусловием

Как вы, наверное, уже поняли из названия, while — это цикл, в котором условие стоит перед телом. Причем тело цикла выполняется тогда и только тогда, когда условие true ; как только условие становится false

While имеет формат:

while < условие> do <оператор 1>; {Пока … делай ….}

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

Решение задачи.

Program example_while; var i, N: integer; { объявляем переменные } begin i:= 1; { Присваиваем i значение 1 } readln(N); { Считываем последнее число } while i <= N do {Как только i станет больше N, цикл прекратится (можно было бы написать просто <, но пришлось бы добавлять 1 к N) } begin {Открываем операторные скобки} write(i, " "); {Выводим i} Inc(i); {увеличиваем i на один.} end; { закрываем скобки } end.

Repeat, или цикл с постусловием

Repeat — полная противоположность while . Repeat — это цикл, в котором условие стоит после тела. Причем оно выполняется тогда и только тогда, когда результат условия false ;как только логическое выражение становится true , выполнение цикла прекращается.

Repeat имеет формат:

repeat { повторяй … }
<оператор 1>;
< оператор 2>;
…
until {до…} <условие>

Begin и end не требуются.

Решение задачи.

Program example_repeat; var i, N: integer;{ объявляем переменные } begin i:= 1; { Присваиваем i значение 1 } readln(N); { Считываем последнее число } repeat {после repeat не требуется begin и end } write(i, " "); {Выводим i} Inc(i); {увеличиваем i на один.} until i = N + 1; {Например, i = 11, а N = 10. Цикл прекратится, так условие стало true.} end.

For, или цикл с параметром

For — это цикл, в котором тело выполняется заданное количество раз.

Существует две формы записи этого цикла:

Первая форма

<счетчик1> будет увеличиваться на 1.

<значение1> — это начальное значение счетчика. Это может быть переменная или число.
<конечное_значение> : как только значение <счетчик1> станет больше <конечное_значение>

Если требуется написать несколько операторов в теле цикла, используем begin и end .

И <счетчик1>, и <конечное_значение>, и <значение1> — переменные целого типа.

Чаще всего в качестве счетчика используется переменная i.

Вторая форма

После каждой итерации значение <счетчик2> будет уменьшатся на 1.

<значение2> — это начальное значение счетчика.
<конечное_значение> : как только значение <счетчик2> станет меньше <конечное_значение>, выполнение цикла прекратится.

Два важных примечания:

1. Цикл повторяется, пока значение значение счетчика лежит в отрезке [значение; конечное_значение].
2. Изменять значение счетчика внутри тела нельзя ! Вот что выводит компилятор:

Решение задачи:

Program example_for; var i, N: integer; begin read(N); {предположим, что мы ввели 10} for i:= 1 to N do write(i, " "); {количество итераций - 10 - 1 + 1 = 10} end.

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

Давайте решим пару задач.

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

Организовываем простой цикл от 1 до требуемого числа.

Program for1; var K, N, i: integer; begin read(K, N); for i:= 1 to N do write(K, " "); {Пишем К через пробел } end.

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

Так как A < B, то цикл должен будет выводить все числа от А до B. Чтобы сосчитать количество чисел, используем формулу: <конечное_значение> — <начальное_значение> + 1.

Program for2; var A, B, i, count: integer; begin read(A, B); for i:= A to B do write(i, " "); {выписываем числа от меньшего к большему} count:= B - A + 1; {считаем количество чисел} writeln; write("Количество чисел - ", count); end.

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

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

Program for9; var A, B, i, S: integer; begin read(A, B); S:= 0; {PascalABC делает это автоматически, но если у вас другой компилятор советуем обнулять переменные вручную} for i:= A to B do S:= S + Sqr(i); {складываем все квадраты} writeln; write("Сумма квадратов - ", S); end.

For13° . Дано целое число N (> 0). Найти значение выражения 1.1 – 1.2 + 1.3 – … (N слагаемых, знаки чередуются). Условный оператор не использовать.

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

Program for13; var N, A, i: integer; S: real; begin Write("N = "); readln(N); S:= 1.1; A:= 1; {Сначала положительное} for i:= 2 to N do {первую итерацию цикла мы уже произвели, поэтому начинаем отсчет с 2} begin A:= -A; {Теперь отрицательное} S:= S + A * (1 + i / 10); {Складываем} end; Writeln(S:5:1); {Отдадим под дробную часть одно знакоместо} end.

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

Каждый раз вычитаем B из А, пока А — В >= 0.

Program while1; var A, B: integer; begin readln(A, B); while (A - B) >= 0 do A:= A - B; {Пока разница положительная, вычитаем. Необходимо предусмотреть вариант с кратностью А и B, поэтому >=} write(A); end.

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

Действуем следующим образом: пока N делится нацело на три, делим N нацело. Затем, если N = 1 — число является степенью тройки; если N <> 1, тогда число — не степень тройки. Для того чтобы решить эту задачу, требуется знать, что такое , и как работают .

Program while4; var N: integer; begin readln(N); while N mod 3 = 0 do N:= N div 3; {Пока остаток от деления на три равен нулю, делим N нацело } writeln(N = 1); {логическое выражение} end.

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

Пожалуйста, приостановите работу AdBlock на этом сайте.

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

Программа: Игральный кубик.

Программа заменяет обычный игральный кубик.

Управление:

• 1 -- бросить кубик;
• 0 -- закончить игру.

Давайте напишем заготовку для нашей игры.

Листинг 1.

#include #include #include int main(void) { srand(time(NULL)); printf("########### Devil\"s bones ###########\n"); printf("# #\n"); printf("# Commands: #\n"); printf("# #\n"); printf("# 1 - new game #\n"); printf("# 0 - exit #\n"); printf("# #\n"); printf("########################################\n\n"); int control; int value = 0; printf("Enter command: "); scanf("%d", &control); if(control == 1){ value = 1 + rand()%6; printf("Result: %d\n", value); } return 0; }

Тут-то мы и сталкиваемся с проблемой. Понятно, что заранее узнать, когда игра закончится невозможно. А значит использовать цикл for напрямую не получится. Одним из выходов из подобной ситуации является использование других циклических конструкций. Например, цикла while .

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

Листинг 2.

While (условие) оператор;

1. Программа встречает ключевое слово while , значит дальше идёт циклическая конструкция;
2. Проверяется условие. Вычисляется логическое выражение, записанное в скобках;
3. Если значение условия ИСТИНА , то выполняется тело цикла. Переходим к пункту 2;
4. Если значение условия ЛОЖЬ , то цикл завершается. Управление передаётся на оператор, следующий за телом цикла.

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

Давайте перепишем нашу программу с использованием данного цикла.

Листинг 3.

#include #include #include int main(void) { srand(time(NULL)); printf("########### Devil\"s bones ###########\n"); printf("# #\n"); printf("# Commands: #\n"); printf("# #\n"); printf("# 1 - new game #\n"); printf("# 0 - exit #\n"); printf("# #\n"); printf("########################################\n\n"); int control; int value = 0; printf("Enter command: "); scanf("%d", &control); while(control != 0){ switch(control){ case 1: value = 1 + rand()%6; printf("Result: %d\n", value); break; default: printf("Error! Try again...\n"); break; } printf("Enter command: "); scanf("%d", &control); } printf("Good bye!\n"); return 0; }

Опишем словами алгоритм работы данной программы:

1. Выводим меню пользователя и предложение ввести команду;
2. Запускаем цикл while . Проверяем условие;
3. Если пользователь ввёл 0 , то условие выполнения цикла принимает значение ЛОЖЬ . Тело цикла не выполняется. Управление передаётся на следующий за циклом оператор. Выводится строка Good bye! . Программа завершается;
   1. Оператор выбора:
      1. Если пользователь ввёл 1 , то генерируем случайное число от 1 до 6 и выводим его на экран. Выходим из оператора выбора;
      2. Если пользователь ввёл что-то иное, выводим сообщение об ошибке. Выходим из оператора выбора.
   2. Выводим пользователю предложение ввести новую команду;
   3. Считываем код команды в переменную control ;
   4. Возвращаемся к проверке условия. Пункт 3.

Цикл while называют циклом с предусловием, т.к. прежде, чем выполнить тело цикла, проверяется условие. Это значит, например, что возможна такая ситуация, что тело цикла не выполнится вообще ни один раз. Другое название цикла while – цикла ПОКА . Дословный перевод с английского. Это название отображает саму суть цикла.

Мнемоническое правило:

ПОКА условие ИСТИНА, выполняй тело цикла.

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

И последняя, третья циклическая конструкция – цикл do-while .

Данный цикл отличается от цикла while тем, что условие проверяется не перед выполнением тела цикла, а после выполнения тела цикла. Это значит, что тело цикла do-while выполнится хотя бы один раз обязательно.

Синтаксис данной циклической конструкции таков:

Листинг 4.

Do оператор; while (условие);

Работает эта конструкция следующим образом:

1. Программа встречает ключевое слово do . Значит перед ней цикл do-while ;
2. Выполняется тело цикла;
3. Проверяется условие;
4. Если условие ИСТИНА ,то снова выполняется тело цикла;
5. Если условие ЛОЖЬ , то работа циклической конструкции прекращается. Программы выполняет оператор, следующий за циклом do-while .

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

Листинг 5.

#include #include #include int main(void) { srand(time(NULL)); printf("########### Devil\"s bones ###########\n"); printf("# #\n"); printf("# Commands: #\n"); printf("# #\n"); printf("# 1 - new game #\n"); printf("# 0 - exit #\n"); printf("# #\n"); printf("########################################\n\n"); int ch_control; int value = 0; do { printf("Input command: "); scanf("%d", &ch_control); switch(ch_control){ case 0: break; case 1: value = 1 + rand()%6; printf("Result: %d\n", value); break; default: printf("Error! Try again...\n"); break; } }while(ch_control != 0); printf("Good bye!\n"); return 0; }

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

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

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

В блок-схеме цикл while изображается так, как показано на рис. 5.3.

Рис. 5.3. Блок-схема цикла while

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

Рис. 5.4. Вставка оператора цикла while

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

Пример 5.4. Найти первый отрицательный член последовательности

Блок-схема алгоритма решения примера:

Пример 5.5. Вычислить значения функции при изменении аргумента х от -1 до 3 с шагом 0.5 и сформировать из этих значений вектор y .

Эта задача уже была рассмотрена, но с использованием цикла For , решим ее с циклом While .

Описание и вызов программы-функции:

Пример 5.6. Найти количество и сумму цифр заданного натурального числа.Описание и вызов программы-функции:

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

· mod – выдаёт остаток при делении x на y .

· trunc – выдает целую часть z , удаляя дробную часть.

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

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

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

Описание и вызов программы-функции:

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

Если телом цикла является циклическая структура, то такой цикл называется вложенным или сложным. Алгоритм со структурой вложенных циклов – это алгоритм, содержащий цикл, внутри которого размещены один или несколько других циклов.

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

Пример 6.1. Вычислить .

Описание и вызов программы-функции:

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

Оператор цикла while называется циклом с предусловием, поскольку условие выполнения цикла проверяется перед входом в него, он имеет следующий формат: while (выражение) тело цикла;

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

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

Если выражение ложно, то выполнение оператора while заканчивается и выполняется следующий по порядку оператор. Если выражение истинно, то выполняется блок операторов (тело цикла while ).

Процесс повторяется с пункта 1.

Блок-схема цикла с предусловием.

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

Рассмотрим следующий фрагмент программы:

int x =0;

while (x<10)

{ printf("%d\n",x);

x++;

printf(" The end ");

Такой цикл выполнится 10 раз, напечатав значения х от 0 до 9 , и только после этого управление перейдет на второй, стоящий за циклом printf() .

Цикл с постусловием (Оператор do … while)

По поведению он очень похож на предыдущий цикл while() , за тем исключением, что условие проверяется после выполнения тела цикла. Если условие окажется ложным, цикл на этом заканчивается, в противном случае – выполняется очередная итерация цикла. Этот тип цикла используется в тех случаях, когда необходимо выполнить тело цикла хотя бы один раз. Формат оператора имеет следующий вид: do тело цикла while (выражение);

Блок-схема цикла с постусловием.

Чтобы прервать выполнение цикла до того, как условие станет ложным, можно использовать оператор break . Напечатаем значения х от 0 до 9 с использованием цикла do … while

int x =0;

{ printf("%d\n", x);

} while (x<10);

printf("The end");

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

int x=0;

printf(" х =%d\n", x);

} while (x !=0);

Цикл со счетчиком (оператор for)

Оператор for - это наиболее общий способ организации цикла. Он имеет следующий формат:

for (выражение 1 ; выражение 2 ; выражение 3) тело цикла

Выражение 1 обычно используется для установки начальных значений переменных, используемых в цикле («блок инициализации»). Выражение 2 определяет условие, при котором тело цикла будет выполняться. Выражение 3 определяет регулярные изменения переменных после каждого прохода тела цикла («блок модификации»).

Блок-схема пошагового цикла.

Схема выполнения оператора for :

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

Вычисляется выражение 2 (перед каждым проходом цикла), если оно отлично от нуля –true (истина), то выполняется тело цикла, иначе (если выражение ложно) – цикл прекращается и управление передается оператору, следующему за оператором for .

Вычисляется выражение 3 (модификация данных после каждой итерации цикла), переход к пункту 2.

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

Пример: Эта программа, как и две предыдущие напечатает цифры от 0 до 9

for (x=0; x<10; x++)

printf ("% d \ n ", x );

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

Пример: Вот как будет выглядеть тот же алгоритм с отсутствующими частями инициализации и модификации в цикле for :

for (; x<10 ;)

{printf("%d\n",x);

Как видите, x=0 теперь стоит перед циклом, а оператор x++ стал последним в теле цикла.

Можно опустить и условие выхода, тогда программа будет считать, что условие всегда истинно и будет печатать строку "hello" до бесконечности.

for (;;)

printf (" hello \ n ");

аналогичный бесконечный цикл while будет выглядеть так:

while (1)

printf("hello\n");

while (1) – этокороткая запись оператора while (1!=0 ), то есть проверка условия 1!=0 всегда будет давать результат – true

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

Пример: Вычислять квадраты натуральных чисел от 0 до k , где k вводится с клавиатуры.

#include

using namespace std;

void main()

{ int i=0,b,k;

cout <<" k ="; // вывод текста "k=" на экран дисплея

cin >> k ; // ввод данных с клавиатуры в переменнуюk

cout << endl ; // перевод строки (вывод «конец строки» на экран)

for (;;)

{ i=i+1;

cout<

if (i == k ) break ; // выход из цикла по условию

Усложним условие задачи, пусть необходимо в начале цикла задать начальные значения не одной, а двум переменным (допустим x и y ), а в цикле изменить значения их обеих. Можно сделать эту работу следующим образом:

int y, x=0;

for (y=10; x

Благодаря оператору « , » (запятая) можно поступить проще:

int y, x;

for (x=0, y=10; x

{ printf("x=%d\ty=%d\n", x, y);