Сложное ветвление N-го порядка имеет один существенный недостаток: Приходится писать большое количество однотипных операторов IF-THEN-ELSE. Такую структуру может заменить компактный оператор варианта CASE-OF. Синтаксис этого оператора представлен ниже:
CASE имя_переменной OF
<Вариант1> : [Оператор_1];
………………….
<ВариантN> : [Оператор_N];
ELSE [Оператор_N+1];
END;
Если переменная с именем, указанным после CASE, принимает значение одного из нижеприведенных диапазонов, то выполняется соответствующий блок операторов. Если ни в один из диапазонов ее значение не попадает, то выполняется альтернативные операторы, стоящие после ELSE. Если же альтернативная ветвь отсутствует, то программа выходит из оператора, ничего не исполнив.
Пример:
Program ZACHET;
Uses crt;
Label metka;
Var examination:char;
Begin
metka: write(‘зачет (Y/N)?-’);
readln(examination);
Case examination of
‘Y’: write(‘зачет’);
‘N’: write(‘не зачет’);
‘I’: write(‘не явка’);
Else Goto metka;
End;
Repeat Until KeyPressed;
End.
На экране
зачет (Y/N)?-Да нужно повторить ввод, т.к. набрано на русском языке.
Циклическим (циклом) называется такой алгоритм, в котором некоторая группа действий повторяется неоднократно. Группа действий, повторяемая в цикле, называется телом цикл. Однократное выполнение тела цикла называется шагом. Для того чтобы алгоритм не зацикливался (не стал бесконечным), циклом надо управлять. Для это используется специальная величина – параметр цикла. Параметр (переменная) цикла – это величина, которая изменяется от шага к шагу и по значению которой определяются, продолжать исполнение цикла или закончить его. Если количество повторений известно заранее, то это определенный цикл, если определяется в процессе работ цикла, то это неопределенный цикл.
Циклы по числу повторений делятся на циклы с заданным числом повторений и итерационные.
-В итерационных циклах выполнение цикла оканчивается при выполнении общего условия, связанного с проверкой монотонно изменяющейся величины.
- Вложенные циклы – это, когда определённый цикл повторяется многократно в другом цикле охватывающем данный.
Определенные циклы ‘FOR…DO…’
Определенный цикл FOR-DO (цикл со счетчиком) имеет следующую структуру:
(ОТ ДО)
FOR <перем_цикла>:=<нач_знач> TO <конеч_знач> DO
Begin
<тело_цикла>
End;
<перем_цикла> - переменная цикла- любая переменная целочисленного типа (Например INTEGER, кроме REAL). Переменную цикла также называют счетчиком.
<нач_знач> - начальное значение - выражение того же типа;
<конеч_знач> - конечное значение - выражение того же типа;
При выполнении оператора FOR вначале вычисляется выражение <нач_знач> и осуществляется присваивание <перем_цикла>:=<нач_знач>. После этого циклически повторяется:
- проверка условия <перем_цикла> <= <конеч_знач>; если условие не выполнено, оператор FOR завершает свою работу;
- выполнение операторов входящих в <тело_цикла>;
- наращивание переменной <перем_цикла> на единицу;
Первая форма записи оператора FOR с последовательным увеличением счетчика.
ü Для целой переменной строится цикл с шагом +1 по возрастанию параметра
for i:=1 to 8 do Оператор;
В этом случае i последовательно принимает значения 1,2,3,..,8.
ü Попытка организовать цикл «от большего к меньшему»
for i:=8 to 1 do Оператор;
не приведет к ошибке, но будет пройден лишь один шаг (i=8).
Пример: Написать программу для вычисления суммы N первых натуральных чисел, т.е. требуется вычислить 1+2+3+…N
Program PRIMER;
Var
N: integer; {последнее число суммы- исходное данное}
i, s :integer; {счетчик цикла и слагаемое, сумма результата}
Begin
Write(‘N’);Readln(N); {Вводим значение N}
s:=0; {Начальное значение суммы}
for i:=1 to N do {Цикл подсчета суммы}
s:=s+i;
Writeln(‘S = ’, s); {вывод на экран результата}
End.
Замечание 1. Условие <перем_цикла> <= <конеч_знач>, управляющее работой
цикла FOR-DO проверяется перед выполнением тела цикла: если условие не выполняется в самом начале работы цикла FOR-DO, цикл не будет выполнен ни разу.
Замечание 2. Шаг наращивания параметра цикла строго постоянен и равен 1.
Замечание 3. Внутри тела цикла нельзя менять значения переменной цикла, то есть если i – переменная цикла, то в цикле недопустимо присвоение i какого-нибудь значения: i:=5 неверно.
Вторая форма записи оператора FOR c уменьшением счетчика:
FOR <перем_цикла>:=<нач_знач> DOWNTO <конеч_знач> DO
Begin
<тело_цикла>
End;
Замена зарезервированного слова TO на DOWNTO означает, что шаг наращивания переменной цикла равен (-1).
Пример . for i:=8 downto 2 do Оператор;
В этом случае i последовательно принимает значения 8,7,6,…2
Пример. Написать программу для вычисления суммы N первых натуральных, т.е. требуется вычислить 1+2+3+…N
Фрагмент программы:
s:=0;
for i:=N downto 1 do {от N до 1 вниз}
s:=s+i;
Замечание: Если в цикле выполняется один оператор, то его можно не ставить в последовательно операторов Begin-End.
Циклы с постусловием ‘REPEAT…UNTIL…’
(Повтор Пока не готовы)
Синтаксис оператора цикла REPEAT…UNTIL:
REPEAT
<тело_цикла>
{операторы begin-end не требуются}
UNTIL <логическое условие>
Здесь REPEAT, UNTIL – зарезервированные слова (повторять до тех пор, пока не будет выполнено условие);
Операторы <тело_цикла> выполняются хотя бы один раз, после чего вычисляется выражение <условие>: если его значение есть FALSE (ложь), операторы <тело_цикла> повторяются, в противном случае оператор REPEAT…UNTIL завершает свою работу.
Обратите внимание: пара REPEAT…UNTIL подобна операторным скобкам begin…end, поэтому перед Until ставить точку с запятой необязательно.
Алгоритм выполнения: Выполнять тело цикла, пока не станет истинным(true) условие, т.е. пока условие ложно (false) выполняется цикл. После слова UNTIL надо записывать условие завершение цикла. Даже если условие сразу окажется истинным, цикл выполнится хотя бы один раз.
1) Выполнение цикла продолжается, если проверка логического условия дает результат ложь;
2) Если логическое условие выполнено выход из цикла.
Пример. Написать программу для вычисления суммы N первых натуральных, т.е. требуется вычислить 1+2+3+…N
Фрагмент программы
s:=o; {начальное значение суммы)
i:=1; {начальное значение счетчика и слагаемое}
REPEAT
s:=s+i; {добавим слагаемое к сумме}
i:=i+1; {увеличение значения счетчика и слагаемое на 1}
UNTIL i>N; {вып. пока ложно, условие завершение цикла)
Циклы с предусловием ‘WHILE…DO…’
(Пока Делать)
Синтаксис оператора цикла ‘WHILE…DO…’:
WHILE <логическое условие> DO
Begin
<тело_цикла>
End;
Здесь WHILE, DO – зарезервированные слова (пока [выполняется условие] делать);
Если выражение <условие> имеет значение TRUE (истина), то выполняется <тело_цикла>, после чего вычисление выражения <условие> и его проверка повторяются. Если условие имеет значение FALSE (ложь), оператор WHILE прекращает свою работу.
Замечание. Если <тело_цикл> состоит из одного оператора, слова begin end могут быть опущены.
Алгоритм выполнения: Пока условие истинно, выполнять операторы тела цикла. Если условие сразу оказывается ложным, цикл не будет выполнен ни разу.
While проверялось условие продолжения цикла.
После WHILE записывать условие выполнения операторов цикла.
Пример. Написать программу для вычисления суммы N первых натуральных, т.е. требуется вычислить 1+2+3+…N
Фрагмент программы
s:=o; {начальное значение суммы)
i:=1; {начальное значение счетчика и слагаемое}
WHILE i<=N DO {нужно выполнить цикл N раз}
s:=s+i; {добавим слагаемое к сумме}
i:=i+1; {увеличение значения счетчика и слагаемое на 1}
End; {законченное тело цикла}
Пример. Вычислить факториал числа N(N!).
ФАКТОРИАЛОМ называют такую функцию целочисленного аргумента
f(i), что f(0) = 1 ; f(i) = i * f(i-l)
Тогда
f(l) = l*f(0) =1*1 = 1
f(2) = 2*f(l) = 2*1 = 2
f(3) = 3*f(2) = 3*2*1 = 6
f(4) = 4*f(3) = 4*3*2*1 = 24 и т.д.
Получаем, что факториал числа N - это произведение всех натуральных чисел от 1 до N. Дополнительная трудность заключается в том, что факториал нуля есть 1 (как результат договора между математиками), а факториал отрицательного аргумент не определен. Убедитесь самостоятельно в том, что поставленная задача решается с помощью программы:
Program Factorial;
Uses CRT;
Label start;
Var
n,i:Integer;
t:LongInt;
Begin
start:ClrScr;
Write('N = '); Readln(n);
If (n<0) Then Begin
Writeln('N>=0!!!');
Goto start;
End
Else If (n=0) Then t:=l
Else Begin t: = l;
for i:=l to n Do t:=t*i;
End;
Writeln('Факториал числа ',n,' равен ',t);
Repeat Until KeyPressed
End.
Ответ:
N = -3
N>=0!!!
N- = 8
Факториал числа 8 равен 40320
Если не поставить начальное значение t=l перед циклом, то по умолчанию ЭВМ обнулит t, из-за чего и все произведение будет равно нулю. Заметьте, что факториал настолько быстро растет,что результат пришлось описывать типом LongInt. Уже 8! оказалось больше числа MaxInt.
Пример. Вычислить сумму S=ln3+ln5+ln7+…
при условии, что в нее входят слагаемые, не превосходящие 5, и количество этих слагаемых.
Логика построения суммы очевидна: s:=s+ln(i)/ Главная проблема заключается в постановке условия на выход из цикла.
Program Logorif;
Uses CRT;
Var
i, j: byte; a, s:real;
Begin
ClrScr;
j:=1; i:=3; a:=ln(i); s:=0;
While (a<5) do
Begin
s:=s+a;
inc(j); inc(i,2);
a:=ln(i);
End;
Writeln(j-1, ' slagaemich');
Writeln('сумма = ',s:7:3);
Repeat Until KeyPressed; {стандартная функция из библиотеки CRT, приводит к задержке окна
результатов до нажатия любой клавиши}
End.
Результат работы программы 73 слагаемых, сумма=296.140.
Вложенные циклы
Вложенные циклы – это структура, при которой один цикл вносится в другой. Пример рассмотрим на практическом занятии.
Рекурсивные функции
В ряде случаев удается создать цикл, не прибегая к операторам FOR-DO,REPEAT-UNTIL, WHILE-DO с помощью функции или процедуры, такие функции вызывающие сами себя, называют рекурсивными, а процесс их вычисления – рекурсией.
Структура похожа на матрешку: внешний синус sin(1+…) имеет аргументом следующий синус sin(2+…) и т.д. Введем функцию FUN, которая будет при вычислении синуса вызывать себя же, но для большего значения аргумента.
Program Recurcia;
Uses CRT;
Function Fun(x:Byte):Real;
Begin
If (x=15) Then Fun:=Sin(x)
Else Fun:=Sin(x+Fun(x+1));
End;
Begin
ClrScr;
Writeln('F= ',Fun(1):6:3);
Repeat Until Keypressed; End. Ответ: F=0.994
Операторы прерывания
Операторы Break и Continue
введены в язык Турбо Паскаль версии 7.0 для удобного управления ходом цикла.
1)Break ([breik]перевод с англ. – прерывать)– выход из цикла, прерывание выполнения цикла.
2)Continue (перевод с англ. – продолжать) – переход к следующему шагу цикла.
Пример. Найти сумму S=2+4+6…, не превосходящую 100.
Заметим, что цикл по четным числам можно завести различными способами: Цикл FOR_DO с проверкой условия IF(Not ODD(i)); Цикл While_Do или Repeat_Until с увеличением параметра цикла на два Inc(i,2) и т. п. С использованием оператора “CONTINUE” возможна и другая логика – завести цикл FOR_DO по значениям, идущим подряд, но при появление нечетных значений переходить к следующей итерации цикла. Далее, когда сумма превысит 100, можно выйти из цикла с помощью BREAK. Тогда текст программы:
Program sum1;
Uses CRT;
Var
s: integer; i: byte;
Begin
ClrScr;
s:=0;
For i:=1 to High(Byte) do {Стандартные функции}
begin
if Odd(i) then Continue;
s:=s+i;
if (s>100) then break;
end;
s:=s-i;
Writeln(' s= ',s); Repeat Until Keypressed; End.
Лекция 8
Обработка одномерных и двумерных массивов
Понятие и описание массива
Массив – это совокупность однотипных данных, хранящихся в последовательных ячейках памяти и имеющих общее имя. Ячейки называются элементами массива. Все элементы пронумерованы по порядку, и этот номер называется индексом элемента массива. Все элементы массива имеют один и тот же тип данных. Сам массив при этом имеет имя – одно для всех элементов. Для обращения к конкретному элементу массива нужно указать имя массива и в квадратных скобках индекс элемента.
Описание массива
<Имя массива>:array[<тип индекса>] of <тип компонентов>;
<тип компонентов> - это тип данных, который имеет каждый элемент массива,
Сейчас Massive - это тип, соответствующей последовательности из семи целочисленных чисел (одномерный массив длины 7):
t[1]
t[2]
t[3]
t[4]
t[5]
t[6]
t[7]
Индекс i=1 2 3 4 5 6 7
t[1] – обозначение 1-го элемента массива
Замечание. Попытка извлечь элемент с индексом, не лежащим в диапазоне от 1 до 7 приведут к сообщению об ошибке Constant out of Range (вне установленных рамок).
Двухмерный массив t[i,j] характеризуется двумя индексами .
t[1..4,1..7] – это двумерный массив размерности 4х7
Type
Matrix=array[1..4,1..7] of integer;
Var T:Matriix;
Трехмерный массив t[i,j,k] характеризуются тремя индексами – размерность 4х7х12, а тип описывается так:
Type
Massive=array[1..12] of integer;
Matrix=array[1..4,1..7] of integer;
Var
T:Matrix of Massive;
Замечание. В Паскале размерность массива практически неограниченна. Единственное ограничение заключается в том, что размер возникающей структуры не должен превышать примерно 64 КБ. Пример если массив состоит из вещественных чисел (6 байт), то их не может быть более 10797; аналогичный предел для чисел типа Integer (2 байта) – 32392.
Способы ввода одномерных массивов:
Предположим, что массив уже описан в программе. Например:
Const n=15;
Type Massive=array[1..n] of integer; {Определение типов ‘TYPE’}
Var {Описание переменных}
a: array [0..8] of string[20];
b, с : array [10..n+5] of real;
d: Massive;
Как только в памяти машины вырезаны ленточки нужной длины, эти ячейки заполняются нулями. Теперь нам предстоит их заполнить конкретными значениями.
1. Способ последовательное присваивание элементам массива соответствующий значений.
Фрагмент программы:
Const n=10;
Var
a: array [2..n] of integer;
Begin
a[2]:=-4,a[4]:=-6; a[5]:=10; a[9]:=-12;
В результате в соответствующие ячейки ленточки ‘a’ заносятся нужные значения, а остальные элементы по-прежнему равны нулю:
-4
-6
-12
t[2]
t[3]
t[4]
t[5]
t[6]
t[7]
t[8]
t[9]
t[10]
Eсли в массиве много элементов, но не вводить же 50 элементов массива пятьюдесятью операторами присваивания!
2. Способ ввода массива с клавиатуры.
Стандарт ввода массива A из n элементов:
For i:= 1 to n do Begin
Write(‘a[‘,i,’]=?);
Readln(a[i]);
End;
В результате запрашивается последовательно элементы массива a[1]=?, a[2]=?, …a[n]=? Этот способ ввода хорош тем, что пользователь видит элементы, которые вводит. Но, ошибившись с вводом одного элемента, он вынужден продолжать ввод, пока не закончится цикл. Далее, при повторном запуске программы пользователю придется вновь вводить те же самые элементы. Поэтому предпочтительнее последующие способы ввода.
3. Способ ввода массива, заданного формулой.
Этот способ ввода наиболее прост, удобен, но реализуется он редко из-за того, что в нашем мире мало что происходит по формулам. Введем массивы А, В, С, D такие, что:
A – массив заглавных латинских букв;
B – массив четных байтовых чисел;
C – массив степеней двойки от нулевой до двадцатой;
D – массив, где каждый элемент равен синусу его номера, а номера не превосходят 100.
Соответствующий фрагмент программы:
Var i: byte; t :LongInt;
a: array [1..26] of Char;
b: array [0..50] of Byte;
c: array [0..20] of LongInt;
d: array [0..100] of Real;
Begin
For i:=1 to 26 do a[i]:=chr(i+64);
For i:=0 to 50 do b[i]:=2*i;
t:=1; c[0]:=1;
For i:=1 to 20 do begin
t:=t*2; c[i]:=t;
end;
For i:=0 to 100 do d[i]:=sin(i);
Заметьте, во-первых, что ASCII – коды заглавных латинских изменяются от 65 до 90, что и позволяет реализовать формулу a[i]:=chr(i+64);. Во-вторых, степени двойки накапливались в целочисленной ячейке t, что чуть более громоздко, чем реализация формулы b[i]:=exp(i*ln(2)), но зато получается результат целого, а не вещественного типа.
4. Способ ввода массива через типизированные константы.
В этом случае, если при последующих запусках на исполнение программа будет обрабатывать один и тот же массив, имеет смысл ввести его в программе через типизированные константы. Получаем следующую структуру ввода массива:
Const n=10;
Type Massive=array[1..n] of Real;
Const
a: Massive=(-2,0,8,9,5,-9,2,0,6,-7);
Теперь в программе вполне можно использовать массив а[i] из 10 элементов с начальными значениями a[1]:=-2.0, a[2]:=0.0… Если мы изменим количество элементов в большую или меньшую сторону, то вырезаемая в структуре TYPE-CONST ленточка окажется или слишком большой, или слишком маленькой для восьми перечисляемых чисел. В результате ЭВМ сообщениями об ошибках либо предложит добавить числа в перечень, либо выбросить из него последние числа. Это снижает универсальность ввода.
5. Способ ввода массива через генератор случайных чисел.
Если конкретные значения элементов массива не играют роли, то можно позволить себе ввести их случайным образом. Для этого необходимо знать: 1) Тип элементов массива, 2) Примерный диапазон их возможных значений.
Генерация случайных чисел осуществляется с помощью функций Random или Random(N). В первом случае генерируется случайное ВЕЩЕСТВЕННОЕ число от 0 до 1. Если умножить Random на число N, то будет получено случайное ВЕЩЕСТВЕННОЕ число от 0 до N. Функция Random(N) производит генерацию случайного ЦЕЛОГО числа от 0 до N.
Пример. Сгенерируем 10 случайных целых чисел, заключенных на отрезке от 0 до 100:
Program Random_Int;
Uses CRT;
Var
i: byte;
Begin
{ Randomize; }
For i:=1 to 10 do Write(Random(100),’ ‘);
Writeln;
Repeat Until KeyPressed;
End.
Результат работы программы:
0 3 86 20 27 67 31 16 37 42
Запустим программу еще раз. Вновь получим ряд чисел:
0 3 86 20 27 67 31 16 37 42
Следовательно, о случайности производимых чисел можно говорить лишь с некоторой приближенностью, ибо программа генерации этих чисел каждый раз производит одни и те же числа. Но если убрать фигурные скобки вокруг слова Randomize, тогда процедура изменения программы генерации случайных чисел Randomize уже будет запускаться при исполнении программы, меняя результат:
6 47 70 17 41 40 70 80 50 35
И еще раз:
4 16 21 3 29 60 74 33 73 32
Если требуется получить случайные числа x, принадлежащие отрезку [a,b], можно воспользоваться формулами:
x:=a+Random(b-a) - для целых чисел;
x:=a+(b-a) *Random- для вещественных чисел;
В приведенных соотношениях генератор случайных чисел в первую очередь масштабируется по длине отрезка (b-a), а потом результат сдвигается на а.
Печать массива
Пусть в программе уже стандартизирована константа N, соответствующая количеству элементов массива, и сам тип Massive:
Const n=15;
Type Massive=array[1..n] of real;
Тогда печать массива целесообразно оформить как процедуры, учитывая то, что эта операция выполняется довольно часто:
Procedure PrintMas(aa: Massive);
Var ii: byte;
Begin
Writeln;
For ii:=1 to n do Write(aa[ii]:6:2,’ ‘); {вывод на экран результата}
Writeln; Writeln;
End;
Заметим, что процедура вызывается PrintMas(Имя_Массива), то есть требуется лишь имя распечатываемого массива. При этом предполагается, что элементы массива относятся к типу Real. Если мы заменим тип Real на Integer, то придется исправить еще и формат вывода, убрав одну лишнюю цифру, так как формат aa[ii]:6:2 соответствует выводу вещественных чисел.
Локальная обработка массива
Локальной обработкой массива называют такую обработку, при которой обрабатываются не все элементы, а лишь те, что удовлетворяют некоторым условиям. При этом условия могут накладываться на индексы элементов, на сами элемент или по комбинированным условиям.
Пример. Дан массив a, состоящий из 10 целых чисел. Найти 1) количество нулевых; 2) сумму положительных; 3) произведение отрицательных элементов массива.
