Программа выводящая на экран таблицу сложения натуральных чисел от 1 до 9.
Рrogram addition table;
Uses Crt;
const n = 9;
Var
a : array [1..9, 1..9] of Integer;
i, j : Integer;
Вegin
CIrScr;
for i : = 1 to n do
for j := 1 to n do a[i ,j] := i + j;
for i := 1 to n do
begin
for j := 1 to n do write(a[i, j], ‘ | ‘);
writeln;
end;
readln;
Еnd.
Формирование нового одномерного массива из элементов заданного массива. (Дан массив X(N). Получим новый массив Y(N), такой, что в нём сначала идут положительные числа, затем нулевые и затем отрицательные из Х).
Program NewOrder;
Uses Crt;
var N, i, k : Integer;
X,Y : Array [1..20] of Real;
Begin
CIrScr;
Write(‘ Введите N =');
readln(N);
For i := 1 to N do
begin
Write('X[', i,' ] = ');
readln(X[i]);
end;
k:=0;
For i := 1 to N do
If X[i]>0 then
begin
k:=k+l;
Y[k]:=X[i];
end;
For i := 1 to N do
If X[i]=0 then
begin
k:=k+l;
Y[k]:=X[i];
end;
For i:= 1 to N do
If X[i]<0 then
begin
k:=k+l;
Y[k]:=X[i];
end;
write('O т в е т: полученный массив');
For i := 1 to N do write(Y[i]: 5 : 1);
writeln;
readln;
End.
Формирование списка кандидатов в школьную баскетбольную команду. (В баскетбольную команду могут быть приняты ученики, рост которых превышает 170 см).
ProgramBascetBall;
Uses Crt;
Var
SurName : Array [1..30] of String; { фамилии учеников}
Height : Array [ 1.. 30] of Real; { рост учеников }
Cand : Array [ 1.. 30] of String; { фамилии кандидатов }
NPupil, i, К : Integer { NPupil - число учеников, К — количество зачисленных}
Begin
CIrScr;
write('BКОМАНДУ ЗАЧИСЛЯЮТСЯ УЧЕНИКИ,');
writeln('POCT КОТОРЫХ ПРЕВЫШАЕТ 170 CM.');
writeln;
write('Cколько всего учеников ? ');
readln(NPupil);
writeln(‘ Введитефамилии и рост учеников:');
For i := 1 to NPupil do
begin
write(i,'.Фамилия -');
readln(SurName[i]);
write(' Рост-');
readln(Height[i]);
end;
writeln;
K:=0; { Составление списка команды}
For i := 1 to NPupil do
If Height[i]>170 then
begin
K:=K+1;
Cand[K] := SurName[i];
end;
If K=0 then writeln('B КЛАССЕ НЕТ КАНДИДАТОВ В КОМАНДУ.')
else
begin
writeln(‘KAHДИДATbI В БАСКЕТБОЛЬНУЮ КОМАНДУ:');
For i := 1 to К do writeln( i, '. ', Cand[i]);
end;
readln;
End.
Подсчет суммы элементов двухмерного массива.
Program NewOrder;
Uses Crt;
var a:array[1..10,1..2] of integer;
s:longint;
i,j:integer;
Вegin
CIrScr;
writeln('введете 20 элементов массива');
s:=0;
for i:=1 to 10 do
begin
for j:=1 to 2 do
begin
readln( a[i,j] );
s:=s+a[i,j];
end;
end;
writeln( 'Сумма элементов массива = ', s );
readln;
Еnd.
Поиск максимального элемента в массиве.
Program max;
Uses Crt;
var a: array[1..10] of integer;
max: integer;
i: integer;
Вegin
writeln('введите 10 элементов массива');
max:=-(MAXINT+1);
for i:=1 to 10 do
begin
readln( a[i] );
if max<a[i] then max:=a[i];
end;
writeln( 'Максимальный элемент массива = ', max );
readln;
Еnd.
Поиск среднего арифметического в массиве.
Program sred;
Uses Crt;
var a: array[1..10] of integer;
s: longint;
i, n: integer;
Вegin
CIrScr;
s:=0; n:=0;
writeln('введите 10 элементов массива');
for i:=1 to 10 do
begin
readln( a[i] );
s:=s+a[i]; inc(n);
end;
writeln( 'Среднее арифметическое в массиве = ', s/n );
readln;
Еnd.
Печать всех элементов массива из интервала C..D.
Program cd;
Uses Crt;
var a: array[1..10] of integer;
c, d: integer;
i: integer;
Begin
CIrScr;
writeln('введите 10 элементов массива');
for i:=1 to 10 do readln( a[i] );
writeln('введите интервал C и D');
readln( c,d );
for i:=1 to 10 do
begin
if (a[i]>=C) and (a[i]<=D) then writeln(a[i]);
end;
readln;
Еnd.
Циклический сдвиг элементов массива вправо.
Program sdvig;
Uses Crt;
var a: array[1..10] of integer;
x: integer;
i: integer;
Вegin
CIrScr;
writeln('введите 10 элементов массива');
for i:=1 to 10 do readln( a[i] );
x:=a[10];
for i:=10 to 2 do
begin
a[i]:=a[i-1];
end;
a[1]:=x;
writeln('после сдвига:');
for i:=1 to 10 do writeln( a[i] );
readln;
Еnd.
Вывод самого часто встречающегося элемента из массива.
Program chasto;
Uses Crt;
var a: array[1..10] of integer;
i, j, m, p, n: integer;
Вegin
CIrScr;
writeln('введите 10 элементов массива');
for i:=1 to 10 do readln( a[i] );
m:=1; p:=1;
for i:=1 to 10 do begin
n:=0;
for j:=1 to 10 do begin
if a[i]=a[j] then inc(n);
end;
if n>m then begin
m:=n; p:=i;
end;
end;
writeln('самый часто встречающийся элемент:', a[p]);
readln;
Еnd.
Определение все ли элементы массива различны?
Program raz;
Uses Crt;
var a:array[1..10] of integer;
i,j:integer;
Вegin
CIrScr;
writeln('введите 10 элементов массива');
for i:=1 to 10 do readln( a[i] );
i:=1;
while (i<10) and (j<11) do begin
j:=i+1;
while (j<11) and (a[i]<>a[j]) do inc(j);
inc(i);
end;
if i<11 then writeln('в массиве есть одинаковые элементы')
else writeln('все элементы массива различны');
readln;
Еnd.
АЛГОРИТМЫ СОРТИРОВКИ
Простейшая задача сортировки заключается в упорядочении элементов массива по возрастанию или убыванию. Другой задачей является упорядочение элементов массива в соответствии с некоторым критерием. Обычно в качестве такого критерия выступают значения определенной функции, аргументами которой выступают элементы массива. Эту функцию принято называть упорядочивающей функцией.
Существуют различные методы сортировки. Будем рассматривать каждый из методов на примере задачи сортировки по возрастанию массива из N целых чисел.
СОРТИРОВКА ВЫБОРОМ
Идея метода заключается в том, что находится максимальный элемент массива и меняется местами с последним элементом (с номером N). Затем, максимум ищется среди элементов с первого до предпоследнего и ставится на N-1 место, и так далее. Необходимо найти N-1 максимум. Можно искать не максимум, а минимум и ставить его на первое, второе и так далее место. Также применяют модификацию этого метода с одновременным поиском максимума и минимума. В этом случае количество шагов внешнего цикла N div 2
Вычислительная сложность сортировки выбором - величина порядка N*N, что обычно записывают как O(N*N). Это объясняется тем, что количество сравнений при поиске первого максимума равно N-1. Затем N-2, N-3, и так далее до 1, итого: N*(N-1)/2.
ПРИМЕР: Сортировка выбором по возрастанию массива A из N целых чисел.
Рrogram Vybor1;
Uses Crt;
var A: array [1..100] of integer;
N, i, m, k, x : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
for k:=n downto 2 do { k - количество элементов для поиска max }
begin
m:=1; { m - место max }
for i:=2 to k do if A[i]>A[m] then m:=i;
{меняем местами элементы с номером m и номером k}
x:=A[m]; A[m]:=A[k]; A[k]:=x;
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
ПРИМЕР: Та же задача с одновременным выбором max и min.
Рrogram Vybor2;
Uses Crt;
var A: array[1..100] of integer;
N, i, m, k, x, p : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
for k:=1 to n div 2 do { k - номер пары max и min }
begin
m:=k; { m - место max }
p:=k; { p - место min }
{max и min ищутся среди элементов с k до n-k+1}
for i:=k+1 to n-k+1 do
if A[i]>A[m] then m:=i
else if A[i]<A[p] then p:=i;
{меняем местами элементы с номером p и номером k}
x:=A[p]; A[p]:=A[k]; A[k]:=x;
if m=k then m:=p;
{если max стоял на месте k, то сейчас он на месте p}
{меняем местами элементы с номером m и номером n-k+1}
x:=A[m]; A[m]:=A[n-k+1]; A[n-k+1]:=x;
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
СОРТИРОВКА ОБМЕНОМ (методом "пузырька")
Идея метода заключается в том, что последовательно сравниваются пары соседних элементов массива. Если они располагаются не в том порядке, то совершаем перестановку, меняя местами пару соседних элементов. После одного такого прохода на последнем месте номер N окажется максимальный элемент ("всплыл" первый "пузырек"). Следующий проход должен рассматривать элементы до предпоследнего и так далее. Всего требуется N-1 проход. Вычислительная сложность сортировки обменом O(N*N).
ПРИМЕР: Сортировка обменом по возрастанию массива A из N целых чисел. (Базовый вариант)
Рrogram Obmen1;
var A: array[1..100] of integer;
N, i, k, x : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
for k:=n-1 downto 1 do { k - количество сравниваемых пар }
for i:=1 to k do
if A[i]>A[i+1] then
{меняем местами соседние элементы}
begin x:=A[i]; A[i]:=A[i+1]; A[i+1]:=x; end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
Можно заметить, что если при выполнении очередного прохода в сортировке обменом не произведено ни одной перестановки, то это означает, что массив уже упорядочен. Таким образом, можно модифицировать алгоритм, чтобы следующий проход делался только при наличии перестановок в предыдущем.
ПРИМЕР: Сортировка обменом с проверкой факта перестановки.
Рrogram Obmen2;
Uses Crt;
var A: array [1..100] of integer;
N, i, k, x : integer; p: boolean;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
k:=n-1; {количество пар при первом проходе}
p:=true; {логическая переменная p истинна, если были
перестановки, т.е. нужно продолжать сортировку}
while p do
begin
p:=false;
{Начало нового прохода. Пока перестановок не было.}
for i:=1 to k do
if A[i]>A[i+1] then
begin
x:=A[i]; A[i]:=A[i+1]; A[i+1]:=x;
{меняем элементы местами}
p:=true; {и запоминаем факт перестановки}
end;
k:=k-1;
{уменьшаем количество пар для следующего прохода}
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
Следующая модификация алгоритма сортировки обменом получается при запоминании места последней перестановки. Если при очередном проходе последней парой элементов, которые поменялись местами, были A[i] и A[i+1], то элементы массива с i+1 до последнего уже стоят на своих местах. Использование этой информации позволяет нам сделать количество пар для следующего прохода равным i-1.
ПРИМЕР: Сортировка обменом с запоминанием места последней перестановки.
Рrogram Obmen3;
Uses Crt;
var A: array [1..100] of integer;
N, i, k, x, m : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
k:=n-1; {количество пар при первом проходе}
while k>0 do
begin
m:=0;
{пока перестановок на этом проходе нет, место равно 0}
for i:=1 to k do
if A[i]>A[i+1] then
begin
x:=A[i]; A[i]:=A[i+1]; A[i+1]:=x; {меняем элементы местами}
m:=i; {и запоминаем место перестановки}
end;
k:=m-1; {количество пар зависит от места последней перестановки}
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
ШЕЙКЕРНАЯ СОРТИРОВКА
Этот алгоритм, по сути, является модификацией сортировки обменом. Отличие состоит только в том, что если в сортировке обменом проходы осуществлялись только в одном направлении, то здесь направление каждый раз меняется. В шейкерной сортировке также можно проверять факт перестановки или запоминать место последней перестановки. В базовом алгоритме количество двойных проходов равно N div 2. Вычислительная сложность шейкерной сортировки O(N*N).
ПРИМЕР: Шейкерная сортировка по возрастанию массива A из N целых чисел.
Рrogram Shaker;
Uses Crt;
var A: array [1..100] of integer;
N, i, k, x, j, d : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
d:=1; i:=0;
for k:=n-1 downto 1 do { k - количество сравниваемых пар }
begin
i:=i+d;
for j:=1 to k do
begin
if (A[i]-A[i+d])*d>0 then
{меняем местами соседние элементы}
begin x:=A[i]; A[i]:=A[i+d]; A[i+d]:=x; end;
i:=i+d;
end;
d:=-d;
{меняем направление движения на противоположное}
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
СОРТИРОВКА ВКЛЮЧЕНИЕМ
Идея данного метода состоит в том, что каждый раз, имея уже упорядоченный массив из K элементов, мы добавляем еще один элемент, включая его в массив таким образом, чтобы упорядоченность не нарушилась. Сортировка может производиться одновременно со вводом массива.
В начале сортировки упорядоченная часть массива содержит только один элемент, который вводится отдельно или, если массив уже имеется, считается единственным, стоящим на нужном месте. Различные методы поиска места для включаемого элемента приводят к различным модификациям сортировки включением.
При использовании линейного поиска вычислительная сложность сортировки включением составляет O(N*N), а при использовании двоичного поиска - O(N*LogN) (имеется в виду логарифм по основанию 2).
ПРИМЕР: Сортировка по возрастанию массива A из N целых чисел включением с линейным поиском.
Рrogram Include1;
Uses Crt;
var A: array [1..100] of integer;
N, i, k, x : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
read(A[1]); {for i:=1 to n do read(A[i]);}
{k - количество элементов в упорядоченной части массива}
for k:=1 to n-1 do
begin
read(x); {x:=A[k+1];}
i:=k;
while (i>0)and(A[i]>x) do
begin
A[i+1]:=A[i];
i:=i-1;
end;
A[i+1]:=x;
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
ПРИМЕР: Сортировка по возрастанию массива A из N целых чисел включением с двоичным поиском.
Рrogram Include2;
Uses Crt;
var A: array [1..100] of integer;
N, i, k, x, c, left, right : integer;
Вegin
CIrScr;
write('количество элементов массива ');
read(N);
read(A[1]); {for i:=1 to n do read(A[i]);}
{k - количество элементов в упорядоченной части массива}
for k:=1 to n-1 do
begin
read(x); {x:=A[k+1];}
left:=1; right:=k;
{левая и правая граница фрагмента для поиска}
while left<right do
{двоичный поиск последнего вхождения}
begin
c:=(left+right+1) div 2;
{середина с округлением в большую сторону}
if x>=A[c] then left:=c
{берем правую половину с серединой}
else right:=c-1; {берем левую половину без середины}
end;
if x>=A[left] then left:=left+1;
{сдвигаем на 1 вправо часть массива, освобождая место
для включения x}
for i:=k downto left do A[i+1]:=A[i];
A[left]:=x;
end;
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
СОРТИРОВКА С ИСПОЛЬЗОВАНИЕМ ВЕКТОРА ИНДЕКСОВ
В отличии от всех ранее изложенных методов сортировки, этот не является самостоятельным алгоритмом, а представляет собой идею, которую можно применять к любому из них. Идея заключается в том, что вводится дополнительный массив B, который принято называть вектором индексов. Числа в нем говорят о том, в каком порядке нужно смотреть на элементы из A, например: Массив A : 4 7 3 5 Массив B : 3 1 4 2 { A[3] A[1] A[4] A[2] }
В начале программы в вектор индексов B записываются последовательно натуральные числа от 1 до N. При работе любой сортировки вместо элемента A[i] обращаются к элементу A[B[i]]. Это сделано для того, чтобы менять местами не элементы массива A, а их индексы, т.е. элементы массива B.
Процедуры
procedure имя процедуры(var параметр 1: тип 1;
var параметр 2 : тип 2; раздел описаний процедуры
. . .
var параметр n : тип n;
Begin
раздел операторов процедуры
end;
Нахождение наибольшего числа из четырёх.
Programlargest;
Uses Crt;
var a, b, c, d, mab, mcd, max : Real;
Procedure max2(x, у : Real; var z : Real);
Begin
if x >= у then z := x else z := y; {z = max(x ,y)}
end; {max2}
Begin {Основная программа}
CIrScr;
write('Введите четыре числа ');
readln(a, b, c, d);
max2(a, b, mab); {Вызов процедуры}
max2(с, d, mcd); {Процедура работает именно в момент вызова}
write('Количество строк и столбцов — '); readln(N);
For i:= 1 to N do
For j := 1 to N do
begin
write('A[', i, ‘, ‘,j, ']=');
readln(A[i, j]);
end;
writeln;
writeln('Заданнаяматрица ;');
For i := 1 to N do
begin
For j := 1 to N do Write(A[i, j] : 5);
writeln;
end;
writeln;
End; { of InputOutput }
ProcedureSolution(Var A : Mas); {описание процедуры поиска решения}
var Flag : Boolean;
Begin
Flag:=FALSE; i:=l;
While (i<=N) and not Flag do
If (A[i, i]>0) and (A[i, i] mod 2 = 1) then Flag:=TRUE else i:=i+l;
writeln(‘ Ответ :’);
write('Cpeди элементов главной диагонали ');
If Flag then writeln('ecтьнечетные положительные.')else writeln('нетнечетных положительных.');
readln;
End; { Solution}
Begin
InputOutput(A); {вызов процедуры ввода-вывода данных }
Solution(A); {вызов процедуры поиска решения задачи}
End.
Решение биквадратного уравнения ax4+bx2+c=0.
Program bikvur;
UsesCrt;
Var
а, b, с : Real;
{Глобальные переменные}
yl, y2 : Real;
flag : Boolean;
Procedure kvur(var yl,y2 : Real; var flag : Boolean);
var d : Real;
{Дискриминант локальная переменная}
begin
d := sqr(b) - 4 * a * с; {Глобальные переменные a, b и с известны процедуре}
if d >= 0 then
begin
flag := true;
yl := (-b + sqrt(d)) / 2 / a;
y2 := (-b - sqrt(d)) /2/a;
end
else flag := false;
end; {kvur}
Begin
CIrScr;
write('Введите значения коэффициентов a, b, с:’);
readln(a, b, c);
kvur(yl, y2, flag);
if flag then
begin
if yl >= 0 then writeln(‘xl= ', sqrt(yl):10:5, ' x2=', -sqrt(yl):18:5)
else writeln('Вещественных корней xl и х2 нет');
if y2 >= 0 then writeln(‘x3= ', sqrt(y2):10:5, ' x4=', -sqrt(y2):10:5)
else writeln('Вещественных корней хЗ и х4 нет');
end
else writeln('Вещественных корней нет');
readln;
End.
Задача о Ханойских башнях. Формулировка задачи:
Дано три стержня. На первом стержне размещены п дисков разных диаметров в порядке их уменьшения, так что сверху находится диск с наименьшим диаметром.
Требуется переложить диски на третий стержень, соблюдая следующие правила:
• можно перемещать лишь по одному диску;
• больший диск не разрешается класть на меньший;
• откладывать диски в сторону не разрешается.
Program Hanoy;
UsesCrt;
varn: Integer;
ProcedureSolve(h, а, b, с: Integer); {h - количество дисков; а - номер стержня, с которого осуществляется перенос; b - номер стержня, на который осуществляется перенос; с - номер свободного стержня}
Begin
If h>0 then
Begin
Solve(h-1, a, c, b);
writeln(' Диск ' , h, ' переносится со стержня ' , a, ' на стержень ' , b) ;
Solve(h-1, с, b, а);
End;
End; { Solve }
Begin
CIrScr;
write(' Введите количество дисков n=') ;
readln(n) ;
Solve(n, 1, 3, 2);
readln;
End.
Рекурсивные алгоритмы: генерация перестановок.
Program bikvur;
UsesCrt;
const n = 3; { количество элементов в перестановке}
var a:array[1..n] of integer;
index : integer;
procedure generate (l,r:integer);
var i, v:integer;
begin
if (l=r) then begin
for i:=1 to n do write(a[i],' ');
writeln;
end else begin
for i := l to r do begin
v:=a[l]; a[l]:=a[i]; a[i]:=v; {обмен a[i],a[j]}
generate(l+1,r); {вызов новой генерации}
v:=a[l]; a[l]:=a[i]; a[i]:=v; {обмен a[i],a[j]}
end;
end;
end;
Вegin
CIrScr;
for index := 1 to N do A[index]:=index;
generate( 1,n );
readln;
Еnd.
СОРТИРОВКА ХОАРА
Эту сортировку также называют быстрой сортировкой. Метод был разработан в 1962 году профессором Оксфордского университета К. Хоаром. Это прекрасный пример использования рекурсии. Рассмотрим принцип работы алгоритма при упорядочении массива A из N элементов по возрастанию.
Значение какого-нибудь элемента, обычно центрального, записывается в переменную X. Просматриваются элементы массива. При движении слева-направо ищем элемент больше или равный X. А при движении справа-налево ищем элемент меньше или равный X. Найденные элементы меняются местами и продолжается встречный поиск.
После этого массив окажется разделенным на две части. В первой находятся элементы меньше либо равные X, а справа - больше либо равные X. Можно заменить исходную задачу о сортировке массива A на две подзадачи о сортировке полученных частей массива.
Вычислительная сложность одного вызова данного рекурсивного алгоритма пропорциональна количеству элементов сортируемого фрагмента массива. В лучшем случае деление на части производится пополам, поэтому вычислительная сложность всего алгоритма быстрой сортировки составляет величину порядка N*LogN (логарифм по основанию 2). Вычислительная сложность в среднем того же порядка.
ПРИМЕР: Быстрая сортировка по возрастанию массива A из N целых чисел.
Рrogram Quick_Sort;
var A: array [1..100] of integer;
N, i : integer;
{В процедуру передаются левая и правая границы сортируемого фрагмента}
procedure QSort(L,R:integer);
UsesCrt;
var X, y, i, j: integer;
Вegin
CIrScr;
X:=A[(L+R) div 2];
i:=L; j:=R;
while i<=j do
begin
while A[i]<X do i:=i+1;
while A[j]>X do j:=j-1;
if i<=j then
begin
y:=A[i]; A[i]:=A[j]; A[j]:=y;
i:=i+1; j:=j-1;
end;
end;
if L<j then QSort(L,j);
if i<R then QSort(i,R);
end;
begin
write('количество элементов массива ');
read(N);
for i:=1 to n do read(A[i]);
QSort(1,n); {упорядочить элементы с первого до n-го}
for i:=1 to n do write(A[i],' '); {упорядоченный массив}
readln;
Еnd.
Функции
function имя функции(параметр 1 : тип 1;
параметр 2 : тип 2; раздел описаний функции
. . .
параметр n : тип n) : тип функции;
Begin
раздел операторов функции
имя функции := выражение;
end;
Программа вычисления факториала.
Program factorial;
UsesCrt;
var n: integer;
Function fact(n: integer): word;
Begin
If n=0 then fact:=1 else fact:=n*fuct(n-1);
End; {fact}
Begin
CIrScr;
writeln(‘Введите число, факториал которого вы хотите получить’);
readln(n);
if n<0 then writeln(‘Для отрицательного числа факториал не определён’) else writeln(‘Факториал ’, n, ‘равен: ’, fact(n));
writeln(InsideSector(1,1,5,1,7,2,3,3)); {test2, no Intersection}
readln;
Еnd.
Арифметические алгоритмы: возведение целого числа в натуральную степень.
Program chislo;
UsesCrt;
var x,y:integer;
function Degree(a,b:integer):longint;
var r:longint;
begin
r:=1;
while b>0 do
begin
r:=r*a;
b:=b-1;
end;
Degree:= r;
end;
Вegin
CIrScr;
writeln('введите число и (через пробел) степень числа');
readln(x,y);
writeln(Degree(x,y)); { print x^y }
readln;
Еnd.
Графика
Библиотека CRT
Библиотека (модуль) CRT содержит константы, переменные, процедуры и функции, обеспечивающие управление текстовым режимом работы монитора и звуковым генератором.
procedure имя процедуры(var параметр 1: тип 1;
function имя функции(параметр 1 : тип 1;