Блог учителя Информатики Московской Марины Николаевны

Turbo Pascal 7.1 Справочник (конспект)

Turbo Pascal 7.1Справочник (конспект)

Содержание
(продолжение следует)


1) Введение. Символы. Числа. Идентификаторы. Типы данных

Символы языка Pascal:
26 латинских строчных и прописных букв:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z    a b c d e f g h i j k l m n o p q r s t u v w x y z
Пробел, нижнее подчеркивание _ 
Цифры: 0 1 2 3 4 5 6 7 8 9
Знаки операций:
+
- сложение
 –
- вычитание
*
- умножение
/
- деление
=
- равно
<>
- не равно
<
- меньше
>
- больше
<=
- меньше или равно
>=
- больше или равно
:=
- присваивание
@
- взятие адреса

      
      
       

Ограничители:    .  ,  '  ( )  [ ]  (. .)  { }  (* *)  ..  :  ;
Спецификаторы:  ^   #   $
Числа в языке Pascal, в основном, используются  в десятичной системе счисления:
Целые числа записываются в форме без десятичной точки (отрицательные - со знаком), например:  217    -45     8954    +483
В действительных числах целая и дробная часть разделяются точкой:   28.6     0.65     -0.018     4.0
Экспоненциальная форма числа с использованием десятичного порядка, который изображается буквой Е:
          5Е12 = 5*1012    
         –1.72Е9 = 1.72*109
         73.1Е-16 = 73.1*10-16
Можно использовать шестнадцатеричную форму записи чисел:  $7F   3F   $ABC0
Строки – это последовательность символов, записанная в одиночных кавычках '     ' (апострофах). В виде строк можно выводить в программах какие либо указания пользователю, текст, заголовки и т.д.
Комментарии - пояснения в программах записываются в скобках {   } или (*   *) и могут занимать любое число строк.Комментарии игнорируются компилятором.
Идентификаторы - это имена любых объектов в программе (переменных, констант, меток, процедур, функций, модулей и т.д.) Идентификаторы (имена) могут состоять только из букв латинского алфавита (причем, строчные и прописные буквы не различаются), цифр (но цифра не должна стоять на первом месте!) и символа нижнего подчеркивания. 
Пробелы, знаки препинания и другие символы использовать нельзя!
Также запрещено использовать в качестве идентификаторов зарезервированные служебные слова и команды.

and,  array,  begin,  case,  const,  div,  do,  downto,  else,  end,  far,  file,  for,  forward, function,  goto,  implementation,  in,  interface,  label,  mod,  nil,  not,  or,  of,  pointer, procedure,  program,  record,  repeat,  set,  shl,  shr,  string,  text,  then,  to,  type,  unit,  until, uses,  var,  while,  with,  xor
Эти служебные слова можно использовать только по их прямому назначению!





Типы данных языка Pascal
Компилятор языка Pascal требует, чтобы сведения об объеме памяти, необходимой для работы программы, были предоставлены до начала ее работы.
Для этого в начале программы нужно перечислить все переменные, используемые в программе. Кроме того, необходимо также указать, сколько памяти каждая из этих переменных будет занимать. Все это можно сообщить, указав тип будущей переменной.
Имея информацию о типе переменной, компилятор понимает, сколько байт необходимо отвести под нее, какие действия с ней можно производить и в каких конструкциях она может участвовать.
Тип данных
Длина (байт)
Диапазон значений
Операции
Целые типы
Integer
2
 32768...32768

+, -, /, *,
Div, Mod,
 <, >, =, >=, <=, <>
Byte
1
 0...255
Word
2
 0...65535
Shortint
1
 128...127
Longint
4
 2147483648...2147483647
Вещественные типы (дробные)
Real
6
 2.9*10-39...1.7*1038

+, -, /, *,
 <, >, =, >=, <=, <>
Single
4
 1.5*10-45...3.4*1038
Double
8
 5*10-324...1.7*10308
Exstended
10
 3.4*10-4932...1.1*104932
Логический тип
Boolean
1
  true, false (истина, ложь)
Not, And, Or, Xor,
=, <, >, <=, >=, <>
Символьные типы
Char
1
  все символы кода ASCII
+,=, <, >,
<=, >=, <>
String
  символьная строка (до 255)
* Операции Div и Mod - описаны в разделе Математические операции
Программа, записанная по правилам стандартного языка Паскаль должна иметь следующую структуру:
Program name1                                                          {имя программы,точку с запятой ставить в заголовке обязательно!}
    Uses Crt, graph                                                       {список подключенных модулейточку с запятой ставить обязательно!}
    Label m1, m2;                                                            {Список меток из основного блока программы}
    Const g=9.8, f=200;                                                  {Определение констант в программе}
    Var a, b: integer;                                                       {раздел описания переменных, a, b - целые числа}
          c, d: real;
                                                             {c, d - вещественные числа}
    Procedure work (r: integer; s: real; var q: real );    {описание процедуры work}
    ...
    Function 
stp (xy: real) : real;                                  {описание функции stp}
    ...

Begin                                                                             
{в слове begin не надо ставить точку с запятой!}
    оператор1;                                                               {основной блок программы: операторы, команды, действия}
    оператор2;                                                               {точки с запятыми после каждого оператора ставить обязательно!}    ...
End.                                                                               {в конце программы ставится точка!}
Правила оформления программ:
  • Некоторые из перечисленных блоков раздела описаний могут отсутствовать за ненадобностью, но оставшиеся должны следовать в указанной последовательности!
  • В Турбо Паскале оператор заголовка программы может быть пропущен.
  • Все операторы должны заканчиваться точкой с запятой (Исключения: в начале программы после слова begin точку с запятой ставить не нужно. В конце программы после слова end ставится точка).
  • При наборе текста программы ее операторы следует располагать таким образом, чтобы была понятной логика работы программы. Для этого используются пробелы между операторами и отступы от левого края.
  • Пробелы и отступы помогают читателю программы определить уровень подчиненности каждой строки.
  • Не следует размещать в одной строке более одного-двух операторов.
  • При записи программы на Паскале допускаются пустые строки, которые можно использовать для выделения логически связанных групп операторов.
Операторы ввода-вывода необходимы для ввода в компьютер данных с клавиатуры и вывода результатов расчета на экран монитора.
Для того, чтобы ввести данные вручную (с консоли), применяются команды Read и Readln:
Read(a);                  {ввод значения a}
Read(a, b, c);
          {ввод значений a b c в строку через пробел} 
Readln(a);
               {ввод значения a и перевод курсора в начало следующей строки} 
Readln(a, b, c);
       {ввод значений a b c в строку и перевод курсора в начало следующей строки}
После этих команд компьютер ожидает действий пользователя. Пользователь набирает на клавиатуре значения переменных в том порядке, в котором они указаны в списке, отделяя их друг от друга пробелами. В конце ввода нажимает Enter.
Команду Readln; всегда следует писать в конце программы, перед командой End. для того, чтобы результат остался на экране, ожидая дальнейших действий пользователя, например, нажатия какой-либо клавиши.
Для того, чтобы вывести на экран какое-либо сообщение, используются команды Write и Writeln:
Write (а);                              {вывести значение переменной аWrite (а, b, c);                      {вывести в строку значения переменных a b c
Writeln (a);       
                    {вывести значение а и перевести курсор в начало следующей строки}
Writeln
 ('Любой текст');      {вывод текста, который заключен в апострофы}
Writeln;                               
 {вывод пустой строки}Writeln (‘----*----*----*----*----’);     {вывод декоративной строки из черточек и звездочек} 
 
Для совместного вывода текста и значений переменных используйте такую запись:
Writeln ( 'Ответ: ', c );   вывод текста Ответ: и значения переменной c}
Чтобы выводимые числовые значения не сливались визуально в одно число, перечисляемые в операторе Writeln переменные следует разделять пробелами, заключенными в апострофы  '
Writeln (а,' 
 ', b,'  ',c)      {вывести в сроку через пробелы a b c}
Вывод данных по формату

Другой способ разделения выводимых данных заключается в использовании формата длины поля:

Для целых чисел (типа Integer):  Writeln (A:n); где А - имя переменной;
      n - число знакомест, резервируемых в строке на экране под выводимое значение переменной.
Если количество цифр в значении переменной окажется меньше, чем было указано в длине поля вывода n, то выводимые символы будут выравниваться по правой границе отведенного поля, а оставшееся слева от числа пустое пространство будет заполнено пробелами. Если длина поля окажется недостаточной , Pascal автоматически увеличит длину поля до необходимого размера.
Для вещественных чисел (типа Real) в формате поля вывода необходимо указать общую длину и количество знакомест, выделяемых под дробную часть числа (т.е. определяет количество знаков после запятой):
Writeln (A:n:k);
где А - имя переменной типа Real;
      n - общая длина поля (считая точку!);
      k
 - число знакомест в длине поля, отводимых под дробную часть числа.
Пример: команда Writeln (X:10:3);
               
выведет число X=12.3456789 в формате 10:3 (всего 10 знакомест, из них 3 после запятой) так:
                X:=_ _ _ _12.346
                (число округлится до 3 знаков после запятой, слева 4 свободных знакоместа будут заполнены пробелами)

Переменная - это несколько ячеек оперативной памяти, имеющих общее имя и предназначенных для хранения одного значения определенного типа.
Запоминание переменной своего значения или, иначе говоря, запись в ячейки памяти данных, выполняется с помощью оператора присваивания:
a:= b;    – переменной а присваивается значение b
                В правой части (вместо b) может находиться переменная, константа, арифметическое выражение или вызов функции.
Примеры:
а := 3.75;   b := 2*а;
radikal :=
 sqrt(a*a+b*b);                {имя переменной задано словом radikalsqrt - извлечение квадратного корня}
Константа - это объект, значение которого известно еще до начала работы программы (постоянное значение). Константы незаменимы при использовании в тексте программы многократно повторяемых значений, или в случае необходимости изменения этих значений сразу во всей программе.
Const a=5; b=7; g=9.8;
Для вывода на экран текста используется команды Write ('        '); и Writeln ('          ');   - внутри апострофов пишется текст.
Для того, чтобы можно было изменить цвет фона экрана и цвет символов, необходимо в начале программы (перед словом Begin)подключить модуль Crt с помощью команды Uses Crt;
Процедура ClrScr; очищает экран (при этом экран закрашивается указанным фоновым цветом, а курсор устанавливается в левый верхний угол экрана).
Цвет фона устанавливает  процедура TextBackGround (Х);
                    
где Х- код или название цвета (*см. таблицу 0-7)
Цвет символов устанавливает процедура TextColor (Х)
                   где Х- код или название цвета (*см. таблицу 0-15)
 

Цвет
Образец
Код

Black – черный
0

Blue – синий
1

Green  -  зеленый
2

Gyan – бирюзовый
3

Red – красный
4

Magenta – малиновый
5

Brown – коричневый
6

LightGray – светло-серый
7

DarkGray – темно-серый
8

LightBlue – голубой
9

LightGreen – ярко-зеленый
10

LightGyan  ярко-бирюзовый
11

LightRed – ярко-красный
12

LightMagenta – ярко-малиновый
13

Yellow – желтый
14

White – белый
15
* В таблице для фона можно применять только цвета 07, а  для символов – цвета 015.
Дополнительно можно использовать процедуры:
NormVideo; - устанавливает нормальную яркость символов (используется по умолчанию) 
H
ighVideo; - устанавливает высокую яркость символов (полужирный шрифт) 
L
owVideo устанавливает низкую яркость символов.
GotoXY(k,n); - установка курсора в нужное место на экране, где k - номер позиции (столбца), n - номер строки (на экране 80 символов, 25 строк)
Пример:
Program SvetText;
U
ses Crt;                                                  {подключаем модуль Crt}

Begin
TextBackGround
 (1);                               {меняем цвет фона на синий}
ClrScr;
                                                      {очищаем экран и одновременно закрашиваем его синим цветом} 
TextColor
 (14);                                        {меняет цвет символов на желтый}HighVideo;                                               {устанавливаем повышенную яркость символов}
Gotoxy
 (20,5);                                          {перейти в 20-позицию на 5 строке)}
Writeln
 ('Я люблю желтый цвет!');       {выводим текст: Я люблю желтый цвет!}

Readln;
                                                    {чтобы не исчезло с экрана}
End.
Линейными называются программы, в которых действия выполняются последовательно в порядке записи команд. Решение задач всегда начинается с построения математической модели (с формулы)
Пример линейной программы: Деление простых дробей.
Program Division;                                                                                                            {имя программы}
     Var a, b, c, d, m, n:
 integer;                                                                                       {определяем тип данных - целые}

Begin
                                                                                                                                {начало}
     Writeln (‘Введите через пробел числитель и знаменатель первой дроби: 
’);       {приглашение к вводу первой дроби}
     Readln (a,b);                                                                                                                {ввод a, b}
     Writeln (‘Введите через пробел числитель и знаменатель второй дроби: ’);       {приглашение к вводу второй дроби}
     Readln (c,d);                                                                                                                {ввод c, d }
          m:=a*d;                                                                                                                 {вычисление числителя дроби}
          n:=b*c;                                                                                                                   {вычисление знаменателя дроби}   
     
Writeln (‘числитель:
 ,m);                                                                                            {вывод числителя дроби m}
     Writeln (‘знаменатель: ,n);                                                                                        {вывод знаменателя дроби n}   Readln;                                                                                                                              {чтобы не исчезло с экрана}
End.                                    
                                                                                               {конец}
Пример линейной программы: Вычисление времени падения яблока.
Program Newton; 
Const  g=9.8;
                          {ускорение свободного падения g=9.8 описана как константа }
Var  
h: integer;                       {высота ветки h - целое число }
      
  treal;                             {время падения t - вещественное число, по формуле не может быть целым числом! }

Begin
Writeln
 (‘Введите высоту ветки в метрах’); 
    {приглашение ввести высоту ветки}
Readln (h);                                                           {ввод высоты ветки }
     t:= sqrt ((2*h) / g);                                        {вычисление времени падения по формуле }
Writeln
 ('Время падения ' ,t:6:2, ' секунд');      {вывод текста и результата по формату с двумя знаками после запятой}

Readln;
End.
Помимо обычных математических операций сложения (+), вычитания (–), умножения (*) и деления (/) в Паскале используются и другие операции:
a:=X div Y;      - выполняет деление целых чисел X на Y (без остатка, нацело!) 
                          123 div 10 
даст результат 12  (123/10=12  т.е, в ответе отбрасывается остаток 3)
b:=X mod Y;    - получает остаток от деления целых чисел Х на Y
                          123 
mod 10 даст результат 3 (т.е, наоборот, в ответ выносится остаток 3)
Для того, чтобы уменьшать или увеличивать переменные или числа на определенные величины существуют процедуры:

Inc (х,у);  от англ. Increment (увеличение)

Dec (х, у);
  от англ. Decrement (уменьшение)
Inc (а); – при отсутствии 2-го параметра увеличивает переменную на 1 Inc (а, 10);  – увеличивает переменную а на 10 Inc (а, z);    увеличивает переменную а на переменную z
Dec (a);  – при отсутствии 2-го параметра уменьшает переменную на 1 Dec (a5); – уменьшает переменную а на 5Dec (az); – уменьшает переменную а на переменную z
В качестве математических операций часто используются стандартные математические функции:
Функция
Описание
ПримерРезультат
Abs (х)
Абсолютное значение, модуль числа Х
abs (–3.5)
3.5
Sin (х)
Синус в радианах
sin (pi)
0
Cos (х)
Косинус в радианах
cos (pi)
–1
Arctan (х)
Арктангенс
arctg (0)
0
Int (х)
Взятие целой части числа Х
int (3.5)
3.0
Frac (x)
Взятие дробной части числа Х
frac (3.5)
0.5
Odd (x)
Проверка нечетности числа Х
odd (3)
True
Sqr (x)
Возведение в квадрат числа Х
sqr (2)
4
Sqrt (x)
Извлечение квадратного корня из числа Х
sqrt (25)
5
Pi
Значение числа Пи (Пи=3,1415926...)
pi
3.141592...
Exp (x)
Экспонента числа ех (е=2,71828...)
exp (1)
2.71828...
Ln (x)
Натуральный логарифм числа Х (по основанию е)
ln (2.7182)
1
Trunc (x)
Округление с отбрасыванием дробной части (в меньшую сторону)
trunc (12.75)
12
Round (x)
Округление к ближайшему целому по правилам
round (12.75)
13
Random (x)
Случайное целое число в диапазоне от 0 до X-1
random(10)
число [0,10)
Запись алгебраических выражений:
S=x2+2xy+y2   на языке Pascal запишется так:    S := sqr(x) + 2*x*y + sqr(y);
a=|x –y| 
         
на языке Pascal запишется так:    a := abs (x – y);
Возведение в степень:
В языке Pascal нет функции для возведения числа в степень, поэтому для того, чтобы возвести число а в степень b (х=ab)используют запись  x:= exp (b*Ln(a));
Примеры: 
(x-3)7           запись:  exp (7*ln(x-3))2x                 запись:  exp (x*ln(2)) 3x =x1/3    запись:  exp (1/3*ln(x))
Случайные числа – это такая последовательность чисел, для которой невозможно предсказать следующее число, даже зная все предыдущие.
Для генерации случайных чисел в начале программы необходимо вызвать процедуру Randomize;
Функция Random (X); возвращает случайное целое число в диапазоне от 0 до значения X-1. Например, Random (100);возвратит в программу случайное целое число из диапазона от 0 до 99 включительно.
Для изменения диапазона значений случайных целых чисел используется запись Random (Х)+k, где k - положительное или отрицательное целое число, начало диапазона.
Например, функция вида а:=Random (21)-10;  - вызовет случайное целое число из диапазона от -10 до 10,
а:=Random (10)+5;  - вызовет случайное целое число из диапазона от 5 до 14.
Если функция Randomиспользуется без параметров, то она возвращает случайное дробное число из диапазона  [0, 1)
Для изменения диапазона случайных дробных чисел используют запись: Random+k;  где k - положительное или отрицательное целое число, начало диапазона или запись вида z*Random; где множительный коэффициент
Например, функция а:=Random+10 вызовет случайное дробное число из диапазона от 10 до 11,
а:=5*Random;  - вызовет случайное дробное число из диапазона от 0 до 5,
а:=10*Random-5;  вызовет случайное дробное число из диапазона от -5 до 5.

Ветвление – выбор одного из двух возможных действий в зависимости от условия.
К командам ветвления относятся операторы If и Case.
Условный оператор If выбирает между двумя вариантами развития событий:
If условие               {если…}
Then оператор1      {то …}
Else оператор2;      {иначе… этой ветви может не быть!}
Обратите внимание, что внутри команды (после слов  If и Then) знак ; не ставится - это разорвало бы оператор!
If x > 0
Then modul := x
Else modul := -x;
Условный оператор Iработает следующим образом:
1. Сначала вычисляется значение условия  это может быть любое выражение, возвращающее значение типа boolean
    (истина или ложь). В условии используются знаки сравнения < (меньше), > (больше), = (равно), <> (не равно), 
    <= (меньше или равно), >= (больше или равно)
2. Затем, если в результате получена истина (true), то выполняется оператор1, стоящий после ключевого слова then,
    а если ложь (false) – без дополнительных проверок выполняется оператор2, стоящий после ключевого слова else.
3. Если же else-ветвь отсутствует, то не выполняется ничего.
В  операторе if может быть использовано сложное условие, состоящее из нескольких простых условий (отношений), связанных с помощью логических операций:
and (и, одновременное выполнение условий); 
or
 (или, выполнение хотя бы одного условия)
not
 (не, отрицание); 
xor
 (исключающее или, выполнение одного из двух условий, но не обоих сразу)
В этом случае отдельные логические выражения нужно заключить в скобки (  ) и соединить их союзами and, or, not, xor
Пример: ввести с клавиатуры 2 числа a и b, сравнить их и вычесть из большего числа меньшее.
Program Sravnenie;
var a, b, c: integer;
Begin
writeLn (‘Введите число a');              
{приглашение ввести число а}
readln (a);                                           
{ввод числа а}
writeLn (‘Введите число b');              
{приглашение ввести число b}
readln (b);                                           
{ввод числа b}
if a > b                                               {если а больше b}
then c := a – b                                   
{то переменной с присвоить значение a – b }
else c := b – a;
                                   {иначе переменной с присвоить значение b – a} 
writeLn (‘Результат ‘ , c);                  {вывести значение переменной с}
readln;
end.
Если после слов Then и Else выполняется больше одного оператора, т.е. несколько команд, то их следует писать между словамиBegin и End (в конце команды ветвления после слова End ставиться не точка, а точка с запятой!)
Program Sravnenie;
var a, b, c: integer;
Begin
writeLn (‘Введите число a');              
{приглашение ввести число а}
readln (a);                                           
{ввод числа а}
writeLn (‘Введите число b');              
{приглашение ввести число b}
readln (b);                                            
{ввод числа b}
if a > b                                                 {если а больше b}
then begin         c := a  b ;                                   
{то переменной с присвоить значение a – b }
         writeLn (‘Результат ‘ , c);        
   {и вывести значение переменной с}
end
                                                        {конец блока действий после слова then  точку с запятой не ставить!!!}          
else begin
       
c := b – a;
                                     {иначе переменной с присвоить значение b – a}
       
writeLn (‘Результат ‘ , c);            {и вывести значение переменной с}
end;                                                    
  {конец блока действий после слова else}      
readln;
end.                                                     
{конец программы}      
Пример со сложным условием: В зависимости от возраста, ограниченного 7 и 16 годами, принимаем в школу или нет.
Program Priem;
Var v
integer;                                                            {вводим переменную v- возраст ребенка, целое число}

Begin     
     Write (‘Введите возраст ребенка:’);                 
  {приглашение ввести возраст}
     Readln (v);                                                             {ввод значения переменной v}
          If (v>=7) and (v<=16)    
                                 {проверка сложного условия: если возраст>=7 лет И возраст<=16 лет}
          Then Writeln(‘Принимаем в школу’)              
{то пишем текст: Принимаем в школу}
          Else Writeln (‘Не принимаем в школу’);         
{иначе пишем текст: Не принимаем в школу}
Readln;                                
 
                                      {чтобы не исчезло с экрана}

End.

Оператор Case позволяет сделать выбор между несколькими вариантами:
Case переключатель of 
      список_констант1 : оператор1;
      список_констант2 : оператор2;
      список_констант3 : оператор3;
   Else оператор4;
End;
Обратите внимание, что после Else двоеточие не ставится! Оператор End; относится к концу команды выбора, а не программы!
В каждом списке констант оператора Case можно указывать несколько значений через запятую или в виде диапазона (диапазон указывается через двоеточие ..)
Если для каждого списка нудно выполнить более одного оператора, то их следует заключить между словами Begin и End;
Работа оператора Case происходит следующим образом:
1. Вычисляется значение переключателя;
2. Полученный результат проверяется на  принадлежность к тому или иному списку констант;
3. Если такой список найден, то дальнейшие проверки  уже не производятся, а выполняется оператор, соответствующий
    выбранной ветви, после чего управление передается оператору, следующему за ключевым словом End, которое закрывает
    всю конструкцию Else.
4. Если подходящего списка констант нет, то выполняется оператор, стоящий за ключевым словом Else.
    Если else-ветви нет, то не выполняется ничего.
Пример: По номеру месяца выводится время года.
Program Season;
Var m:byte;
                                               {переменная m - номер месяца, целое число не больше 12}                        

Begin

Write(‘Введите номер месяца’);      
       {приглашение ввести номер месяца}
Readln(m);                                                {ввод номера месяца}

Case m of 
                                               
  {начинаем выбор, проверяем значение m}
     1, 2, 12: writeln(‘Зима’);                        
  {если m = 1, 2, 12, т.е. январь, февраль, декабрь - то пишем текст: Зима}
     3, 4, 5: writeln(‘Весна’);                           
{если 3, 4, 5 т.е. март, апрель, май - пишем текст: Весна}
     6, 7, 8: writeln(‘Лето’);      9, 10, 11: writeln(‘Осень’);      Else writeln(‘Такого месяца нет’);        
  {если введено какое-то другое число - пишем текст: Такого месяца нет}
     End;                                                           
{конец выбора!}

Readln;
                                                     
{чтобы не исчезло с экрана}
End
.                                                          
 {конец программы}
Оператор безусловного перехода применяется  в случаях, когда после выполнения некого оператора надо перейти к определённому месту программы, обозначенному меткой.
Метка может представлять собой целое число (от 0 до 9999) или идентификатор (имя). Одной меткой можно пометить только один оператор.
Все метки должны быть описаны в разделе Label перед началом программы (перед словом Begin). Label m1, m2, m3;
Оператор перехода имеет вид: Gotm1;    - означает перейти к строке с меткой m1
Оператор с меткой в программе будет выглядеть так: m1:  Writeln (‘Конец программы’);
Примечание: использование безусловных переходов типа GoTo в структурном и надежном программировании считается «дурным тоном».  Если вы все же считаете необходимым использование этого оператора в программе, то:
Не следует злоупотреблять переходами;
Старайтесь применять операторы перехода для передачи управления вниз (вперед) по тексту программы;
Расстояние между меткой и оператором перехода на нее не должно превышать одной страницы текста
   (или высоты экрана дисплея).
Пример:
Program Perehod;

var 
a,b,c: Integer;
S: 
Char                                               {переменная символьного типа} 
Label m1;                                             {метка m1} 

       Begin 
m1: Write('Введите число a: ');          {оператор с меткой m1к которому будет переход из программы} 
       Readln(
a);
       Write('Введите число 
b: ');
       Readln(
b);        c:=a+b;
       Writeln(‘Сумма 
a+b = ',с);
       Write(‘Повторить еще раз? (Y/N): ');  
 {спрашиваем, повторить?}
       Readln(S);
                                               
{считываем или N}        if S = 'Y'                                                   {если выбран ответ Y} 
           Then 
goto m1;                                     { то переходим к оператору с меткой m1 } 

Readln;
end.

В большинстве задач, встречающихся на практике, необходимо производить многократное выполнение некоторых действий. Такой многократно повторяющийся участок вычислительного процесса называется циклом.
Существует возможность организовать цикл внутри тела другого цикла. Такой цикл будет называться вложенным циклом.
Если заранее известно количество необходимых повторений, то цикл называется арифметическим.
For i := a to b do оператор;
Читается так: Для переменной i от начального значения a до конечного значения b выполнять оператор (являющийся телом цикла)
Оператор For вызывает оператор (действие), находящийся после слова do по одному разу для каждого значения в диапазоне от значения a до значения b
Выполняется цикл For по следующему алгоритму:
1. Переменной-параметру присваивается начальное значение2. Выполняется тело цикла (действие); 3. Переменная-параметр автоматически увеличивается на 1; 4. Если параметр превышает конечное значение, то происходит выход из цикла, иначе - переход к пункту 2.
Существует еще один вариант цикла for, который позволяет производить обработку в противоположном направлении (от большего к меньшему):
For i:= a downto b do оператор;
Цикл for-downto работает аналогично циклу for-to, только значение переменной i не увеличивается на 1, а уменьшается на 1.
* Если после слова Do выполняется несколько операторов, то их следует писать между словами Begin и End (в этом случае после слова End ставиться не точка, а точка с запятой!)
Запомните: В операторе цикла не разрешается присваивать параметру цикла какое-либо значение. После окончания цикла значение параметра цикла i неопределенно. 
Пример: Таблица квадратов чисел от 1 до 10
ProgramTablica;
var x, y, i: integer;                             
 
{переменная х - число, у - квадрат числа, - счетчик циклов, целые числа}

Begin
Writeln('
Таблица квадратов');         {вывод заголовка таблицы}
Writeln('-----------------------');
          {разделительная линия}
Writeln('
Число        Квадрат');
Writeln('-----------------------');

x:=1;                                                   
{начинаем с х=1}
For i:=1 to 10 do
                                {для от 1 до 10 делать следующие действия:}
   Begin
                                               {начало этих действий}
   y:=sqr(x);
                                        {переменная у=х2}
   Writeln (x:3, y:15);
                         {вывод по формату: для х - 3 знакоместа, для у - 15 знакомест}
   x:=x+1
;                                           {увеличиваем х на 1, т.е. переходим к следующему числу}
   End;
                                                 {конец цикла!}

readln;
                                                {чтобы не исчезло с экрана}
End.                                                     {конец программы}
В итерационных циклах производится проверка некоторого условия, и в зависимости от результата этой проверки происходит либо выход из цикла, либо повторение выполнения тела цикла.
Если проверка производится после выполнения тела цикла, то это цикл с постусловием (цикл До). Тело цикла До всегда выполняется хотя бы один раз.
Repeat оператор1; оператор2; ... Until выражение;
Читается так: Повторять выполнение оператора1, оператора2 … До выполнения условия.
Обратите внимание на то, что данный оператор цикла предполагает наличие нескольких операторов в теле цикла, поэтому дополнительные служебные слова Begin и End не нужны!
Операторы между словами Repeat и Until повторяются до тех пор, пока логическое выражение является ложным (False).
Как только логическое выражение становится истинным (True), происходит выход из цикла.
Пример:
Program Povtor;
var S: Integer; 

B
egin
R
epeat Write('Введите целое число (0 - выход): ');       {повторяется запрос на ввод числа, до тех пор ...}
Readln(S); 
Until
 S=0;                                                                            {...пока не будет нажат 0}
Write('Вот и все! Вы ввели 0!');                                         {после выхода из цикла, т.е. когда будет введен 0}

Readln; 

E
nd.

Если проверка условия производится перед выполнением блока операторов, то такой итерационный цикл называется циклом с предусловием (цикл Пока)
While условие Dоператор;
Можно прочитать так: Пока истинно условие, Выполнять оператор (или операторы). Оператор после Do будет выполняться до тех пор, пока условие (логическое выражение) принимает истинное значение (True).
Истинность условия проверяется каждый раз перед очередным повторением тела цикла. Как только логическое выражение принимает значение ложь (False), осуществляется переход к оператору, следующему за While. Если первая проверка условия показывает, что оно ложно, то тело цикла Пока может не выполниться ни разу.
* Если после слова Do выполняется несколько операторов, то их следует писать между словами Begin и End (в этом случае после слова End ставиться не точка, а точка с запятой!)
Пример:
Program Stop;
var 
 S: integer;

B
egin 
While S <> 
0 do                                   {пока S≠0…}
    Begin    Writeln(‘Введите целое число’);        {запрос на ввод числа}
    Readln(S);
    end;     
                                                 {конец действий в цикле}
Write('Вот и все! Вы ввели 
0!');         {выводится после выхода из цикла, т.е после ввода 0}

Readln; 
End.
Запомните:
Вместо арифметического цикла For всегда можно использовать цикл с предусловием While.
- Обратная замена 
While на For возможна только тогда, когда можно заранее рассчитать число шагов цикла.
- Любой оператор цикла с предусловием 
While можно записать с помощью условного оператора If и оператора цикла с
   постусловием
 Repeat.
- Любой оператор цикла 
Repeat можно записать с помощью условного оператора If и оператора цикла While.
- Но в программировании различные типы циклов не подменяют друг друга, а используются для решения задач, к которым они
  более подходят.
Цикл For
Цикл Repeat
Цикл While
 Запись оператора:
For i:=a  to (downto)   
do
  оператор;
Repeat  оператор1; оператор2; ...
Until
   
условие
While условие 
do
 
оператор;
 Сколько раз выполняется
 цикл?
Точно известно число повторений цикла  b–a+1 раз
Число повторений тела цикла определяется условием.
Проверка условия послеокончания цикла
Проверка условия передначалом цикла
Всегда выполнится
хотя бы 1 раз
Может не выполниться
ни разу
 Если в теле цикла нужно
 выполнить несколько
 действий:
Нужны дополнительные блокиbegin ... end;
Не нужныдополнительные блоки
Нужны дополнительные блоки begin ... end;
Массив - это совокупность элементов одного типа. Характеризуется массив следующим:
- Каждый компонент массива может быть явно обозначен и к нему имеется прямой доступ;
- Число элементов массива определяется при его описании и в дальнейшем не меняется.
Одномерный массив представляет из себя следующую структуру:
Значения элементов указаны в ячейках таблицы:
 
 0.1
   5
 10
 2.3
 5.7
   2
 3.1
 4.9
   8
 6.5
   1        2        3        ...                 ...              ...                   10         –  порядковые номера (индексы) элементов массива
Mas[1]  Mas[2]   ...              ...               ...              ...          Mas[10]  
Массив должен быть объявлен в разделе объявления переменных Var в начале программы. Для обозначения массива используется имя переменной-массива и индексы, которые указывают нужный элемент. Тип индекса может быть только порядковым. Чаще всего используется интервальный тип (диапазон).
Описывается массив в разделе описаний так: 
Var  М: array [1..10] of real; Где  M - имя массива,
       array обязательное служебное слово (массив, множество)
       [1..10] - размерность, т.е порядковые номера в интервале от 1 до 10
      
 real тип элементов (вещественные числа)
или так: type M = array[1..10]  of  real;
или так: 
Const  n=10; 
             {n –размерность массива определена как константа}
Var  M: array [1..n] of real;
В программе можно обращаться к любому элементу этого массива. Делается это посредством указания имени переменной с номером элемента в квадратных скобках.
Примеры:
M[1] := 0.1;                            {1-му элементу массива присвоить значение 0.1} Readln (M[2]);                        {прочитать 2-ой элемент массива} Write (M[4]:4);                       {ввести 4-ый элемент массива по формату 4 знакоместа} Write (M[2]:4:1);                    {ввести 2-ый элемент по формату 4 знакоместа с одним знаком после запятой} if M[5] < 10 then …;               {если 5-ый элемент массива <10, то…} M[9] := Mas[1] + Mas[5];      {9-му элементу массива присвоить значение, равное сумме 1-го и 5-го}
Ввод элементов массива:
1) С клавиатуры     For i:=1 to n do begin     Writeln ('Введите число');
     Read (A[i]);
     end;
2) С помощью типизированных констант:    Const     A: array [1..6] of integer =(-5,8,5,0,7,-8);      {числа    В: array [1..3] of char =('a','b','c');                 {символы}
3) C помощью генератора случайных чисел    Randomize;                                     {включаем генератор случайных чисел}    For i:=1 to 100 do                            {цикл для формирования массива из 100 чисел}
    Begin     A[i]:=Random (200)+1       
            {элемент массива - случайное целое число из диапазона от 1 до 200}
    Write (A[i]:5);                                  {печать по формату на 5 знакомест}  
    
End;
Вывод элементов массива:
1) В строку: 
    For i:=1  to  n  do  

    W
rite (a[i]:5);
2) В таблицу (в столбик с разделительной чертой):   
     For i:=1 to 10 do
     Writeln
 (i:2, '|', a[i]:6);
Сумма всех элементов массива A:
S:=0              {начальное значение суммы =0}
For i:=1 to n do
S:= S + A[i]
Произведение всех элементов массива A:
P:=1            {начальное значение произведения}
For i:=1 to n do
P:= P * A[i]
Пример: Вычисление суммы элементов массива:
Program Summa;
var  m: array [1..5] of integer;   
 {массив из 5 целых чисел}
       i, s: integer;                          {i – порядковый номер элемента массива, s – сумма}
begin
randomize;                       
           {запуск генератора случайных чисел}
   for i := 1 to 5 do  begin            {в цикле от 1 до 5 элемента}
   m[i] := random (10);               {присвоить случайное значение }
   Write (m[i]:5);                         {напечатать это значение в строку по формату 5 знакомест на число}
   end;
s := 0; 
                                        {установить начальное значение суммы = 0}
for i := 1 to 5 do                        {в цикле от 1 до 5 элемента}
    s := s + m[i];                         {прибавляем к сумме по очереди все элементы массива}
writeln('Сумма = ', s);               {вывести ответ}
readln;
end.
Пример: Поиск максимального числа в массиве:
Program PoiskMax;
var А: Array [1..10] of integer;                   
{описываем массив А из 10 целых чисел }
      m: Integer;                               
      {m максимальное число, i- порядковый номер}
    
begin 
Writeln('Поиск максимального из 10 целых чисел: ');

For i := 1 to 10 do                                        
{ввод чисел в массив}
    begin
       Write('Введите число N', i, ': ');            
{числа будут запрашиваться в цикле по очереди N1, N2... до N10}
       Readln(A[i]);
    end;
      

m := A[1];                                             
 {первое число принимаем за максимальное }

For i := 1 to 10 do                                      {в цикле сравниваем его со всеми оставшимися по очереди}
    if A[i] > m                                           {если элемент массива больше принятого за максимум}
       then := A[i];                 
                {то это число принимается за максимум}

          Write('Максимальное число: ', m);         {вывод максимального числа}  

Readln; 

end.


Двумерный массив (матрица)
 - это структура однотипных элементов, расположенных в виде таблицы. Каждый элемент в двумерном массиве имеет два индекса: номер строки i и номер столбца j, на пересечении которых он расположен.
A - двумерный масси
[i,j] - элементы массива, где i - номер строки, j - номер столбца
[1,1]
[1,2]
[1,3]
...
[1,j]
[2,1]
[2,2]
...
...
...
[3,1]
...
...
...
...
...
...
...
...
...
...
...
...
...
...
[i,1]
...
...
...
[i,j]
Описание: Aarray [1..i] Of Array [1..jointeger; или  A: array [1..i, 1..j] of integer;
К элементам двумерного массива можно обращаться по индексам:
A[1,1]:=12;
if A[i,j] <=0 then ...
Работа с многомерными массивами почти всегда связана с организацией вложенных циклов. Внешний цикл предназначен для изменения номера строки i, а второй, внутренний, - для изменения номера столбца  j в текущей строке i.
Ввод двумерного массива:
1) С клавиатуры:
    
for i:=1 to n do                                   {в строках с 1-ой по или какое-нибудь число - количество строк}
    for j:=1 to m do begin
                        {в столбцах с 1-го по m или какое-нибудь число - количество столбцов выполнять...}
    write ('
Введите элемент: ');
    readln (A[i,j]);
    end;
2) Чтобы заполнить двумерный массив (матрицу) случайными числами, используют конструкцию вида:
    Randomize;                       {включаем генератор случайных чисел}
    for i:=1 to n do
    for j:=1 to m do 
    A[i,j]:=random (100);          {случайные числа от 0 до 99}
3) Заполнение по индексам (для квадратной матрицы n*n).
    Элементы, у которых i=j находятся на главной диагонали матрицы: 

    for  i:=1  to  n do 
 
    A[
i,i]:= d;                      {или какое-нибудь число}
   Элементы, у которых i<j находятся над главной диагональю матрицы: 
   for  i:=1  to  n-1 do   
      {с первой строки до предпоследней}
   for  j:=i+1
 to  n do         {со следующей клетки в строке до последнего столбца }
   A[i,j]:= v                      {или какое-нибудь число}
   Элементы, у которых i>j находятся под главной диагональю матрицы:     for  i:=2   to  n do    for  j:=1  to  i-1 do    A[i,j]:= p;                     {или какое-нибудь число}

  Элементы, у которых i+j=n+1 находятся на побочной диагонали:
  
for  i:=1   to  n do
  A[i,n–i+1]:= s;             
{или какое-нибудь число}
  Элементы, у которых  i+j<n+1 находятся над побочной диагональю:
  
for  i:=1   to  n–1 do
  
for j:=1 to n–i  do
  A[i,j]:= t;
                      
{или какое-нибудь число}
  Элементы, у которых i+j>n+1 находятся под побочной диагональю:
  
for  i:=n   downto  2 do
  for  j:=n–i+2  to n  do
  A[i,j] := k;                     
{или какое-нибудь число}
Вывод двумерного массива:
1) В строку
    
for i:=1 to n do
    for j:=1 to m do
    write (a[i,j]:5);             
{
вывод по формату}
2) Для красивого вывода матрицы на экран в виде таблицы используйте такой цикл:
    
for i:=1 to n do  begin
    for j:=1 to m do
    write(a[i,j]:5); writeln;           
{вывод по формату и переход на следующую строку}
    end;
Пример: Найти сумму всех элементов двумерного массива 3*3
Program Summa;
var a: array [1..3, 1..3] of integer;
i, j, s: integer;     
            {i - номер строки, - номер столбца, s - сумма}

begin
writeln (‘Исходный массив со случайными числами:’);
randomize;
    for i:=1 to 3 do
    for j:=1 to 3 do
    A[i,j]:=random(9)+1;               
   {заполнение массива 3*3 случайными числами от 1 до 9}

    for i:=1 to 3 do
    begin
         for j:=1 to 3 do
         write(A[i,j]:4);
                              {вывод массива таблицей 3*3 по формату}
         writeln;
    end;

s:=0; 
                                             {начальное значение суммы=0}
    for i:=1 to 3 do                            

    for j:=1 to 3 do
    s:=s+a[i,j]; 
                                   {считаем сумму, прибавляем по очереди все элементы массива}
writeln (‘Сумма всех элементов массива = ’,s);

readln;
end.
При работе с массивами очень часто возникают задачи перестановки элементов массива, например, поменять их местами.
1) Удаление из массива одного элемента с номером k:
    F
or i:=k  to  ndo
    A[i] := A[i+1];
    A[i] := 0; 

    Где  
n - количество элементов массива,            k - номер удаляемого элемента
2) Перестановка элементов массива:
   I способ – с помощью дополнительной переменной b:   b := A[1];                    {в переменную запишем значение 1-го элемента массива}
   A[1] := A[2];             
 {в освободившуюся ячейку переместим 2-ой элемент массива}
   A[2] := 
b                  {во освободившейся 2-ой элемент массива запишем переменную, хранившуюся в b}
   II способ – с помощью арифметических действий:
   A[1] := A[1] + A[2];
   A[2] := A[1]  A[2];
   A[1] := A[1]  A[2];
3) Перенести в конец одномерного массива элемент из k-той позиции:
   for i:=1 to n do    ...      {ввод элементов массива вручную или случайным образом}    read (k);                                {считать номер нужной позиции}
   b := A[k]; 
                              {сохранение  элемента с k-ой позиции в дополнительной переменной b}    for i:=k  to n–1 do                 {с k-го до предпоследнего}
   A[i] := A[i+1];
                       {сдвиг элементов массива следующих за k-ым на одну позицию влево}    A[n] := b                              {восстановление последнего значения  из переменной  b}
4) Перенести в начало одномерного массива элемент из k-той позиции:
   for i:=1 to n do    ...      {ввод элементов массива вручную или случайным образом}    read (k);                                {считать номер нужной позиции}
   b := A[k];   
                             {сохранение элемента с k-ой позиции в дополнительной переменной b}    for i:=k downto 2 do              {обратный цикл с k-го до второго}                  
   A[i] := A[i1];   
                      {сдвиг всех элементов до элемента с номером k вправо}                                 
   A[1] := b;                                
{записать на первое место значение из переменной b}
5) Реверс массива: переставить элементы массива в обратном порядке (обмен происходит до середины диапазона через третью
    переменную b)
I способ
   for i:=1 to n div 2 do begin
          
   b
 := A[i];
   A[i]
 := A[n+1–i];
   A[n+1–i]
 := b;
   end;
II способ – вывод через обратный цикл for i:=n downto 1 do...

6) Сдвиг: сдвинуть элементы массива влево на 1 ячейку, а первый элемент становится на место последнего.
    b := A[1];
    for i:=1 to n–1 do
    A[i]
 := A[i+1];
    A[n] := b;
7) Удаление k-той строки
    for i:=k to n do
    for j:=1 to n do
       a[i,j] := a[i+1,j]                  
{Cдвинуть все строки, начиная с k-той на одну вверх}
    for j:=1 to n do
       a[n,j] := 0                            
{Последнюю строку обнулить}
    При выводе уменьшить количество строк на 1
.
8) Вставка строки после k-той (в описании массива учтите, что размерность массива при выводе увеличится!)
    (var a: array [1..6,1..5] of… )
    for i := k+1 to n do
    for j := 1 to n do
    a[i+1, j] := a[i, j]; 
             {Все строки, начиная с k+1 сдвинуть на одну назад}
    for j := 1 to n do
    a[k+1, j] := 0; 
                  {Элементам строки k+1 присвоить заданное значение (0)}
    
При выводе увеличить количество строк на 1.
 * Для удаления или вставки столбцов используются практически те же алгоритмы, только изменяется размерность и происходит
    сдвиг по столбцам j.
Сортировка – процесс перестановки элементов массива в определенном порядке (по возрастанию, по убыванию и т.д.).
1) Базовый алгоритм сортировки: 
    Начинаем с первого элемента. Сравниваем два соседних элемента, если 1-ый элемент больше 2-го, меняем их местами.
    Затем сравниваем 1-ый и 3-ий, если 1-ый элемент больше, меняем их местами. Далее сравним 1-ый элемент с 4-ым,
    потом с 5-ым и т.д. В результате самый маленький элемент встанет на 1-ое место. В результате, самый маленький элемент
     из оставшихся встанет на 2-ое место.
 
   for  i := 1 to n–1 do                  {начиная с 1-го до предпоследнего элемента}
   for  j := i+1 to n do                  {сравниваем со следующим и до последнего}
         if  a[i] > a[j]  then begin        {если элемент больше следующего, то…}
          c := a[i];                            {меняем местами через доп. переменную}
          a[i] := a[j];
          a[j] := c;
      end;
  

    Где i – номер элемента, который сравниваем (от 1 до n–1)          j – с чем сравниваем (следующий за номером от i+1 до n)          с – дополнительная переменная для обмена
2) Сортировка пузырьковым методом состоит из двух циклов:
    Внешний цикл для просмотра массива n–1 раз (где n – размер массива).
    Во втором, внутреннем цикле выполняется проверка: если текущий элемент больше, чем следующий, то они меняются
    местами с помощью промежуточной переменной (если делать проверку со знаком >, то сортировка будет производиться
    по возрастанию; если со знаком < – то по убыванию)
    …
    for i := 1 to n–1 do
    for j := n–1 downto i do
             {элементы выше i уже поставлены!}
    if A[j] > A[j+1] then                {сравниваем соседние элементы}
    begin
    с := A[j];
    A[j] := A[j+1]; 
                        {меняем элементы местами}
    A[j+1] := с;
    end;
    …

3) Сортировка массива методом простого выбора (поиска минимального элемента)
    Этот метод основывается на алгоритме поиска минимального (или максимального) элемента.
    В массиве  А[1..n] отыскивается минимальный элемент, который ставится на первое место A[1].
    Для  того, чтобы  не потерять элемент, ранее стоявший на первом месте, этот элемент меняется местами с A[1].
    Затем, из оставшихся элементов  А[2..n] отыскивается минимальный элемент и ставится на второе место и т.д.  n–1 раз,
    пока не  встанет  на свое место предпоследний n–1 элемент массива А, сдвинув максимальный элемент в самый конец.
    ...
    for i:=1 to n–1 do 
              {просмотр элементов}
    begin k := i;                          {запомнить номер позиции}
    x := a[i];                              {запомнить элемент в доп. переменной х}     
    for j := i+1 to n do               {поиск минимального от A[i] до A[n]}   
    if a[j]<x then begin            {сравнить и поменять местами}   
    k := j;     
    x := a[j];     
    end;
    a[k] := a[i];
    a[i] := x;
                            {восстановить элемент из доп. переменной}
    end; 

4) Сортировка массива методом вставок
    В начале работы алгоритма массив разделяется на две части: отсортированную и неотсортированную. В отсортированной
    части массива находится только один первый элемент, а в неотсортированной части – все остальные элементы.
    Элементы из неотсортированной части поочередно выбираются и вставляются в отсортированную часть так, чтобы не  
    нарушить в ней упорядоченность элементов.
    Таким образом, алгоритм будет состоять из n–1 проходов, каждый из которых будет включать четыре действия:
    - взятие очередного i-гo неотсортированного элемента и сохранение его в дополнительной переменной b;
    - поиск позиции j в отсортированной части массива, в которой присутствие взятого элемента не нарушит упорядоченности
      элементов;
    - сдвиг элементов массива от i–1 -го до j–1 -го вправо, чтобы освободить найденную позицию вставки;
    - вставка взятого элемента в найденную j-ю позицию.
     …
     for i:=2 to n do
               {начинаем со 2-го элемента}
     begin b := a[i];                 {помещаем очередной элемент в доп. переменную b}
     j := i–1;                             { ищем ему новую позицию j }
     while (j>=1) and (a[j]>b) do begin 
     a[j+1] := a[j];                  {сдвигаем элементы вправо}
     j := j–1;
     end;
     а[j+1] := b;
     end;
     …
Строки - последовательность символов, записанная между одиночными апострофами ('   '). Допускается формирование строк с использованием записи символов по десятичному коду (в виде комбинации знака # и кода символа). При этом используется таблица кодировки ASCII (всего можно описать 256 символов).
Существует два типа строковых переменных: Char и String.
1) Переменная типа Char (символ) описывает один отдельный символ кодовой таблицы ASCII (всего можно описать 256 символов).
Символьные переменные описываются в разделе Var  z: char; С такими переменными могут быть использованы функции Ord(a); Chr(x); UpCase(a);
Функция Ord (a) возвращает код символа в системе ASCII: k:=Ord(a); где k – числовой код, а – символ.
Функция Chr (k) возвращает символ по его числовому коду. k можно так же представить как числовую константу, или можно пользовать запись #k. Пример: #161#168#226 (закодировано слово бит
a:=Chr(k); где a – символ, соответствующий коду k
Функция UpCase(a) при наличии в параметре прописных латинских символов преобразует их в заглавные, а все остальные символы выдаст без изменения.
2) Переменная String (Строка)  последовательность из некоторого количества символов. Количество символов последовательности называется длиной строки.
Тип String во многом похож на одномерный массив символов A: array [0..n] of Char.
Строковые переменные описываются в разделе var так:
var s: string[n];    где n - максимально возможная длина строки (целое число в диапазоне 1..255) var s: string;        - если параметр n не указан, то по умолчанию он принимается равным 255.
Для работы со строками используются следующие функции:
Length (s)- функция возвращает в качестве результата значение длины строки (количество символов в строке).
Copy (s, i, k)- функция возвращает часть строки, выделенную из исходной строки s, начиная с символа под номером 
и длиной 
k символов.
Delete (s, i, k);  удаляет из исходной строки s часть строки, начиная с символа под номером i и длиной k символов.
Insert (s1, s, i); - предназначена для вставки строки s1 в строку s, начиная с символа i этой строки.  
Pos (frag, stroka);   –  осуществляет поиск некоторого фрагмента frag в строке stroka
                                      
Если такого фрагмента нет, то результат = 0
Eoln(s); - логическая функция, результат выполнения которой равен True, если достигнут маркер конца строки s.
Примеры:
а) s := 'Система Turbo Pascal';           {исходная цепочка символов}
   s1:= length(s)
;                                переменной s1 присвоить значение, равное длине строки s, т.е.= 20 }
   s2 := copy(s, 1, 7);
                          {копируем с 1-го символа, всего 7 символов, т.е.  s2 будет равно слову 'Система'}
b) s:= 'Система Turbo Pascal'; 
    delete(s, 8, 6);
                               {удаляем, начиная с 8-го символа, 6 символов, т.е. s будет равно 'Система Pascal'}
c) s:= 'Система Pascal'; 
    insert('Turbo ',s,9);
          {вставляем 'Turbo' в исходную строку, начиная с 9-ой позиции, s будет равно 'Система Turbo Pascal'}
d) While  not  Eoln(s)  do              {пока не достигнут конец строки s, делать…}

В программировании часто встречаются случаи, когда в разных частях программы встречается одна и та же последовательность операторов, решающая одинаковую задачу.
В Паскале, как и в других языках программирования, этот фрагмент можно представить как отдельную самостоятельную программу, имеющую собственное имя. При этом такая программа записывается только один раз, а вызывать ее можно многократно в разных частях программы.
Такой принцип дефрагментации программы называется нисходящим программированием и соответствует принципам структурного программирования. Использование подпрограмм позволяет:
1) Сделать основную программу более наглядной;
2) Уменьшить объем используемой памяти ЭВМ;
3) Сократить время отладки программы.
Объект такого рода называется подпрограммой. Существуют две разновидности подпрограмм: процедуры и функции
Процедура – вспомогательный алгоритм, описывающий некоторые действия.
Процедура имеет ту же структуру, что и главная программа, содержит разделы Label, Const, Var и выполняемую часть.
Procedure Имя_процедуры (Переменные: Тип_переменных);
   
Label ...
   
Const ...
   
Var ...
Begin        
     
Раздел операторов
     ...

End;
Обратите внимание, что имеется только два отличия процедуры от основной программы: процедура начинается с заголовкаProcedure  и заканчивается точкой с запятой.
Переменные, которые описаны в основной программе, называются – глобальными. Глобальные переменные действуют во всей программе и в каждой ее процедуре.

Переменные, которые описаны и используются внутри процедуры, называются – локальными. Локальные переменные действуют только внутри данной процедуры!Формальные параметры – это параметры, которые указаны в скобках после имени процедуры в разделе описания процедуры и служат для описания порядка действий в процедуре.

Фактические параметры – это параметры, которые указываются в скобках при вызове процедуры. При вызове фактические параметры как бы подставляются вместо формальных, стоящих на тех же местах в заголовке.Пример: Программа для вычисления площади четырехугольника, заданного длинами его сторон и диагональю. Процедура предназначена для вычисления площади треугольника по формуле Герона.

program Figura;
var AB, BC, CD, DA, AC, S1, S2: real; 
           {глобальные переменные, действую во всей программе}
 
Procedure Ploshad( a, b, c:real; var s:real );    {формальные параметры}
var p:real;
                                                  {локальная переменная действует только внутри процедуры}
begin
    p:=(a+b+c)/2; 
                                 {полупериметр треугольника}
    s:=sqrt(p*(p-a)*(p-b)*(p-c)); 
         {формула Герона}
end;
                                                       {конец процедуры!}

begin                      
{основная программа}
Writeln('Задайте стороны 4-х угольника ABCD и диагональ AC');
readln (AB, BC, CD, DA, AC);
    Ploshad (AB, BC, AC, S1);       
{вызов процедуры с фактическими параметрами АВ, ВС, СD - стороны a, b, c; S1 - площадь s}

    Ploshad (DA, AC, CD, S2);
Writeln ('Площадь ABCD= ', S1+S2:8:2);    
{вывести сумму двух площадей}

readln;
end.                                                            

Правила использования процедур с параметрами:

1) Соответствие между параметрами команды вызова процедуры и параметрами описания процедуры устанавливается не по
    именам параметров, а по порядку следования (1-ый параметр в команде вызова соответствует 1-му параметру в описании
    процедуры, 2-ой – 2-му и т.д.
2) Количество фактических параметров должно соответствовать количеству формальных параметров.
3) Типы фактических параметров должны соответствовать типам формальных параметров.
4) Фактические параметры, соответствующие результатам вычислений в процедуре, должны быть только именами переменных.
 
Функция – вспомогательный алгоритм для выполнения вычислений, возвращающий от своей работы какое-либо значение в основную программу.
Помимо стандартных математических функций, существующих в Паскале, можно создавать свои свою функции, описывая их в следующем виде:
Function Имя_Функции (var Параметр1: Тип1;                       {имя функции, параметры, тип параметров}
                                var Параметр2:Тип2;
                                .....
                                var Параметрj:Tипj) :ТипJ
                     {в конце за скобками указан тип результата!}
const
var
begin

end;
 
Пример: Использование функции тангенса
Program primer(input, output);
var x, y: real;

function tg (x : real) : real;       {описание функции tg - вычисление тангенса }
begin
    tg := sin(x)/cos(x);
end;

begin                                       
{основная программа }
    write(' Введите x');
    readln(x);
    y:=tg(x);                                  
{использование функции tg}
end;
writeln('y=', y:6:2)

readln;
end.

Рекурсией  в программировании называется вызов функцией (процедурой) самой себя.
Различают 2 формы рекурсии: прямую и косвенную.
При прямой рекурсии процедура содержит оператор обращения к самой себе: —>А
При косвенной рекурсии одна процедура вызывает другую, которая сама либо посредством других процедур вызывает исходную процедуру: > B > A
Количество вложенных вызовов функции или процедуры называется глубиной рекурсии. Рекурсивная функция обязательно должна содержать в себе условие окончания рекурсии, чтобы не вызвать зацикливания программы!
Пример рекурсии - функция вычисления факториала:
Program Factorial;
Var n: integer;

Function Fact (n: integer): longint;
begin 
   if  n = 0       then  Fact:=1       else  Fact:= n * Fact ( n–1);          
{процедура Fact вызывает сама себя, но с другими параметрами}
end;

Begin                   
                              {основная программа }
    writeln (‘Введите число n (n=1..12)’);     readln (N);     writeln( ‘n! = ‘ , Fact (n) );

readln;
end.
Включение динамика производится командой Sound(F);    
где 
F – частота сигнала (Гц)
Задержка времени (пауза) Delay(t);  где t – время в миллисекундах (1 мс = 0,001 с)
Отключение динамика – NoSound;
Октавы
Значения частот
Ноты
до
ре
ми
фа
соль
ля
си
малая
130
147
165
175
196
220
246
первая
262
284
330
349
392
440
494
вторая
523
587
659
698
783
880
998




Пример: Гамма
Program Gamma;
Uses Crt; 
                                                                                                              
{подключение модуля Crt}
Var    i : Integer; 
                                                                                                  {счетчик цикла}
Const  f : array[1..7] of word = (523, 587, 659, 698, 783, 880, 998); 
                
{массив из 7 нот с частотами} 

Begin
For i:=1 to 7 do 
                                                                 
                                  {цикл: от 1 до 7 ноты делать...}
   Begin        Sound(f[i]);                                                                                                          {включение динамика для каждой ноты}
       Delay(10000);                                                                                                      
{пауза - значение можно изменять}
   End;                                    
                                                                                  {конец цикла}
NoSound;  
                                                                                                            {отключение динамика}  
End.
Файл – это область на диске, имеющая имя.

Текстовые файлы - файлы, состоящие из символов ASCII, которые содержат только текст без форматирования (т.е не содержат управляющих символов (с кодами < 32):  ACSII (символ=1 байт) Unicode (1 символ=2 байта)  *.txt,  *.log, *.htm,  *.html
Текстовые файлы являются файлами с последовательным доступом. В любой момент времени доступна только одна запись файла. Другие записи становятся доступными лишь в результате последовательного продвижения по файлу. Текстовые файлы внутренне разделены на строки, длины которых различны. Для разделения строк используется специальный маркер конца строки. Объявляются текстовые файлы переменной типа text:
var  f : text;
Обрабатывать их можно только последовательно с помощью процедур и функций:
Assign(f, name) - устанавливает связь между именем файла в программе (файловой переменной ) и физическим именем файла.
Reset(f) - открывает существующий файл для чтения.
Rewrite(f) - создает и открывает новый файл для записи на внешнем устройстве (если файл ранее существовал, вся предыдущая информация из него стирается).
Close(f) - закрывает открытый файл.
Readln(f , st) - чтение строки st из файла f и переход на начало следующей ;
Writeln(f, st) - запись строки st в файл f и маркера конца строки ;
Append(f) - процедура, открывающая файл для добавления строк в конец файла;
Eoln(st) - логическая функция, результат выполнения которой равен True, если достигнут маркер конца строки st.
Пример: В файле input.txt записаны числа (в столбик), сколько их – неизвестно. Записать в файл output.txt их сумму.
Program in_out;
var s, x: integer;
f: text;                                   
{файловая переменная}

begin
   {$I-}                                      
 {отключение контроля ошибок}
    assign (f, 'input.txt');             
{связываем файловую переменную с файлом}
    reset(f);                                
  {открываем файл}
   {$I+}                                      
{включение контроля ошибок}

if IOresult <>0 then
   writeln (‘Ошибка открытия файла')
   else begin
        s:=0;
        while not eof(f) do begin      
{пока не достигнут конец файла, делать...}
             readln(f, x);
             s := s + x;
        end;
   end;
close(f);                                
{закрыть файл}
assign(f, 'output.txt'); 
         {связываем файловую переменную с новым файлом}
rewrite(f);
writeln(f, ‘Summa =', s);      
{вывод в файле значения s}
close(f);
end.