Замечание: Альтернатива Else считается принадлежащей ближайшему условному оператору IF , не имеющему ветви Else.

При вычислениях необходимо помнить о том, чтобы правильно выбрать тип результата. Это особенно касается переменных, хранящих значения произведений (типа факториала), так как значение результата «растет» очень быстро и в результате может произойти переполнение.

В рассмотренных выше примерах вводилось ограничение на диапазон входного значения (n<10). Для того, чтобы программа корректно отработала, необходимо, чтобы контроль ввода осуществлялся в явном виде.

Для этого программист должен взять контроль «на себя» и отработать все «критические» ситуации, которые могут привести к аварийному завершению программы и досрочному ее завершению. Компилятор жестко контролирует при выполнении программы границы массивов и соответствие типов. Этим контролем можно управлять (включать или отключать при необходимости). Достаточно при этому компилятору указать, каким образом ему действовать в той или иной ситуации – задать соответствующую директиву специальным комментарием.

const N_max = 10;

var a: Array [ 1 .. N_Max ] of Real;

2). (* такое объявление удобнее *)

const N_max = 10;

Type Vector = Array [ 1 .. N_max ] of Real;

var a: Vector;

b: Array [1..n] of Real;

c,d: Vector;

С точки зрения транслятора Pascal a и b разные, а cи d одинаковые и можно выполнять групповые присваивания (операции).

3). Const nmax = 10;

nmin = -2;

Type Vector = Array [ nmin .. nmax ] of Real;

{ 13 элементов }

VectorChar = array [‘a’..’z’] of char; { 26 элементов }

var a: Vector;

b: VectorChar;

Switch : Array [ Boolean ] of Byte;

Как видно из третьего примера, ничто не обязывает объявлять диапазон индексов массива числами от 1 до N_max, в качестве индексов можно использовать любые перечислимые типы, как встроенные, так и вводимые пользователем. Если диапазон соответствует всему типу, то вместо него можно записать просто имя этого перечислимого типа.

Рассмотренные массивы – одномерные, то есть такие, у которых компоненты – скаляры. Разрешено объявлять массивы массивов (матрицы).

const N_Max = 5;

M_Max = 6;

Type Matrix = array [ 1 .. N_Max , 1 .. M_max] of Real;

Type Matr_Sqr = array [ 1..N_Max, 1 .. N_Max ] of Real;

var a: Matrix; {матрица n x m}

b : Matr_Sqr; {квадратная матрица}

Другое описание двумерного массива (вектор векторов) выглядит следующим образом:

const n = 5; m = 6; {объявление матрицы размером n x m}

Type Vector = array [1..m] of Real;

Matrix = array [1..n] of Vector;

var a: Vector;

Расположение матрицы в памяти компьютера     …   1строка( m элементов) 2 строка (m элементов)

b: Matrix;

Первый вариант описания матрицы более наглядный, так как позволяет сразу определить размеры «таблицы», в которой будут храниться данные.

Замечание: рекомендуется описывать массивы, используя раздел констант и типов для быстрого изменения не только описания, но и для минимальных исправлений по дальнейшему тексту программы.

В многомерных массивах (количество измерений формально не ограничено) каждое измерение не зависит от остальных, поэтому можно объявлять массивы с разными индексами:

Var M: Array [ -10..10, ‘A’ .. ‘D’, Boolean ] of Byte;

Эквивалентная запись выглядит следующим образом:

Var M: Array [ -10..10 ] of

Array [‘A’ .. ‘D’] of

Array [Boolean] of Byte;

Тип элемента массива М зависит от числа указанных в нем индексов:

M[0] – массив-матрица типа Array [‘A’..’D’, Boolean] of Byte;

Замечание: Работа с элементами массива занимает больше времени, чем со скалярной переменной (необходимо вычислять местоположение элемента в памяти). Поэтому, если какой-то элемент массива используется многократно, то его лучше переписать в скалярную переменную.

3.1.2. Ввод и вывод массивов.

Ввод массивов можно организовать по-разному: для одномерных массивов (векторов) – в строку или в столбец; для двумерных ( матриц ) – по строкам или по столбцам.

{Ввод вектора в столбец }

for i = 1 to n do RealLn(a[i]); { Можно но не нужно! }

{ Лучше ввод организовать так: }

WriteLn(‘Введите элементы вектора:’);

for i := 1 to n do begin

Write(‘a[‘, i, ’] = ’);

ReadLn( a[i] );

end;

{ Вывод вектора: }

Writeln(‘Результирующий вектор: ’);

for i := 1 to n do Write(a[i], ‘_‘);

WriteLn;

{Ввод матрицы по строкам }

for i = 1 to n do Begin

for j := 1 to m do

Real(a[i,j]);

ReadLn;

End;

{ Лучше ввод матрицы организовать так: }

WriteLn(‘Введите элементы матрицы:’);

for i := 1 to n do begin

WriteLn( ‘Введите элементы ‘,i,’-ой строки матрицы’);

for j := 1 to m do Begin

Write( ‘a[‘, i, ‘,’ , j,’] = ’);

ReadLn(a[i,j]);

End;

End;

{Вывод матрицы по строкам }

Writeln(‘Результирующая матрица’);

for i := 1 to n do begin

for j := 1 to m do Write(a[i,j], ‘_‘);

WriteLn;

end;

3.1.3. Форматы вывода.

Для удобства вывода при выводе данных лучше использовать так называемый «форматный вывод», когда под каждую выводимую переменную отводится определенное количество позиций

Write( a [ :F [ :n ] ] ); { [ ] здесь означают необязательность }

F - общее число позиций, отводимое переменной (если необходимо вывести больше, то F игнорируется).

n - число знаков после десятичной точки (употребляется только для вывода действительных чисел).

Примеры:

a: real; { a = 354.78 }

Write(a); { 0.3547800000E+03 => 0.35478*10³ }

Write(a:8:4); { 345.4700 }

I: Integer; { I = 371 }

Write (I:8); {_ _ _ _ _371 }

Write (I:-8); { 371 }

Write (a:6:2); { a = 15.448 }

{ _ 15.45 }

Write ( <...> ); { Просто выводит информацию на экран }

WriteLn( <...> ); { Выводит на экран и переводит курсор на следующую строку }

WriteLn; { переводит курсор на следующую строку }

Write ('сообщение пользователя': 50); {можно центрировать по ширине }

3.1.4. Базовые алгоритмы обработки векторов.

Описательная часть

var a: array [1..n] of <T>;

min, max : <T>;

Number : Byte;

2). Найти произведение четных элементов:

p:=1;

for i:=1 to n do

if a[i] mod 2=0 then p:=p*a[i];

3). Найти минимальный элемент массива:

min:=a[i];

for i:=2 to n do

if a[i]<min then min:=a[i];

4). Найти минимальный элемент и его номер:

3.1.5. Алгоритмы поиска.

При другой реализации программы возможны скрытые ошибки (не рекомендуется изменять переменную цикла внутри цикла).

k := 0;

for i := 1 to n do

if a[i] = x then begin

k := i;

i := n; { <— Возможна ошибка }

end;

2). Найти в массиве максимальное четное число:

i:=1; {поиск первого четного элемента вектора}

while (i<=n) and (a[i] mod 2=1) do inc(i);

if i>n then write(‘Четных элементов нет’)

Else begin {четный элемент найден}

max:=a[i];

for k:=i+1 to n do

if (a[k] mod 2=0) and (a[k]>max) then max:=a[k];

Write(‘max=’, max);

end;

3). Алгоритм поиска последнего отрицательного элемента.

3.1.6. Базовые алгоритмы обработки матриц.

1). Сумма элементов матрицы.

S := 0;

for i := 1 to n do

for j := 1 to m do

S := S + a[i,j];

2). Сумма элементов под главной диагональю (диагональ учитывается).

S := 0;

for i := 1 to n do

for j := 1 to i do

S := S + a[i,j];

3). Сумма элементов над главной диагональю (диагональ учитывается).

S := 0;

for i := 1 to n do

for j := i to n do

S := S + a[i,j];

4). Сумма над побочной диагональю.

S := 0;

for i := 1 to n do

for j := 1 to n-i+1 do

S := S + a[i,j];

5). Сумма под побочной диагональю.

S := 0;

for i := 1 to n do

for j := n-i+1 to n do

S := S + a[i,j];

6). Сумма элементов над главной и побочной диагоналями.

S := 0;

for i := 1 to (n+1) div 2 do

for j := 1 to n-i+1 do

S := S + a[i,j];

7). Сумма под главной и побочной диагоналями.

S := 0;

for i := n div 2 +1 to n do

for j := n-j+1 to i do

S := S + a[i,j];

8). Сумма слева от главной и побочной диагоналей.

S := 0;

for i := 1 to (n+1) div 2 do

for j := 1 to n-i+1 do

S := S + a[i,j];

9). Сумма справа от главной и побочной диагоналей.

S := 0;

for i := n div 2 +1 to n do

for j := n-j+1 to i do

S := S + a[i,j];

10). Сумма элементов главной диагонали.

S := 0;

for i := 1 to n do S := S + a[i,i];

11). Сумма элементов побочной диагонали.

S := 0;

for i := 1 to n do S := S + a[i,n-i+1];

12). Транспонирование матрицы.

var a: array [1..n,1..m] of <T>; {T – заданный тип}

b: array [1..m,1..n] of <T>;

...

Begin

for i := 1 to n do

for j := 1 to m do

b[i,j] := a[j,i];

End.

13). Транспонирование матрицы в самой себе (относительно главной диагонали).

var a: array [1..n,1..n] of <T>;

V: <T>;

...

Begin

for i := 2 to n do

for j := 1 to i-1 do begin

V := a[j,i];

a[j,i] := a[i,j];

a[i,j] := V;

end;

14). Умножение матриц ( A(n x m) x B(m x l) = C(n x l))

Замечание: Описание массива влияет на программную реализацию алгоритма.

3.1.7. Алгоритмы сортировки массивов.

Для упорядочивания массивов по разным признакам (по возрастанию, по убыванию, по невозрастанию, по неубыванию и т.д.) применяют алгоритмы сортировки, при которых элементы в массиве меняют свое месторасположение в зависимости от условия сортировки. Известно большое количество алгоритмов [1], но в учебных целях используются наиболее простые из них.

1). Обменная поразрядная сортировка (сортировка “пузырьком”).

Для вектора из n элементов делается (n-1) просмотр, в каждом просмотре сравниваются попарно элементы, начиная с первого, если предыдущий элемент больше последующего, их меняют местами. После каждого просмотра очередной наибольший элемент встает на свое место (сортировка по возрастанию).

2). Сортировка посредством выбора.

Находится минимальный элемент массива и меняется местами с первым. Среди оставшихся элементов ( то есть начиная со второго) опять находится минимальный и меняется местами со вторым и процесс повторяется.

For i:=1 to n-1 do Begin

min:=i;

for j:=i+1 to n do

if a[j]<a[min] then min:=j;

r:=a[min]; a[min]:=a[i]; a[i]:=r;

End;

3.1.8. Совместные алгоритмы обработки матриц и векторов.

1). По матрице А(n x m) получить вектор, элементы которого равны сумме элементов строк матрицы:

For i:=1 to n do Begin

S:=0;

For i:=1 to m do S:=S+a[i,j];

b[i]:=S;

End.

2). По матрице А(n x m) получить вектор, содержащий минимальный элемент соответствующих строк матрицы:

For i:=1 to n do Begin

min:=a[i,1];

For j:=2 to m do

If a[i,j]<min then min:=a[i,j];

b[i]:=min;

End.

3.2. Множества.

3.2.1.Описание множеств.

Множество – это набор значений из некоторого скалярного (перечислимого) типа. Скалярные типы (Byte и Char) вводятся языком, они – перечислимые (все элементы можно поштучно назвать) и на их основе можно построить множество. Если же их станет мало, то всегда можно ввести свой скалярный тип, например:

Type VideoAdapterType = (MDA, CGA, EGA, VGA, Other, NoDetected);

и использовать переменную

Var VideoAdapter : VideoAdapterType;

которая может иметь только перечисленные в задании типа значения. Далее можно ввести переменную – множество из тех же значений.

В описании множества как типа используется конструкция Set of и следующее за ней указание базового типа. Способов задания множеств несколько:

Type

SetOfChar = Set Of Char; {множество символов}

SetOfByte = Set Of Byte; {множество чисел}

SetOfVideoAdapter = Set of VideoAdapterType;

{ множество из названий видеоадаптеров}

SetOfDigit = Set of 0 .. 9; {множество из цифр от 0 до 9}

SetOfDChar = Set of ‘0’ .. ‘9’; {множество из символов от ‘0’ до ‘9’}

SetOfVGA = Set Of CGA .. VGA;

{множество из названий видеоадаптеров}

Как видно из примеров, можно в задании типа «урезать» базовый тип, определяя диапазон его значений. В итоге множество может состоять только из элементов, вошедших в этот диапазон.

Разрешено описывать множество сразу в разделе переменных, но это возможно только в случае, если переменная-множество не является параметром процедуры или функции.

Var M1 : Set of …;

В Turbo Pascal’e разрешено определять множества, состоящие не более, чем из 256 элементов (столько же содержат типы Byte и Char). Каждый элемент множества имеет сопоставимый номер. Для типа Byte номер равен значению числа, для символов – определяется его ASCII-кодом. Всегда нумерация идет от 0 до 255, поэтому для множеств базовыми не являются типы ShortIn, LongInt, Word, Integer. Множества имеют весьма компактное машинное представление: на один элемент расходуется 1 бит. Поэтому для хранения 256 элементов множества понадобится всего 32 байта. Для меньшего диапазона значений понадобится еще меньше памяти.

Переменная, описанная как множество, подчиняется специальному синтаксису, элементы множества должны заключаться в квадратные скобки []:

SByte := [1..5, 6, 9,89,97]; {целые числа}

LatLetter := [‘a’ .. ‘z’, ‘A’ ..‘Z’]; {задание латинского алфавита}

Sdigit := [‘0’ .. ‘9’]; {задание цифр}

RusLetter := [‘А’ .. ’п’, ‘р’ .. ‘я’]; {задание русского алфавита}

SChar := [‘а’, ‘е’, ‘и’, ‘о’, ‘у’, ‘ы’, ‘ю’, ‘я’, ‘э’, ‘ё’]; {гласные буквы}

Empty :=[]; {пустое множество}

Замечание: Порядок следования внутри скобок не имеет значения так же, как не имеет значение число повторений (элемент в множество включается только один раз).

3.2.2. Операции, применимые к множествам.

Замечание: Операции пересечения и объединения множеств не зависят от мест операндов, но операция дополнения чувствительна к порядку следования операндов в выражении.

Результат вычислений S1-S2 не будет в общем случае равен результату S2-S1, точно также как и результат выражения S1-S2-S3 будет зависеть от порядка вычислений (слева направо и наоборот), устанавливаеимых компилятором. Обычно принято вычислять слева направо, но лучше не закладывать в программу явные особенности компилятора и вычислять «многоместные» разности через промежуточные переменные, избегая тем самым получение неправильных результатов.

Достоинства множеств очевидны:

· Гибкость представления наборов значений;

· Удобство их анализа и возможность накапливания однотипных значений или их выборок;

· Компактность кодировки.

Недостатки множеств – обратная сторона их достоинств. За компактность приходится платить невозможностью вывода их на экран (хотя содержимое множества можно посмотреть через отладчик); ввод множеств возможен только по элементам.

Пример:

{Ввод множества символов до нажатия точки или клавиши Enter}

Uses Crt; {для использования функции ReadKey}

Var SChar : Set Of Char;

Ch : Char;

Begin

SChar := []; { «обнуление значений»}

Repeat

Ch := ReadKey; {Ожидание нажатия клавиши}

If Ch = #0 Then {если управляющая клавиша, то пропускаем}

Else SChar := SChar + [Ch];

Until Ch in [‘.’, #13]; {ожидание нажатия клавиши ‘.’ или Enter}

SChar := SChar - [Ch]; {исключение последнего символа}

End.

{ Вывод элементов множества на экран }

Var SByte : Set of Byte;

X : Byte;

Begin

SByte := [23, 45, 67, 89, 123, 204, 213, 225];

{Возможно заполнение множества }

{ в режиме диалога с пользователем}

WriteLn(‘Содержимое множества Sbyte ’);

For X := 0 To 255

If X in SByte Then Write(X:4);

End.

3.2.3. Хранение множеств в памяти компьютера.

Несмотря на недостатки, множества – очень удобный инструмент для обработки данных и оптимальный для некоторых приложений способ хранения данных. Как уже говорилось п.2.1.1., каждому элементу множества соответствует бит, определяемый по номеру элемента исчисления.

S1:=[1,3,5] S2 := [3, 5, 7];

Var Color:set of (Red, Blue, Green, Black);

{ 0 1 2 3 }

Color:=[Red,Green];

7 6 5 4 3 2 1 0

4. Обработка символов и строк.

Язык Turbo Pascal дает возможность создавать программы с развитыми алгоритмами обработки символьной информации.

4.1. Символьный и строковый типы (Char и String).

Язык поддерживает стандартный символьный тип Char и динамические строки, описываемые типом String или String[n].

Значение типа Char – это непустой символ из алфавита компьютера, заключенный в одиночные кавычки. Кроме этой классической формы записи Turbo Pascal вводит еще два способа:

1. представление символа его кодом ASCII (American Standart Code for Interchange Information), для этого используется префикс #;

2. представление символа его клавиатурным обозначением (для управляющих символов с кодами в диапазоне от 0 до 31), для этого используется префикс ^;

Максимальная длина строки составляет 255 символов. Строки называются динамическими, поскольку они могут иметь различные длины в пределах объявленных границ. Тип String является базовым и совместим со всеми производными символьными типами. При попытке записать в строку длиннее, чем объявлено в описании, «лишняя часть» будет отсечена.

Тип String очень похож на массив символов Аrray [0..255] of char, но это не совсем так. В нулевом элементе строки хранится ее длина (динамическая «переменная»), которая автоматически меняется в зависимости от наполнения строки символами, чего не скажешь о символьном массиве.

Const n=10;

var a: String; { В такой строке максимум 255 символов }

b: String[n]; { В такой строке максимум 10 символов }

c: String[255]; { то же, что и String }

Значением строки может быть любая последовательность символов, заключенная в одинарные кавычки:

‘abcdefg….’ {Английский алфавит}

‘Строка’ {произвольная строка}

‘’ { пустая строка.}

‘’’’ {строка из одной одиночной кавычки}

^G’После сигнала нажмите ’^J’ клавишу пробела’^J^M

{«Звонок» сообщение «переход на следующую строку» сообщение «переход на следующую строку» «клавиша Enter»}

В такой записи не должно быть пробелов вне кавычек. Более общим способом включения в строку любых символов является их запись по ASCII-коду через префикс # или функцию Chr. Механизм показан ниже:

#179‘ Номер п/п ’#179’ Ф.И.О. ’ +Chr(179)+’ Должность ’#179

{то же, что и ‘| Номер п/п | Ф.И.О. | Должность |’}

#7#32#179#32#32#179 {то же, что и ^G’ | |’}

Строки различных длин совместимы между собой в операторах присваивания и сравнения, но «капризно» ведут себя при передаче параметров в процедуры и функции (если тип фактического параметра является производным от строкового, то при вызове он должен совпадать с типом формального параметра (принципы передачи параметров в подпрограммы будут обсуждаться в следующих параграфах)). Поэтому для полной совместимости типов параметры, описываемые на уровне подпрограммы, должны быть описаны исключительно типом String и компилировать программу необходимо в режиме {$V-} (режим проверки совместимости формальных и фактических параметров).

К любому символу в строке можно обратиться по его номеру, как к элементу массива, отдельный символ совместим по типу со значением типа Char, поэтому можно выполнять различные присваивания как на уровне символов строки, так и на уровне произвольных символов.

Пример:

Var Ch : Char; I : Byte; St : String[10];

Begin

St := ‘Example ’; {длина 8 символов}

For i := 1 to 4 Do Write (St[i]); {‘Exam’}

Ch:=’1’;

St := St + Ch; {‘Example 1’, длина 9 символов}

St[9]:=’2’; Write(St); {St = ‘ Example 2’}

St[10]:=Ch; Write(St); {St = ‘ Example 21’}

End.

Как уже говорилось выше, каждая строка «знает», сколько символов в ней содержится в текущий момент времени. Символ St[0] содержит код, равный числу символов в строке St, т.е. длина строки всегда равна Ord(St[0]). Об этой особенности необходимо помнить при заполнении строки одинаковыми символами. Проблему заполнения решает встроенная процедура FillChar :

Var St : String;

Begin

FillChar ( St[1], 50, ‘ ‘ ); { заполняем 50 пробелов }

St[0] := Chr(50); { устанавливаем заданную длину строки }

End.

FillChar(St, SizeOf(St), 0); { Обнуление строки }

Замечание: Не рекомендуется принудительно изменять длину строки, т.е. символ St[0], за исключением рассмотренной ситуации.

В рассмотренной ситуации принудительное установление длины строки необходимо, так как сама процедура FillChar не устанавливает заданную длину. При работе с указанной процедурой всегда есть риск «выйти» за пределы, отводимые заданной строке, и заполнить символом рабочую область памяти. Так как компилятор эту ситуацию не контролирует, то вся ответственность ложится на программиста.

4.2. Операции над символами.

Символы можно лишь присваивать друг другу и сравнивать между собой. Сравнение осуществляется на уровне ASCII-кодов (так как в памяти по существу хранятся не сами символы, а их кодовое обозначение). Символы равны, если равны их ASCII-коды, один символ больше другого, если его код имеет большее значение

1). Присваивание.

<Переменная> := <Значение>; a := ‘a’;

2). Сравнение (проводится традиционным способом по правилам лексико-графического упорядочивания (как в словаре)).

>, <, <>, =, >=, <=

‘а’ > ‘A’ – True {код 97 > кода 65}

‘a’ <> ‘A’ – True { код 97 <> коду 65}

3). Прочие.

Внимание !!! Следующие значения функций не определены:

PRED(#0); SUCC(#255);

4.3. Операции над строками.

Строки можно присваивать, сливать и сравнивать.

1). Ввод/Вывод строк осуществляется с помощью стандартных операторов ввода/вывода:

ReadLn(S); { ввод строки (максимальное число введенных символов 128 – определяется буфером клавиатуры (128 байт)) }

Write(S); { вывод строки (курсор остается в текущем положении) }

WriteLn(S); { вывод строки (курсор переводится в начало следующей стоки) }

Сравнение строк происходит посимвольно, начиная с первого символа в строке. Строки равны, если они равны по длине и посимвольно эквивалентны:

2). Присваивание строки.

S1 := S2;

a := ‘a’;

Empty := ‘’;

3). Сравнение строк ( если при посимвольном сравнении окажется, что один символ (его код) больше другого, то строка, его содержащая, тоже окажется большей, остаток строк при этом будет игнорироваться и длины строк уже не играют роли)

‘abcd’ = ‘abcd’ { True }

‘abcd’ = ‘ABCD’ { False, так как #65 <> #97 ‘a’ <>’A’ }

‘ abcd’ < ‘abcd’ { True, так как #32 < #65 = ‘a’ }

‘Яковлев’ > ‘Я’ { True, так как длина первой строки больше }

‘ ' <> ‘’ { True, так как #32 > ‘’ }

‘__’ = ‘_’ { False, так как длина первой строки больше }

‘__’ > ‘_’ { True, так как длина первой строки больше }

‘’ = ‘’ { True, так как обе строки пусты}

4.4. Процедуры и функции обработки строк.

4.5. Базовые алгоритмы обработки строк.

Описательная часть: Var St : String;