Понятие о языке программирования Pascal. Линейные алгоритмы.

Содержание
Понятие о языке программирования Pascal. Линейные алгоритмы. ........................................2
Условный оператор, оператор множественного выбора .........................................................14
Циклы............................................................................................................................................23
Подпрограммы .............................................................................................................................32
Массивы........................................................................................................................................38
Обработка строк и символов ......................................................................................................44
Графика в Pascal...........................................................................................................................48
Записи ...........................................................................................................................................50
Работа с файлами .........................................................................................................................52
Понятие о языке программирования Pascal. Линейные
алгоритмы.
Понятие алгоритма
Алгоритм – строго определенная последовательность действий, приводящая к решению задачи.
Исполнителем алгоритма может быть человек или техническое устройство – станок,
робот, компьютер.
Свойства алгоритма:
1)
дискретность – алгоритм должен состоять из отдельных действий;
2)
определенность – каждое действие не должно допускать различных толкований;
3)
понятность – команды должны быть понятны исполнителю;
4)
результативность – алгоритм за конечное число шагов должен привести к
определенному результату;
5)
массовость (необязательное) – алгоритм описывает решение некоторого
класса задач.
Способы записи алгоритма:
6)
7)
8)
словесная;
графическая (блок-схема);
на алгоритмическом языке.
Пример: составить алгоритм деления обыкновенных дробей a/b и c/d
9)
числитель первой дроби умножить на знаменатель второй;
10)
знаменатель первой дроби умножить на числитель второй;
11)
записать дробь, в числителе которой – результат пункта 1), а в знаменателе –
результат пункта 2)
начало
ввод a, b, c, d
m=a*d
n=b*c
вывод m/n
конец
Program pr1;
Var a, b, c, d, m, n:integer;
Begin
Write (‘a, b, c, d =’); Readln (a,b,c,d);
m:=a*d;
n:=b*c;
Write (m, ‘/’, n);
End.
Линейные алгоритмы
Линейный алгоритм – алгоритм, в котором все команды выполняются последовательно друг за другом.
Пример: составить алгоритм обмена значений переменных a и b.
Команды a
b
c
a=5,
b=12
c=a
a=b
b=c
5
12
-
5
12
12
12
12
5
5
5
5
a
b
2) a=b
5
1
1) c=a
3) b=
5
c
Error!
Пример: составить алгоритм вычисления a8, используя не более 3х действий умножения (возведение в степень не использовать)
a: 2 ->4 ->16 -> 256
a=a*a | a2
a=a*a | a4
a=a*a | a8
Команды a
a=2
2
4
a=a*a
16
a=a*a
256
a=a*a
Д. з.
1) Составить алгоритм обмена значений переменных a и b без использования дополнительной переменной.
Команды a
a=3, b=7 3
10
a=a+b
10
b=a-b
7
a=a-b
b
7
7
3
3
2) Составить алгоритм вычисления a6, используя не более трех команд умножения.
Команды a
a=2
2
22
a=a*a
22
b=a
24
a=a*a
26
a=b*a
b
22
22
22
Язык программирования Turbo Passcal
Информацию в компьютере обрабатывает процессор, следовательно, алгоритм должен быть записан на языке, понятном для процессора, т.е. на машинном языке, представляющем последовательности нулей и единиц.
На заре компьютерной эры, в 50-е годы 20 в., программы писались на машинном
языке и представляли собой очень длинные последовательности нулей и единиц. Составление и отладка таких программ было чрезвычайно трудоемким делом.
В 60-70-е г. Для облегчения труда программистов начали создаваться языки программирования высокого уровня, формальные языки, кодирующие алгоритмы в привычном для человека виде (в виде предложений). Такие языки строились на основе использования определенного алфавита и строгих правил построения предложений (синтаксиса).
Наиболее широко распространенным типом языков программирования высокого
уровня являются процедурные языки. В таких языках широко используются управляющие
конструкции (операторы), которые позволяют закодировать различные алгоритмические
структуры (линейную, ветвление, цикл).
Одним из первых процедурных языков программирования был Basic, созданный в
1964 г. Другим широко распространенным языком программирования алгоритмического
типа является Pascal.
В настоящее время наибольшей популярностью пользуются системы объектноориентированного визуального программирования Microsoft Visual Basic и Borland Delphi.
В 1970г. появилось сообщение о языке программирования, названном в честь знаменитого математика Блеза Паскаля.
Автором языка программирования Паскаль является Никлаус Вирт, профессор, директор института информатики Швейцарской высшей политехнической школы. По темпам роста числа пользователей этого языка, он не знает себе равных в истории программирования.
При разработке программирования языка Паскаль преследовались две цели. Первая дать язык, пригодный для обучения программированию как систематической дисциплине,
основанной на ряде фундаментальных понятий, ясно и естественно отраженных в этом
языке. Вторая - осуществить реализацию этого языка, которая была бы надежна и в то же
время эффективна на существующих вычислительных машинах.
Мы будем использовать версию Турбо-Паскаль 7.1.
Основными элементами языка Pascal являются:
1) латинские буквы a, b, c …, z, A, B, C … Z (регистр не учитывается);
2) цифры 0 … 9;
3) спец. Символы *, - , (, ), <, > и.т.д.;
4) служебные слова begin, end, if …;
5) идентификаторы – имена переменных, констант, процедур, функций.
Имена должны начинаться с латинской буквы, за которой могут следовать буквы и
цифры (A, A23, Sum, MyProgram). Любая программа представляет собой текстовый
файл с собственным именем и расширением (pas. Primer.pas, Summa.pas).
Данные, обрабатываемые программой, могут быть следующих типов:
1) числовые (-25, 148, 0.325);
2) строковые (‘Паскаль’, ‘2+7’);
3) символьные (‘A’, ‘*’, ‘5’);
4) логические (true (истина), false (ложь)).
Числовые данные делятся на целые (integer), вещественные (real). Над числами определены операции +, -, *, /. Для целых чисел определены операции div – целочисленное деление и mod – вычисление остатка от деления.
15 div 4 = 3;
15 mod 7 = 1
8 div 5 = 1
8 mod 5 = 3
-20 div 7 = -2
-20 mod 7 =-6
2534 div 10 = 253
2534 mod 10 =4 // запомнить!!!
Типы переменных в Паскале:
INTEGER – целый тип (диапазон -32768...32767)
REAL – действительный, вещественный тип (диапазон 2.9*10-39...1.7*10+38)
CHAR – литерный, символьный тип
BOOLEAN – логический тип
BYTE – целые числа от 0 до 255
LONGINT – целый тип (диапазон -2147483648... 2147483647)
STRING – СТРОКОВЫЙ ТИП (ОТ 0 ДО 255 СИМВОЛОВ)
Стандартные операции и функции от скалярных данных.
Функция,
операция
A+B
Назначение
Сумма
Тип
переменных
REAL, INTEGER
Тип результата операции, функции
REAL, INTEGER
A-B
Разность
REAL, INTEGER
REAL, INTEGER
A*B
Произведение
REAL, INTEGER
REAL, INTEGER
A/B
Частное
REAL, INTEGER
REAL
ABS(x)
REAL, INTEGER
REAL, INTEGER
SQR(x)
Абсолютное значение
Вычисление х2
REAL, INTEGER
REAL,INTEGER
sin(x)
Нахождение sin x
REAL,INTEGER
REAL
cos (x)
Вычисление cos x
REAL, INTEGER
REAL
Arctan(x)
Вычисление
arctan x
Вычисление
экспоненты ех
Вычисление ln x
REAL, INTEGER
REAL
REAL, INTEGER
REAL
REAL, INTEGER
REAL
х
REAL, INTEGER
REAL
INTEGER
INTEGER
Exp(x)
Ln(x)
SQRT(x)
A div B
Вычисление
Нахождение целой
части при делении А
на B
A mod B
TRUNC(x)
ROUND(x)
PI
Нахождение остатка
INTEGER
при делении А на B
Нахождение целой
REAL, INTEGER
части х
Округление х в сто- REAL, INTEGER
рону ближайшего
целого
Зарезервированная
константа число π
INTEGER
INTEGER
INTEGER
REAL
Некоторые математические функции, не реализованные в языке Паскаль.
В математике
xn
log b a
tg x
ctg x
В программировании на языке Паскаль
exp(n*ln(x))
ln(a)/ln(b)
sin(x)/cos(x)
cos(x)/sin(x)
Примеры записи математических выражений
a2  x
= (sqr(a)+sqrt(x))/(siin(x)+cos(x))
sin x  cos x
e x  ex
= (exp(x)+exp(-x))/2
2
tgx  ctgx
= (sin(x)/cos(x)+cos(x)/sin(x))/ln(x)
ln x
Структура программы на Pascal
1) Заголовок (Program …)
2) Описание
a) описание внешних модулей (Uses)
b) описание типов (Type)
c) описание констант (Const)
d) описание переменных (Var)
e) описание меток (Label)
f)
описание процедур и функций (Procedure…
Function …)
3) Раздел операторов
Begin
…
End.
Команда присваивания
Переменная получает свое значение в результате выполнения команды присваивания
<имя_переменной>:=<значение>;
a:=22;
c1:=a/10;
text:=’Privet!’;
Команды ввода и вывода
Для вывода значений переменных, констант и выражений используются команды
Write и Writeln.
Write (t1, t2, … , tn);
Write(‘a+b’, 3+7); - a+b=10
При выполнении команды Writeln осуществляется переход на новую строку.
Функции вывода допускают использование указания о ширине поля, отводимого под
значение в явном виде:
WRITE (Y:m:n,X:k:l,...);
WRITELN (Y:m:n:,X:k:l,...);
где m и k- количество позиций, отведенных под запись значения переменных Y и X
соответственно;
n и I - количество позиций, отведенных под запись дробной части чисел Y и X.
Ввод значений переменных осуществляется с помощью команд Read или Readln.
Read(x1, x2, …, xn);
Если вводятся значения нескольких переменных, то их стоит набирать, разделяя
пробелом.
Пример 1. Найти сумму двух вещественных чисел.
program primer;
var
X, Y, Z: Real;
begin
Writeln(‘Введите два целых числа X и Y:');
Readln(X,Y);
Z := X + Y;
Writeln('Сумма чисел X и Y’, Z);
Readln;
end.
Пример 2. Вводится вещественное число а. Не пользуясь никакими арифметическими
операциями, кроме умножения, получить a4 за две операции.
program primer;
var a: integer;
begin
writeln('введите a');
readln (a);
a:=a*a;
a:=a*a;
writeln('a=',a);
readln;
end.
Пример 3. Составить программу расчета значения функции.
Z = |cos х4 – 3 tg х2 |+0.8 sin yх2+ 10 при любых значениях х и у. Результат вывести в виде: при х= и у=…
z=…
program primer;
var x,y,z: real;
begin
writeln('введите X Y');
{вывод строки подсказки}
readln (x,y);
{ввод аргументов x и y}
z:=abs(cos(sqr(x)*sqr(x)-3*sin(sqr(x))/cos(sqr(x))))+0.8*sin(y*sqr(x))+10;
writeln('при x=',x:8:2,' y=',y:8:2,' z=',z:8:2); {вывод результата}
readln;
{задержка до нажатия клавиши Enter}
end.
Пример 4. Найти периметр и площадь прямоугольного треугольника по его катетам.
program primer;
var a, b, c, S, P: real;
begin
writeln('введите катеты a, b:');
readln (a,b);
c:=sqrt(sqr(a)+sqr(b));
P:= a+b+c;
S:= a*b/2;
writeln('P =', P:6:3, ‘S=’, S:6:3);
readln;
end.
Пример 5. Вычислить сумму цифр введенного натурального трехзначного числа.
Program primer;
Var n, a, b, c: integer;
begin
write('n= '); readln(n);
a:=n div 100;
b:=(n div 10) mod 10;
c:=n mod 10;
writeln('сумма = ', a+b+c);
readln;
end.
Пример 6. Введенное 4-значное число изменить так, чтобы 2 и 3 цифры поменялись местами.
program primer;
var n,a,b,c,d:integer;
begin
write('введите n ');
readln (n);
a:=n div 1000;
b:=n div 100 mod 10;
c:=n div 10 mod 10;
d:=n mod 10;
n:= a*1000+c*100+b*10+d;
writeln('результат', n);
readln;
end.
ОПЕРАТОРЫ:
Оператор
Readln
Writeln
Read
Write
Назначение
ввод значений с клавиатуры c переводом курсора на новую строку
вывод значений на экран c переводом курсора на новую строку
ввод значений с клавиатуры
вывод значений на экран
Синтаксис
Readln( перем1, …, перемN)
Writeln('Текст')
Writeln(перем1, ..., перемN)
Read( перем1, …, перемN)
Write('Текст')
Write(перем1, ..,перемN)
Справка по работе с системой Turbo Pascal
Запуск - C:/TPascal7.1/Bin/TURBO.EXE.
Выход Alt + X.
Верхняя строка содержит «меню» возможных режимов работы Турбо Паскаля, нижняя — краткую справку о назначении основных функциональных клавиш.
Вся остальная часть экрана принадлежит окну редактора, очерченному двойной рамкой и предназначенному для ввода и коррекции текста программ. В его верхней строке
приводятся имя того дискового файла, откуда был прочитан текст программы (новому
файлу присваивается имя NONAME00.PAS), два специальных поля, используемых при
работе с мышью (эти поля выделены квадратными скобками), и цифра 1 — номер окна.
Команды предаваемые функциональными клавишами:
F1 – активизировать окно помощи;
F2 – записать редактируемую программу на диск;
F3 – прочитать файл с диска в окно редактора;
F4 – включить выполнение программы до строки, в которой находится курсор;
F5 – распахнуть текущее окно до полного экрана;
F6
– сделать активным окно редактора Edit или окно просмотра переменных
Watch или окно вывода результатов Output (в зависимости от текущего окна);
F7
– отладочная операция: выполнить следующую строку программы в режиме
тросировки (прослеживает действие программы внутри процедур и функций);
F8
– отладочная операция: выполнить следующую строку программы без захода в
процедуры и функции;
F9
– компилировать программу;
F10 – активизировать главное меню;
Ctrl+F2 – сбросить режим отладки программы;
Ctrl+F7 – добавить выражение в окно просмотра Watch;
Ctrl+F8 – переключить контрольную точку (останова) программы;
Ctrl+F9– выполнить прогон программы: компилировать, загрузить в оперативную
память, выполнить программу, вернуться в среду Турбо Паскаль;
Alt+F5 – сменить окно редактора на окно вывода результата – Output.
Команды текстового редактора: Турбо Паскаль;
PgUp
– смещение курсора на страницу вверх;
PgDn
– смещение курсора на страницу вниз;
Home
– смещение курсора в начало строки;
End
– смещение курсора в конец строки;
Ctrl+PgUp
– смещение курсора в начало текста;
Ctrl+PgDn
– смещение курсора в конец текста;
Backspace
– стереть символ слева от курсора;
Delete
– стереть символ над курсором;
Ctrl+Y
– удалить строку, на которой расположен курсор;
Enter
– вставить новую строку;
Shift+<стрелки> – пометить блок;
Ctrl+Insert
–копировать блок в буфер редактора;
Shift+Insert
–копировать буфер в окно редактора.
Команды меню:
File / New
– создать новый файл;
File / Open
– открыть существующий файл;
File / Save
– сохранить файл;
File / Save as
– сохранить файл под новым именем;
Run / Run
– запустить программу на выполнение;
Compile / Destination – установить место размещения исполняемого
Файла;
Compile / Compile – компилировать программу;
Компиляция - F9.
Компиляция и запуск - Ctrl—F9.
Если в программе нет синтаксических ошибок, то на экране сообщается о количестве
строк откомпилированной программы и объеме доступной оперативной памяти, среда выводит на экран окно прогона программы, а после завершения работы программы вновь
берет управление компьютером на себя и восстанавливает на экране окно редактора.
Если на каком—либо этапе среда обнаружила ошибку, она прекращает дальнейшие
действия, восстанавливает окно редактора и помещает курсор на ту строку программы,
при компиляции или исполнении которой обнаружена ошибка. При этом в верхней строке
редактора появляется диагностическое сообщение о причине ошибки.
Неотъемлемой составной частью среды Турбо Паскаля является встроенная справочная служба. В затруднительной ситуации достаточно нажать на клавишу F1 и на экране
высветится необходимая справка. Эта справка зависит от текущего состояния среды (такую справочную службу называют контекстно-зависимой). Например, если нажать на F1 в
момент, когда среда обнаружила ошибку в программе, в справке будут сообщены дополнительные сведения о причинах появления этой ошибки и рекомендации по ее устранению.
Существуют четыре способа обращения к справочной службе непосредственно из
окна редактора:
F1 — получение контекстно-зависимой справки;
Shift—F1 — выбор справки из списка доступных справочных сообщений;
Ctrl—Fl — получение справки о нужной стандартной процедуре, функции, о стандартной константе или переменной;
Alt—Fl — получение предыдущей справки.
При использовании команды Shift—F1 на экране появляется справочное окно, содержащее упорядоченный по алфавиту список стандартных процедур, функций, констант
и переменных, для которых можно получить справочную информацию. В этот момент
клавишами смещения курсора следует передвинуть указатель в окне к нужному слову и
нажать клавишу Enter, чтобы получить справку.
Эту же справку можно получить и другим способом: напечатать на экране имя стандартной процедуры (функции, константы, переменной) или подвести курсор к имеющемуся уже в тексте программы стандартному имени и нажать Ctrl—Fl. Среда проанализирует
ближайшее окружение курсора, выделит стандартное имя и даст нужную справку.
Доступ к справочной службе возможен и через главное меню Турбо Паскаля
Во многих случаях справка содержит пример небольшой программы, иллюстрирующей соответствующие возможности Турбо Паскаля. Ее можно «вырезать» из справки и
перенести в окно редактора.
Окно просмотра переменных Watch предназначено для отладки программы. В нем
можно наблюдать изменение значений переменных при пошаговом выполнении программы с целью локализации ошибок в программе. Ввода переменных и выражений в окно Watch осуществляется командой Ctrl+F7 или через главное меню - Debug / Add Watch.
Окно Watch включается клавишей F6.
Условный оператор, оператор множественного выбора
Алгоритмы с ветвлением
Часто при выполнении алгоритма должны предлагаться различные действия в зависимости от выполнения или невыполнения некоторого условия. Такие алгоритмические
структуры называют ветвлением.
Полное ветвление
Неполное ветвление
Пример. Вычислить выражение y  x для введенного x.
Исходные данные: x.
Результат: y, или ‘функция не определена’
проверяемый
случай
x=9
x=-9
x>=0
y
результат
9>=0
да
-9>=0
нет
y= 9  3
y=  3
-
функция не
определена
Пример. Вычислить выражение y  x для введенного x.
 x, x  0
x 
 x , x  0
проверяемый
случай
x>=0
y
результат
x=9
9>=0
да
y= 9  3
y=  3
x=-9
-9>=0
нет
-
функция
не определена
Пример. Выбрать максимальное из 2х чисел a и b.
проверяемый
случай
a=9
b=15
x
y
результат
9>15
нет
15>9
да
15
a=18
b=3
a=7
b=7
18>3
да
7>7
нет
-
18
7>7
нет
числа равны
проверяемый
случай
a=9
b=15
c=2
a=8
b=3
с=22
a=12
b=9
c=1
x
max
y
результат
9>15
нет
15
2>15
нет
15
8>3
да
8
22>8
да
22
17>9
нет
17
1>17
нет
17
Пример. Выбрать максимальное из
3х чисел a, b, c.
Ветвление в Pascal
Логические выражения
Переменные логического типа описываются с помощью служебного слова Boolean.
Они могут принимать два значения: true – истина и false – ложь.
Var
F: Boolean;
Begin
F:=true;
…
Логическое выражение – выражение, содержащее константы, переменные, знаки математических операций, знаки отношений (=, <, >, <>, <=, >=) и логические операции (not,
or, and, xor).
2+3=5 – true
2*5>20 – false
7+8<>10+5 – false
Логические операции
1. ОТРИЦАНИЕ NOT (НЕ)
Инвертирует (меняет на противоположное) значение логического выражения.
x
true
false
Not (x)
false
true
NOT (2+3=5) – false
2. ЛОГИЧЕСКОЕ СЛОЖЕНИЕ OR (ИЛИ)
x OR y – истинно, если истинно либо x, либо y.
x
true
true
false
false
y
x OR y
true
true
false
true
true
true
false
False
(2>3) OR (7=7) – true
3. ЛОГИЧЕСКОЕ УМНОЖЕНИЕ AND (И)
x AND y – истинно, если истинны и x, и y.
x
true
true
false
false
y
x OR y
true
true
false
false
true
false
false
false
(2>3) AND (7=7) – false
4. ИСКЛЮЧАЮЩЕЕ ИЛИ XOR
x XOR y – истинно, когда значения x и y различны.
x
true
true
false
false
y
true
false
true
false
x OR y
true
true
false
false
Пример 1. Определить, является ли введенное число четным. Вывести true (четное), false (нечетное).
program primer;
var
N: integer;
f: boolean;
begin
Writeln(‘N=');
Readln(N);
F := N mod 2 =0;
Writeln(F);
Readln;
end.
Пример 2. Определить, принадлежит ли введенное число интервалу (0; 10).
0< x< 10
(x>0) and (x<10)
program primer;
var
x: integer;
f: boolean;
begin
Writeln(‘x=');
Readln(x);
F := (x>0) and (x<10);
Writeln(F);
Readln;
end.
Команды ветвления
1. УСЛОВНЫЙ ОПЕРАТОР IF
If <условие> then <оператор1> else < оператор2>
Условие – это логическое выражение. Если оно принимает значение true, то выполняется оператор1, если false, то оператор2.
Можно использовать сокращенную форму записи:
If <условие> then <оператор1>
В этом случае при невыполнении условия, управление передается следующей команде.
Если после then должны выполняться несколько операторов, то они должны быть заключены в операторные скобки begin … end. Такое оператор называется составным.
Пример 3. Вводится число. Если оно положительное, то уменьшить его в 10 раз.
Program primer;
Var a: real;
BEGIN
write('a='); readln(a);
if a>0 then a:=a/10;
writeln('a=', a);
readln
END.
Пример. Из чисел a и b выбрать минимальное.
Program primer;
Var a, b: integer;
BEGIN
write('a, b='); readln(a, b);
if a<b then writeln('Мin=', a) else writeln('Мin=', b);
readln
END.
Если предусмотреть случай равенства a и b, то условный оператор следует записать в
виде:
if a<b
then writeln('Мin=', a)
else if a>b then writeln('Мin=', b)
else writeln('a=b');
Другой вариант:
if a<b then writeln('Мin=', a);
if a>b then writeln('Мin=', b);
if a=b then writeln('a=b');
Пример 4. Выбрать минимальное из трех введенных целых чисел.
Program primer;
Var a, b, c, m: integer;
BEGIN
write('a, b, c='); readln(a, b, c);
if a<b then m:=a else m:=b;
if c<m then m:=c;
writeln('Мin=', m);
readln
END.
Пример 5. Вводятся координаты точки. Определить попадает ли точка в заштрихованную область или нет.
y
x2+y2=25
1
x
x +y =4
2
2
program primer;
var x,y: real;
begin
Write('введите x y ');
readln (x,y);
if (sqr(x)+sqr(y)<=25) and (sqr(x)+sqr(y)>=4) then writeln('точка попадает в
заштрихованную область')
else writeln('точка не попадает в заштрихованную область');
readln;
end.
Пример 6. Вводятся три числа A, B, C. Определить, сколько среди них нечетных.
program primer;
var a, b, c, k: integer;
begin
write('a, b, c= ');
readln (a, b, c);
k:=0;
if (a mod 2=1) then k:=k+1;
if (b mod 2=1) then k:=k+1;
if (c mod 2=1) then k:=k+1;
writeln(‘k=’,k);
readln;
end.
Пример 7. Введено трехзначное число. Необходимо разбить его на цифры. Все четные
цифры, которые меньше 8 увеличить на 2, а 8 заменить на 0.
program primer;
var n,a,b,c,d:Integer;
begin
write('введите n');
readln (n);
a:=n div 1000;
b:=n div 100 mod 10;
c:=n div 10 mod 10; d:=n mod 10;
if (a mod 2=0) and (a<8) then a:=a+2 else if a=8 then a:=0;
if (b mod 2=0) and (b<8) then b:=b+2 else if b=8 then b:=0;
if (c mod 2=0) and (c<8) then c:=c+2 else if c=8 then c:=0;
if (d mod 2=0) and (d<8) then d:=d+2 else if d=8 then d:=0;
n:=1000*a+100*b+10*c+d;
writeln('результат= ', n);
readln;
end.
Пример. Вычислить выражение y  x для введенного x.
Program primer;
Var x, y : real;
BEGIN
write('x ='); readln(x);
if x>=0 then
begin
y:=sqrt(x);
writeln(‘y=’, y: 6:3);
end
else writeln('недопустимое x');
readln;
END.
2. ОПЕРАТОР CASE.
Оператор Case позволяет выбрать один из возможных направлений программы. Общий вид оператора:
case <ключ выбоа> of
<значение1> : <оператор1>;
<значение2> : <оператор2>;
<набор значений3> : <оператор3>;
… … …
else
<альтернативный оператор>
end.
Пример 8. Составить программу, которая по введенному номеру месяца определяет
время года.
N – номер месяца. Зима – 12, 1, 2. Весна – 3, 4, 5 и т.д.
Program primer;
Var n: integer;
Begin
Write(‘n=’);
Readln(n);
Case n of
12, 1, 2 : writeln(‘зима’);
3, 4, 5 : writeln(‘весна’);
6, 7, 8 : writeln(‘лето’);
9, 10, 11 : writeln(‘осень);
else
writeln(‘Ошибка’);
end;
End.
3. КОМАНДА БЕЗУСЛОВНОГО ПЕРЕХОДА GOTO
Общий вид: GOTO<метка>
Команда GOTO позволяет перейти в нужную часть программы без проверки какихлибо условий.
Метка – произвольный идентификатор (имя), который должен быть описан в разделе
Label.
Program primer;
Label m;
Var x, y, r: real;
op: char;
Begin
Write(‘x, y=’); Readln(x, y);
Write(‘op=’); Readln(op);
If (op=’/’) and (y=0) then
begin
Writeln(‘делить на 0 нельзя’);
Goto m;
end;
Case op of
‘+’ : r:=x+y;
‘-’ : r:=x-y;
‘*’ : r:=x*y;
‘/’ : r:=x/y;
else
writeln(‘Ошибка’);
end;
m: Readln;
End.
ОПЕРАТОРЫ:
Оператор
if … then…
Назначение
проверка
условий
case
выбор
Синтаксис
if <условие> then <оператор1> else <оператор2>
if <условие> then <оператор>
case <переменная> of
<константа 1>: <операторы 1>;
…
< константа n>: <операторы n>
[else <операторы>]
end;
Циклы
Алгоритмы с циклами
Цикл – многократное повторение одних и тех же действий.
1. Цикл с предусловием
Такой цикл называют «пока». Механизм его работы: пока
условие истинно, повторять…
Пример. Вывести все «-» члены арифметической прогрессии -11; -7…
Пусть a – очередной член прогрессии.
a=a1+4 – следующий член прогрессии.
Пока a<0, повторять a=a1+4.
Цикл с предусловием может не выполниться ни разу, если условие сразу оказалось
ложным.
Пример. Найти сумму первых десяти натуральных чисел.
S=1+2+…+10
S – сумма
а – очередное слагаемое.
S:=S+a
Выполнять, пока a<=10
a:=a+1
2. Цикл с постусловием.
Механизм работы: повторять, пока условие не станет истинным.
Этот цикл всегда выполняется хотя бы 1 раз.
Пример. Найти сумму положительных членов арифметической прогрессии: 17; 11
…
S=a+S
a:=a-6
тело цикла
повторять до тех пор,
пока не выполнится
условие a<=0
Пример. Вычислить n!
F=F*k
k=k+1
тело цикла
повторять до тех пор,
пока не выполнится
условие k>N
Циклы в Pascal
Паскаль предусматривает использование трех операторов цикла:
• оператор цикла с параметром for
• оператор цикла с предусловием while
• оператор цикла с постусловием repeat
1. Цикл с параметром
Цикл с параметром используется в тех случаях, когда число повторений заранее известно.
Общий вид: for <параметр>:=<начальное значение> to <конечное значение> do
<оператор>;
Значение параметра меняется с шагом 1. Оператор представляет тело цикла, которое
может быть простым или составным оператором.
Пример 1. Вывести квадраты первых десяти натуральных чисел.
Program primer;
Var i, x: integer;
begin
for i:=1 to 10 do begin
x:=sqr(i);
write(x, ' ');
end;
readln
end.
{перебираем натуральные числа от 1 до 10}
{возводим очередное число в квадрат}
{выводим полученное значение}
Пример 2. Найти сумму 1 + 1/3 + 1/5 +...(N слагаемых).
Program primer;
Var I, N: integer;
S: real;
begin
Write('N='); Readln(N); {вводим количество слагаемых}
S:=0;
{обнуляем сумму}
For I:=1 to N do
{выполняем цикл N раз, добавляя к сумме по од ному слагаемому}
S:=S+1/(2*I-1);
Writeln('S=',S:5:2);
{выводим значение суммы с двумя десятичными знаками}
Readln
end.
Пример 3. Подсчитать количество двузначных чисел, кратных 3.
Program primer;
Var i, k: integer;
begin
k:=0; for i:=10 to 99 do begin
if i mod 3=1 then k:=k+1;
end;
writeln ('k=', k);
readln;
end.
Пример 4. Найти сумму четных делителей введенного целого числа.
Program primer;
Var i, S, n: integer;
begin
Write (‘n=’); Readln(n);
S:=0;
for i:=2 to (n div 2) do
if (n mod i=0) and (i mod 2=0) then s:=s+i;
writeln('S=', S);
readln;
end.
Если необходимо, чтобы параметр цикла менялся с шагом -1, следует вместо to записать
downto.
For i:=10 downto 1 do Writeln (i);
2. Цикл с предусловием.
While <условие> do <оператор>;
Цикл выполняется, пока условие остается истинным.
Пример. Первоначальный вклад составил S рублей. Через сколько лет сумма вклада более, чем в 2 раза превысит первоначальный вклад, если годовой процент составляет x%.
Например, S=1000 р, x=10%
1 год S=1000+1000*10/100=1100
2 год S=1100+1100*10/100=1210
Program primer;
Var s, sum, x: real;
n: integer;
Begin
Write(‘S=’); Readln(S);
Write(‘x=’); Readln(x);
Sum:=2*s; n:=0;
S:=0; a:=1; b:=2;
While S<=Sum do begin
s:=s+x/100;
n:=n+1;
end;
write('через ', n, ‘ лет’);
readln
end.
Пример 5. Задана арифметическая прогрессия -21; - 16;… Определить номер первого
положительного члена прогрессии.
a – очередной член прогрессии, n – его порядковый номер
a=a+5
n=n+1
Program primer;
var
повторять, пока a<=0
Program primer;
var
a, n: integer;
begin
a:= -21; n:=1;
while a<=0 do begin
a:=a+5; n:=n+1; end;
writeln(‘n=’, n);
readln;
end.
a, n: integer;
begin
a:= -21; n:=1;
repeat
a:=a+5;
n:=n+1;
until a>0;
writeln(‘n=’, n);
readln;
end.
Примечание: необходимо учитывать следующую особенность: команды, составляющие
тело цикла, должны содержать по крайней мере, одну команду, влияющую на значение
логического выражения (условия).
3. Цикл с постусловием
Repeat
<опреаторы>;
Until <условие>
Оператор повторяет последовательность команд пока условие не станет истинным.
Этот цикл всегда выполняется хотя бы 1 раз.
Пример. Найти сумму цифр введенного натурального числа.
Program primer;
var
a, n, s: integer;
begin
Write(‘n=’); Readln(n);
S:=0;
repeat
a:=n mod 10;
s:=s+a;
n:=n div 10;
until n=0;
writeln(‘s=’, s);
readln;
end.
Пример 6. Протабулировать (вывести на экран таблицу значений) функции y=2x+1 интервале [-3; 3] с шагом 0.5.
x= - 3
y=…
x= - 2.5
y=…
…
x=3
y=…
Program primer;
var
x, y: real;
begin
x:=0;
repeat
y:=sqrt(sqr(sin(x)+2));
writeln(‘x=’, x:6:2, ‘y=’, y:8:4);
x:=x+0.2;
until x>1;
readln;
end.
Пример 7. Вычислить сумму S 
i
(i  1) 2
с заданной точностью E=0.0001.
Program primer;
Var S, e, slag: real;
k: integer;
begin
e:=0.0001; s:=0; k:=1;
slag:= k/sqr(k+1);
repeat
s:=s+slag;
k:=k+1;
slag:=k/sqr(k+1);
until slag<e;
write (‘s=’, s:6:2);
readln;
end.
Вложенные циклы
Циклическая конструкция может содержать в теле цикла другой цикл. Такие конструкции называют вложенными циклами. Глубина вложения и тип циклов может быть
различными.
Например, a) For . . . do – внешний цикл
While . . . do – внутренний цикл (в данном случае глубина = 2)
b) While . . . do
For . . . do
Repeat
...
Until (глубина =3)
Рассмотрим механизм работы вложенных циклов на примере:
For a:=1 to 2 do
For b:=1 to 3 do
Writeln(‘a=’, a, ‘ b=’, b);
a=1
b=1
выполняется внутa=1
b=2
ренний цикл по b
a=1
b=3
при a=1
a=2
b=1
выполняется внутa=2
b=2
ренний цикл по b
a=2
b=3
при a=2
Параметр внешнего цикла не меняет свое значение до тех пор, пока внутренний цикл
не завершит свою работу.
Пример: вывести на экран таблицу Пифагора.
внутренний цикл
1 2 3 4 5 6 7 8 9
1
2
3
внешний цикл
4
5
6
7
8
9
Program primer;
var
i, j: integer;
begin
for i:=1 to 9 do
begin
for j:= 1 to 9 do
write(i*j:4);
writeln;
end;
readln;
end.
Внутренний цикл формирует каждую строку таблицы. Writeln – перевод курсора на
новую строку.
повторить
Пример. Вводятся k натуральных чисел. Найти сумму цифр каждого из них.
1. Ввести число N
2. Найти сумму его цифр
3. Вывести результат
Program primer;
var
n, s, a, i, k: integer;
begin
write (‘k=’); readln(k);
for i:=1 to k do
begin
Write(‘n=’); readln (n); s:=0;
Repeat
a:=n mod 10;
s:=s+a;
n:=n div 10;
until n=0;
writeln (‘s=’,s);
end;
readln;
end.
ОПЕРАТОРЫ:
Оператор
For
Назначение
Цикл
с параметром
While
Цикл
с предусловием
Repeat
Until
Цикл
с постусловием
Синтаксис
For <перем>:=<начальное знач> to <кон.знач> do <оператор>;
Значение переменной изменяется от начального значения
к конечному с шагом 1.
For <перем>:=<нач. знач> downto <конеч. знач> do
<оператор>;
Значение переменной изменяется от начального значения
к конечному с шагом -1
While <условие> do <оператор>;
Цикл выполняется, пока условие истинно.
Repeat
<Операторы>;
Until <условие>;
Цикл выполняется, пока условие ложно.
Подпрограммы
Подпрограмма – это последовательность действий, которые можно выполнять в различных местах программы для различных исходных данных. Данные передаются в подпрограмму через параметры или глобальные переменные.
Существует два вида подпрограмм – функции и процедуры. Функция возвращает результат через свое имя, поэтому имя функции ставится в правой части оператора присваивания. Процедура возвращает результат через параметры, поэтому процедура является
оператором.
Структура подпрограмм аналогична структуре основной программы, за исключением заголовка.
Функции пользователя
Синтаксис заголовка функции:
Function <имя функции> (описание параметров): тип;
Для передачи основной программе результата в теле функции необходимо имени функции
присвоить значение вычисления.
Синтаксис функции
Function <имя_функции>(<параметры>) : <тип результата>;
Label <метки>;
Const <константы>;
раздел объявления меток, констант, типов данных,
Type <типы данных>;
переменных (может отсутствовать)
Var <переменные>;
Begin
<операторы, составляющие тело функции>;
End;
Для того, чтобы значение функции было определено и передано в основную программу, в теле функции обязательно должен быть хотя бы один оператор присваивания
вида:
<имя_функции>:=<значение>.
Вызов функции, определенной пользователем, осуществляется так же, как и любой
стандартной функции Паскаля.
Пример 1. Создать функцию пользователя, вычисляющую х!
Program primer;
Var
x: integer; y: real;
Function Fact(x: integer): real;
Var
i: integer; f: real;
begin
f:=1;
for i:=1 to x do f:=f*i;
{вычисляем произведение}
Fact:=f;
{имени функции присваиваем полученное значение}
end;
begin
{основная программа}
Write (‘x=’); Readln(x);
{ввод значения х}
y:=Fact(x);
Writeln(‘y=’, y:4:0);
Readln;
{вызов функции с аргументом х }
{вывод результата}
end.
Пример 2. Вычислить, используя функцию нахождения знаменателя:
1 2 3
   ... (n слагаемых)
2! 3! 4!
Program primer;
Var s: real;
i, n: integer;
Function Fakt(x: integer): real;
{функция вычисления факториала}
Var
i: integer; f: real;
begin
f:=1;
for i:=1 to x do f:=f*i;
Fakt:=f;
end;
BEGIN
write('n= ');
Readln(n);
{вводим количество слагаемых суммы}
s:=0;
For i:=1 to n do
{перебираем i от 1 до n}
s:=s+i/Fakt(i+1);
{добавляем к сумме очередную дробь, вызывая}
{ функцию для вычисления знаменателя}
writeln('s=',s:6:4);
{вывод результата}
Readln;
END.
Пример 3. Два треугольника заданы длинами своих сторон. Определить, площадь какого
из них больше (создать функцию для вычисления площади треугольника по длинам его
сторон).
Для решения задачи используем формулу Герона S  p   p  x    p  y    p  z  , где x, y, z
– стороны треугольника, p – полупериметр)
Program primer;
var
a1, b1, с1, s1, a2, b2, с2, s2: real;
Function PlTr(x ,y, z: real): real;
Var
p: real;
Begin
p:= (x + y + z)/2;
{полупериметр треугольника}
PlTr:=Sqrt(p*(p-x)*(p-y)*(p-z));
End;
BEGIN
{основная программа}
Write('Cтороны 1-го треугольника:'); Readln(a1, b1, c1);
Write('Cтороны 2-го треугольника:'); Readln(a2, b2, c2);
S1:=PlTr(a1, b1, c1);{вызов функции для нахождения площади 1-го треугольника}
S2:=PlTr(a2, b2, c2);{вызов функции для нахождения площади 2-го треугольника}
if S1>S2 then Writeln(‘S1>S2’)
else if S1<S2 then Writeln(‘S1<S2’)
else Writeln(‘S1=S2’);
Readln;
END.
Процедуры
Процедура – это относительно самостоятельная часть программы, имеющая собственное имя. Процедура описывается перед основной программой.
Синтаксис заголовка процедуры:
Procedure <имя процедуры> (описание параметров);
В заголовке перед параметром, значение которого передается в основную программу, ставится слово var.
Структура процедуры:
Procedure <имя_процедуры>(<параметры>); -заголовок процедуры
Label <метки>;
Const <константы>;
раздел объявления меток, констант, типов данных,
Type <типы данных>;
переменных (может отсутствовать)
Var <переменные>;
Begin
<операторы >
- тело процедуры
End;
Параметры, указанные в заголовке процедуры называются формальными. Вызов
процедуры осуществляется из основной программы указанием ее имени. При вызове процедуры формальные параметры заменяются фактическими. Количество и тип формальных и фактических параметров должны совпадать. Для передачи исходных данных в
процедуру используются параметры-значения. Фактические параметры-значения могут
быть константами, переменными, выражениями. Полученный в процедуре результат передается в основную программу с помощью параметров-переменных. В заголовке описания процедуры перед параметрами-переменными пишется Var.
Параметры функции
В описании процедуры или функции задается список формальных параметров. Каждый параметр, описанный в списке формальных параметров, является локальным по отношению к описываемой процедуре или функции, и в теле подпрограммы на него можно
ссылаться по его идентификатору.
Существует три основных типа параметров: параметр-значение, параметрпеременная и параметр-константа. Они характеризуются следующим:
1 Группа параметров без предшествующего ключевого слова var является списком
параметров-значений.
2 Группа параметров, перед которыми стоит ключевое слово var является списком
параметров-переменных.
3 Группа параметров, перед которыми стоит ключевое слово const является списком
параметров-констант.
Параметры-значения
Формальный параметр-значение обрабатывается, как локальная по отношению к
процедуре или функции переменная, за исключением того, что он получает свое начальное значение из соответствующего фактического параметра при активизации процедуры
или функции. Изменения, которые претерпевает формальный параметр-значение, не влияют на значение фактического параметра. Фактическое значение параметра-значения не
должно иметь файловый тип или какой-либо структурный тип, содержащий в себе файловый тип. Фактический параметр должен иметь тип, совместимый по присваиванию с типом формального параметра-значения.
Примеры:
function MaxElem(A: Vector; n:Byte): Real;
function IsZero(I, K: Integer): Boolean;
Параметры-переменные
Параметр-переменная используется, когда значение должно передаваться из процедуры или функции вызывающей программе. Соответствующий фактический параметр в
операторе вызова процедуры или функции должен быть ссылкой на переменную. При активизации процедуры или функции формальный параметр-переменная замещается адресом фактической переменной, любые изменения в значении формального параметрапеременной отражаются на фактическом параметре. Внутри процедуры или функции любая ссылка на формальный параметр-переменную приводит к доступу к самому фактическому параметру. Тип фактического параметра должен совпадать с типом формального
параметра-переменной.
Примеры:
function SumMatr(A, B: Matrix; var C: Matrix):Real;
function ChrString(var S: String):String;
Параметры-константы
Параметры-константы также как и параметры-переменные передаются в программу
своим адресом. Но в отличии от них изменять параметры-константы в теле подпрограммы
не допускается.
Пример 4. Создать процедуру для вычисления периметра и площади прямоугольного треугольника по его катетам a, b.
Program primer;
Var
a, b, p, s: real;
{ a, b- катеты, p - периметр, s - площадь }
Procedure Treug(a,b: real; Var p, s: real);
{a, b- входные данные(параметры-значения),}
s-выходные данные(параметры-переменные)}
Begin
p:= a + b + Sgrt(a*a + b*b); {периметр треугольника с катетами a, b}
s:= a*b/2;
{ площадь треугольника с катетами a, b }
End;
Begin
{основная программа}
Write('a, b =');Readln(a, b);
{ввод исходных данных}
Treug(a, b, p, s);
{вызов процедуры и передача исходных данных a, b}
Writeln('p=', p:4:1, ‘ s=’, s:4:1); {вывод результата, полученного из процедуры}
Readln;
End.
Пример 5. Создать процедуру обмена значениями 2-х переменных.
Program primer;
Var
A, B: real;
Procedure Obmen(Var X,Y:real);
Var
{p,
T: real;
Begin
T:=X;
X:=Y;
Y:=T;
End;
begin
Write('A, B ='); Readln(A,B);
Obmen(A,B);
Writeln('A=', A:5:2,' B=');
Readln;
end.
Пример 6. Создать процедуру для вывода первых N членов арифметической прогрессии,
заданной значением первого члена а и разностью d. Вывести первые 7 членов прогрессии 2, 5, … (a=2, d=3) и первые 10 членов прогрессии 20, 19, ….(a=20, d= -1)
Program primer;
Procedure progres(a,d,n:integer);
Var
i: integer;
{i – номер очередного члена прогрессии }
Begin
for i:=1 to n do
{перебираем i от 1 до n}
begin
write(a,' ');
{выводим очередной член прогрессии}
a:=a+d;
{вычисляем следующий член прогрессии}
end;
End;
begin
{основная программа}
{вызов процедуры для вывода 7 членов арифметической прогрессии 2, 5,…}
progres(2,3,7);
writeln;
{вызов процедуры для вывода 10 членов прогрессии 20,19,…}
progres(20,-1,10);
Readln;
end.
Пример 7. Выяснить, какие натуральные числа от 2 до 10 являются простыми, а какие составными (создать процедуру, определяющую простым или составным является данное число).
Число называется простым, если оно не имеет делителей кроме 1 и самого себя.
Если у него есть другие делители, то число – составное.
Program primer;
Var
i: integer;
Procedure prostoe(x:integer);
Var
k,n: integer; {n - возможные делители числа, k – количество делителей}
Begin
k:=0;
for n:=2 to x div 2 do {перебираем числа от 2 до x div 2 для поиска делителей}
if x mod n = 0
{если n –делитель числа x}
then k:=k+1;
{увеличиваем количество делителей на 1}
if k=0
{если у числа нет делителей}
then writeln (x,' - prostoe')
{то число простое}
else writeln (x,' - sostavnoe');
{иначе число составное}
End;
begin
{основная программа}
for i:=2 to 10 do
{перебираем числа от 2 до 10}
prostoe(i);
{вызываем процедуру для проверки очередного числа}
Readln;
end.
Массивы
Одномерные массивы
Массив – последовательность однотипных величин.
Массив можно рассматривать как таблицу, в которой каждый компонент занимает определенную ячейку. Все элементы массива обозначаются одним именем (имя массива), а отдельный элемент определяется своим номером (индексом). Каждая отдельная величина
называется компонентой массива. Тип компонент может быть любым, принятым в языке
ПАСКАЛЬ, кроме файлового типа. Тип компонент называется базовым типом.
-2
5
0
7
11
A[1]=-2
A[2]=5
Описание массива:
Var
M: array [1..10] of integer;
Индексом элементов массива могут быть константы, переменные, выражения: A[1], A[k],
B[2*k].
После объявления массива в памяти компьютера выделяется нужное количество ячеек.
Для того, чтобы заполнить ячейки значениями, необходимо воспользоваться одним из
следующих способов формирования массива:
1) С помощью Read:
Program primer;
Var
A: array [1..10] of integer;
I: integer;
Begin
For i:=1 to 10 do
Begin
Write(‘введите ‘, I, ‘- ый элемент’); Readln(a[i]);
End;
End.
2) C помощью команды присваивания:
a)
For i:=1 to 10 do
Begin
A[i]:=2*i+1;
Write(a[i]:4);
End;
В результате будет получен массив, элементами которого являются числа – 3, 5, 7…
b) заполнение случайными числами:
For i:=1 to 10 do
Begin
A[i]:=random(100);
Write(a[i]:4);
End;
В результате будет получен массив, состоящий из 10 случайных чисел из диапазона [0,
100).
Функция Random(N); генерирует случайное число из диапазона [0; N). Если необходимо
выбрать число из диапазона [a; b], записывают random(b-a+1)+a.
[10,50] – x:=random(41)+10;
X:=random(21)-10; - [-10;10]
Для того, чтобы СС каждым запуском программы получать новые последовательности
чисел, необходимо использовать процедуру Randomize, которая инициализирует датчик
случайных чисел.
Стандартные задачи обработки массивов:
Пример 1. Подсчет суммы (произведения) элементов
Задан одномерный массив A[1..5]. Заполнить массив числами, вводимыми с клавиатуры,
определить произведение элементов.
Program primer;
Var
a: array [1..5] of integer;
i, p: integer;
Begin
For i:=1 to 5 do
begin
Write(‘a[‘, I, ‘]=’); Readln(a[i]);
end;
P:=1;
For i:= 1 to 5 do
P:=p*a[i];
Writeln(‘p=’, p);
Readln;
End.
Пример 2. Выбор максимального (минимального) элемента массива
Сформировать одномерный массив из 20 элементов, которые выбираются случайным
образом из диапазона [-50; 50]. Определить максимальный элемент и его индекс.
Program primer;
Var
a: array [1..20] of integer;
i, max, k : integer;
Begin
For i:=1 to 20 do
begin
a[i]:= random(101)-50;
Write(a[ i]:3);
end;
max:=a[1]; k:=1;
For i:=2 to 20 do
begin
if max<a[i] then begin max:=a[i]; k:=I; end;
end;
Writeln(‘max=’, max, ‘index=’, k);
Readln;
End.
Пример 3. Подсчет количества элементов, удовлетворяющих условию
Сформировать одномерный массив из 12 элементов. Определить количество четных
элементов.
Program primer;
Var
a: array [1..12] of integer;
i, k: integer;
Begin
k:=0;
For i:=1 to 20 do
begin
a[i]:= random(101)-50;
Write(a[ i]:3);
if (a[i] mod 2=0) then inc(k);
end;
Writeln(‘kol=’, k);
Readln;
End.
Пример 4. Поиск заданного элемента
Сформировать одномерный массив из 7 элементов. Определить, содержится ли в нем
элемент ‘5’, если элемент найден, поменять его с первым элементом.
Program primer;
Var
a: array [1..7] of integer;
i, k: integer;
Begin
k:=0;
For i:=1 to 7 do
begin
a[i]:= random(101)-50;
Write(a[ i]:3);
if (a[i] =5) then k:=I;
end;
Writeln;
if k<>0 then
begin
a[k]:=a[1]; a[1]:=5;
For i:=1 to 7 do
Write(a[ i]:3);
end
else Writeln(‘net 5’);
Readln;
End.
Пример 5. Сортировка массива
Сформировать одномерный массив из 10 элементов. Упорядочить по возрастанию элементы массива.
Program primer;
Var
a: array [1..10] of integer;
i, j, t: integer;
Begin
For i:=1 to 10 do
begin
a[i]:= random(51);
Write(a[ i]:3);
end;
For i:=1 to 9 do
For j:=i+1 to 10 do
If a[i]>a[j] then begin t:=a[i]; a[i]:=a[j]; a[j]:=t; end;
For i:=1 to 10 do
Write(a[i]:3);
Readln;
End.
Двумерные массивы
Массивы, в которых положение каждого элемента определяется двумя индексами, называется двумерным. Двумерный массив можно рассматривать как таблицу, состоящую из
заданного числа строк и столбцов. Ее можно представить как
a11 a12 a13 … a1n
a21 a22 a23 … a2n
… … … … …
am1 am2 am3 … amn
Первый индекс указывает на номер строки, второй – на номер столбца. В Pascal 2-мерные
массивы могут быть описаны так:
Var
A: array [1..3, 1..4] of integer;
Например, так может быть описан массив:
7 10 -2 0
4 -1 3 5
9 11 -5 8
A[1,1]=7;
A[2,1]=4;
A[2,3]=3
A[3,4]=8
В Pascal 2-мерные массивы можно рассматривать как массив массивов. Допускается следующее описание:
Var
A: array[1..3] of array [1..4] of integer;
В памяти компьютера 2-мерный массив хранится построчно: сначала элементы первой
строки, затем второй и т.д.
Для формирования и обработки 2-мерных массивов необходимо использовать вложенные
циклы.
Пример. Сформировать и вывести на экран в идее таблицы массив a[1..3, 1..4], заполнив
его целыми случайными числами.
A[I,j] – очередной элемент массива, I – номер строки, j – номер столбца.
Program primer;
Var
A: array[1..3, 1..4] of integer;
I,j: integer;
Begin
For I:=1 to 3
Begin
For j:=1 to 4 do
Begin
A[I,j]:=random(100);
Write(a[I,j]:4);
End;
Writeln;
End;
Readln;
End.
В данной программе формирование массива происходит построчно. Внутренний цикл
формирует отдельную строку таблицы, после чего осуществляется переход к следующей
строке.
Пример 6. Сформировать двумерный массив вида:
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
Program primer;
Var
a: array [1..5, 1..5] of integer;
i, j: integer;
Begin
For i:=1 to 5 do
begin
For j:=1 to 5 do
begin
if i=j then a[i, j]:= 1 else a[i, j]:=0;
Write(a[ i, j]:3);
end;
Writeln;
end;
Readln;
End.
Пример 7. Вывести на экран матрицу размером M*N, элементами которой являются
целые случайные числа из интервала [-9,9]. Определить минимальный элемент в каждой
строке.
Program primer;
Const m=5, n=4;
Var a: array[1..m,1..n] of integer;
min, k, j, i : integer;
begin
randomize;
for i:=1 to m do begin
for j:=1 to n do begin
a[i,j]:=random(18+1)-9; write(a[i,j]);
end;
writeln;
end;
for i:=1 to m do begin
min:=a[i,1]; for j:=2 to n do
if min>a[i,j] then min:=a[i,j] ;
writeln(min);
end;
end.
Обработка строк и символов
Для обработки текстовой информации в Pascal используются переменные символьного и строкового типов. Переменные символьного типа описывабтся с помощью служебного слова char.
Var
C: char;
Значением такой переменной может быть один любой символ. Например, c:=’A’,
c:=’1’, c:=’*’.
В памяти компьютера хранится не сам символ, а его ASCII-код – число, поставленное в соответствие данному символу. Для кодировки используется таблица ASCII-кодов
(0…255).
Символ
ASCII-код
0
48
1
…
9
49
…
57
А
65
B
66
…
…
Z
90
a
97
b
98
…
…
z
122
Для определения ASCII кода символа используется функция ORD. Например,
Ord(‘A’)=65; Ord(‘ ‘)=32;
Для преобразования кода символа в соответствующий ему символ используется
функция CHR. Например, Chr(65)=’A’; Chr(48)=’0’;
Пример. Вывести символы латинского алфавита и соответствующие им ASCIIкоды.
Program primer;
Program primer;
Var
Var
C:char;
n:integer;
Begin
Begin
For c:=’A’ to ‘Z’ do
For n:=65 to 90 do
Writeln(c, ord(c):5);
Writeln(chr(n), n:5);
Readln;
Readln;
End.
End.
Переменные строкового типа в Pascal объявляются с помощью служебного слова
string.
Var
St:string;
Максимальная длина строки 255 строки. Однако, можно ограничить длину строки,
указав максимальное количество символов:
Var
St:string [10];
В Pascal строка рассматривается как линейный массив, элементами которого являются символы. Поэтому обращаться к отдельному элементу строки можно как к элементу
массива, указывая его порядковый номер.
St:=’мир’;
St[1]=’м’;
St[2]=’и’;
St[3]=’р’;
Над строками допускается выполнение операций объединения (присоединение, конкатенация), сравнения. Операция объединения обозначается «+» (не путать со сравнением
чисел). Объединенные строки присоединяются одна к другой.
St1:=’пар’;
St2:=’ход’;
St:=st1+’о’+st2;
St=’пароход’;
Сравнение строк осуществляется по их первым символам. Если они равны, то по
вторым и т.д. Сравнение происходит по ASCII-кодам. Большим будет символ, который
расположен в алфавите дальше. ‘Мама’<’Папа’; ‘рыба’>’рак’.
Процедуры и функции обработки строк.
1) length(st) – функция, вычисляющая длину строки.
length(‘паскаль’)=7
2) Copy(st,k,n) – функция, позволяющая скопировать из строки st с k –ой позиции n
символов. Исходная строка не меняется.
St:=’информатика’;
St1:=copy(st,3,5);
St1=’форма’
4) delete(st, k, n) – процедура, удаляющая из строки st с k-ой позиции n символов.
St:=’барабан’;
Delete(st,4,4);
Delete(st,4,2);
St=’бар’;
St=’баран’;
5) Insert(st1,st,k) – процедура, добавляет строку st1 в строку st на k-е место.
St1:=’ ‘;
St:=’Пришлавесна’
Insert(st1,st,7);
St=’Пришла весна’
6) Val(st, x,k) – процедура, позволяющая преобразовать строку st в ее числовое значение. K – код ошибки. K=0, если преобразование прошло успешно. Если преобразование невозможно, k<>0.
Val (‘123’,x,k);
Val (‘12A’,x,k);
X=123 k=0
X=0 k=3
7) Str(x,st) – процедура, преобразующая число x в соответствующую строку st.
Str(25,st);
Str(-0.123,st);
St=’25’
St=’-0.123’
Основные алгоритмы обработки строк
Пример 1. Подсчет количества заданных символов в строке
Вводятся строка и символ. Определить количество заданных символов во введенной
строке.
Program primer;
Var st: string; c: char;
k, n, i: integer;
begin
write(‘stroka=’); readln(st);
write(‘simvol=’); readln(c);
n:= length(st);
k:=0;
for i:=1 to n do
if st[i]=c tnen inc(k);
writeln (‘k=’, k);
readln;
end.
Пример 2. Замена одних символов другими
Заменить во введенной строке все цифры символом *.
Program primer;
Var st: string;
n, i: integer;
begin
write(‘stroka=’); readln(st);
n:= length(st);
for i:=1 to n do
if (st[i]>=’0’) and (st[i]<=’9’) then st[i]:=’*’;
writeln (‘st=’, st);
readln;
end.
Пример 3. Удаление из строки заданных символов
Удалить из введенной строки все символы ‘3’.
Program primer;
Var st1, st: string;
i: integer;
begin
write(‘stroka=’); readln(st);
for i:=1 to length(st) do
if st[i]<>’3’ then st1:=st1+st[i];
writeln (‘st1=’, st1);
readln;
end.
Program primer;
Var st: string;
i: integer;
begin
write(‘stroka=’); readln(st);
i:=1;
repeat
if st[i]=’3’ then delete(st, i, 1) else
i:=i+1;
until i=length(st);
writeln (‘st=’, st);
readln;
end.
Пример 4. Вставка новых символов в строку
Введенную строку преобразовать так, чтобы после каждого слова следовала точка.
Program primer;
Var st: string;
i: integer;
begin
write(‘stroka=’); readln(st);
i:=1;
repeat
if (st[i]<>’ ’) and (st[i+1]=’ ’) then begin insert(‘.’, st, i+1); i:=i+2; end else i:=i+1;
until i=length(st);
writeln (‘st=’, st);
readln;
end.
Пример 5. Преобразование строковых величин в числовые значения
Найти сумму цифр введенной строки, содержащей цифры и буквы.
Program primer;
Var st: string;
i, x, k, s: integer;
begin
write(‘stroka=’); readln(st);
s:=0;
for i:=1 to length(st) do
begin
val(st[i],x,k);
if k=0 then s:=s+k;
end;
write(‘s=’,s);
readln;
end.
Графика в Pascal
Графическое изображение на экране монитора состоит из совокупности светящихся
точек – пикселей. Каждый пиксель определяется своими
координатами, которые отсчитываются от левого верхнего
угла экрана. Разрешающая способность экрана, т.е. количество точек по осям x, y зависит от установки графического режима. Возможны значения 320*200, 640*200,
640*480, 1024*768.
Для построения графических изображений используются специальные процедуры и функции, которые размещены в модуле Graph.tpu. Для использования этих процедур и функций, необходимо после заголовка программы
указать Uses Graph;
Основные графические процедуры и функции
1) Initgraph(var driver, mode: integer, path : string); - инициализация графического
режима.
driver – код графического драйвера (драйвер – программа, управляющая работой
адаптера; адаптер – устройство, управляющее работой экрана),
mode – код графического режима,
path – путь к драйверу. Если код драйвера равен нулю, то драйвер выбирается автоматически и устанавливается режим с максимальным разрешением, т.е. для адаптера
VGA устанавливается размер экрана 640х480 пикселов и 16 цветов.
Каждая программа, использующая графические процедуры и функции, должна содержать строки:
uses graph;
Var dr, reg: integer;
begin
dr:=0; Initgraph(dr, reg, 'c:\program files\tpascal.71\bgi');
{ Driver := Detect; InitGraph(Driver, Mode, ''); - из справки паскаля}
2) closegraph; - выход из графического режима.
3) cleardevice; - очистка всего экрана с перемещением курсора в начало координат.
4) setbkcolor(color : word); - установка цвета фона.
5) setcolor(color : word); - установка рисующего цвета.
Коды цветов приведены в таблице.
Констан.
Black
Blue
Green
Cyan
Red
Magenta
Brown
Lightgray
Код
0
1
2
3
4
5
6
7
Цвет
Черный
Синий
Зеленый
Голубой
Красный
Малиновый
Коричневый
Светло-серый
Константа
Darkgray
Lightblue
Lightgreen
Lightcyan
Lightred
Lightmagenta
Yellow
Whiet
Blink
Код
8
9
10
11
12
13
14
15
16
Цвет
Темно-серый
Светло-синий
Светло-зеленый
Светло-голубой
Бледно-красный
Розовый
Желтый
Белый
Мерцание
6) outtextxy(x,y,txt:string); - процедура выводит текст, заданный параметром txt, в
точке с координатами x, y. Для вывода значения числовой переменной v необходимо
предварительно перевести число в текс процедурой str(v [:w:d]; txt: string), где w – ширина
поля для числа, d – число знаков после запятой, txt – строка результата перевода.
7) getmaxx; getmaxy; - функции, определяющие максимальное количество точек по
осям x и y.
8) putpixel(x,y:integer; c: word); – закраска пиксела с координатами x, y цветом c.
9) moveto (x, y: integer); - процедура перемещает указатель в точку с координатами
x, y.
10) moverel (dx, dy: integer); - процедура смещает указатель на dx пикселей по оси x
и dy пикселей – по y.
11) line(x1,y1,x2,y2:integer); – процедура рисует линию из точки с координатами x1,
y1 в точку с координатами x2, y2.
12) lineto(x,y:integer); – процедура рисует линию из точки с текущими координатами
в точку с координатами x, y.
13) rectangle(x1,y1,x2,y2:integer); – процедура рисует прямоугольник с координатами левого верхнего угла – x1, y1 и координатами правого нижнего угла – x2, y2.
14) circle(x,y:integer; r : word) – процедура рисует окружность, x, y – координаты
центра, r – радиус.
15) arc(x, y, r, a1, a2); - процедура рисует дугу окружности, r – радиус, a1, a2 – углы
в гадусах, определяющие начало и конец дуги.
16) setfillstyle(s,c: integer); - процедура задает текущий стиль (s) и цвет(c) заливки.
S=1 – сплошная заливка.
17) fillellipse(x,y,rx, ry); - процедура рисует закрашенный эллипс, x, y – координаты
центра, rx, ry – горизонтальный и вертикальный радиусы эллипса.
18) bar(x1,y1,x2,y2:integer); – процедура рисует закрашенный прямоугольник с координатами левого верхнего угла – x1, y1 и координатами правого нижнего угла – x2, y2.
Пример 1. Отобразить точку красного цвета в центре экрана.
Program pr1;
uses graph;
Var dr, reg: integer;
begin
dr:=0; Initgraph(dr, reg, 'c:\program files\tpascal.71\bgi');
{ Driver := Detect; InitGraph(Driver, Mode, ''); - из справки паскаля}
putpixel(getmaxx div 2, getmaxy div 2, 4);
readln;
end.
Записи
Запись представляет собой совокупность ограниченного числа логически связанных
компонент, принадлежащих к разным типам. Компоненты записи называются полями,
каждое из которых определяется именем.
Описание записи:
Type
<имя>=record
<список полей>
End;
Type
vedom=record
N: integer;
Fio: string [30];
NZ: integer;
OZ: integer;
End;
После описания типа «Запись», можно в разделе описания переменных объявлять
переменную данного типа. Например, Var a: vedom;
После объявления переменной можно вводить и обрабатывать данные, которые могут быть представлены в виде таблицы. Например, тип Vedom описывает данные таблицы
вида:
№ Fio
Nz
Oz
1 Антонов 33153 5
… …
…
…
Для всей переменной типа record допустима единственная операция – команда присваивания. Например, b:=a; Обращение к отдельным полям записи осуществляется указанием имени записи и конкретного поля:
a.n:=1;
a.fio:=’Антонов’;
a.nz:=33153;
a.oz:=5;
Для полей записи допустимы все операции, которые определены для данного типа.
Поля одного типа можно объединять в секции, перечисляя их имена через запятую.
Например, данные о книгах, хранящихся в библиотеке, можно описать с помощью
типа ‘Запись’.
Type
Lib=record
IN:string [6];
Avt, nazv, izd: string [30];
Gi: integer;
End;
in
avt
nazv
izd
Gi
123456 Пушкин Евгений Онегин Просвещение 1987
…
…
…
…
Компонентой записи может быть также запись. В таком случае структура их описания может быть следующей:
Type
student=record
Fio=record
F, I, o: string[20]
End??
Data=record
D, m, g : integer;
End??
End;
Var a:student;
…
a.fio.f:=’Антонов’;
a.data.d:=7;
Обращение к компонентам записей можно упростить, если воспользоваться оператором присоединения with.
with <имя записи> do <оператор>;
Например, With a do Writeln(n, fio, nz, oz);
Пример 1. Создайте пользовательский тип данных – запись, описывающий данные человека (Фамилия, Имя, Отчество), опишите в программе массив таких записей, состоящий
из пяти элементов. В цикле, при помощи оператора read заполните массив данными ваших товарищей.
Program primer;
Type
Chelovek=Record
Fam: String[15];
Ima: String[15];
Otch: String[15];
End;
Var
Klass:Array[1..5] Of Chelovek;
k:Integer;
Begin
For k:=1 To 5 Do
With Klass[k] Do
Begin
Writeln('Введите фамилию’); Readln(Fam);
Writeln('Введите имя’); Readln(Ima);
Writeln('Введите отчество’); Readln(Otch);
End;
Readln;
End.
Работа с файлами
Файл – это поименованная область на диске, содержащая некоторые данные.
В языке Паскаль допускаются следующие файловые типы:
 типизированные файлы – файлы, состоящие из записей постоянной длины;
 текстовые файлы - файлы, состоящие из записей неопределенной длины;
 нетипизированный файл – файл, представляющий неструктурированный поток
байтов.
Объявление файловых переменных:
типизированного файла - <идентификатор> : file of <тип>;
текстового файла
- <идентификатор> : text ;
нетипизированного файла - <идентификатор> : file ;
где <идентификатор> – имя файловой переменной,
<тип> - любой тип данных, за исключением файлового.
Для доступа к файлу в программе на языке Паскаль необходимо:
1) определить файловую переменную – логический идентификатор файла;
2) связать эту переменную с конкретным физическим файлом;
3) открыть файл: если для записи, то с помощью процедуры Rewrite, если для чтения – то с помощью Reset;
4) обработать файл (прочитать или записать данные);
закрыть файл с помощью Close.
Процедуры и функции для работы с файлами.
assign(var f; name: string); - процедура связи файловой переменной с физическим файлом
где f – файловая переменная, name – переменная, определяющая имя физического файла.
Например, Assign (f, ‘spisok.dat’);
reset(var f); - процедура открывает файл, связанный с файловой переменной f для считывания данных.
rewrite(var f); - процедура открывает файл, связанный с файловой переменной f для записи данных.
read(var f; d1,d2,…dn); - процедура считывает данные из файла f в перечисленные переменные d1,d2,…,dn.
write(var f; d1,d2,…dn); - процедура записывает данные из переменных d1,d2,…dn в файл
f.
seek(var f; n : longint); - процедура устанавливает текущей n-ую запись файла f. После вызова процедуры seek процедура read читает n-ую запись.
close(var f); - процедура закрывает файл f.
eof(var f) - функция возвращает результат boolean: true, если считан последняя запись
файла и false – в противном случае.
Пример 1. Составить пргорамму, создающую на жестком диске текстовый файл, добавить в созданный файл данные (ф.и.о., номер школы, класс).
Program primer;
Var f: text;
x, y: real;
BEGIN
assign(f,'prim.txt');
rewrite(f);
write(‘Иванов Иван Иванович, Школа № 1, 1 «а» класс’);
Close(f);
END.
Пример 2. а) Создать файл, содержащий значения функции y= x2 + x (0= x= 2, h= 0,2).
б) Вывести на экран данные в виде таблицы.
Program primer;
Var f: file of real;
x, y: real;
BEGIN
assign(f,'prim.txt');
rewrite(f);
x:=0;
repeat
y:=sqr(x)+x;
write(f,y, х);
x:=x+0.2;
until x>2;
Close(f);
reset(f);
while not eof(f) do
begin
read(f,y,x); writeln('x=',x:4:2,' y=',y:8:4);
end;
END.
Пример 3. а) Создать файл, содержащий данные:
 ФИО работника;
 склад;
 стаж работы.
б) Просмотреть записи. Определить фамилию работника, имеющего самый
большой стаж работы.
Program pr;
Type rabotnik=record
Fio: string [20];
sklad: char;
stag: integer;
End;
Var
X: rabotnik; f: file of rabotnik;
N, i, max: integer;
Name: string [20];
Begin
Assign(f,’pr.txt’);
Rewrite(f);
Write(‘n=’); Readln (n);
For i:=1 to n do
Begin
Write(‘fio:’); Readln(x.fio);
Write(‘sklad:’); Readln(x. sklad);
Write(‘stag:’); Readln(x. stag);
Write(f,x);
End;
Close(f);
{******************}// можно сделать две разные программы
Assign(f,’pr.txt’);
Rewrite(f);
Max:=0;
While Not EOF(f) do
Begin
Readln(f,x);
Writeln(x.fio: 20, x. sklad:3, x. stag:5);
If x. stag >max then
Begin
Max:=x. stag;
Name:=x.fio;
End;
End;
Writeln(‘max stag -‘, max, name);
Close(f);
Readln;
End.