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

Здравствуйте, дорогие читатели! Вот мы с вами и подошли к изучению циклов. Циклы в Паскаль. Что это такое? Как этим пользоваться? Для чего они нужны? Именно на эти вопросы я сегодня и отвечу.
Если вы читали этот урок, то знаете, что существует три вида алгоритмов: линейный, разветвляющийся и циклический. Мы с вами уже знаем, как реализовывать линейные и разветвляющиеся алгоритмы на Паскале. Приступим к изучению последнего типа алгоритмов.
В языке 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 — это  цикл, в котором тело выполняется заданное количество раз.

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

Первая форма

for <счетчик1> := <значение1> to <конечное_значение> do <оператор1>;

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

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

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

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

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

Вторая форма

for <счетчик2> := <значение2> downto <конечное_значение> do <оператор1>;

После каждой итерации значение <счетчик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. Даны два целых числа A и B (A < 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 включительно.

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

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, тогда число — не степень тройки. Для того чтобы решить эту задачу, требуется знать, что такое div и   mod,  и как работают логические выражения.

program while4;

var
  N: integer;

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

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

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

Важность циклов в программировании

Чем же является цикл? Зачем он необходим и какие преимущества получает программист при его использовании? Цикл является важной структурной составляющей программирования, которая позволяет автоматизировать выполнение определённого ряда действий, при условии что соблюдаются установленные параметры. Так, самый простой пример работы цикла – это поднесение определённого числа в степень. Нет нужды прописывать рядки до тех пор, пока не будет достаточно, ведь техника может всё сделать автоматически с его помощью. При практической реализации циклы также позволяют сэкономить много времени и труда, так как при использовании цикла нет необходимости каждый раз и на все действия прописывать программный код. Достаточно ввести заменяемые переменные и запустить реализацию. Но как построена схема цикла? Или даже нескольких? Самих вариантов реализации цикла довольно много – информации на целую книжку про программирование, «Паскаль» мы будем рассматривать или «Ассемблер». Поэтому в чисто ознакомительных целях предлагаем разобрать теоретическую схему работы двух самых популярных в использовании:

1. Цикл с постусловием.
2. Цикл с предусловием.

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

while «условие» do «программный код»

Общетеоретическая база цикла с постусловием

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

repeat

«Программный код»

until «Условие»

Общетеоретическая база цикла с предусловием

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

Практическая реализация в различных языках программирования

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

Заключение

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

Циклы

Последнее обновление: 10.11.2021

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

• for

• foreach

• while

• do…while

Цикл for

Цикл for имеет следующее формальное определение:

for ([действия_до_выполнения_цикла]; [условие]; [действия_после_выполнения])
{
    // действия
}

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

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

И третья часть — некоторые действия, которые выполняются после завершения блока цикла. Эти действия выполняются каждый раз при завершении блока цикла.

После объявления цикла в фигурных скобках помещаются сами действия цикла.

Рассмотрим стандартный цикл for:

for (int i = 1; i < 4; i++)
{
    Console.WriteLine(i);
}

Здесь первая часть объявления цикла — int i = 1 — создает и инициализирует переменную i.

Вторая часть — условие i < 4. То есть пока переменная i меньше 4, будет выполняться цикл.

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

Весь процесс цикла можно представить следующим образом:

1. Определяется переменная int i = 1

2. Проверяется условие i < 4. Оно истинно (так как 1 меньше 4), поэтому выполняется блок цикла, а именно инструкция
   Console.WriteLine(i), которая выводит на консоль значение переменной i

3. Блок цикла закончил выполнение, поэтому выполняется треться часть объявления цикла — i++. После этого переменная i будет равна 2.

4. Снова проверяется условие i < 4. Оно истинно (так как 2 меньше 4), поэтому опять выполняется блок цикла —
   Console.WriteLine(i)

5. Блок цикла закончил выполнение, поэтому снова выполняется выражение i++. После этого переменная i будет равна 3.

6. Снова проверяется условие i < 4. Оно истинно (так как 3 меньше 4), поэтому опять выполняется блок цикла —
   Console.WriteLine(i)

7. Блок цикла закончил выполнение, поэтому снова выполняется выражение i++. После этого переменная i будет равна 4.

8. Снова проверяется условие i < 4. Теперь оно возвражает false, так как значение переменной i НЕ меньше 4,
   поэтому цикл завершает выполнение. Далее уже выполняется остальная часть программы, которая идет после цикла

В итоге блок цикла сработает 3 раза, пока значение i не станет равным 4. И каждый раз это значение будет увеличиваться на 1. Однократное выполнение блока цикла
называется итерацией. Таким образом, здесь цикл выполнит три итерации. Результат работы программы:

Если блок цикла for содержит одну инструкцию, то мы можем его сократить, убрав фигурные свобки:

for (int i = 1; i < 4; i++)
	Console.WriteLine(i);

// или так
for (int i = 1; i < 4; i++) Console.WriteLine(i);

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

var i = 1;

for (Console.WriteLine("Начало выполнения цикла"); i < 4; Console.WriteLine($"i = {i}"))
{
    i++;
}

Здесь опять же цикл срабатывает, пока переменная i меньше 4, только приращение переменной i происходит в блоке цикла. Консольный вывод данной программы:

Начало выполнения цикла
i = 2
i = 3
i = 4

Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:

int i = 1;
for (; ;)
{
	Console.WriteLine($"i = {i}");
	i++;
}

Формально определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; ;). У нас нет
инициализированной переменной, нет условия, поэтому цикл будет работать вечно — бесконечный цикл.

Мы также можем опустить ряд блоков:

int i = 1;
for (; i<4;)
{
	Console.WriteLine($"i = {i}");
	i++;
}

Этот пример по сути эквивалентен первому примеру: у нас также есть переменная-счетчик, только определена она вне цикла. У нас есть условие выполнения цикла.
И есть приращение переменной уже в самом блоке for.

Также стоит отметить, что можно определять несколько переменных в объявлении цикла:

for (int i = 1, j = 1; i < 10; i++, j++)
    Console.WriteLine($"{i * j}");

Здесь в первой части объявления цикла определяются две переменных: i и j. Цикл выполняется, пока i не будет равна 10. После каждой итерации
переменые i и j увеличиваются на единицу. Консольный вывод программы:

0
1
4
9
16
25
36
49
64
81

Цикл do..while

В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно,
цикл повторяется.

do
{
    действия цикла
}
while (условие)

Например:

int i = 6;
do
{
    Console.WriteLine(i);
    i--;
}
while (i > 0);

Здесь код цикла сработает 6 раз, пока i не станет равным нулю. Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий,
даже если условие в инструкции while не будет истинно. То есть мы можем написать:

int i = -1;
do
{
    Console.WriteLine(i);
    i--;
}
while (i > 0);

Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.

Цикл while

В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:

while (условие)
{
    действия цикла
}

Например:

int i = 6;
while (i > 0)
{
    Console.WriteLine(i);
    i--;
}

Цикл foreach

Цикл foreach предназначен для перебора набора или коллекции элементов. Его общее определение:

foreach(тип_данных переменная in коллекция)
{
	// действия цикла
}

После оператора foreach в скобках сначала идет определение переменной. Затем ключевое слово in и далее коллекция,
элементы которой надо перебрать.

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

Например, возьмем строку. Строка по сути — это коллекция символов. И .NET позволяет перебрать все элементы строки — ее символы с помощью цикла foreach.

foreach(char c in "Tom")
{
    Console.WriteLine(c);
}

Здесь цикл foreach пробегается по всем символам строки «Tom» и каждый символ помещает в символьную переменную c. В блоке цикла
значение переменной c выводится на консоль. Поскольку в строке «Tom» три символа, то цикл выполнится три раза. Консольный вывод программы:

Стоит отметить, что определяемая в объявлении цикла должна по типу соответствовать типу элементов перебираемой коллекции. Так, элементы строки — значения типа
char — символы. Поэтому переменная c имеет тип char. Однако в реальности не всегда бывает очевидно, какой тип представляют
элементы коллекции. В этом случае мы можем определить переменную с помощью оператора var:

foreach(var c in "Tom")
{
    Console.WriteLine(c);
}

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

Операторы continue и break

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

Например:

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        break;
    Console.WriteLine(i);
}

Хотя в условии цикла сказано, что цикл будет выполняться, пока счетчик i не достигнет значения 9, в реальности цикл сработает 5 раз.
Так как при достижении счетчиком i значения 5, сработает оператор break, и цикл завершится.

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

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        continue;
    Console.WriteLine(i);
}

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

Стоит отметить, что операторы break и continue можно применять в любом типе циклов.

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

Одни циклы могут быть вложенными в другие. Например:

for (int i = 1; i < 10; i++)
{
    for (int j = 1; j < 10; j++)
    {
        Console.Write($"{i * j} t");
    }
    Console.WriteLine();
}

В данном случае цикл for (int i = 1; i < 10; i++) выполняется 9 раз, то есть имеет 9 итераций. Но в рамках каждой итерации
выполняется девять раз вложенный цикл for (int j = 1; j < 10; j++). В итоге данная программа выведет таблицу умножения.

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

Y= 1+ 1/2+ 1/3 + …+ 1/ n

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

Если же значение n не фиксируется, а является исходным данным, вводимым в процессе выполнения программы (и даже константой, описанной в программе), то аналогичный оператор присваивания записать невозможно. Ибо запись вида Y:= 1+1/2+1/3+…+1/ n в языках программирования недопустима.

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

Простой арифметический оператор цикла Паскаля (цикл с параметром)

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

На самом деле вычисление этой суммы можно осуществить по очень простому и компактному алгоритму: предварительно положим y=0 (с помощью оператора присваивания y:=0), а затем выполним оператор присваивания y:= y+1/ i для последовательных значений i= 1,2,…, n. При каждом очередном выполнении этого оператора к текущему значению y будет прибавляться очередное слагаемое. Как видно, в этом случае процесс вычислений будет носить циклический характер: оператор y:= y+1/i
должен выполняться многократно, т.е. циклически, при различных значениях i.

Этот пример циклического вычислительного процесса является весьма типичным; его характерные особенности состоят в том, что

· число повторений цикла известно к началу его выполнения (в данном случае оно равно значению n, которое предполагается заданным к этому времени);

· управление циклом осуществляется с помощью переменной порядкового типа, которая в этом циклическом процессе принимает последовательные значения от заданного начального до заданного конечного значений (в нашем случае – это целочисленная переменная i, принимающая последовательные значения от 1 до n).

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

For V:= E1 to E2 do S,

где for (для), to (увеличиваясь к) и do (выполнять, делать) – служебные слова, V – переменная порядкового типа, называемая параметром цикла, Е1 и Е2 – выражения того же типа, что и параметр цикла, S – оператор, который и выполняется многократно в цикле, называемый телом цикла.

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

Этот оператор цикла Паскаля предусматривает присваивание параметру цикла V последовательных значений от начального значения, равного значению выражения Е1, до конечного значения, равного значению выражения Е2, т.е. при каждом повторении выполняется оператор присваивания V:= succ(V)
, и выполнение оператора S при каждом значении параметра цикла V. При этом значения выражений Е1 и Е2 вычисляются один раз, при входе в оператор цикла, а значение параметра цикла V не должно изменяться в результате выполнения оператора S. Если заданное конечное значение меньше начального значения (что допустимо), то оператор S не выполняется ни разу.

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

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

Пример кода программы для суммирования первых n членов гармонического ряда

For i:= 1 to n do y:= y+1/i;

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

For V:= E1 downto E2 do S,

где downto (уменьшаясь к) – служебное слово, а все остальные слова и выражения имеют прежний смысл. Изменение параметра цикла от большего значения к меньшему происходит при выполнении присваивания V:=pred(V). Заметим, что начальное значение может быть меньше конечного значения. В этом случае оператор S не выполнится ни разу. Значение параметра цикла по завершении выполнения такого цикла так же считается неопределенным.

Следует запомнить и то, что для обоих вариантов записи цикла с параметром
справедливо: если начальное и конечное значения равны, то тело цикла (оператор S) выполнится один раз.

Заметим так же, что параметр цикла
может и не использоваться в теле цикла, так что основное его назначение – это управление числом повторений цикла. Например, значение y= x n, где n>=0 – целое, можно вычислить по следующему алгоритму: предварительно положить y=1, а затем n раз домножить это значение на x:

Пример кода программы цикла Паскаля

For i:= 1 to n do y:= y*x;

Как видно, здесь параметр цикла i служит лишь для того, чтобы тело цикла (оператор y:= y* x) выполнилось нужное число раз.

Арифметический оператор цикла Паскаля с произвольным шагом

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

Итерационные операторы цикла Паскаля

Итерационные циклы отличаются от циклов с параметром тем, что в них заранее неизвестно число повторений.

Пусть мы отправляемся за грибами и возвращаемся домой, когда корзина наполнится. Все грибники делятся на 2 категории:

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

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

Отсюда получаются два варианта реализации итерационных циклов:

с предусловием и с постусловием.

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

Какой алгоритм выбрать? Это зависит от конкретной задачи.

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

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

Оператор цикла Паскаля с постусловием

Рассмотрим теперь математическую задачу. Пусть нам необходимо вычислить сумму первых членов гармонического ряда, удовлетворяющих условию 1/i>= e, где 0< e<1, а i=1,2,3…. Эту задачу можно решить по следующему алгоритму: положить предварительно y=0 и i=0, а затем в цикле увеличивать i на 1, к значению y добавлять очередное слагаемое 1/ i до тех пор, пока текущее значение 1/ i впервые окажется больше заданного значения 0< e<1.

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

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

Repeat S1; S2;…; Si until B,

где repeat (повторять) и until (до) – служебные слова, через Si обозначен любой оператор Паскаля, а через В – логическое выражение.

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

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

Пример кода оператора цикла Паскаля с постусловием

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

Пример кода оператора цикла Паскаля с постусловием

Оператор цикла Паскаля с предусловием

В случае оператора цикла Паскаля с постусловием входящая в него последоват

Пусть, например, дано вещественное число М. Требуется найти наименьшее целое неотрицательное число k, при котором 3 k> M. Эту задачу можно решить по следующему алгоритму: предварительно положить y=1 и k=0; затем в цикле домножать значение y на 3 и увеличивать значение k на 1 до тех пор, пока текущее значение y впервые окажется больше значения М. На первый взгляд, здесь можно воспользоваться оператором цикла с постусловием:

Пример кода оператора цикла Паскаля с постусловием

Однако нетрудно убедиться в том, что при M<1 будет получен неправильный результат k=1, тогда как должно быть получено k=0: в этом случае предварительно сформированное значение k=0 является окончательным результатом и действия, предусмотренные в цикле, выполняться не должны.

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

где while (пока), do (делать, выполнять) – служебные слова, В – логическое выражение, S – оператор. Здесь оператор S выполняется ноль или более раз, но перед каждым очередным его выполнением вычисляется значение выражения В, и оператор S выполняется только в том случае, когда значение выражения В true. Выполнение оператора цикла завершается, когда выражение В впервые принимает значение false. Если это значение выражение В принимает при первом же его вычислении, то оператор S не выполнится ни разу.

В рассматриваемой нами задаче правильное значение k при любом значении М может быть получено следующим образом:

Пример кода оператора цикла Паскаля с предусловием

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

Отметим отличия и особенности хорошего стиля работы с рассмотренными циклическими операторами.

Оператор, который выполняется в цикле, сам может быть циклом. Это относится ко всем видам циклов. В результате мы получаем вложенные циклы. Механизм работы вложенных циклов удобнее всего рассмотреть на примере вложенных циклов с параметром. Пусть нам нужно описать работу электронных часов, начиная с момента времени 0 часов, 0 минут, 0 секунд. Значение минут станет равным 1 только после того, как секунды «пробегут» все последовательные значения от 0 до 59. Часы изменят свое значение на 1 только после того, как минуты «пробегут» все последовательные значения от 0 до 59. Таким образом, вывод всех значений времени от начала суток до конца суток может быть представлен следующим фрагментом программы:

For h:=0 to 23 do

For m:=0 to 59 do

For s:=0 to 59 do

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

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

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

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

Повторяемый блок вычислений называют телом
цикла. В теле цикла должно быть обеспечено изменение значения счетчика, чтобы он мог завершиться. Если тело цикла состоит более чем из одного оператора, оно заключается в операторные скобки begin. end;. Однократное выполнение тела цикла называют его шагом
.

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

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

Рис. 9.1. Блок-схемы циклов с предусловием и постусловием

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

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

В языке Паскаль реализованы оба вида циклов. Цикл с предусловием имеет следующий общий вид:

while логическое_выражение do begin

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

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

Общая запись цикла с постусловием следующая:

Работает цикл с постусловием следующим образом: «тело цикла повторяется до тех пор, пока логическое выражение не станет истинным». Обратите внимание, что, в отличие от while, цикл repeat в Паскале работает, пока условие ложно
. Это отличие подчеркивается использованием ключевого слова until («до тех пор, пока не») вместо while («до тех пор, пока»). Кроме того, в виде исключения, тело цикла repeat, даже если оно состоит из нескольких операторов, можно не заключать в операторные скобки.

Довольно часто циклы взаимозаменяемы. Представим, например, что для каждого из значений переменной x=1, 2. 20, нужно выполнить некоторый расчет (математически этот закон изменения x можно записать как
или
). Это можно сделать как в цикле while:

Слайд 1

Циклы

Слайд 2

Цикл for

Слайд 3

Задача: Вывести на экран 5 раз « Hello ». Решение: умеем составлять линейный алгоритм program primer 1; begin writeln(‘ Hello’); writeln(‘ Hello ‘); writeln(‘ Hello ‘); writeln(‘ Hello ‘); writeln(‘ Hello ‘); end. Неэффективная программа

Слайд 4

Для записи повторяющейся последовательности операторов используют циклы Program primer 1; var i: integer; begin for i:=1 to 5 do begin writeln(‘Hello’); end; end. Здесь переменная i запоминает сколько раз выполнилась повторяющаяся команда (тело цикла)

Слайд 5

Цикл – это повторяющаяся последовательность операторов. Циклы бывают арифметические и итерационные Арифметический цикл – это такой цикл, число повторений которого известно заранее. В Pascal такой цикл обычно реализуется с помощью оператора for . Итерационный цикл – это такой цикл, число повторений которого заранее неизвестно и выход из цикла производится в случае выполнения или невыполнения какого-то условия. В Pascal такие циклы обычно реализуются с помощью операторов while и repeat

Слайд 6

Цикл for Принцип работы: Сначала счетчику цикла присваивается начальное значение. Если это значение не больше конечного значения, то выполняется тело цикла. Затем значение счетчика увеличивается на 1 и опять сравнивается с конечным значением. Если оно по-прежнему не больше конечного значения, то оператор выполняется еще раз и так далее. Замечание: если тело цикла состоит из одного оператора, то begin и end можно опустить

Слайд 7

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

Слайд 8

Задачи: 1) Написать программу, которая выводит на экран все натуральные числа от 1 до n 2) Написать программу, которая подсчитывает сумму натуральных чисел от 1 до n 3) Написать программу, которая считает x n для вещественного x и натурального n 4) Написать программу, которая выводит на экран: 20 40 80 160 320 5) Написать программу, которая подсчитывает произведение натуральных чисел от 1 до n Решение

Слайд 10

Решение задач ОГЭ Дан фрагмент программы. Чему будет равна переменная s в результате работы данной программы? Решение: В этой задаче есть цикл for. Тело цикла будет выполняться 4 раза (при n=2,3,4,5 ) . s=2 n=2 s=2+2*2=6 n=3 s=6+3*2=12 n=4 s=12+4*2=20 n=5 s=20+5*2=30 Программа выводит значение переменной s , значит на экране будет число 30 Ответ: 30

Слайд 11

Задачи Даны фрагменты программы. Что будет напечатано на экране в результате работы данных программ?

Слайд 12

Цикл While (цикл с предусловием)

Слайд 13

Задача: написать программу, которая выводит на экран все натуральные числа от 1 до n Решение: умеем составлять алгоритм с циклом for Программа с циклом for Program m 1 ; var i,n:integer; begin writeln(‘Введите n’); readln(n); for i:=1 to n do write(i,’ ‘); end . Программа с циклом while Program m2; var i,n:integer; begin writeln(‘Введите n’); readln(n); i:=1; while i

Слайд 14

Задача: написать программу, которая выводит на экран все натуральные числа от 1 до n Пока истинно условие i

Слайд 15

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

Слайд 16

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

Слайд 17

Задачи: 1) Напечатать целые числа -10, -5, 0, 5…20 2) Найти произведение чисел из диапазона от A до B ( A

Слайд 18

Задачи: 5) Напечатать все целые значения от A до B с шагом h . Вход: 1 10 2 Вход: 5 20 5 Выход: 1 3 5 7 9 Выход: 5 10 15 20 6) Найти сумму чисел из диапазона от A до B с шагом 3. Вход: 1 15 Вход: 0 10 Выход: 35 Выход: 18 7) Для заданного натурального n и действительного x подсчитать сумму Вход: 3 Вход: 5 Выход: 1.83 Выход: 2.28 Напечатать таблицу соответствия между весом в фунтах и весом в килограммах для значений 5,10,15…50 фунтов (1 фунт=0,453 кг) Выход: 5 фунтов=2,265 кг 10 фунтов=4,53 кг … 50 фунтов=22,65 кг Решение

Слайд 21

Цикл repeat (цикл с постусловием)

Слайд 22

Общий вид цикла Принцип работы: выполняется тело цикла. Если истинно, то выполнение цикла завершится. Если ложно, то снова выполняется тело цикла

Слайд 23

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

Слайд 24

Задача: написать программу, которая выводит на экран все натуральные числа от 1 до n Программа с циклом while Program m2; var i,n:integer; begin writeln(‘Введите n’); readln(n); i:=1; while in end .

Слайд 25

Задачи: 1 ) Напечатать все целые значения от A до B с шагом h . Вход: 1 10 2 Вход: 5 20 5 Выход: 1 3 5 7 9 Выход: 5 10 15 20 2 ) Для заданного натурального n и действительного x подсчитать сумму Вход: 3 Вход: 2 Выход: 14 Выход: 5 3 ) Для заданного натурального n и действительного x подсчитать сумму Вход: 3 Вход: 5 Выход: 1.83 Выход: 2.28 Решение

Слайд 27

Источники информации М. В. Огнева, Е. В. Шуринова, Turbo Pascal : первые шаги. Саратов: издательство «Стило», 2001 http://opengia.ru/subjects/informatics-9 http://kpolyakov.spb.ru