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

Паскаль - Урок 6: Циклы while, for, repeat

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

1. Цикл с параметром в Паскале – FOR

Цикл FOR задаёт определённое условие по которому программа будет работать до его выполнения, допустим нужно нам 5 (или n) раз зациклить программу, то это легко сделать с помощью данного цикла. У цикла FOR есть характерная черта – счетчик который обычно обозначается буквой i или j.

Внешний вид цикла с параметром в паскале:

for i:= 1 to n do // присваиваем i сначала одному, потом двум, трем, …, n

После 1-го прохода переменной i присваиваем 1, после второго присваиваем 2 и так до тех пор, пока не дойдем до n. to – это до .. в порядке возрастания, также есть downto – до .. в порядке убывания.

Блок – схема цикла с параметром:

2. Цикл с предусловием в Паскале – WHILE

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

Структура цикла с предусловием:

WHILE   DO
        begin

        end;

– логическое выражение, истинность которого проверяется вначале выполнения циклического оператора;

– любые выполняемые операторы языка.

Порядок выполнения цикла:

Пока условие истинно выполняется тело цикла. Как только условие становится ложно выполнение цикла прекращается.

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

Паскаль - Урок 6: Циклы while, for, repeat

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

Пример:

Задача: вычислить сумму ряда 1+1.5+2+2.5+3+3.5+ .. + 30

program example-while;

var
   sum:real;
   n:real;
BEGIN
   sum:=0;
   n:=1;
   while n

3. Цикл с постусловием – Repeat – until.

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

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

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

Блок – схема цикла с постусловием:

Формат записи, структура цикла:

REPEAT

UNTIL ;

Program test2;
Var b:Real;
Begin
b:=100;
Repeat b:=b/2;
Until b

Выводы:

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

2. Цикл с предусловием выполняется до тех пор, пока условие выполнения не станет ложным, и продолжается, если условие истинно.

3. Цикл с постусловием выполняется до тех пор, пока условие не станет истинно, если условие ложно, цикл продолжается.

Предыдущий урок

Дата: 2012-01-06 19:31:43 Просмотров: 278176

Теги: Паскаль Pascal циклы уроки

Источник

Здравствуйте, любители программирования и читатели сайта progmatem.ru. На одной из предыдущих страниц мы рассмотрели оператор цикла с параметром, поэтому пришло время изучить другие типы циклов – операторы while и repeat.

✎ Операторы цикла while и repeat используются тогда, когда заранее не известно общее количество итераций (повторений вычислений) цикла, а завершение вычислений зависит от некоего условия. Если условие ставится вначале цикла (на входе), то используется оператор While, если на выходе – Repeat.

А теперь расшифруем сказанное: сначала while, а потом ниже repeat.

Оператор цикла while имеет такую структуру:

while условие do
оператор

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

Если оператор в цикле состоит из нескольких операторов, то поместить их нужно в операторные скобки begin – end (сравните оператор цикла for). Не стоит также забывать, что сами операторы разделяются оператором “точка с запятой” (но перед закрывающим END в конце ставить её не обязательно).

while условие do
begin
оператор 1;
оператор 2;
оператор 3;
………..
оператор N
end;

Продемонстрируем сказанное на примере вычисления суммы кубов всех чисел от 1 до 10. Из кода видно, что пока b ≤ 10 (строка 7), будем выполнять тело цикла, в котором на каждой итерации к сумме sum прибавляем b3. При последнем вычислении при b=10 вычислим сумму (строка 9), а ниже увеличим b на 1: b=11, поэтому следующим шагом будет выход из цикла, поскольку условие входа b ≤ 10 нарушится.

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14

var
b, sum: integer;

begin
b := 1;
sum := 0; // начальная сумма
while b <= 10 do
begin
sum := sum + b*b*b;
inc(b)
end;
writeln(‘sum = ‘, sum); // выводим результат
readln
end.

Рассмотрим хорошо известный пример с разложением функции ex в ряд Тейлора:

Будем вычислять его значение с точностью, например, 0.000001 (одна миллионная), а само значение обозначим как S. как видно, первое значение ряда (суммы) равно a0=1, а для вычисления каждого последующего члена an+1 предыдущий an нужно умножить на x и разделить на n. Действительно, an+1 = xn+1/(n+1)! = xn·x/(n!·n) = an·x/n. Это и продемонстрировано в программе ниже.

Смысл таков: пока члены ряда больше 0.000001, будет выполняться тело цикла, в котором вычисляется указанная сумма. Как только член ряда a станет меньше или равен 0.000001, происходит выход из цикла, и в конце выводится результат.

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var
a, x, S: real;
n: integer;

begin
x := 0.5;
n := 0; // начальный номер
a := 1; // начальное значение члена ряда
S := 0; // начальная сумма
while a > 0.0000001 do
begin
S := S + a;
inc(n);
a := a * x / n
end;
writeln(‘S = ‘, S:0:6);
readln
end.

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

Приведем пример.

Код Pascal

1
2
3
4

begin
while 1 < 100 do
writeln(‘Hello!’)
end.

Данная программа будет выводить приветствие “Hello!” бесконечно, то есть до тех пор, пока вы её не остановите. Происходит это потому, что условие 1 < 100 всегда истинно.

Посмотрите ещё пример с гармоническим рядом или другие программы из раздела While задачника Абрамяна.

Выведите наименьший делитель числа x, отличный от 1

Код Pascal

1
2
3
4
5
6
7
8
9
10
11

var
x, d: integer;

begin
write(‘Введите x –> ‘);
readln(x);
d := 2; { <- минимальный делитель отличный от 1 }
while (x mod d <> 0) do inc(d);
writeln(‘d = ‘, d);
readln
end.

Напечатать минимальное число, большее 200, которое нацело делится на 17

Код Pascal

1
2
3
4
5
6
7
8
9

var
n: integer;

begin
n := 201; { <- минимальное число большее 200 }
while (n mod 17 <> 0) do inc(n);
writeln(‘Ответ: ‘, n);
readln
end.

Оператор цикла repeat имеет такую структуру:

repeat
оператор
until условие;

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

repeat
оператор 1;
оператор 2;
оператор 3;
………..
оператор N
until условие;

Ещё одной особенностью оператора repeat – until является то, что по крайней мере один раз оператор в теле цикла выполнится, поскольку условие выхода проверяется в конце. Эта особенность приводит к тому, что любой оператор с предусловием while легко может быть преобразован в оператор с послеусловием repeat, а вот далеко не каждый оператор repeat легко записывается с помощью while.

Вычислить корень квадратный из введенного с клавиатуры числа. Запустите программу и попробуйте ввести отрицательное число: каждый раз вас будет возвращать в начало цикла, поскольку выйти из цикла можно, если ввести неотрицательное число x: x >= 0.

Код Pascal

1
2
3
4
5
6
7
8
9
10

var
x: integer;

begin
repeat
readln(x)
until x >= 0; { <– выходим, если x>=0 }
writeln(‘Квадратный корень: ‘, sqrt(x):0:4);
readln
end.

Вводить с клавиатуры числа до тех пор, пока их сумма не превысит заданное наперед число. Как видим в строке 11, если сумма sum превысит число М, то выходим из цикла и выводим результат:

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14

var
x, M, sum: real;

begin
write(‘Введите контрольное число –> ‘);
readln(M);
sum := 0; { <- начальное значение суммы }
repeat
readln(x); { <- вводим x }
sum := sum + x { <- к сумме прибавляем x }
until sum > M; { <== выходим, если сумма превысит M }
writeln(‘Результат: ‘, sum);
readln
end.

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

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

var
n, pre: integer;
twoEqual: boolean;

begin
twoEqual := false; { <- нету пока равных чисел }
pre := 0; { <- начальное значение предыдущего числа }
writeln(‘Введите элементы последовательности:’);
repeat
read(n);
{ Вычисление twoEqual имеет смысл, если мы ещё не встретили два
равных соседних числа (т.е. при twoEqual=false). В таком случае,
если последнее введенное число n равно предыдущему pre (pre=n),
то индикатор twoEqual станет истинным и больше не изменится: }
if not twoEqual then twoEqual := (n = pre);
pre := n { <- предыдущим pre становится n }
until n = 0; { <- выходим при вводе 0 }
writeln;
if twoEqual then writeln(‘Содержит’)
else writeln(‘Не содержит’);
readln
end.

Вводится последовательность из N целых чисел. Найти наибольшее из всех отрицательных чисел. Первый вариант решения.

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

var
N, i, a, maxNegNum: integer;

begin
i := 0; { <– Номера вводимых чисел }
N := 10; { <– Количество вводимых чисел }
{ Начальное значение максимального отрицательного числа: }
maxNegNum := -MaxInt-1;
repeat
inc(i); { <– Увеличиваем номер вводимого числа }
read(a); { <– Ввордим число }
{ Поскольку нужно найти максимальное число только среди
отрицательных элементов, то положительные или нулевые
элементы нас не интересуют: для этого достаточно добавить
условие a<0. Потом при каждой итерации будем сравнивать
введенное число а с максимальным maxNegNum: если оно(число)
больше максимального, то заменим ним максииальное: maxNegNum=а. }
if (a < 0) and (a > maxNegNum) then maxNegNum := a
until i = N; { <– Выходим из цикла, если введены все N чисел }
writeln(‘Ответ: ‘, maxNegNum); { <– Выводим результат }
readln
end.

Вводится последовательность из N целых чисел. Найти наибольшее из всех отрицательных чисел. Второй вариант решения.

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

var
N, i, a, maxNegNum: integer;

begin
i := 0; { <– Количество введенных чисел }
N := 10; { <– Количество чисел для ввода }
maxNegNum := 0;{ <– Максимальное значение }
writeln(‘Введите ‘, N, ‘ целых чисел:’);
repeat
inc(i);
write(i, ‘) ‘);
readln(a);
if (a < 0) then { <– Проверяем только отрицательные числа }
{ Когда в наборе мы нашли первое отрицательное число,
величина maxNegNum равна 0, поэтому меняем её на а – это
и будет первое ненулевое значение для maxNegNum: }
if maxNegNum = 0 then maxNegNum := a
else { В остальных случаях maxNegNum сравниваем с а и находим большее: }
if (a > maxNegNum) then maxNegNum := a
until i = N; { <– Выходим, когда введены все числа }
{ Когда переменная maxNegNum отрицательная, то это означает, что в наборе
чисел есть отрицательные – тогда выводим максимальное из них, в противном
случае сообщаем об отсутствии отрицательных чисел: }
if maxNegNum < 0 then writeln(‘Максимальное отрицательное число: ‘, maxNegNum)
else writeln(‘В последовательности нет отрицательных чисел’);
readln
end.

Вводится последовательность из N целых чисел. Найти наибольшее из всех отрицательных чисел. Третий способ решения.

Этот вариант решения – это по сути перефразировка предыдущего способа, только здесь используется дополнительная логическая переменная-индикатор bln для указания присутствия или отсутствия отрицательных чисел. Сначала bln ставим false (строка 8). Заходим в цикл, вводим числа, и как только нашли отрицательное число (строка 14), первый раз, когда ещё bln=false, (или not bln), запоминаем это число как maxNegNum, а значение логической переменной меняем: bln=true (строки 15 – 18), что означает наличие отрицательных чисел в наборе. Для остальных отрицательных элементов сравниваем введенное а и maxNegNum, и запоминаем максимальное из них как maxNegNum – оно и будет максимальным среди отрицательных (строки 19 – 20).

Код Pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

var
N, i, a, maxNegNum: integer;
bln: boolean;

begin
i := 0;
N := 10;
bln := false;
writeln(‘Введите ‘, N, ‘ целых чисел:’);
repeat
inc(i);
write(i, ‘) ‘);
readln(a);
if (a < 0) then
if not bln then begin
maxNegNum := a;
bln := true
end
else
if (a > maxNegNum) then maxNegNum := a
until i = N;
if not bln then writeln(‘Нет отрицательных чисел’)
else writeln(‘Ответ: ‘, maxNegNum);
readln
end.

Это коротко об операторах цикла while и repeat. Что еще упущено выше, так это возможность каждый цикл с параметром for преобразовать в оператор с предусловием while или послеусловием repeat. Другие задачи на использование этих операторов вы найдете в разделе while по ссылке Задачник, или разделе Proc (процедуры и функции) того же раздела. Если что не понятно, то комментарии находятся ниже.

Источник

Циклы

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

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

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

for

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

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.

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

Источник