Оператор цикла с предусловием
Оператор имее вид:
While <условие> do
<тело цикла>;
Оператор работает следующим образом: пока справедливо условие, выполняется тело цикла, состоящее из одного или нескольких, объединенных в составной, операторов.
Пример:
Вычислить сумму
program summa1;
var
i,n:integer;
а, s,p:real;
begin
writeln(‘Ввести переменную а и количество слагаемых n’);
readln(a,n);
s:=0; p:=1; {s-сумма, p- факториалы- произведение чисел}
i:=1; { i – счетчик слагаемых }
while i<=n do
begin
p:=p* i;
s:=s+(2*i*a) /p;
i:=i+1;
end; {while}
writeln(‘Сумма=’.s:6:2);
readln;
end.
Оператор цикла с постусловием
Оператор имеет вид
Repeat
<тело цикла>;
until <условие>;
Оператор работает следующим образом: выполняется тело цикла, пока не станет справедливым условие. Как только условие примет значение – истина, осуществляется выход из цикла.
Пример
Вычислить сумму
,
x, n ввести с клавиатуры.
program summa2;
var
i,n,k,j: integer;
x,p,s: real;
begin
writeln(‘Ввести х, n’);
readln(x,n);
s:=0;
k:=-1;
i:=2;
repeat
p:=1;
for j:=1 to i-1 do
p:=p*j; !
s:=s+(k*p)/exp(i*ln(x));
i:=i+2; k:=-k;
until i>2*n;
writeln(‘Сумма=’,s:6:2);
readln;
end.
Пример
Подсчитать количество нечетных, отрицательных чисел и сумму положительных четных чисел, вводимых с клавиатуры. Ввод чисел и вычисления прекратить, когда будет введен 0.
program alfa;
var
k,s,a: integer;
begin
repeat
write(‘Ввести число ’);
readln(a);
if odd(a) and (a<0)
then inc(k)
else
if (a>0) and (a mod 2=0) then s:=s+a;
until a=0;
writeln(‘Количество нечетных отрицательных чисел=’,k,
’ Сумма четных положительных чисел=’,s);
readln;
end.
Пример
Из последовательности чисел, вводимых с клавиатуры посчитать количество четных и нечетных чисел, найти сумму четные чисел кратные трем. Ввод чисел прекратить, после ввода числа 32000.
program chetnechet;
var
c,chet,nechet,s3: integer;
begin
chet:=0;
nechet:=0;
s3:=0;
repeat
write(‘Ввести число ’);
readln(c);
if c<>32000 then
case odd(c) of
false: begin chet:=chet+1;
if c mod 3=0 then s3:=s3+c;
end;
true: nechet:=nechet+1;
end; {case}
until c=32000;
writeln (‘количество нечетных чисел=’,nechet);
writeln(‘количество четных чисел=’,chet,’ , сумма четных чисел кратных 3=’,s3);
readln;
end.
Процедуры и функции
В паскале существует два вида подпрограмм пользователя – процедуры и функции. Процедура может быть вызвана отдельным оператором, а функция может использоваться в выражениях. Подпрограммы должны находиться сразу после описательной части программы непосредственно перед ее телом.
Процедура имеет следующий формат
procedure <имя процедуры>(< формальные параметры>);
lable <метки>;
const <объявление констант>;
type <определение типов данных>;
var <объявление переменных>;
procedures and functions;
begin
<тело процедуры>;
end;
Структуры программы, процедуры и функции аналогичны и отличаются лишь заголовками.
Необходимо отметить, что все данные, определенные в описательной части процедуры являются локальными, т.е. доступными только этой процедуре. Данные, описанные в головной программе, доступны всем ее процедурам и функциям и называются глобальными. Передача данных из вызывающей программы в процедуру и обратно осуществляется через формальные параметры, которым при вызове процедуры присваиваются фактические параметры. Чтобы сделать доступными переменные для процедур и программ их вызывающих, они должны быть описаны в виде формальных параметров с ключевым словом Var. Если формальные параметры описаны без ключевого слова var, то в процедуру из головной программы передаются фактические значения и если они в процедуре как-то меняются, измененные значения в вызывающую программу не передаются, т.е. фактические параметры остаются неизменными. Количество и тип фактических параметров вызывающей программы должны совпадать с количеством и типом фиктивных параметров вызываемой подпрограммы.
Пример
Вычислить сумму
, для ч=2.1, n=10.
Решение
program sum1;
const
n=10;
x=2.1;
var
s, p:real;
I,z:integer;
procedure fact(k:integer, var f:real);
var
j:integer;
begin
f:=1;
for j:=1 to k do f:=f*j;
end;
begin
s:=0;
z:=1;
for i:=1 to n do
begin
fact(2*i, p);
s:=s+z*p/exp((2*i-1)*ln(x));
z:=-z;
end; {for i}
writeln(‘summa=’,s:8:3);
readln;
end.
Функция имеет такой же формат, что и процедура, но в качестве заголовка служит оператор:
Function <имя функции>(<формальные параметры и их тип>):<тип функции>;
Функция может быть вызвана в любом месте программы путем обращения к ней в выражениях математических, логических, либо каких0других. В заголовке программы обязательно необходимо задать тип функции, т.к. результат вычислений передается в вызывающую программу через имя функции, поэтому в самой функции конечный результат ее вычисления должен быть присвоен идентификатору функции.
Пример
Пусть необходимо вычислить ту же сумму, что и в предыдущем примере, но дл вычисления факториала при этом использовать функцию, а не процедуру:
, для х=2.1, n=10.
Решение
program sum1;
const
n=10;
x=2.1;
var
s, p:real;
I,z:integer;
function fct(k:integer):real;
var
j:integer;
begin
fct:=1;
for j:=1 to k do fct:=fct*j;
end;
begin
s:=0;
z:=1;
for i:=1 to n do
begin
s:=s+z*fct(2*i)/exp((2*i-1)*ln(x));
z:=-z;
end; {for i}
writeln(‘summa=’,s:8:3);
readln;
end.
Комментарии
Для внесения пояснений в программу можно вставлять комментарии, которые игнорирует компилятор, и используются лишь для удобства чтения программы. Комментарии ограничиваются либо фигурными скобками и записываются в виде: {<комментарии>}, либо символами (* *) и имеют вид:
(*<комментарии> *).
Оператор безусловного перехода
Оператор безусловного перехода нарушает порядок выполнения программы и имеет вид:
Goto(<метка>);
где <метка> - идентификатор метки, которым помечается оператор, на который нужно передать управление. После метки, помечающей оператор, ставится двоеточие. Все идентификаторы меток должны быть объявлены в описательной части программы в разделе меток label. Использование оператора Goto нежелательно, это считается низким уровнем программирования, поскольку паскаль позволяет составлять программы с использованием более прогрессивных способов, использующих составные операторы и другие логические приемы.
Пример
Вычислить и вывести на печать
, для х=0,5 
8,5; ∆х=0,5.
Вычисления прекратить и выйти из программы, если абсолютная величина знаменателя меньше 10-5.
program tab;
label m7;
const
xn=0.5;
xk=6.5;
h=0.5;
c=1e-5;
var
a,b,x,y,z:real;
begin
writeln(‘a, b=?’);
readln(a,b);
x:=xn;
writeln(‘ x y’);
while x<xk+h/2 do
begin
z:=sqr(x)*(a-b*x*sin(x));
if abs(z)<c
then
begin
writeln(‘’);
goto m7;
end;
y:=(a+b*cos(x))/z;
writeln(‘x=’,x:3:1,’ y=’,y:8:3):
x:=x+h;
end; {while}
7: writeln;
end.
Операторы досрочного выхода из цикла и прерывания программы
Оператор досрочного выхода их цикла имеет вид:
exit;
при его выполнении происходит переход к оператору, следующему за циклом.
Оператор прерывания программы имеет вид:
halt(n);
где n любое целое число. При прерывании программы на печать выводится число n, по которому не сложно установить, в каком месте программы произошло прерывание.
Тогда предыдущую задачу можно решить следующим образом:
program tab;
label m7;
const
xn=0.5;
xk=6.5;
h=0.5;
c=1e-5;
var
a,b,x,y,z:real;
begin
writeln(‘a, b=?’);
readln(a,b);
x:=xn;
writeln(‘ x y’);
while x<xk+h/2 do
begin
z:=sqr(x)*(a-b*x*sin(x));
if abs(z)<c
then
begin
writeln(‘’);
halt(1);
end;
y:=(a+b*cos(x))/z;
writeln(‘x=’,x:3:1,’ y=’,y:8:3):
x:=x+h;
end; {while}
7: writeln;
end.
Массивы
Массивы относятся к стрктурированным типам данных, т.е. к данным, задающим множество сложных значений, каждое из которых образует совокупность нескольких значений другого типа. Массивы называют еще регулярными типами данных. Регулярный тип означает ряд. Массивы названы так, потому что объединяют однотипные (логически однородые) элементы, упорядоченные по индексам. Индексы определяют положение каждого элемента в массиве.
Таким образом, можно сказать, что массив – это структурированный тип данных, состоящий из фиксированного числа элементов, имеющих один и тот же базовый тип.
В качестве элементов массива может быть использован любой, описанный ранее тип , поэтому могут существовать массивы целых чисел, массивы вещественных чисел, массивы строк, массивов, записей и т.д.
Особенностью языка паскаль и его недостатком является то, что число элементов массива фиксируется при при описании его в разделе типов или переменных и не может меняться в процессе выполнения программы.
Элементы массва упорядочены в массиве так, что каждому элементу соответствует индекс (номер), определяющий положение элемента в последовательности. Т.о., доступ к определенному элементу осуществляется при помощи этого индекса. В качестве индекса может использоваться любое выражение скалярного (перечисляемого) типа,. Нельзя использовать в качестве индексов переменные вещественного типа.
Описание массива имеет вид:
Type
<имя>=array[<тип индексов>] of <тип элементов>;
где <имя> - имя типа массив,
<тип индексов>] – границы изменения индекса ( минимальное значение индекса .. максимальное значение индекса,
<тип элементов>; - тип значений, входящих в массив.
При описании типа индексов массива используется в основном ограниченный тип данных, который имеет вид:
<минимальное значение> .. <максимальное значение>.
В зависимости от количества индексов массивы могут быть одномерными (вектор), двумерными (матрица), трехмерными (куб), .. n - мерными. Количество индексов ограничено лишь памятью компьютера.
Пример
type
a=array[1..10] of real;
c=array[‘a’..’z’] of integer;
k=array[1..50] of string[15];
var
d,m:a;
z:c,
r,w,p:k;
begin
d[1]:=1.2;
m[4]:=-3.25;
z[‘a’]:=12;
z[‘b’]:=-43;
r[1]:=’summa=’;
w[1]:=’Группа 1-71-1’;
end.
Массив может быть описан сразу в разделе переменных:
var
d,v:array[1..10] of real;
z:array[‘a’..’z’] of integer;
r,w,parray[1..50] of string[15];
Если в качестве базового типа используется другой массив, то образуется структура, описывающая многомерный массив.
Например,
Type
V=array[1..5] of integer;
w=array[1..6[ of v;
var
k:w;
Эта структура может быть записана в виде:
Var
K: array[1..6,1..5] of integer;
При этом первым индексом является номер строки (ее индекс изменяется в нашем примере от 1 до 6), вторым – столбца (от1 до 5). Таким образом, массив К состоит из 6 строк и 5 столбцов.
Элементы массива в памяти располагаются последовательно. Элементы с меньшими значениями индексов хранятся в более низких адресах памяти. Многомерные массивы хранятся так, что самый правый индекс изменяется первым. В нашем примере элементы массива будут храниться в следующей последовательности:
k1,1], k[1,2], k[1,3], k[1,4],k[1,5],k[1,6], k[2,1], k[2,2], k[2,3], … k[6,5].
При работе с массивами в логических операциях «=» и «<>», а также в операции присваивания «:=» можно использовать только имена массивов, если они имеют одинаковый тип индексов и одинаковый тип элементов и в перечисленных выше операциях участвуют все элементы.
Пример
var
a,b: array[1..5] of integer;
При выполнении нижеуказанных операций результат будет следующим:
a=b – true, если значение каждого элемента массива a равно соответствующему значению элемента массива b.
a<>b – true, если хотя бы одно значение элемента массива a не равно соответствующему значению элемента массива b.
a:=b – все значения элементов массива b присваиваются соответствующим элементам массива a; массив b при этом остается неизменным.
Константы типа массив в разделе констант описываются следующим образом:
const
<имя>:<имя типа>=(<значения констант>);
<имя>:<тип>=(<значения констант>);
Пример
type
a=array[1..4] of integer;
const
b : :a=(2,-3,6,1);
c: array{0..9] of char=(‘a’,’b’,’c’,’d’,’e’,’f’,’j’,’I’,’h’);
d: array[1..3,1..4)] of integer=((-1,3.-6,9), (2,-3,5,-5), (0,8,-4,-7));
Пример:
Упорядочить квадратную матрицу А[8,8], содержащую положительные и отрицательные элементы, полученные случайным образом, таким образом, чтобы максимальный по абсолютной величине элемент в строке был диагональным.
program alt;
uses crt;
var
a::array[1..8,1..8] of real;
max:real;
n,i,j:integer;
begin
randomize;
clrscr;
writeln(‘Исходный массив а’);
for i:=1 to 8 do
begin
for j:=1 to 8 do
begin
a[I,j]:=random-0.5;
write(a[i,j]:6:2:
end; {for j}
writeln;
end; {for i}
for i:=1 to 8 do
begin
max:=a[i,1];
n:=1;
for j:=2 to 8 do
if abs(max)<abs(a[i,j])
then
begin
max:=a[I,j]; {запоминание нового максимального элемента строки n:=j; в переменной max и его места в строке в переменной n }
end; {then}
if n<>i { если максимальный элемент не диагональный }
then { то, переставить его с диагональным }
a[i,n]:=a[i,i];
a[i,i]:=max;
end; {then}
end; {for i}
writeln(‘Новый массив а’);
for i:=1 to 8 do
begin
for j:=1 to 8 do write(a[i,j]:6:2):
writeln;
end; {for i}
readln;
end.
Упакованные массивы
Обычно один элемент массива занимает в оперативной памяти одно слово. В том случае, когда массив состоит из символов, наличие в одном машинном слове всего одного символа невыгодно. В этом случае в одном слове размещают несколько символов, т.е. массив упаковывают, что значительно экономит память. Упакованный массив описывается следующим образом:
<имя>:packed array[<тип индексов>]: of char;
Пример:
Из входного потока символов, состоящих из букв и пробелов, выделить слово и записать его в упакованный массив символов, содержащий максимум 16 букв. Если слово содержит меньше 16 букв, оставшиеся позиции заполнить пробелами.
program simvol;
type
word=packed array[1..16] of char;
var
a:word;
m,d: integer;
s:char;
begin
writeln(‘Начать ввод’);
repeat
read((s); {Ввод очередного символа}
until (s>’A”) and (s<’’z’); {Встретилась буква}
d:=0;
repeat
inc(d) ); {определение длины слова}
a[d]:=s; {запись очередной буквы в массив}
read(s); {чтение очередного символа}
until (s<’A’) or (s>’z’); {пока не выйдем за пределы слова}
for m:=d+1 to 16 do a[m]:=’ ‘; { заполнение пробелами лишних позиций}
writeln(‘Полученное слово’);
for m:=1 to 16 do write(a[i];
writeln;
readln;
end.
Упакованный массив образует символьную строку. Символьная строка может быть либо строковой констпантой, либо строковой переменной.
К строковым переменным и константам применимы операции отношения (<, <=, >, >=, <>, =), если они имеют динаковый тип тип индексов и одинаковую длину.
Например,
Const
s1=’abcd’;
s2=’abce’;
тогда
s1<s2 – true;
s1=s2 – false;
Строки
Ввиду громоздкости упакованных массивов намного проще работать со строковыми типами данных, в которых хранится текстовая информация.
Пример:
Упорядочить в алфавитном порядкесписок из 200 слов. Длина слова – 16 символов.
program simb1;
var
w: array[1..200] of string[16];
g: string[16];
i,n,k: integer;
begin
for i:=1 to 200 do
readln(w[i]); {Ввести очередное слово – формирование массива}
for i:=1 to 199 do {сортировка методом прямого доступа}
begin
g:=w[i]; {i –тый элемент считаем минимальным}
n:= i;
for k:=i to 200 do {поиск наименьшего элемента}
if w[k]<g {если принятый за минимальный элемент оказался не }
then {минимальным}
begin
g:=w[k]; { то заменить его на меньший}
n:=k; { запомнить место минимального элемента в массиве}
end;
if i<>n {если принятый за минимальный элемент оказался не }
then {минимальным}
begin
w[n]:=w[i];
w[i];=g; {поменять его местами с минимальным}
end; {then}
end; {for i}
for i:=1 to 200 do
write(w[i],’ ‘);
readln;
end.
Множества
Множество – это ограниченная совокупность различных элементов базового типа. В качестве базового типа, на котором строится конкретный множественный тип, используются скалярный и ограниченный типы данных.
Множественный тип данных задается в виде:
type
<Имя>= set of <тип>;
где <Имя> - имя типа,
<тип> - базовый тип, на котором строится множество.
Принадлежность переменных к множественному типу м.б. определена н В разделе переменных без определения имени типа в разделе type.
Пример
Множество гласных букв может быть определено следующим образом
type
b=’a’..’z’;
g=set of b;
var
glas:g;
или
type
b=’a’..’z’;
var
glas: set of b;
или
var
glas: set of char;
Множество включает в себя
1) набор элементов простого базового множества;
2) все подмножества данного множества;
3) пустое подмножество, т.е. подмножество, не содержащее ни одного элемента.
Значения переменных и констант множественного типа задаются с помощью конструктора множеств, который записывается в виде последовательности разного числа элементов базового типа, разделенных запятыми и заключенных в [ ]. Конструкция [ ] означает пустое подмножество.
Пример
var
glas: set of char;
begin
glas:=[ ];
glas:= [ ‘a’];
glas:=[‘a’,’e’];
……………….
glas:=[‘a’, ’e’, ‘i’, ‘u’, ‘o’, y’];
Пример
Годы учебы в вузе с 2009 по 2013 могут быть представлены в следующем виде
var
g: set of r;
begin
g:=[ ];
g:= [ 2009];
g:=[2009, 2010];
g:=[2009, 2012];
……………….
g:=[2009, 2010, 2011, 2012, 2013];
Если совокупность элементов, образующих значение переменной множественного типа, упорядочена в соответствии с заданным базовым типом, то можно не перечислять все элементы, записать только граничные, разделив их .. . Например g:=[2009..2013].
К переменным и константам множественного типа применимы операции
1) объединения +;
2) пересечения *;
3) вычитания -.
Например
[2009, 2011] + [2009, 2013] = [2009, 2011, 2013];
[2010]*[2009, 2010, 2012] = [2009];
[2009, 2010, 2011] - [2009, 2011] = [2010]
Дата добавления: 2016-02-24; просмотров: 754;