Институт повышения квалификации и переподготовки работников образования

Курганской области

Е. Г. Квашнин

Turbo Pascal – сборник задач c решениями

Учебно – методическое пособие

для учителей информатики

Курган 2004

Turbo Pascal – сборник задач c решениями: Сопровождение курса лекций / Авт.- сост. Е. Г.
Квашнин; Институт повышения квалификации и переподготовки работников образования Курганской
области. – Курган, 2004. – 37 стр.

Автор составитель: Е. Г. Квашнин доцент кафедры ЕМО

ИПК и ПРО Курганской области

Данное учебное пособие содержит краткие справочные данные и задачи с решениями по курсу
«Основы языка программирования». Изложение ведется с использованием языка программирования
Турбо Паскаль. Рассматриваются некоторые классические алгоритмы. Приводятся примеры типовых
задач с решениями.
Пособие предназначено для учителей информатики и слушателей данного курса.

Оглавление
Стр.

1. Предопределенные типы языка Паскаль. 4

2. Операторы ввода и вывода и присваивания информации. 5
3. Условный оператор. 9
4. Оператор выбора. 15
5. Циклы. 17
6. Массивы. 24
7. Процедуры. 37
8. Функции. 43
9. Графика. 49
10. Символы (строки). 54
 11. Список использованных источников 63
Предопределенные типы языка Паскаль
Группа Подгруппа Название Идентификатор
Простой Порядковый Короткий целый Shortint -128…127
Байтовый Byte 0…255
Слово Word 0…65535
Целый Integer -32768…
32767
Длинный целый Longint -2147483648…
2147483647

Символьный Char Символы из расширенного набора

символов кодаASCII
Логический Boolean False, True
Вещест- Вещественный Real -1,7х1038… -2,9х10-39,
венный 2,9х10 … 1,7х1038
-39

С одинарной точностью Single -3,4х1038… -1,5х10-45

1,5х10-45…
3,4х1038
С двойной точностью Double -1,7х10308…
-5х10-324,
5х10-324…
1,7х10308
С повышенной точностью Extended -1,1х104932…
-1,9х10-4951,
1,9х10-4951…
1,1х104932
Сложный Comp -263+1…263-1
Строковый String
Структурный Массив Array
Множество Set
Файл File
Запись Record
Ссылочный Pointer
Процедурный Процедура Procedure
Функция Function
Объектный Object
Операторы ввода, вывода и присваивания информации
Оператор Запись на языке Пример выполнения программы
Паскаль
Вывод информации write(‘а’); а
writeln(‘а’); а
а:=5; 5
writeln(а);
а:=5; а= 5м
writeln(‘а= ’, а, ‘м’);
Ввод информации read(а); Ввод значения одной переменной. Выполнение программы
приостанавливается до введения значения. После выполнения
оператора read курсор остаётся в этой же строке
readln(а); Ввод значения одной переменной. Выполнение программы
приостанавливается до введения значения. После выполнения
оператора readln курсор переходит в следующую строку
readln(а, b); Ввод значения двух переменных.
2
 Оператор присваивания
Переменная := выражение
а:= 2+7; в результате получим значение а =9
с:= а – 4; с становится равным 5
с:= с+3; значение с увеличивается на 3 и становится
равным 8
с+1:= 2-а неверно, так как слева от знака присваивания
стоит не переменная, а выражение!

Программа, выводящая на экран слово «МИР». Буквы этого слова состоят из символов «*», высота каждой буквы
– 6 символов.
Program mir;
Uses Crt;
Begin
Clrscr;
writeln(‘* * * * *******’);
writeln(‘* * * * * ** * *’);
writeln(‘* ** * * * * * *’);
writeln(‘* * * * * * *******’);
writeln(‘* * ** * * ’);
writeln(‘* * * * * ’);
readln;
End.
Программа, вычисляющая произведение трёх чисел.
Program umnogenie;
Uses Crt;
var a, b, c: real;
Begin
Clrscr;
writeln(‘Введите первое число ’);
readln(а);
writeln(‘Введите второе число ’);
readln(b);
writeln(‘Введите третье число ’);
readln(с);
writeln(‘Произведение чисел равно ’, a*b*c );
readln;
End.

Определение среднего арифметического двух чисел.

Program sredznach;
Uses Crt;
var a, b: real;
Begin
Clrscr;
writeln(‘Введите первое число ’);
readln(а);
writeln(‘Введите второе число ’);
readln(b);
writeln(‘Среднее значение чисел равно ’, (a+b)/2 );
readln;
End.

Вычисление третьего угла треугольника по двум известным углам.

Program treugolnik;
Uses Crt;
var a, b: real;

3
Begin
Clrscr;
writeln(‘Введите первый угол ’);
readln(а);
writeln(‘Введите второй угол ’);
readln(b);
writeln(‘Третий угол равен ’, 180-a-b );
readln;
End.

Вычисление значения арифметического выражения x y .

Program Uravnenie;
Uses Crt;
var x, y: real;
Begin
Clrscr;
write(‘Введите значение переменной х ’);
readln(x);
write(‘Введите значение переменной y ’);
readln(y);
writeln(‘Значение арифметического выражения равно’, exp(x*ln(y)):5:3);
readln;
End.
x
Вычисление значения арифметического выражения 5
x 5

5 x
Program Uravnenie;
Uses Crt;
var x, b: real;
Begin
Clrscr;
write(‘Введите значение переменной х ’);
readln(x);
b:= (exp(x*ln(5))+exp(5*ln(х)))/(5+х);
writeln(‘Значение арифметического выражения равно’, b:5:3);
readln;
End.

Программа записывающая введённое с клавиатуры трёхзначное число теми же цифрами, но в обратном

порядке (то есть, если дано число 149, то получить надо 941).
Program Naoborot;
Uses Crt;
var x, a, b, c: integer;
Begin
Clrscr;
write(‘Введите трёхзначное число ’);
readln(x);
a:= x mod 10;
b:= x div 10 mod 10;
c:= x div 100;
writeln(‘Число наоборот’, 100*а+10*b+а);
readln;
End.

Вычисление площади треугольника по двум сторонам и углу между ними.

Program st;
Uses Crt;
var a, b, c, s: real;
4
Begin
Clrscr;
writeln(‘Введите длину первой стороны ’);
readln(а);
writeln(‘Введите длину второй стороны ’);
readln(b);
writeln(‘Введите угол между ними ’);
readln(с);
s:=0.5*a*b*sin(c);
writeln(‘Площадь треугольника равна ’, s );
readln;
End.

Вычисление площади треугольника по 3 вершинам.

Program st;
Uses Crt;
var x1,y1,x2,y2,x3,y3,a,b,c,p,s:real;
Begin
Clrscr;
writeln('введите A(X1,Y1), B(X2,Y2) и C(X3,Y3)');
readln( x1,y1,x2,y2,x3,y3 );
c:=sqrt(sqr(y1-y2)+sqr(x1-x2));
a:=sqrt(sqr(y2-y3)+sqr(x2-x3));
b:=sqrt(sqr(y1-y3)+sqr(x1-x3));
p:=(a+b+c)/2;
s:=p*sqrt((p-a)*(p-b)*(p-c));
writeln('площадь треугольника = ',s);
readln;
End.

Вычисление суммы целых частей двух введённых с клавиатуры действительных чисел.

Program summa;
Uses Crt;
var a, b, c: real;
Begin
Clrscr;
writeln(‘Введите первое число ’);
readln(а);
writeln(‘Введите второе число ’);
readln(b);
с:= trunc(a)+ trunc(b);
writeln(‘Произведение чисел равно ’, c );
readln;
End.

Программа, которая по правилам математики округляет введённое с клавиатуры действительное число и

возводит его в степень, введённую с клавиатуры.
Program okrugl;
Uses Crt;
var a, b, c: real;
Begin
Clrscr;
writeln(‘Введите действительное число ’);
readln(а);
writeln(‘Введите степень ’);

5
 readln(b);
с:=round(a);
d:=exp(b*ln(c));
writeln(‘Округление числа ’, a, ‘=’c );
writeln(‘числа ’, с,’ в степени ’, ’ b’, ‘=’, d );
readln;
End.

Вычисление длины отрезка, зная координаты A и B.

Program size;
Uses Crt;
var x1,y1,x2,y2,d:real;
Begin
Clrscr;
writeln('введите A(X1,Y1) и B(X2,Y2)');
readln( x1,y1,x2,y2 );
d:=sqrt(sqr(y2-y1)+sqr(x2-x1));
writeln('длина отрезка |AB|=',d);
readln;
End.

Условный оператор
1) ifусловие then оператор 1 else оператор 2;
2) ifусловие 1 and условие 2 then оператор 1 else оператор 2;
3) ifусловие 1 or условие 2 then оператор 1 else оператор 2;
4) ifусловие then
begin
оператор 1;
оператор 2;
…
end
else
begin
оператор 1;
оператор 2;
…
end ;
5) Краткая форма записи условного оператора: if условие then оператор;

Программа, которая позволяет определить по номеру месяца время года.

Program seasons;
var a : Integer;
Begin
write('Введите номер месяца ');
readLn(a);
if (a > 2) and (a < 6) then write('весна');
if (a > 5) and (a < 9) then write('лето');
if (a > 8) and (a < 12) then write('осень');
if (a < 3) or (a = 12) then write('зима');
readln;
End.

Определение большего числа из двух не равных чисел введённых с клавиатуры.

6
Program Max;
Uses Crt;
var a, b: real;
Begin
Clrscr;
writeln(‘Введите первое число ’);
readln(а);
writeln(‘Введите второе число ’);
readln(b);
if a>b then writeln(‘число’, a, ‘ больше числа’, b)
else writeln(‘число ‘,b, ‘ больше числа’, a);
readln;
End.

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

Program Min;
Uses Crt;
var a, b: real;
Begin
Clrscr;
writeln(‘Введите первое число ’);
readln(а);
writeln(‘Введите второе число ’);
readln(b);
if a < b then writeln('Наименьшим является первое число')
else
if a = b then writeln('Введенные значения равны')
else writeln('Наименьшим является второе число');
readln;
End.

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

Program change;
Uses Crt;
var a, b, c: real;
Begin
Clrscr;
writeln(‘Введите первое число ’);
readln(а);
writeln(‘Введите второе число ’);
readln(b);
writeln(‘Введите третье число ’);
readln(с);
if a>b and a>c then writeln(‘число’, a, ‘ больше чисел’, b, ‘ и ’, c);
if b>a and b>c then writeln(‘число’, b, ‘ больше чисел’, a, ‘ и ’, c)
else writeln(‘число ‘, c, ‘ больше чисел’, a, ‘ и ’, b);
readln;
End.

Условие задачи: развивая предельно возможную скорость, жираф пробегает за t1с S1м (например, за 23
с 335,8 м). Заяц пробегает за t2c S2м (например, за 55 с 918,5 м). Кто из них достоин звания чемпиона?
Program champion;
Uses Crt;
var sl, s2, tl, t2, vl, v2: real;

7
Begin
Clrscr;
writeln ('Введите показатели жирафа ');
readln (sl, tl);
writeln ('Введите показатели зайца ');
readln (s2, t2);
vl:= sl/tl;
v2:= s2/t2;
if vl = v2.then
begin
textcolor (10) ;
writeln ('Победила дружба');
end
else if vl > v2 then
begin
textcolor (14);
writeln ('Жираф — чемпион');
end
else
begin
textcolor (9) ;
writeln ('Заяц — чемпион');
end;
readln;
End.

Требуется определить, является ли заданное трехзначное число палиндромом (палиндром читается

одинаково слева направо и справа налево, например, палиндромами являются числа 121, 282, слова
«шалаш», «наган»).
Program palindrom;
Uses Crt;
var х : Integer;
Begin
Clrscr;
write('Введите целое число: ');
readln(x);
If х mod 10 = х div 160 then Write('Введенное число является палиндромом')
else Write('Введенное число не является палиндромом');
readln;
End.

Решение квадратного уравнения ax2+bx+c=0

Program uravnenie;
Uses Crt;
var a, b, c, x1, x2, D: Integer;
Begin
CIrScr;
write( ' Введите коэффициенты а, b, с : ');
readln(a, b, с);
If (a=0) and (b=0) and (c=0) then
begin
write('Bce коэффициенты равны нулю.');
writeln('x — любое число ');
end
else
If (a=0) and (b<>0) then writeln(' Линeйнoe уравнение. Один корень: х =', (—с/ b):6:2)
else

8
 If (a=0) and (b=0) and (c<>0) then writeln('Heпpaвильнoe уравнение.')
else
begin
D:= b*b - 4*a*c;
If D>0 then
begin
xl:=(-b + Sqrt(D)) / (2*a);
x2:=(-b - Sqrt(D)) / (2*a);
writeln('xl=' , xl:6:2 , '; x2=' , x2:6:2);
end
else
If D=0 then
begin
xl := -b/(2*a);
witeln(Корни равны: xl = ', xl:6:2, '; x2 = ', xl:6:2)
еnd
else writeln('Действительных корней нет.');
end;
readln;
End.
Программа нахождения координат точки пересечения двух заданных прямых (ax1+bx1+c1=0,
ax2+bx2+c2=0).
Program Intersection;
Uses Crt;
var а1, bl, с1,
a2, b2, с2,
x, y: real;
Begin
CIrScr;
write('Введите а1, b1, с1:’);
readln( а1, bl, с1);
write('Введите a2, b2, с2 : ') ');
readln( a2, b2, с2);
writeln; Write('0 т в е т : ');
If ((al=0) and (bl=0) ) or ( (a2=0) and (b2=0) then writeln( 'это не прямая (прямые).’)
else
if (al*b2=a2*bl) and (a 1*c2=a2*c1) then writeln( 'прямые совпадают.' )
else
if al*b2 = a2*bl then writeln('пpямыe параллельны.')
else
begin
x:=(cl*b2-c2*bl)/(bl*a2-b2*al);
y:=(c2*al-cl*a2)/(bl*a2-b2*al);
writeln(‘Координаты точки пересечения: х= ’,x:5:2, ‘, y= ‘, y:5:2);
end;
readln;
End.

Программа, определяющая какая точка (A или B) ближе к началу координат.

Program tochka;
Uses Crt;
var x1,y1,x2,y2,d1,d2:real;
Вegin
CIrScr;
9
 writeln('введите A(X1,Y1) и B(X2,Y2)');
readln( x1,y1,x2,y2 );
d1:=sqrt(sqr(y1)+sqr(x1));
d2:=sqrt(sqr(y2)+sqr(x2));
if d1<d2 then writeln('Точка A ближе')
else if d1>d2 then writeln('Точка B ближе')
else writeln('Одинаково');
readln;
Еnd.
Определение попадания точки M(x,y) в круг с центром O (xc, yc) и радиусом R.
Program Inter;
Uses Crt;
var xc,yc,mx,my,d,r:real;
Вegin
CIrScr;
writeln('введите M(X,Y), O(Xc,Yc) и R');
readln( mx,my,xc,yc,r );
d:=sqrt(sqr(xc-mx)+sqr(yc-my));
if d<=r then writeln ('точка M лежит в круге')
else writeln ('точка M лежит вне круга');
readln;
Еnd.
Решение системы 2-х уравнений с двумя неизвестными
------------------------------------------------------------------------
Вид уравнения:
a1*x + b1*y = c1
a2*x + b2*y = c2

метод решения:
|c1 b1| |a1 c1|
|c2 b2| |a2 c2|
x=--------- y=---------
|a1 b1| |a1 b1|
|a2 b2| |a2 b2|

выражаем определители второго порядка:

x = (c1*b2-c2*b1)/(a1*b2-a2*b1)
y = (a1*c2-a2*c1)/(a1*b2-a2*b1)
------------------------------------------------------------------------
Program sistema2;
Uses Crt;
var a1,a2,b1,b2,c1,c2,x,y,d,dx,dy:real;
Вegin
CIrScr;
writeln('введите коэффициенты уравнения: a1,b1,c1,a2,b2,c2');
readln(a1,b1,c1,a2,b2,c2);
d := (a1*b2-a2*b1);
dx := (c1*b2-c2*b1);
dy := (a1*c2-a2*c1);
if ( d=0 ) and ( (dx=0) or (dy=0) ) then
writeln('бесконечное множество решений')
else if ( d<>0 ) and ( (dx=0) or (dy=0) ) then
writeln('нет решений')
else begin

10
 x:=dx/d; y:=dy/d;
writeln('x = ', x); writeln('y = ', y);
end;
readln;
Еnd.

Решение системы 3-х уравнений с тремя неизвестными

------------------------------------------------------------------------
решение уравнений вида:
|a1*x + b1*y + c1*z = d1|
|a2*x + b2*y + c2*z = d2|
|a3*x + b3*y + c3*z = d3|

метод решения:
|d1 b1 c1| |a1 d1 c1| |a1 b1 d1|
|d2 b2 c2| |a2 d2 c2| |a2 b2 d2|
|d3 b3 c3| |a3 d3 c3| |a3 b3 d3|
x = ---------- y = ---------- z = ----------
|a1 b1 c1| |a1 b1 c1| |a1 b1 c1|
|a2 b2 c2| |a2 b2 c2| |a2 b2 c2|
|a3 b3 c3| |a3 b3 c3| |a3 b3 c3|

выражаем определители третьего порядка:

e := (a1*b2*c3+b1*c2*a3+c1*a2*b3-a3*b2*c1-b3*c2*a1-c3*a2*b1);
ex := (d1*b2*c3+b1*c2*d3+c1*d2*b3-d3*b2*c1-b3*c2*d1-c3*d2*b1);
ey := (a1*d2*c3+d1*c2*a3+c1*a2*d3-a3*d2*c1-d3*c2*a1-c3*a2*d1);
ez := (a1*b2*d3+b1*d2*a3+d1*a2*b3-a3*b2*d1-b3*d2*a1-d3*a2*b1);
x = ex/e
y = ey/e
z = ez/e
------------------------------------------------------------------------
Program sistema3;
Uses Crt;
var a1,a2,a3,b1,b2,b3,c1,c2,c3,d1,d2,d3,x,y,z,e,ex,ey,ez:real;
Вegin
CIrScr;
writeln('введите коэффициенты уравнения:a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3');
readln(a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3);
e := (a1*b2*c3+b1*c2*a3+c1*a2*b3-a3*b2*c1-b3*c2*a1-c3*a2*b1);
ex := (d1*b2*c3+b1*c2*d3+c1*d2*b3-d3*b2*c1-b3*c2*d1-c3*d2*b1);
ey := (a1*d2*c3+d1*c2*a3+c1*a2*d3-a3*d2*c1-d3*c2*a1-c3*a2*d1);
ez := (a1*b2*d3+b1*d2*a3+d1*a2*b3-a3*b2*d1-b3*d2*a1-d3*a2*b1);
if ( e=0 ) and ( (ex=0) or (ey=0) or (ez=0) ) then
writeln('бесконечное множество решений')
else if ( e<>0 ) and ( (ex=0) or (ey=0) or (ez=0) ) then
writeln('нет решений')
else begin
x:=ex/e; y:=ey/e; z:=ez/e;
writeln('x = ', x); writeln('y = ', y); writeln('z = ', z);
end;
readln;
Еnd.
Оператор выбора
Case выражение of
Список значений 1 : оператор 1;
Список значений 2 : оператор 2;
11
 …
Список значений n : оператор n;
else оператор;
end;

Программа, определяющая этаж по введённому с клавиатуры номеру квартиры (в пятиэтажном доме

один подъезд по четыре квартиры на каждом этаже).
Program dom;
Uses Crt;
var х : Integer;
Begin
Clrscr;
write('Введите номер квартиры: ');
readln(x);
Case x of
1, 2, 3, 4: writeln(‘Первый этаж’);
5, 6, 7, 8: writeln(‘Второй этаж’);
9, 10, 11, 12: writeln(‘Третий этаж’);
13, 14, 15, 16: writeln(‘Четвёртый этаж’);
17, 18, 19, 20: writeln(‘Пятый этаж’);
end;
else writeln(‘Квартиры с таким номером в доме нет’);
readln;
End.

Программа, определяющая номер подъезда и этаж по введённому с клавиатуры номеру квартиры (в

пятиэтажном доме два подъезда по четыре квартиры на каждом этаже).
Program dom;
Uses Crt;
var х : Integer;
Begin
Clrscr;
write('Введите номер квартиры: ');
readln(x);
Case x of
1, 2, 3, 4: writeln(‘Первый подъезд. Первый этаж’);
5, 6, 7, 8: writeln(‘Первый подъезд. Второй этаж’);
9, 10, 11, 12: writeln(‘Первый подъезд. Третий этаж’);
13, 14, 15, 16: writeln(‘Первый подъезд. Четвёртый этаж’);
17, 18, 19, 20: writeln(‘Первый подъезд. Пятый этаж’);
21, 22, 23, 24: writeln(‘Второй подъезд. Первый этаж’);
25, 26, 27, 28: writeln(‘Второй подъезд. Второй этаж’);
29, 30, 31, 32: writeln(‘Второй подъезд. Третий этаж’);
33, 34, 35, 36: writeln(‘Второй подъезд. Четвёртый этаж’);
37, 38, 39, 40: writeln(‘Второй подъезд. Пятый этаж’);
else writeln(‘Квартиры с таким номером в доме нет’);
end;
readln;
End.

Программа, определяющая по номеру месяца – время года.

Program year;
Uses Crt;
var х : Integer;
12
Begin
Clrscr;
write('Введите номер месяца: ');
readln(x);
Case x of
12, 1, 2: writeln(‘Зима’);
3, 4, 5: writeln(‘Весна’);
6, 7, 8: writeln(‘Лето’);
9, 10, 11: writeln(‘Осень’);
end;
readln;
End.

В старояпонском календаре был принят двенадцатилетний цикл. Годы "внутри цикла носили названия
животных: крысы, коровы, тигра, зайца, дракона, змеи, лошади, овцы, обезьяны, петуха, собаки и
свиньи. Написать программу, которая позволяет ввести номер года и печатает его название по
старояпонскому календарю.
Справка: 1996 г. — Год Крысы — начало очередного цикла.
Program Goroskop;
Uses Crt;
var Year : integers;
Begin
Clrscr;
write('Введите год ');
readln(Year);
Case Year mod 12 of
0: writeln('Год Обезьяны');
1: writeln(' Год Петуха');
2: writeln(' Год Собаки');
3: writeln(' Год Свиньи');
4: writeln(‘ Год Крысы');
5: writeln(‘ Год Коровы');
6: writeln(‘ Год Тигра');
:7: writeln(‘ Год Зайца');
8: writeln(‘ Год Дракона');
9: writeln(‘ Год Змеи');
10: writeln(‘ Год Лошади');
11: writeln(‘ Год Овцы');
end;
readln;
End.
Циклы
Цикл с предусловием: Цикл с постусловием: Цикл со счётчиком:
while условие do repeat for переменная:= начальное
begin оператор 1; значение to конечное значение
оператор 1; оператор 2; do
оператор 2; … begin
… оператор n; оператор 1;
оператор n; until условие; оператор 2;
end; …
оператор n;
13
 end;

Программа, выводящая на экран сто символов (*).

Цикл с предусловием: Цикл с постусловием:
Program Star; Program Star;
Uses Crt; Uses Crt;
var х : Integer; var х : Integer;
Begin Begin
Clrscr; Clrscr;
x:=1; x:=1;
while x<100 do repeat
begin write(‘*’);
write(‘*’); x:=x+1;
x:=x+1; until x>=100;
end; readln;
readln; End.
End.

Цикл со счётчиком:
(1 способ) (2 способ)
Program Star; Program Star;
Uses Crt; Uses Crt;
var х : Integer; var х : Integer;
Begin Begin
Clrscr; Clrscr;
for x:=1 to 100 do for x:=100 downto 1 do
begin begin
write(‘*’); write(‘*’);
end; end;
readln; readln;
End. End.

Программа, вычисляющая факториал числа, введённого с клавиатуры.

Цикл с предусловием: Цикл с постусловием:
Program Faktorial; Program Faktorial;
Uses Crt; Uses Crt;
var i, х, s : Integer; var i, х, s : Integer;
Begin Begin
Clrscr; Clrscr;
write(‘Введите число’); write(‘Введите число’);
readln(x); readln(x);
i:=1; s:=1; i:=1; s:=1;
while i<x do repeat
begin s:=s*i+s;
s:=s*i+s; i:=i+1;
i:=i+1; until i>x;
end; writeln(‘Факториал числа’, x, ‘=’, s);
writeln(‘Факториал числа’, x, ‘=’, s); readln;
readln; End.
End.
Цикл со счётчиком:
Program Faktorial;
14
Uses Crt;
var i, х, s : Integer;
Begin
Clrscr;
write(‘Введите число’);
readln(x);
i:=1; s:=1;
for i=1 to x do s:=s*i+s;
writeln(‘Факториал числа’, x, ‘=’, s);
readln;
End.

1 1 1 1
Программа, вычисляющая сумму слагаемых      .
1 2 3 100
Цикл с предусловием: Цикл с постусловием:
Program summa; Program summa;
Uses Crt; Uses Crt;
var i, s : Integer; var i, s : Integer;
Begin Begin
Clrscr; Clrscr;
i:=1; s:=0; i:=1; s:=0;
while i<100 do repeat
begin s:=1/i+s;
s:=1/i+s; i:=i+1;
i:=i+1; until i>100;
end; writeln(‘Сумма элементов равна’, s);
writeln(‘Сумма элементов равна’, s); readln;
readln; End.
End.
Цикл со счётчиком:
Program summa;
Uses Crt;
var i, х, s : Integer;
Begin
Clrscr;
i:=1; s:=0;
for i=1 to 100 do s:=1/i+s;
writeln(‘Сумма элементов равна’, s);
readln;
End.

Программа вывода таблицы соответствия между температурными шкалами Цельсия и

Фаренгейта в интервале температур от 0ºС до 100ºС.
Цикл с предусловием: Цикл с постусловием:
Рrogram Celsius to Fahrenheit; Рrogram Celsius to Fahrenheit;
Uses Crt; Uses Crt;
var i, Celsius: Integer; Fahrenheit: real; var i, Celsius: Integer; Fahrenheit: real;
Вegin Вegin
Clrscr; Clrscr;
writeln("Таблица соответствия между writeln("Таблица соответствия между
температурными шкалами'); температурными шкалами');
writeln('Цельсия и Фаренгейта'); writeln('Цельсия и Фаренгейта');
writeln; writeln;
i:=0; i:=0;
15
 while i <= 20 do repeat
begin Celsius := 5 * i;
Celsius := 5 * i; Fahrenheit := 32 + Celsius * 9 div 5;
Fahrenheit := 32 + Celsius * 9 div 5; write(‘ С =' , Celsius) ;
write(‘ С =' , Celsius) ; write(‘ F =', Fahrenheit);
write(‘ F =', Fahrenheit); writeln;
writeln; i:=i+1;
i:=i+1; until i>20;
end; readln;
readln; End.
End.

Цикл со счётчиком:
Рrogram Celsius to Fahrenheit;
Uses Crt;
var i, Celsius: Integer; Fahrenheit: real;
Вegin
Clrscr;
writeln("Таблица соответствия между
температурными шкалами');
writeln('Цельсия и Фаренгейта');
writeln;
for i := 0 to 20 do
begin
Celsius := 5 * i;
Fahrenheit := 32 + Celsius * 9 div 5;
write(‘ С =' , Celsius) ;
write(‘ F =', Fahrenheit);
writeln;
end;
readln;
End.

Программа, загадывающая число от 0 до 10. Если пользователь его угадывает, то программа поздравляет
его, а если нет, то просит попытаться ещё раз, но убавляя количество призовых баллов.
Рrogram roulette;
Uses Crt;
var number, guess, bonus: byte;
Вegin
Clrscr;
bonus:=10;
Randomize;
number := Random(ll);
writeln('Задумано целое число от 0 до 10. Угадайте!');
writeln;
wr1teln('Введите целое число от 0 до 10');
readln(guess);
while guess <> number do
begin
Dec(bonus);
writeln('Bы не угадали.');
writeln;
16
 if guess < number then writeln('Ваше число меньше задуманного')
else
writeln('Ваше число больше задуманного');
writeln('Попытайтесь еще раз!');
readln(guess);
end;
writeln('Поздравляю! Вы угадали и набрали ', bonus, ' очков');
readln;
Еnd.

Вычисление произведения пары неотрицательных вещественных чисел вводимых с клавиатуры и сумму

всех чисел.
Program cycle;
Uses Crt;
var x, y, sum: real;
otv: char;
Begin
Clrscr;
sum:=0;
repeat
write('Введите числа x,y > 0 ');
readln(x,y);
writeln('Их произведение = ',x*y:8:3);
sum:=sum+x+y;
write('Завершить программу (Д/Н)? ');
readln(otv);
until (otv='Д') or (otv='д');
writeln('Общая сумма = ',sum:8:3);
readln;
End.
Программа, определяющая является ли число совершенным. Число является совершенным, если оно
равно сумме всех своих делителей, включая единицу. (Например 6=1+2+3, 28=1+2+4+7+14).
Program sover;
Uses Crt;
var а, i, s : Integer;
Begin
Clrscr;
write('Введите целое число а:');
readln(a);
s := 0;
for i := 1 to a div 2 do
if a mod i = 0 then
begin
s : = s + i;
write('+', i);
end;
if s =a then writeln('Число ', a, 'совершенное')
else writeln('Число ', a, ' не совершенное');
17
 readln;
End.

Программа печати всех делителей натурального числа A.

Program delit;
Uses Crt;
var a,n,c,d:word;
Вegin
CIrScr;
readln( a );
n:=1;
while ( n <= sqrt(a) ) do begin
c:=a mod n;
d:=a div n;
if c = 0 then begin
writeln( n );
if n <> d then writeln( d );
end;
inc( n );
end;
readln;
Еnd.

Программа печати всех совершенных чисел до 10000.

Program strong;
Uses Crt;
var n,i,j,s,lim,c,d : word;
Вegin
CIrScr;
for i:=1 to 1000 do
begin
s:=1; lim:=round(sqrt(i));
for j:=2 to lim do
begin
c:=i mod j;
d:=i div j;
if c = 0 then
begin
inc(s,j);
if (j<>d) then inc(s,d); {дважды не складывать корень числа}
end;
end;
if s=i then writeln(i);
end;
readln;
Еnd.

Программу вывода на экран всех простых чисел до 500.

Program prost;
Uses Crt;
const LIMIT = 500;
var i,j,lim : word;
Вegin
CIrScr;
writeln; {перевод строки, начинаем с новой строки}
18
 for i:=1 to LIMIT do begin
j:=2; lim:=round(sqrt(i));
while (i mod j <> 0) and (j <= lim) do inc( j );
if (j > lim) then write( i,' ' );
end;
readln;
Еnd.

Подсчет суммы цифр числа.

Program summa;
Uses Crt;
var a,x: integer;
i,s: integer;
Вegin
CIrScr;
writeln('введите целое число');
readln( a ); x:=a;
s:=0;
while ( x<>0 ) do
begin
s := s + (x mod 10);
x := x div 10;
end;
writeln( 'Сумма цифр числа ',a,' = ', s );
readln;
Еnd.

Программа перевода чисел из десятичной системы счисления в римскую (от 1 до 3999

включительно).
Program dectoroman;
Uses Crt;
const rom: array[1..13] of string[2] = ('I’, ‘IV’, ‘V’, ‘IX’, 'X', 'XL', 'L', 'XC', 'С', 'CD', 'D', 'CM', 'M');
dec: array[1..13] of word = (1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000);
var n: word;
s: string;
i: byte;
Begin
Clrscr;
write('Введите число в десятичной системе счисления: ');
readin(n) ;
s := ‘ ‘;
i := 13;
while n <> 0 do
begin
while n >= dec[i] do
begin
n : = n - dec[ i ];
s := s + rom[i];
end;
i := i – 1;
end;
writeln('Число в римской системе счисления: ', s);
readln;
End.

Кодировка: Пример простой кодировки (сдвиг по ключу)

19
-----------------------------------------------------------------------------------------------------
Алгоритм: каждый код символа увеличивается на некоторое число - "ключ"
-----------------------------------------------------------------------------------------------------
Program kod;
Uses Crt;
var s: string;
i, key: integer;
Вegin
CIrScr;
writeln('Введите текст');
readln(s);
writeln('Введите ключ (число от 1 до 255)');
readln(key);
for i:=1 to length(s) do s[i]:=char( ord(s[i]) + key );
writeln('Зашифрованный текст: ',s);
readln;
Еnd.

Обработка текста: Разрешение ввода только цифр

----------------------------------------------------------------------------------
На входе - текст с цифрами (но будут вводиться только цифры)
----------------------------------------------------------------------------------
Program number;
Uses Crt;
const ENTER #13;
var c:char;
Вegin
CIrScr;
writeln('Вводите буквы и цифры');
c:=readkey;
while (c<>ENTER) do
begin
if c in ['0'..'9'] then write(c);
c:=readkey;
end;
writeln;
readln;
Еnd.

Массивы
Одномерный массив
Var Имя массива : array[начальный индекс .. конечный индекс] of тип данных;
Двумерный массив
Var Имя массива : array[номер первой строки .. номер последней строки , номер первого столбца
номер последнего столбца] of тип элементов массива;

Вычисление значения многочлена степени N, коэффициенты которого находятся в массиве A в точке X

по схеме Горнера.
Pn(x) = A[0]*X^n + A[1]*X^(n-1) + ... + A[n-1]*X + A[n] =
= (...((A[0]*X + A[1])*X + A[2])*X + ... + A[n-1])*X + A[n].
Program Scheme Gorner;

20
type Mas = array[0..100] of integer;
var A: Mas;
i, j, n: integer;
x, p: real;
Begin
write('степень многочлена = ');
readln(n);
writeln('введите целые коэффициенты : ');
for i:=0 to n do read(A[i]);
write('значение X = ');
readln(x);
p:=0;
for i:=0 to n do p:=p*x+A[i];
writeln('Pn(X) = ',p);
readln;
End.

Вычисление суммы элементов заданного одномерного числового массива А=(а1, а2, …, аn).
Program Summa;
Uses Crt;
Type Mas = Array [1..20] of Real;
var A : Mas;
i, N : Integer;
S : Real;
Begin
CIrScr;
write('Введите N =');
readln(N);
For i := 1 to N do
begin
write('A [', i ,']=');
readln(A[i]);
end;
S := 0;
For i := 1 to N do S := S+A[i];
writeln;
writeln('Cyммa равна', S : 5 :1);
readln;
End.

Программа выводящая на экран таблицу сложения натуральных чисел от 1 до 9.

Рrogram addition table;
Uses Crt;
const n = 9;
var
a : array [1..9, 1..9] of Integer;
i, j : Integer;
Вegin
CIrScr;
21
 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 см).
Program BascetBall;
Uses Crt;
22
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];

23
 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 );

24
 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;

25
 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}

26
 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;
27
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; {и запоминаем факт перестановки}

28
 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.

ШЕЙКЕРНАЯ СОРТИРОВКА
Этот алгоритм, по сути, является модификацией сортировки обменом. Отличие состоит только в
том, что если в сортировке обменом проходы осуществлялись только в одном направлении, то здесь
направление каждый раз меняется. В шейкерной сортировке также можно проверять факт перестановки

29
или запоминать место последней перестановки. В базовом алгоритме количество двойных проходов
равно 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;

30
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;
31
 {середина с округлением в большую сторону}
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
35 Массив 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;

Нахождение наибольшего числа из четырёх.

Program largest;
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 {Основная программа}
32
 CIrScr;
write('Введите четыре числа ');
readln(a, b, c, d);
max2(a, b, mab); {Вызов процедуры}
max2(с, d, mcd); {Процедура работает именно в момент вызова}
max2(mab, mcd, max);
writeln ('Большее из ', а:10:5, b:19:5, с:10:5, d:10:5, ‘ = ‘, max:10:5);
readln;
End.

Определение принадлежности хотя бы одной точки заданного множества точек на плоскости

внутренней области круга с центром в точке(a, b) и радиусом R.
Program SetOfPoints;
Uses Crt;
Type Mas = Array [1..20] of Real;
Var X, Y: Mas; {массивы координат точек}
i, NPoints : Integer; {NPoints - количество точек}
a, b, Radius: Real; {координаты центра и радиус}
Flag: Boolean;
Procedure Input; {описание процедуры ввода данных}
Begin
CIrScr;
write('Введите координаты центра круга:'); readln(a, b);
write(‘Введите радиус круга:'); readln(Radius);
write('Введите количество точек:'); readln(NPoints);
For i := 1 to NPoints do
begin
writeln(i: 4, '-я точка');
write('X ='); readln(X[i]);
write(‘Y = '); readln(Y[i]);
end;
writeln
End; {of Input}
Procedure Inside(var Flag : Boolean); {описание процедуры проверки}
Begin {принадлежности точек области}
Flag := FALSE; i:=l;
While (i<=NPoints) and not Flag do
If Sqr(X[i]-a)+Sqr(Y[i]-b)<Sqr(Radius) then Flag := TRUE else i:=i+l;
End; {of Inside}
Procedure Output( Flag: Boolean); {описание процедуры}
Begin {вывода результатов}
write('O т в е т: в множестве точек');
If Flag then writeln('coдepжaтcя') else writeln('He содержатся');
writeln(' точки, принадлежащие заданной области.');
readln;
End; {of Output}
Begin
Input; {вызов процедуры ввода данных}
Inside(Flag); {вызов процедуры проверки принадлежности}
Output(Flag); {вызов процедуры вывода результатов}
End.

Определение наличия среди элементов главной диагонали заданной целочисленной матрицы А(N, N)
хотя бы одного положительного нечётного элемента.

33
Program Diagonal;
Uses Crt;
Type Mas = Array [1.. 10, 1.. 10] of Integer;
var A: Mas;
N, i, j: Integer;
Flag: Boolean;
Procedure InputOutput(Var A : Mas); {описание процедуры ввода- вывода исходных данных}
Begin
CIrScr;
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 }
Procedure Solution(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;
Uses Crt;

{Глобальные переменные}
var
а, b, с : Real;
yl, y2 : Real;
flag : Boolean;
Procedure kvur(var yl,y2 : Real; var flag : Boolean);

{Дискриминант локальная переменная}

var d : Real;
begin
34
 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;
Uses Crt;
var n: Integer;
Procedure Solve(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.

35
Рекурсивные алгоритмы: генерация перестановок.
Program bikvur;
Uses Crt;
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;
{В процедуру передаются левая и правая границы сортируемого фрагмента}

36
procedure QSort(L,R:integer);
Uses Crt;
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;
Uses Crt;
var n: integer;
Function fact(n: integer): word;
Begin

37
 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));
readln;
End.

Решение биквадратного уравнения ax4+bx2+c=0.

Program largest_2;
Uses Crt;
var
a, b. с, d : Real;
function max2(x. у : Real.) : Real;
begin
if x > у then max2 := x else max2 := y;
end;
Begin
CIrScr;
write('Введите четыре числа:');
readln(a, b. с, d);
writeln('Большее из ‘, a:10:5, b;10;5, c;10;5, d:10;5, ‘ = ‘,max2(max2(a, b), max2(c,d));10;5;
readln;
End.

Программа вычисления площади n-угольника.

Рrogram area;
Uses Crt;
const n= 4;
var
х, у : array[1..n] of Real;
i : Word;
su, pi : Real;
function length(nl, n2 : Word) : Real;
begin
length := Sqrt(sqr(x[nl] - x[n2]) + sqr(y[nl] - y[n2]))
end; {length}
procedure space(nl, n2, n3 : Word; var pi : Real);
var
a, b, c, p: Real;
begin
a := length(nl, n2);
b := length(n2, n3);
с := length(nl, n3);
p := (а + b + с) / 2;
pi := Sqrt(p * (p - a) * (p - b) *(P - c));
end; {space}
Begin
Clrscr;

38
 write('Введите координаты 1-й и 2-й вершин ');
readln(x[l] , у[1], х[2] , у[2]);
i := 2;
su := 0;
repeat
i := i + 1; {Подсчет вершин}
write('Введите координаты ', i, '-и вершины');
readln(x[i] , у[I]) ;
space(l, i - 1, i, pi);
su := su + pi;
until i = n;
writeln(‘Площадь = ', su:10:5);
readln;
End.

Составить программу перевода десятичного числа в двоичное.

Program perevod;
Uses Crt;
var a : longint;
function DEC_BIN(x:longint):string;
const digits:array [0..1] of char = ('0','1');
var res:string; d:0..1;
begin
res:='';
while (x<>0) do
begin
d:=x mod 2; res:=digits[d]+res;
x:=x div 2;
end;
DEC_BIN:=res;
end;
Вegin { основная программа }
CIrScr;
readln( a );
writeln( DEC_BIN(a) );
readln;
Еnd.

Составить программу перевода двоичного числа в десятичное.

Program perevod2;
Uses Crt;
var a : string;
function BINDEC(x: string): longint;
const digits: array [0..1] of char = ('0','1');
var res, ves: longint;
i, j: byte;
begin
res:=0; ves:=1;
for i:=length(x) downto 1 do begin
j:=0;
while (digits[j]<>x[i]) do inc(j);
res:=res+ves*j;
ves:=ves*2;
end;
39
 BINDEC:= res;
end;
Вegin { основная программа }
CIrScr;
readln( a );
writeln( BINDEC(a) );
readln;
Еnd.

Программа перевода десятичного числа в шестнадцатеричное.

Program perevod3;
Uses Crt;
var a : longint;
function DECHEX(x:longint):string;
const digits:array [0..15] of char = ('0','1','2','3','4','5','6','7',
'8','9','A','B','C','D','E','F');
var res:string; d:0..15;
begin
res:='';
while (x<>0) do
begin
d:=x mod 16;
x:=x div 16;
res:=digits[d]+res;
end;
DECHEX:=res;
end;

Вegin { основная программа }

CIrScr;
readln( a );
writeln( DECHEX(a));
readln;
Еnd.

Программа перевода шестнадцатеричного числа в десятичное.

Program perevod4;
Uses Crt;
var a : string;
function HEXDEC(x: string): longint;
const digits: array [0..15] of char = ('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
var res, ves: longint;
i, j: byte;
begin
res:=0; ves:=1;
for i:=length(x) downto 1 do
begin
j:=0; a[i]:=UpCase(a[i]);
while (digits[j]<>x[i]) do inc(j);
res:=res+ves*j;
ves:=ves*16;
end;
HEXDEC:= res;
end;
Вegin { основная программа }
40
CIrScr;
readln( a );
writeln( HEXDEC(a));
readln;
Еnd.

Рекурсивные алгоритмы: нахождения НОД и НОК двух чисел.

Program nodnok;
Uses Crt;
var a,b:longint;
function NOD(x, y: longint): longint; { фукнция поиска наиб. общ. делителя }
begin
if x<>0 then NOD:=NOD(y mod x, x) else NOD:=y;
end;
function NOK(x, y: longint): longint; { фукнция поиска наим. общ. кратного }
begin
NOK:=( x div NOD(x, y) ) * y;
end;
Вegin { основная программа }
CIrScr;
write(‘Введите два числа ’);
readln(a, b);
writeln( 'НОД этих чисел = ', NOD(a, b) );
writeln( 'НОК этих чисел = ', NOK(a, b));
readln;
Еnd.

Рекурсивные алгоритмы: вычисление факториал.

Program factorial;
Uses Crt;
var n: integer;
function f(x: integer): longint;
begin
if x = 1 then f := 1 else f := x * f(x-1);
end;
Вegin
CIrScr;
writeln('введите N (N=1..13)');
readln(n);
writeln('N!=',f(n));
readln;
Еnd.

Геометрические алгоритмы: Пересекаются ли 2 отрезка?

------------------------------------------------------------------------
Определяет пересечение отрезков A(ax1,ay1,ax2,ay2) и B (bx1,by1,bx2,by2),
функция возвращает TRUE - если отрезки пересекаются, а если пересекаются
в концах или вовсе не пересекаются, возвращается FALSE (ложь)
------------------------------------------------------------------------
Program line;
Uses Crt;
function Intersection(ax1,ay1,ax2,ay2,bx1,by1,bx2,by2:real):boolean;
var v1,v2,v3,v4:real;
begin
41
 v1:=(bx2-bx1)*(ay1-by1)-(by2-by1)*(ax1-bx1);
v2:=(bx2-bx1)*(ay2-by1)-(by2-by1)*(ax2-bx1);
v3:=(ax2-ax1)*(by1-ay1)-(ay2-ay1)*(bx1-ax1);
v4:=(ax2-ax1)*(by2-ay1)-(ay2-ay1)*(bx2-ax1);
Intersection:=(v1*v2<0) and (v3*v4<0);
end;
Вegin { основная программа, вызов функции - тест }
CIrScr;
writeln(Intersection(1,1,5,5,1,2,3,1)); {test1, yes Intersection}
writeln(Intersection(1,1,5,5,1,2,1,3)); {test2, no Intersection}
readln;
Еnd.

Геометрические алгоритмы: Точка внутри сектора или нет?

------------------------------------------------------------------------
Если точка внутри сектора (или на сторонах) - TRUE, если нет - FALSE
tx,ty - вершина сектора
x1,y1,x2,y2 - точки на сторонах сектора
px,py - точка на плоскости
возвращает знак числа, 1 - положительное число, -1 - отрицательное, 0 - 0
------------------------------------------------------------------------
Program inter;
Uses Crt;
function sign(r:real):integer;
begin
sign:=0; if r=0 then exit;
if r<0 then sign:=-1 else sign:=1;
end;
function InsideSector(tx,ty,x1,y1,x2,y2,px,py:real): boolean;
var x,y,a1,a2,b1,b2,c1,c2:real;
var i1,i2,i3,i4:integer;
begin
x:=(tx+x1+x2)/3; y:=(ty+y1+y2)/3;
a1:=ty-y1; b1:=x1-tx; c1:=tx*y1-ty*x1;
a2:=ty-y2; b2:=x2-tx; c2:=tx*y2-ty*x2;
i1:=sign(a1*x+b1*y+c1); i2:=sign(a2*x+b2*y+b2);
i3:=sign(a1*px+b1*py+c1); i4:=sign(a2*px+b2*py+c2);
InsideSector:=((i1=i3) and (i2=i4)) or ((i1=0) and (i2=i4)) or ((i1=i3) and (i2=0));
end;
Вegin { основная программа, вызов функции - тест }
CIrScr;
writeln(InsideSector(1,1,5,1,1,5,3,3)); {test1, yes Inside}
writeln(InsideSector(1,1,5,1,7,2,3,3)); {test2, no Intersection}
readln;
Еnd.

Арифметические алгоритмы: возведение целого числа в натуральную степень.

Program chislo;
Uses Crt;
var x,y:integer;
function Degree(a,b:integer):longint;
var r:longint;
begin
r:=1;
while b>0 do
42
 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 содержит константы, переменные, процедуры и функции,
обеспечивающие управление текстовым режимом работы монитора и звуковым генератором.
Процедуры
ClrScr Очищает экран или окно и помещает курсор в верхний левый угол.
Delay(D: Word) Приостанавливает работу программы на указанное число D миллисекунд. Практически
время задержки зависит от тактовой частоты процессора.
GotoXY(X, Y: Byte) Перемещает курсор в позицию Х строки Y экрана.
NoSound Выключает источник звука.
Sound(F: Word) Запускает источник звука с частотой F (Гц).
TextBackGround(Color: Byte) Устанавливает цвет фона.
TextColor(Color: Byte) Устанавливает цвет символов.
Wmdow(Xl, Yl, X2, Y2: Byte) Определяет текстовое окно на экране. XI, Yl - координаты левого
верхнего угла окна, X2, Y2 - правого нижнего угла окна.

Функции
KeyPressed: Boolean Анализирует нажатие клавиши. Результат TRUE, если на клавиатуре нажата
клавиша (кроме Alt, Ctrl и т. п.), и FALSE в противном случае. Не задерживает исполнение программы.
ReadKey: Char Читает символ с клавиатуры без эхоповтора на экране. Приостанавливает исполнение
программы до нажатия на любую клавишу, кроме Alt, Ctrl и т. п.

Библиотека GRAPH
Библиотека (модуль) GRAPH содержит константы, процедуры и функции для управления графическим
режимом работы монитора.
Константы цвета
Black 0 Чёрный DarkGray 8 Тёмно-серый
Blue 1 Синий LightBlue 9 Ярко-синий
Green 2 Зелёный LightGreen 10 Ярко-зелёный
Cyan 3 Голубой LightCyan 11 Ярко-голубой
Red 4 Красный LightRed 12 Розовый
Magenta 5 Фиолетовый LightMagenta 13 Малиновый
Brown 6 Коричневый Yellow 14 Жёлтый
LightGray 7 Светло - серый White 15 Белый

Стили заполнения геометрических фигур

Константа Код Описание
EmptyFill 0 Сплошное заполнение цветом фона

43
SolidFill 1 Сплошное заполнение заданным цветом

LineFill 2 Заполнение горизонтальными линиями

LtSlashFill 3 Диагональное заполнение (///)

SlashFill 4 Диагональное заполнение толстыми линиями

BkSlashFill 5 Обратное диагональное заполнение толстыми линиями

LtBkSlashFill 6 Обратное диагональное заполнение (\\\)

HatchFill 7 Клетчатое заполнение

XhatchFill 8 Косое клетчатое заполнение
InterleaveFill 9 Чередующееся линейное заполнение
WideDotFill 10 Редко расположенные точки
CloseDotFilI 11 Часто расположенные точки
UserFill 12 Стиль определен пользователем

Процедуры
Arc(X, Y: Integer; Ul, U2, R: Word) Строит дугу окружности текущим цветом с текущими параметрами
линии. X, Y — координаты центра дуги; Ul — угол до начальной точки дуги, отсчитываемый против
часовой стрелки от горизонтальной оси, направленной слева направо; U2 — угол до конечной точки
дуги, отсчитываемый так же, как Ul; R — радиус дуги.
Bar(Xl, Yl, X2, Y2: Integer) Строит прямоугольник, закрашенный текущим цветом с использованием
текущего стиля (орнамента, штриховки). XI, Yl, X2, Y2 — координаты левого верхнего и правого
нижнего углов прямоугольника.
Bar3D(Xl, Yl, X2, Y2: Integer; Glubina; Word; Top: Boolean) Строит параллелепипед,
используя текущий стиль и цвет. XI, Yl, X2, Y2 — координаты левого верхнего и правого
нижнего углов передней грани; Glubina — ширина боковой грани (отсчитывается по
горизонтали); Тор — признак включения верхней грани (если True — верхняя грань
вычерчивается, False — не вычерчивается).
Circle(X, Y: Integer; R: Word) Рисует текущим цветом окружность радиуса R с центром в точке (X, Y).
ClearDevice Очищает графический экран, закрашивает его в цвет фона.
ClearViewPort Очищает выделенное графическое окно, закрашивает его в цвет фона.
CloseGraph Закрывает графический режим, т. е. освобождает память, распределенную под
драйверы графики и файлы шрифтов, и восстанавливает текстовый режим работы экрана.
Ellipse(X, Y: Integer; Ul, U2, XR, YR: Word) Рисует дугу эллипса текущим цветом. X, Y — координаты
центра эллипса; Ul, U2 - углы до начальной и конечной точек дуги эллипса (см. процедуру Arc); XR, YR
— горизонтальная и вертикальная полуоси эллипса.
FillEllipse(X, Y: Integer; XR, YR: Word) Рисует заштрихованный эллипс, используя X, Y как центр и
XR, как горизонтальную и вертикальную полуоси эллипса.
FillPoly(N: Word; Var PolyPoints) Рисует и штрихует многоугольник, содержащий N вершин с
координатами в PolyPoints.
InitGraph(Var Driver, Mode: Integer; Path: String) Организует переход в графический режим.
Переменные Driver и Mode содержат тип графического драйвера и его режим работы. Третий параметр
определяет маршрут поиска графического драйвера. Если строка пустая (т. е. равна "), считается, что
драйвер находится в текущем каталоге.
Line(Xl, Yl, X2, Y2: Integer) Рисует линию от точки XI, Yl до точки X2, Y2.
LineTo(X, Y: Integer) Рисует линию от текущего указателя к точке X, Y.
MoveTo(X, Y: Integer) Смещает текущий указатель к точке X, Y.
OutTextXY(X, Y: Integer; TextString: String) Выводит текст в заданное место экрана.
PieSlice(X, Y: Integer; Ul, U2, Radius: Word) Строит сектор круга, закрашенный текущей штриховкой и
цветом заполнения. X, Y - координаты центра сектора круга; Ul и U2 - начальный и конечный углы
сектора, отсчитываемые против часовой стрелки от горизонтальной оси, направленной вправо; Radius
— радиус сектора.
44
PutPixel(X, Y: Integer; Color: Word) Выводит точку цветом Color с координатами X, Y.
Rectangle(Xl, Yl, X2, Y2) Рисует контур прямоугольника, используя текущий цвет и тип линии. XI, Yl —
координаты левого верхнего угла прямоугольника; X2, Y2 — координаты правого нижнего угла
прямоугольника.
Sector(X, Y: Integer; Ul, U2, XR, YR: Word) Рисует и штрихует сектор эллипса радиусами XR, YR с
центром в X, Y от начального угла Ul к конечному углу U2.
SetBkColor(Color: Word) Устанавливает цвет фона.
SetColor(Color: Word) Устанавливает основной цвет рисования.
SetFaiStyle(Pattern, Color: Word) Устанавливает образец штриховки и цвет.
SetLineStyle(LineStile, Pattern, Thickness: Word) Устанавливает толщину и стиль линии.
SetTextStyle(Font, Direction, CharSize: Word) Устанавливает текущий шрифт, направление
(горизонтальное или вертикальное) и размер текста.
SetViewPort(Xl, Yl, X2, Y2: Integer; ClipOn: Boolean) Устанавливает прямоугольное окно на
графическом экране. Параметр ClipOn определяет «отсечку» элементов изображения, не умещающихся
в окне.
Функции
GetMaxX и GetMaxY Возвращают значения максимальных координат экрана в текущем режиме работы
соответственно по горизонтали и вертикали.
GraphResult Возвращает значение GrOk, соответствующее коду 0, если все графические операции
программы выполнились без ошибок, или возвращает числовой код ошибки (от -1 до -14).

Заполнение графического экрана диагональными линиями

Program diagonals;
Uses Graph;
var gd, gm, i : Integer;
Begin
gd := Detect;
InitGraph(gd, gm, ' ');
i := -GetMaxY;
while i <= GetMaxY do
begin
Line(0, i, GetMaxX, i GetMaxY);
i := i + 20:
end;
Readln;
CloseGraph;
End.

Рисование 14 разноцветных вертикальных полос, окрашенных 14 цветами (кроме белого и черного).

(Можно с помощью процедур рисования линий и установки цвета).
Program stripes;
Uses Graph;
var
gd, gm, с, х, у, i Integer;
Begin
gd := Detect;
InitGraph(gd, gm, ' ' );
45
 SetBkColor(white);
ClearDevice;
x :=0;
for с := 1 to 14 do
begin
x := x + 35;
SetColor(c);
Line(x, 0, x, 400);
for 1 :=1 to 5 do Line(x + i, 0, x + i, 400); {Рисуем 6 полос}
end;
Readln;
CloseGraph;
End.

Программа рисует картинку, состоящую из разноцветных кружков.

Program bubbles;
Uses Graph, Crt;
var gd, gm, ec, uf : Integer;
Begin
gd := Detect;
gm := 0;
InitGraph(gd, gm, ' ');
Randomize; {Инициализация датчика случайных чисел}
for gm := 1 to 500 do
begin
ес := ес + 1;
if ec = 16 then ec := 1;
SetColor(ec);
Circle(Random(GetMaxX), Random(GetMaxY), Random(gd + 10));
end;
SetColor(Random(White));
SetTextStyle(0, HorizDir, 5);
OutTextXY(50, 29, 'Bubbles');
ReadKey;
CloseGraph;
End.
Программа рисует 16 разноцветных кружков, равномерно расположенных на отрезке прямой,
соединяющем точки (х1, у1) и (х2, у2), в каждом из которых помещен один символ текстовой строки:
Program vinnie;
Uses Graph, Crt;
46
var
х1, у1, х2, у2, с, г : Integer;
x, y, dx, dy : Real;
gm, gd : Integer;
a : String;
Begin
a := ' Vinnie The Pooh ';
gd := Detect;
InitGraph(gd, gm, ' ');
writeln('Введите х1, у1, х2, у2:');
readln(xl, у1, х2, у2);
ClearDevice;
dx := (х2 - х1) / 19;
dy := (у2 - у1) / 19;
SetColor(Green);
r := Round(Sqrt(dx * dx + dy * dy) / 2);
x := х1;
y := у1;
for с := 0 to 18 do {с-цвет}
begin
SetColor(c mod 13 + 1);
SetTextStyle(l, 0, 2);
Circle(round(x), round(y), r);
OutTextXY(Round(x) , Round(y), a[c +1]);
x := x + dx;
у := у + dy;
end;
readln;
CloseGraph;
End.

Программа рисования человека.

Program man;
Uses Graph;
var gd, gm : Integer;
Begin
gd := Detect;
ImtGraph(gd, gm, ' ') ;
SetFillStyle(l, Green); {Трава}
Bar(0, 350, 639, 479);
SetFillStyle(1, LightBlue); {Небо}
FloodFill(0, 0, Green);
SetColor(Red);
Circle(320, 200, 19); {Голова}
SetLineStyle(0, 0, 3);
Rectangle(390, 220, 340, 300);{Туловище}
Line(320, 300, 300, 350)
Line(320, 300, 340, 350)
Line(300. 240, 250, 250)
L1ne(340, 240, 390, 250)

47
 SetFillStyle(1, Red).; {Закрашивание человека}
FloodFill(320, 200, Red);
FloodFill(320, 230, Red);
SetColor(Yellow) ;
Circle(3l5. 190, 2); {Левый глаз}
Circle(325, 190, 2);{Правый глаз}
Line(3l5, 210, 325, 210);{Рот}
Readln:
CloseGraph;
End.

Символы (строки)
Функции и команды обработки строк
Процедуры
Delete(Var S:String; N, MJnteger) Удаляет М символов из строки S, начиная с позиции N.
Insert(SubS: String; Var S:String; N:Integer) Вставляет подстроку SubS в строку S, начиная с позиции
N.
Str(X:Integer; Var S:String) Возвращает представление числа Х в его символьной форме S.
Val(S:String; Var X, Code: Integer) Возвращает представление символов строки S в ее числовой форме
К-Параметр Code содержит признак ошибки преобразования (если Code = 0 ошибки нет).

Функции
Chr(X:Byte):Char Возвращает символ с заданным порядковым номером X.
Concat(Sl[, S2, .... SN]):String Выполняет сцепку (конкатенацию) последовательности строк.
Copy(S:String; N, M:Integer):String Возвращает подстроку из строки S, начиная с позиции N и длиной
М символов.
Length(S:String):Byte Возвращает количество символов в строке S.
Ord(X:Char):LongInt Возвращает порядковый номер символа Х в таблице кодов символов.
Pos(SubS, S: String):Byte Возвращает номер позиции, начиная с которой в строке S располагается
подстрока SubS (если значение функции равно нулю, то S не содержит SubS).

Программа, которая ведёт с вами в диалог.

Program primer 1;
Uses crt;
var a, b : string [50];
Begin
Clrscr;
writeln ('Добрый день!');
writeln ('Назовите, пожалуйста, свое имя');
readln (a) ;
writeln ('Рад познакомиться, ' , а);
writeln ('Как поживаете? ' ) ;
readln (b) ;
writeln ('Какое совпадение! И я ' , b);
readln;
End.

Сравнение строк
Метод сортировки трёх строк по алфавиту.
Program primer 2;
Uses crt;
var a, b, c, d : string [20] ;
48
Begin
Clrscr;
writeln ('Введите 1-е слово');
readln (a) ;
writeln ('Введите 2-е слово');
readln (b) ;
writeln ('Введите 3-е слово');
readln (с) ;
d : = ‘ ‘;
If a > b then
begin
d:= a ;
a:= b;
b:= d;
end;
If b > с then
begin
if с < a then
begin
d = a;
a = c;
с = d;
end;
d:= b;
b:= c;
c:= d;
end;
writeln (a);
writeln (b);
writeln (c);
readln;
End.

Объединение строк
Составление предложения.
Program primer 3;
Uses Crt;
var
a, b, c, d : string[30];
Begin
Clrscr; В результате получим:
a:='To be'; To be or not To be That is the question
b: = 'or not';
c:='That is the question';
d:=a+b+a;
writeln (d);
writeln (c);
readln;
End.
Сцепление строк.
Program primer 4 ;
49
Uses Crt;
var
a, b, c, d , 1, m, n, p : string [10]; В результате работы этой программы на
экране появятся следующие слова
Begin
Clrscr; парад паром сом сад
а:='пар';
b:='ад';
с:='ом';
d:='c';
l:=a+b; m:=a+c; n:=d+c; p:=d+b;
writeln (1, ' ' , m, ' ', n, ' ', p);
readln;
End.

Копирование подстроки
Составление простых слов из более сложного.
Program primer 5 ;
Uses Crt;
var
a, b, c, d , e : string [15] ;
Begin
Clrscr;
a:='стихотворение' ; В результате работы этой программы получим:
b:=copy(a, 1, 4) ; стих, тихо, творение, вор
c:=copy(a, 2, 4) ;
d:=copy(a, 6, 8) ;
e:=copy(a, 7,3);
writeln (b, ' , ' , с, ' , ' , d, ' , ' , е);
readln;
End.

Вставка, замена и удаление подстроки

Преобразование слова лево в слово компот.
Program primer 6;
Uses Crt;
var
a, b,c,d : string [15];
Begin
Clrscr;
a:='лекарство';
delete(a, 3, 5);
writeln(a); {лево}
delete(а, 3, 1);
b:='т';
insert(b, a, 3);
writeln(a); {лето}
с:='кот';
d:='мпo';
insert(d, с, 3);
writeln(c); {компот}
readln;
50
End.

Поиск подстроки
Поиск слов в предложении.
Program primer 7;
Uses Crt;
var
a, b, с : string [100];
m, n : integer;
Begin
Clrscr;
a ='Жил-был в норе под землей хоббит';
b :='был';
с :='хоббит';
m :=pos (b, a);
n :=pos (с, а);
writeln (b, ' - ', m); {был - 5}
writeln (с, ' - ', n); {хоббит – 27}
readln;
End.

Определение длины строки

Program primer 8;
Uses Crt;
var a, b : string[25];
Begin
Clrscr ; В результате получим: 8 19.
a:='computer';
b:='calculating machine';
writeln(length(a), ' ', length(b));
readln;
End.

Преобразование строк
Программа, определяющая и сравнивающая в введённом с клавиатуры числе количество чётных и
нечётных цифр.
Program primer 9;
Uses Crt;
var a: string[5] ;
b: string[1];
i, k, s, sn , x : integer;
Begin
Clrscr;
s: =0; sn: =0 ;
write('Задайте число'); readln(a);
for i:=l to length(a) do
begin
b:=copy(a,i,l) ;
val(b,x,k) ;
if x mod 2=0 then s:=s+l else sn:=sn+l;
end;
if s>sn then writeln ('Четных цифр больше');
if s<sn then writeln ('Нечетных цифр больше');
51
 if s=sn then writeln ('Одинаково');
readln;
End.

Программа, заменяющая в предложении одно слово на другое.

Program Replace;
Uses Crt;
var Text, Slovol, Slovo2 : String;
i, DlinaSlova, P : Integer;
Begin
CIrScr;
write(‘Введите строку :');
readln(Text);
write('Kaкoe слово заменить ? '); readln(Slovol);
write('Ha какое слово заменить ? '); readln(Slovo2);
writeln;
writeln('0 т в е т : ');
writeln('Исходный текст: ', Text);
DlinaSlova := Length( Slovol);
P := Pos(Slovol,Text); {номер позиции, с которой в строке Text в первый раз встречается подстрока Slovol}
while P>0 do {цикл продолжается до тех пор, пока подстрока Slovol встречается в строке Text}
begin
Delete(Text, P, DlinaSlova); {удаление подстроки Slovol, начинающейся с позиции P, из строки Text}
Insert(Slovo2, Text, P); {вставка подстроки Slovo2 в строку Text с позиции P}
P:=PostSlovol, Text);{номер позиции, с которой подстрока Slovol встречается в строке Text в очередной раз}
end;
writeln('Hoвый текст: ', Text);

End.

Программа подсчета различных букв в слове.

Program schot;
Uses Crt;
var s: string;
r: real;
i, j, n: integer;
Вegin
CIrScr;
r:=0;
readln(s);
for i:=1 to length(s) do
begin
n:=0;
for j:=1 to length(s) do
if s[i]=s[j] then inc(n);
r:=r+1/n;
end;
writeln('количество различных букв = ', r:1:0);
readln;
Еnd.

Программа определяющая, является ли слово "перевертышем" .

{Например, "шалаш", "казак" - перевёртыш}.
Program kazak;
52
Uses Crt;
var s1, s2: string;
i: integer;
Вegin
CIrScr;
readln(s1); s2:='';
for i:=length(s1) downto 1 do
s2:=s2+s1[i];
if s1=s2 then writeln(s1, ' - перевертыш')
else writeln(s1, ' - не перевертыш');
readln;
Еnd.

Обработка текста: Выделение слов из текста

--------------------------------------------------------------------------
На входе - текст, на выходе - список слов
--------------------------------------------------------------------------
Program slovo1;
Uses Crt;
const Alpha : set of char=['A'..'Z', 'А'..'П', 'Р'..'Я', 'a'..'z', 'а'..'п', 'р'..'я'];
var s, t: string;
i: integer;
Вegin
CIrScr;
writeln('Введите текст'); readln(s);
writeln('Список слов в тексте:');
i:=1;
Repeat
while NOT(s[i] in Alpha) and (i<=length(s)) do inc(i);
t:=' ';
while (s[i] in Alpha) and (i<=length(s)) do
begin
t:=t+s[i];
inc(i);
end;
if length(t)<>0 then writeln(t);
Until (i>length(s));
readln;
Еnd.

Обработка текста: Подсчет количества слов в тексте

--------------------------------------------------------------------------
На входе - текст, на выходе - количество слов в тексте
--------------------------------------------------------------------------
Program slovo2;
Uses Crt;
const Alpha : set of char=['A'..'Z', 'А'..'П', 'Р'..'Я', 'a'..'z', 'а'..'п', 'р'..'я'];
var s: string;
i: integer;
wc: integer;
Вegin
CIrScr;
writeln('Введите текст'); readln(s);
i:=1; wc:=0;
Repeat
53
 while NOT(s[i] in Alpha) and (i<=length(s)) do inc(i);
if (i<=length(s)) then inc(wc);
while (s[i] in Alpha) and (i<=length(s)) do inc(i);
Until (i>length(s));
writeln('Количество слов в этом тексте = ', wc);
readln;
end.

Обработка текста: Выделение чисел из текста

--------------------------------------------------------------------------
На входе - текст, на выходе - список чисел
--------------------------------------------------------------------------
Program number;
Uses Crt;
const Digits : set of char=['0'..'9'];
var s, d: string;
i: integer;
Вegin
CIrScr;
writeln('Введите текст, в котором есть и цифры:');
readln(s);
writeln('Список чисел в тексте:');
i:=1;
Repeat
while NOT(s[i] in Digits) and (i<=length(s)) do inc(i);
d:=' ';
while (s[i] in Digits) and (i<=length(s)) do
begin
d:=d+s[i];
inc(i);
end;
if length(d)<>0 then writeln(d);
Until (i>length(s));
readln;
Еnd.

Обработка текста: Перевод в маленькие буквы (нижний регистр)

-------------------------------------------------------------------------
На входе - текст, на выходе - текст из маленьких букв
--------------------------------------------------------------------------
Program text1;
Uses Crt;
var s: string;
function SmallAlpha(ps: string): string;
var i: integer;
begin
for i:=1 to length(ps) do
begin
case ps[i] of
'A'..'Z','А'..'П': inc(ps[i],32);
'Р'..'Я' : inc(ps[i],80);
end;
end;
SmallAlpha:=ps;
54
end;
Вegin
CIrScr;
writeln('Введите любой текст'); readln(s);
writeln('Этот же текст маленькими буквами:');
writeln(SmallAlpha(s));
readln;
Еnd.

Обработка текста: Перевод в заглавные буквы (верхний регистр)

--------------------------------------------------------------------------
На входе - текст, на выходе - текст из больших букв
--------------------------------------------------------------------------
Program text2;
Uses Crt;
var s: string;
function BigAlpha(ps: string): string;
var i: integer;
begin
for i:=1 to length(ps) do
begin
case ps[i] of
'a'..'z','а'..'п': dec(ps[i], 32);
'р'..'я' : dec(ps[i], 80);
end;
end;
BigAlpha:= ps;
end;

Вegin
ClrScr;
writeln('Введите любой текст');
readln(s);
writeln('Этот же текст большими буквами:');
writeln(BigAlpha(s));
readln;
Еnd.

Список использованных источников

Лахтин А.С., Искакова Л.Ю. Языки и технология программирования. Начальный курс.

Учебное пособие. Екатеринбург. 1998.
Немнюгин С., Перколаб Л. Изучаем Turbo Pascal. – СПб.: Питер, 2002.
Шауцукова Л. З. Информатика: Учеб. Пособие для 10-11 кл. общеобразоват. Учреждений. М.:
Просвещение, 2002.

55