|
|
 |
|
|
|
|
|
|
|
|
Циклы
I. Цикл FOR ("повторять для").
Синтаксис (правило записи в Паскале) этого оператора:
for <переменная> := <начальное значение> to <конечное значение> do
begin
<тело цикла>
end;
Расшифровывается эта запись так: для <переменной> от <начального
значения> до <конечного значения> с шагом 1 выполнять <тело цикла>. Суть
состоит в том, что <переменной> (она еще называется переменная цикла)
присваивается <начальное значение>, и затем в цикле выполняются
следующие действия:
Например, пусть надо 100 раз умножить N само на себя.
Можно, конечно, написать:
P:=N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N
*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N
*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N*N;
но вряд ли это будет лучшей идеей. А с помощью цикла:
P := 1; { инициализация }
for i := 1 to 100 do
begin
P := P*N;
end;
Здесь i - целая переменная.
Значение переменной цикла можно использовать в теле цикла, но нельзя
изменять. Например:
P := 1; { инициализация }
for i := 1 to 100 do
begin
P := P*N;
writeln(i, '-ая степень числа ', N, ' равна ', P);
end;
Внимание! Переменная цикла должна иметь тип, значения которого можно
перенумеровать. Например, integer, char, boolean, перечислимый или
ограниченный. Нельзя использовать вещественный тип, т.к. его значения не
нумеруются.
Начальное и конечное значения должны иметь тот же тип, что и переменная
цикла. Причем конечное значение должно быть не меньше начального, иначе
цикл не выполнится ни раза (см. условие прекращения).
Можно написать и цикл, в котором переменная цикла изменяется от большего
к меньшему, но он записывается несколько иначе:
for <переменная> := <начальное значение> downto <конечное значение> do
begin
<тело цикла>
end;
<Начальное значение> и <конечное значение> могут быть не только
константами, но и переменными, и вообще любыми выражениями (того же
типа, что и <переменная> цикла).
Цикл for применяется, когда число повторений известно до начала цикла,
т.e. когда известны границы изменения переменной цикла. В противном
случае невозможно записать условие выполнения цикла. Кроме того, шаг
изменения переменной цикла всегда равен 1 или -1, и если требуется
изменять переменную с другим шагом, цикл for также не подходит.
Рассмотрим пример, в котором лучше всего применить цикл for.
Ввести последовательность целых чисел длины N (N > 0). Определить, как
расположены числа в последовательности:
a) в порядке возрастания
b) в порядке убывания
c) в беспорядке
Это задача с циклической структурой, хотя... это может быть неочевидно.
Порассуждаем немного о ее решении.
Что вводится? Число N (длина последовательности) и N целых чисел (сама
последовательность). Что выводится? Сообщение о том, какой из случаев
a),b),c) в данном случае имеет место. Как выяснить, какой? Разберемся с
первым. Слова "последовательность возрастает" означает, что ее элементы
подчиняются следующим условиям:
a1 <= a2 <= a3 <= ... <= aN
т.е. каждый следующий элемент больше предыдущего. Значит, условие
наличия случая a) звучит так "Для любого i от 2 до N выполняется a[i-1]
<= a[i] ". (a[i-1] в данном случае означает (i-1)-ый элемент
последовательности). Если хотя бы для одного i условие не выполняется,
последовательность не возрастает.
Аналогично для случая b).
Случай с) реализуется, когда ни a), ни b) не имеют место.
Каков алгоритм наших действий для решения задачи? Например, можно
выбрать такой порядок действий:
1. Ввести N.
2. Если N < 0 то вывести сообщение "неверные исходные данные" и
закончить программу, иначе
3. Присвоить переменным IsA и IsB значение истина
4. Ввести элемент a[1] и поместить его в переменную ap (эта переменная
будет хранить первый из пары необходимых нам одновременно элементов).
5. Для i от 2 до N с шагом изменения i, равным 1:
Ввести элемент a[i] (при самом первом выполнении i = 2, это второй
элемент из пары).
Сравнить элементы ap и a: если ap > a то изменить значение перемен ной
IsA на ложь; если ap < a то изменить значение переменной IsB на ложь.
Переместить элемент a в переменную ap (теперь а становится первым
элементом)
6. Если переменная IsA хранит значение истина то вывести сообщение
"последовательность возрастает"
7. Если переменная IsB хранит значение истина то вывести сообщение
"последовательность убывает"
8. Если обе переменные IsA и IsB хранят значение ложь то вывести
сообщение "элементы последовательности расположены в беспорядке"
program prim_31;
uses crt;
var i, n, a, ap: integer;
IsA, IsB: boolean;
begin
clrscr;
textcolor(cyan);
writeln('Определение характера последовательности');
write('Введите длину последовательности n=');
readln(n);
if n <= 0 then writeln('Неверные исходные данные')
else
begin
IsA := true;
IsB := true;
write('введите a[1]=');
readln(ap);
for i := 2 to n do
begin
write('введите a[', i, ']=');
readln(a);
if a < ap then IsA := false;
if a > ap then IsB := false;
ap := a;
end;
if IsA then writeln('Последовательность возрастает');
if IsB then writeln('Последовательность убывает');
if ( not IsA) and ( not IsB) then
writeln('элементы последовательности расположены в беспорядке');
end;
readln;
end.
II. Цикл WHILE ("повторять, пока").
Синтаксис:
while <условие повторения> do
begin
<тело цикла>
end;
Эта запись означает: повторять <тело цикла>, пока истинно <условие
повторения>
. <Условие повторения> - это логическое выражение.
Алгоритм выполнения этого цикла:
Внимание! Условие надо составлять так, чтобы через некоторое число
повторений оно стало ложным, иначе цикл не закончится никогда (ведь он
заканчивается, когда <условие повторения> становится ложным!). Такой
цикл называется бесконечным. Бесконечно выполняемой будет и программа, в
которой встретился хотя бы один такой цикл. Для Вас это означает, что
программа "зависнет", и Вы никогда не увидите результата. (На всякий
случай: для прерывания зависшей программы нажмите Ctrl+Break для всех
видов Pascal кроме
ABCPASCAL).
Если же условие выполнения ложно с самого начала, <тело цикла> не
выполнится ни разу.
Цикл while является более общим, нежели for. С помощью цикла while можно
for смоделировать. Например, для того же примера с сотой степенью N цикл
while будет выглядеть так:
i := 1; { инициализация i }
P := 1; { инициализация P }
while i <= 100 do
begin
P := P*N;
i := i+1;
end;
При прибавлении 1 к i, i рано или поздно превзойдет 100, и цикл
закончится.
В отличие от for, здесь значение переменной i можно изменять в теле
цикла.
Цикл while применяется, когда число повторений заранее неизвестно, зато
известно условие повторения, или когда шаг изменения переменной не равен
единице.
Рассмотрим пример для цикла while.
Вычислить значения функции f (x) = ax •2 + bx + c при x, изменяющемся от n до m с шагом h (n < m, h > 0). Шаг может быть не целым.
Цикл for нельзя применить сразу по двум причинам: шаг не равен единице
и, помимо этого, выражается вещественным числом. Впрочем правильнее
сказать так: переменная x не может быть переменной цикла for по этим
причинам (поскольку можно исхитриться и написать программу для этой
задачи с циклом for. Сами догадайтесь как).
А цикл while прямо-таки напрашивается на применение. Вообще любая
переменная X, которая "изменяется от N до M с шагом h ", будет
изменяться как надо внутри цикла
X := N;
while X < M do
begin
<тело цикла>
X := X+h;
end;
Наша задача как раз к таким и относится. И это все, что здесь было
сложного. Все остальное проще простого:
1. Ввести a, b, c, n, m, h
2. Если n > m или h < 0 то вывести сообщение "неверные исходные данные"
и закончить программу; иначе
3. Присвоить переменной x начальное значение, т.е. n
4. пока значение переменной x меньше конечного значения m выполнять:
вычислить значение f(x) по формуле
вывести текущие значения x и f(x)
прибавить к x шаг h.
5. Все!
А соответствующая программа на Паскале выглядит так:
program prim_32;
uses crt;
var a, b, c, n, m, h, x, f: real;
begin
clrscr;
textcolor(lightblue);
writeln('Вычисление значений функции f(x) = ax•2 + bx + c');
writeln('Введите a,b,c:');
readln(a, b, c);
writeln('Введите n,m и шаг h:');
readln(n, m, h);
if (n>m) or (h<0) then writeln('Неверные исходные данные')
else
begin
x := n;
while x < m do
begin
f := a*x*x + b*x + c;
writeln('f(', x, ')=', f);
x := x+h;
end;
end;
end.
III. Цикл REPEAT - UNTIL ("повторять, пока не").
Синтаксис:
repeat
<тело цикла>
until <условие прекращения>
Эта запись означает: выполнить <тело цикла>, и выполнять до тех пор,
пока <условие_прекращения> не станет истинным.
Алгоритм работы:
От while этот цикл отличается, во-первых, тем, что истинность условия
указывает, что цикл закончился, а, во-вторых, тем, что тело цикла
выполняется минимум один раз (в while и for оно может не выполниться ни
разу).
Наш пример со степенью N с применением этой разновидности цикла выглядит
так:
i := 1; { инициализация i }
P := 1; { инициализация P }
repeat
P := P*N;
i := i+1;
until i >= 100;
Цикл repeat- until применяется, когда число повторений заранее
неизвестно, зато известно условие прекращения (или повторения - оно
является отрицание условия прекращения, и наоборот), и тело цикла должно
выполниться хотя бы один раз. Например, если значение условия
становиться ясным только в результате выполнения тела цикла. Тогда while
менее удобен.
Рассмотрим пример с циклом repeat- until.
Ввести последовательность целых чисел. Признаком конца считать ввод 0.
Определить процент чисел в последовательности, делящихся нацело на 10.
Цикл repeat- until здесь более удобен, чем while, поскольку, нам нужно
вводить числа, пока не встретится 0, а чтобы сравнить число с нулем,
нужно его сначала ввести. Если сравнение выполняется после тела цикла
(как в repeat- until), то нет проблем, а если до (как в while), тело
цикла придется целиком повторить перед его началом, чтобы ввести число
для сравнения с 0. Поэтому программа с repeat- until в данном случае
будет короче. Цикл же for неприменим принципиально, поскольку неизвестно
количество повторений.
Сама программа проста: условие прекращения известно (введенное число
равно 0); в теле цикла нужно вводить очередное число и проверять,
делится ли оно на 10. Cложность может возникнуть с вычислением процента.
Сделаем так: подсчитаем общее количество введенных чисел и количество
положительных. Тогда процент положительных вычисляется по формуле
Естественно, вычисление процента в тело цикла не входит, так как
выполняется только один раз (зачем больше-то?) после ввода всех чисел, а
значит, по окончании цикла.
Алгоритм:
1. Обнулить переменные для хранения количеств положительных и всех чисел
(перед тем, как мы введем первое число они очевидно равны 0!)
2. Ввести a (т.е. очередное число)
3. Увеличить количество всех чисел на 1
4. если a > 0 то увеличить количество положительных чисел на 1
5. если a = 0 то закончить цикл, иначе перейти на шаг 2
6. Вычислить процент положительных чисел.
7. Вывести этот процент
Переменную для хранения количества всех чисел назовем n, для хранения
количества положительных - p. Программа на Паскале:
program prim3;
uses crt;
var percent, p, n, a: integer;
begin
clrscr;
textcolor(lightred);
writeln('Определение процента положительных элементов в
последовательности');
n := 0;
p := 0;
repeat
write('Введите a[',n,']=');
readln(a);
n := n + 1;
if a mod 10 = 0 then p := p + 1;
until a = 0;
percent := p/n*100;
writeln('Процент положительных элементов составляет ', percent:6:2);
end.
Обратите внимание на способ проверки делимости на 10: для этого
достаточно взять остаток от деления на 10 (это делает операция mod),
если он равен 0, то число делится на 10 нацело. Также можно проверить
делимость на любое другое число.
ПОЛЕЗНЫЕ СОВЕТЫ.
1. Не используйте в качестве переменной цикла for
вещественную переменную. Это запрещено.
2. Не изменяйте значение переменной цикла for в теле этого цикла - Вы
можете получить разнообразные неприятные эффекты.
3. Помещайте в тело цикла только те операторы, которые должны
выполняться несколько раз.
4. Для переменной с шагом изменения, не равным 1 или -1, цикл for
написать невозможно.
5. Не забывайте об инициализации переменной цикла while перед его
началом.
6. Следите за тем, чтобы циклы while и repeat- until заканчивались (т.е.
чтобы их условия меняли значение с истины на ложь и наоборот). Если Ваша
программа не завершается в течении 1 минуты, скорее всего, в ней имеется
бесконечный цикл. Прервать такую программу можно только нажав Ctrl+Break