BEGIN

clrScr;

Write('Введите кол-во элементов массива>');{Вывод запроса на ввод.}

Readln(n); {Ввод кол-ва элементов.}

Randomize; {Процедура генерации разных чисел.}

For i:=1 To n Do {Цикл для формирования элементов массива.}

Begin {Начало цикла формирования массива.}

a[i]:=Random(65535)-32767; {Генерация случайных чисел из диапазона}

{-32768..32767.}

Write('a[',i:2,']=',a[i]:8,' '); {Контрольный вывод I-го эл.}

End;

B:=A; {Сохраняем исходный массив для вывода.}

For j:=1 To n-1 Do {Внешний цикл сортировки на 1 меньше, чем кол-во эл.}

For i:=1 To n-j Do {Внутренний цикл с ограничением (зависит от J).}

If a[i]>a[i+1] Then {Сравнение двух рядом стоящих эл.}

Begin a[i]:=a[i]+a[i+1]; {Сохраняем результат сложения в I-ом.}

a[i+1]:=a[i]-a[i+1]; {Вместо (I+1)-го запишем разность I-го и (I+1)-го.}

a[i]:=a[i]-a[i+1]; {Вернем I-му разность I-го и (I+1)-го.}

End;

ClrScr; {Чистим экран перед выводом}

GoToXY(10,2);Write('Исходный массив'); {Выводим}

GoToXY(35,2);Write('После сортировки');{заголовки.}

y:=4; {Задаем позицию первого вывода.}

For i:=1 To n Do {Цикл для вывода.}

Begin

GoToXY(10,y); {Установили курсор для вывода исходного.}

Write('a[',i:2,']=',b[i]:8,' ');{Вывод исходного .}

GoToXY(35,y); {Установили курсор для вывода результирующего.}

Write('a[',i:2,']=',a[i]:8,' ');{Вывод результирующего.}

y:=y+1; {Переопределили позицию расположения следующего вывода.}

If (y Mod 24)=0 Then Begin {Если остаток от деления =0,}

Readkey; {задержали выдачу на экране,}

y:=4; {установили курсор для первого вывода}

End; {следующей страницы.}

End;

For i:=y To 25 Do {Цикл чистки экрана от позиции последнего вывода}

Begin {до конца страницы (25 строк).}

GoToXY(1,i); {Установили курсор и вывели}

Write(' ');{пустую}

End; {строку.}

Readkey; {Задержка вывода.}

END.

Задача №12 Уплотнить массив путем изъятия нулевых элементов из массива, не используя сортировку.

Алгоритм решения.

Для решения этой задачи нужно каждый нулевой элемент массива затереть,

поднимая «на ступеньку» выше все элементы, расположенные ниже нулевого.

0 3

0 4

3 5

0 0

4 0

5 0

Необходимо предусмотреть в программе ограничение цикла, в котором будем искать нулевые элементы, что бы избежать проверки нулей, которые мы сами допишем вниз массива;

Uses Crt;

Const

k=50; {Количество элементов массива.}

Type

mas=Array[1..k] Of Integer; {MAS - тип массива из 50 элементов целого}

{типа.}

Var

A,B :mas; {А,B - массивы.}

i,j,n,l:Byte; {I,J - параметры циклов;

N - количество элементов массива;

L - счетчик нулей в массиве.}

BEGIN

ClrScr; {Чистим экран.}

Write('введите кол-во элементов массива>'); {Выводим запрос на ввод.}

Readln(n); {Вводим количество элементов массива.}

For i:=1 To n Do {Организовываем цикл ввода элементов массива.}

Begin {Начало цикла формирования массива.}

Write('Введите ',I:2,'элемент>');{Выводим запрос на ввод элемента массива.}

Readln(a[i]); {Вводим элемент массива.}

End; {Конец цикла ввода.}

B:=A; {Запоминаем исходный массив для вывода в два столбика.}

L:=1; {Индекс элемента массива (нулевого).}

For i:=1 To n-L Do {Организовываем цикл по элементам массива с}

{учетом того, что бы не проверять нули, дописанные нами же в конец массива.}

If a[L]=0 Then Begin {Если L-ый элемент - нулевой,}

For j:=l To n-1 Do {в цикле "поднимаем" все нижестоящие элементы,}

a[j]:=a[j+1]; {записывая на предыдущий - следующий.}

a[n]:=0; {Вниз дописываем ноль.}

End

Else Inc(L);{Переходим на следующий элемент массива.}

ClrScr; {Чистим экран.}

For i:=1 To n Do {Организовываем цикл по элементам массива для вывода.}

Begin

GoToXY(5,3+i);{Устанавливаем курсор для вывода исходного элемента

Write(B[i]); { массива и выводим исходный элемент массива.}

GoToXY(45,3+i); {Устанавливаем курсор для результирующего элемента

Write(A[i]); { массива и выводим результирующий элемент массива.}

End;

Readkey;

END.

Задача №13 Разработать программу умножения двух матриц. Матрица в Паскале - это двумерный массив. Ввод элементов матрицы и вывод результирующей матрицы предусмотреть по строкам следующим образом:

A[1,1]= A[1,2]= A[1,3]=

A[2,1]= A[2,2]= A[2,3]= и т.д.

Алгоритм решения.

Решение этой задачи можно условно разделить на 4 части:

1). Ввод порядка матриц А и В.

2). Проверка сцеплены ли они и, если да, то формирование матриц А и В.

3). Умножение матриц А*В и получение результирующей матрицы С.

4). Вывод результирующей матрицы С.

Справка:

1). При вводе порядка матриц необходимо помнить, что умножить можно только "сцепленные" матрицы. "Сцепленные" матрицы - это те, у которых кол-во столбцов А равняется кол-ву строк В. Если А(2 х 4), то В(4 х 1), В(4 х 2),В(4 х 3)...

|_______|

2). Результирующая матрица С будет иметь:

- кол-во строк равное кол-ву строк А;

- кол-во столбцов равное кол-ву столбцов В.

С(2 х 1) или С(2 х 2) или С(2 х 3) и т. д. в зависимости от исходных матриц.

3). Каждый элемент результирующей матрицы - это сумма произведений соответствующих элементов строки и столбца. Если нужно получить С[1,1],то необходимовзять первую строку матрицы А и первый столбец матрицы В.

С[1,1]=A[1,1]*B[1,1]+A[1,2]*B[2,1]+A[1,3]*B[3,1]...

Первый индекс матрицы С говорит о том, какую взять строку из матрицы А для умножения, а второй индекс говорит, какой нужно взять столбец матрицы В.

Для C[1,2] - первую строку матрицы А, второй столбец матрицы В

C[1,3] - первую строку матрицы А, третий столбец матрицы В

...

C[2,3] - вторую строку матрицы А, третий столбец матрицы В.

4). Пример для работы с матрицами пятого порядка. При необходимости работы с матрицами большего порядка нужно подкорректировать ввод и вывод с учетом размера экрана (25 строк на 80 позиций в строке). }

Uses Crt;

Const k1=5; {Максимальный порядок матрицы.}

Type

mas= Array[1..k1,1..k1] of Real; {mas - тип двумерного массива.}

Var

A,B,C:mas; {А,В - исходные массивы; С - результирующий массив.}

I,J,L:Byte; {I,J,L - параметры циклов.}

N_A,M_A:Byte; {N_A,M_A - кол-во строк и столбцов матрицы А.}

N_B,M_b:Byte; {N_B,M_В - кол-во строк и столбцов матрицы В.}

X:Byte; {Х - координата установки курсора.}

BEGIN

rScr; {Чистим экран.}

{--------------1 часть - Ввод порядка матриц А и В-------------------------}

Write('Введите кол-во строк и столбцов матрицы А<N_A,M_A>'); Readln(N_A,M_A); {Вводим кол-во строк и столбцов матрицы А.}

Write('Введите кол-во строк и столбцов матрицы В<N_B,M_B>'); Readln(N_B,M_B); {Вводим кол-во строк и столбцов матрицы B}

{--------------2 часть - Проверка сцеплены ли матрицы-------------------}

IF M_A<>N_B Then Writeln('Кол-во столбцов А не равно кол-ву строк В')

Else Begin {Если матрицы "сцеплены" - формируем их}

For I:=1 To N_A Do {Формирование по строкам матрицы А.}

Begin {Начало цикла по строкам A.}

x:=2; {Задаем "исходную" координату Х для установки курсора.}

For J:=1 to M_A Do{Организуем цикл по столбцам матрицы А.}

Begin {Начало цикла по столбцам А.}

GoToXY(x,i+4); {Устанавливаем курсор.}

Write('A[',i:2,',',j:2,']=');{Выводим подсказку на ввод.}

Readln(A[i,j]); {Вводим [i,j] элемент массива A.}

x:=x+15; {Изменяем позицию курсора по Х.}

Write(' '); {Выводим пробел для разделения элементов друг от друга.}

End; {Конец цикла по столбцам A.}

End; {Конец цикла по строкам A.}

{Формирование матрицы В.}

For I:=1 To N_B Do {Организуем цикл по строкам матрицы В.}

Begin {Начало цикла по строкам B.}

x:=2; {Задаем "исходную" координату Х для установки курсора.}

For J:=1 to M_B Do {Организуем цикл по столбцам матрицы В.}

Begin {Начало цикла по столбцам B.}

GoToXY(x,i+10); {Устанавливаем курсор.}

Write('B[',i:2,',',j:2,']=');{Выводим подсказку на ввод.}

Readln(B[i,j]); {Вводим [i,j] элемент массива B.}

x:=x+15; {Изменяем позицию курсора по Х.}

Write(' '); {Выводим пробел для разделения элементов друг от друга.}

End; {Конец цикла по столбцам B.}

End; {Конец цикла по строкам B.}

{-------------3 часть - умножение матриц А и В-----------------------------}

For I:=1 To N_A Do {Организуем цикл по строкам матрицы А.}

For J:=1 to M_B Do {Организуем цикл по столбцам матрицы В.}

Begin {Начало циклов для формирования матрицы С.}

c[i,j]:=0; {Обнуляем каждый [i,j] элемент массива С.}

For L:=1 To N_B Do {Цикл подсчета суммы произведений соотв. элемен.}

C[i,j]:=c[i,j]+a[i,L]*B[L,j];{Находим элемент результирующей матрицы С.}

End; {Конец цикла по столбцам матрицы В.}

{-------------4 часть - вывод результирующей матрицы С---------------}

For I:=1 To N_A Do {Организуем цикл по строкам матрицы А.}

Begin {Начало цикла по строкам матрицы А.}

x:=2; {Задаем "исходную" координату Х для установки курсора.}

For J:=1 to M_B Do {Организуем цикл по столбцам матрицы В.}

Begin {Начало цикла по столбцам матрицы В.}

GoToXY(x,i+17); {Устанавливаем курсор.}

Write('C[',i:2,',',j:2,']=',C[i,j]:5:2,' ');{Выводим (i,j) элемент рез. матрицы.}

x:=x+15; {Изменяем позицию курсора по Х.}

End; {Конец цикла по столбцам.}

End; {Конец цикла по строкам.}

End; {Конец ELSE (если матрицы сцеплены).}

Readkey; {Задержка вывода на экране}

END. {Конец программы}

Задача №14 Рассмотрим решение задачи умножения массивов с использованием процедур.

Использование процедур позволит сделать программу более "элегантной" и удобной.

Справка:

1). Описание процедуры состоит из:

Procedure Input_Mas( Var N,M:Byte;Var A:mas;K:Byte);

служ. слова имени формальных параметров

2). Располагаются описания процедур в области описаний.

3). Формальные параметры, если таковые есть, делятся на:

- входные (те, которые передаем в процедуру);

- выходные (те, которые получаем в процедуре, а используем вне).

4). Формальные параметры бывают:

- параметры-переменные (выходные всегда Var);

- параметры-значения (когда вместо формального параметра при обращении ставятся конкретные значения).

5). Обращаются к процедуре по имени в главной программе, заменяя формальные параметры фактическими Input_Mas(N_A,M_A,A,4);

6). Фактические и формальные параметры должны строго соответствовать по:

- количеству;

- типу;

- месту расположения.

7). При использовании процедур, фрагмент формирования матриц будет один и описан в процедуре, к которой будем обращаться дважды.

8). Кроме того используем процедуру ввода размерности массивов.

Uses Crt;

Const k1=5; {Размерность массива.}

Type

mas= Array[1..k1,1..k1] of Real; {mas - тип массива размером 5*5.}

Var

A,B,C:mas; {А,В,С - массивы.}

N_A,M_A:Byte; {Размерность массива А.}

N_B,M_B:Byte; {Размерность массива В.}

{---------Процедура формирования массива------------------------}

Procedure Input_Mas( Var N,M:Byte;Var A:mas;K:Byte);

{ N,M,A,K - формальные параметры процедуры:

N - кол-во строк;

M - кол-во столбцов;

A - массив;

K - смещение для координаты Y.

N,M,A - выходные параметры (обязательно Var), K - входной параметр-значение }

Var {Локальное описание процедуры:}

i,j,x:Byte; {I,J - параметры цикла;}

{X - координата для установки курсора.}

Begin {Начало процедуры.}

For I:=1 To N Do {Организовываем цикл по строкам массива.}

Begin {Начало цикла по строкам.}

x:=2; {Устанавливаем начальное значение Х для курсора.}

For J:=1 to M Do {Организовываем цикл по столбцам массива.}

Begin {Начало цикла по столбцам.}

GoToXY(x,i+k); {Устанавливаем курсор.}

Write('A[',i:2,',',j:2,']=');{Выводим запрос на ввод.}

Read(A[i,j]); {Вводим элемент массива.}

x:=x+15; {Изменяем значение Х.}

Write(' ');{Выводим пробел для разделения элементов массива на экране.}

End; {Конец цикла по столбцам.}

End; {Конец цикла по строкам.}

End; {------------------Конец процедуры Input_Mas---------------------------}

{Процедура умножения массивов.}

Procedure Mult_mas(N,M,O:Byte;A,B:mas;Var C:mas);

{ N,M,О,A,В,С - формальные параметры процедуры:

N - кол-во строк массива С;

M - кол-во столбцов массива С;

О - кол-во столбцов А или кол-во строк В;

A,В - массивы-сомножители, С - результирующий массив.

N,M,О,A,В - входные параметры, С - выходной (обязательно Var). }

Var

i,j,l:Byte; {Параметры циклов.}

Begin {Начало процедуры.}

{Два внешних цикла строим по индексам результирующего массива.}

For I:=1 To N Do {Цикл по строкам результирующего массива.}

For J:=1 to M Do {Цикл по столбцам результирующего массива.}

Begin {Начало цикла по столбцам.}

c[i,j]:=0; {Обнуляем элементы результирующего массива.}

For L:=1 To O Do {Цикл для нахождения суммы произведений соответствующих элементов двух матриц - А и В.}

C[i,j]:=c[i,j]+a[i,L]*B[L,j];{Находим элемент результирующей матрицы.}

End; {Конец циклов.}

End; {------------Конец процедуры Mult_mas----------------------------------}

Procedure Write_mas(N,M:Byte;A:mas;K:Byte); {Процедура вывода массива.}

{ N,M,A,K - формальные параметры процедуры:

N - кол-во строк,

M - кол-во столбцов,

A - массив, K - смещение для координаты Y.

Все параметры N,M,A,К - входные параметры. }

Var

i,j,x:Byte; {I,J - парметры цикла;}

{Х - координата установки курсора.}

Begin {Начало процедуры.}

For I:=1 To N_A Do {Цикл по строкам.}

Begin {Начало цикла по строкам.}

x:=2; {Задаем начальное значение Х для установки курсора.}

For J:=1 to M_B Do {Цикл по столбцам массива.}

Begin {Начало цикла по столбцам.}

GoToXY(x,i+k); {Устанавливаем курсор.}

Write('C[',i:2,',',j:2,']=',C[i,j]:5:2,' ');{Выводим эл. массива.}

x:=x+15; {Изменяем координату Х для установки курсора.}

End; {Конец цикла по столбцам.}

End; {Конец цикла по строкам.}

End; {---------------------Конец процедуры Write_mas---------------------}

{Процедура для ограничения ввода размерности массива.}

Procedure Input_Size(Var n,m:Byte; st:String);

Begin

ClrScr; {Чистим экран.}

Write(st);

{Организовываем цикл для ограничения ввода размерности массива.}

Repeat {В цикле:}

Write('<N,M>'); {выводим запрос на ввод,}

Readln(N,M); {вводим размерность массива,}

Until (N<=k1) and (M<=k1);{пока не введем допустимую размерность

(1..k1).}

End; {---------------------Конец процедуры Input_Size---------------------}

BEGIN {MAIN}

Input_Size(N_A,M_A,'размерность массива А');{обращаемся к пр. ввода размерности массива А.}

Input_Size(N_B,M_B,'размерность массива B');{обращаемся к пр. ввода размерности массива B.}

IF M_A<>N_B Then {Если матрицы не сцеплены,}

Writeln('матрицы не сцеплены'){выводим сообщение.}

Else Begin {Если матрицы сцеплены,выполним следующее:}

Input_Mas(N_A,M_A,A,4); {обращаемся к пр. ввода массива А,}

Input_Mas(N_B,M_B,B,N_A+6); {обращаемся к пр. ввода массива B,}

Mult_mas(N_A,M_B,N_B,A,B,C); {обращаемся к пр. умножения ,}

Write_mas(N_A,M_B,C,N_B+N_A+8);{обращаемся к процедуре вывода массива С.}

End; {Конец (Else) условия.}

Readkey; {Задержка выдачи на экране.}

END. {конец программы}

Задача №15 Найти определитель кадратной матрицы. Ввод исходной матрицы и вывод треугольной матрицы организовать в естественном для матрицы - по строкам. Диагональные элементы треугольной матрицы выделить другим цветом.

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

Этот способ не универсальный, т. к. даст сбой, если встретит 0 на диагонали.

Для тестирования программы взять:

1 2 4 0 2 4

А 2 2 2 результат -6 А 2 2 2 выдаст ошибку: деление на 0

4 2 1 4 2 1

Решение этой задачи можно разделить на 4 части:

1). Ввод исходных данных (порядка матрицы и элементов матрицы);

2). Приведение матрицы к треугольному виду;

3). Нахождение определителя;

4). Вывод результата (треугольной матрицы и самого определителя.

Справка:

1). Т.К. матрица должна быть квадратной, вводить нужно порядок матрицы, а не кол-во строк, кол-во столбцов, что позволит избежать лишней проверки.

2). Для ввода матрицы по строкам нужно организовать 2 цикла:

- внешний (по строкам);

- внутренний (по столбцам).

Т.к. внутренний цикл "крутится" быстрее, будут вводиться все элементы первой строки, а затем произойдет переход на следующий шаг внешнего цикла и будут вводиться элементы второй строки и т.д.

3). Для установки курсора на экране в позицию ввода или вывода использовать процедуру GoToXY(x,y), параметрами которой являются координаты экрана (25 строк - Y и 80 столбцов - X)

4). Привести матрицу к треугольной - это значит преобразовать ее так, чтобы ниже главной диагонали стояли 0:

А[1,1] A[1,2] A[1,3] A[1,1] A[1,2] A[1,3]

из A[2,1] A[2,2] A[2,3] в 0 A[2,2] A[2,3]

A[3,1' A[3,2] A[3,3] 0 0 A[3,3]

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

Так как под диагональными элементами кроме последнего должны быть 0,

нужно:

ѕ 3 цикла:

- внешний цикл - по диагональным элементам;

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

- 2-ой внутренний по элементам строки, которую нужно преобразовать.

ѕ найти коэффициент, разделив элемент массива, стоящий под диагональным элементом, на диагональный (K:=A[2,1]/А[1,1];).

ѕ затем преобразовать всю строку под диагональным путем вычитания из элемента этой строки произведения коэффициента на соответствующий элемент из строки с диагональным элементом (a[j,L]:=a[j,L]-a[i,L]*k;).

Uses Crt;

Const k1=5; {Порядок матрицы (размерность массива).}

Type

mas= Array[1..k1,1..k1] of Real; {Тип массива вещественный, размером 5*5.}

Var

A:mas; {Рабочий массив.}

k,opr:Real; {К - коэффициент; opr - определитель.}

I,J,L:Byte; {Параметры циклов.}

N:Byte; {Размерность массива.}

BEGIN

ClrScr; {Чистим экран.}

{1 часть - формирование квадратной матрицы.}

Write('Введите порядок матрицы <1..',k1,'>'); {Выводим запрос на ввод.}

Readln(N); {Вводим (порядок матрицы) размерность массива.}

For I:=1 To N Do {Организовываем цикл по строкам.}

For J:=1 to N Do {Организовываем цикл по столбцам.}

Begin {Начало цикла по столбцам.}

GoToXY(j*15,i+1); {Устанавливаем курсор на экране.}

Write('A[',i:2,',',j:2,']=');{Выводим запрос "шапку" для ввода.}

ReadLN(A[i,j]); {Вводим элемент массива строки.}

Write(' '); {Выводим пробел для разделения эл. массива на экране.}

End; {Конец цикла по столбцам - переходим на внешний цикл.}

{2 часть - приведение матрицы к треугольному виду.}

For I:=1 To N-1 Do {Цикл по диагональным элементам.}

For J:=i+1 to N Do {Цикл по строкам, начиная со строки под диаг. эл.}

Begin {Начало цикла по строкам.}

k:=a[j,i]/a[i,i]; {Находим коэффициент.}

For L:=i To N Do {Ццикл по строке, которую преобразовываем.}

a[j,L]:=a[j,L]-a[i,L]*k;{Преобраз. Эл. строки под диаг. элементом.}

End; {Конец цикла по строкам - переходим на новую строку.}

{3 часть - нахождение определителя (произв. диагональных элементов).}

opr:=a[1,1]; {Заносим первый диагональный элемент.}

For I:=2 To N Do {В цикле по диагональным элементам}

opr:=opr*a[i,i]; {находим произведение диагональных элементов.}

Writeln; {Пропускам строку на экране.}

For I:=1 To N Do {Организовываем цикл по строкам.}

For J:=1 to N Do {Организовываем цикл по столбцам.}

Begin {Начало цикла по столбцам.}

If (i=j) Then TextColor(4) {Устанавливаем цвет для диаг. эл. массива.}

Else TextColor(7);{Цвет для всех остальных эл. масс.}

GoToXY(j*15,i+5); {Устанавливаем курсор на экране для вывода.}

Write('A[',i:2,',',j:2,']=',a[i,j]:5:2,' ');{Поэлементно выводим.}

End; {Конец цикла по столбцам - переходим на новую строку.}

Writeln; Writeln; {Пропускаем строки на экране.}

TextColor(7); {Устанавливаем цвет для вывода определителя.}

Writeln('2Определитель=',opr:6:3);{Выводим определитель.}

Readkey; {Задержка вывода на экране.}

END. {Конец программы.}

Задача №16 Найти определитель квадратной матрицы, используя выбор "главного элемента".

Этот метод можно использовать для любых матриц.

Справка:

1). Под выбором "главного элемента" подразумевается исключение деления на 0

при нахождении коэффициента.

Для этого нужно проверить диагональный элемент и, если он равен 0:

- найти максимальный элемент в столбце с диагональным элементом;

- зафиксировать строку, в которой этот максимальный;

- поменять местами строки (строку с диагональным элементом и строку с максимальным).

2). Т.к. нахождение максимального элемента рассмотрено в предыдущих задачах, останавливаться на этом не будем. Напомним только, что для перестановки элементов строк нужно:

- вначале сохранить элемент в каком-либо "буфере";

- записать в него элемент из другой строки;

- в элемент другой строки вернуть из буфера. См. программу сортировки.

3). Комментарии в программе приводятся только в месте выбора главного элемента.

Uses Crt;

Const k1=5;

Type

mas= Array[1..k1,1..k1] of Real;

Var

A:mas;

k,opr:Real;

max,Buf:Real; {max - для нахождения максимального элемента столбца;}

{Buf - для хранения значения эл. при перестановке строк.}

I,J,L:Byte;

N:Byte;

X:Byte;

BEGIN

ClrScr;

{Ввод исходных данных.}

Write('Введите порядок матрицы<1..',k1,'>');

Readln(N);

X:=1;

For I:=1 To N Do

Begin

For J:=1 to N Do

Begin

GoToXY(x,i+1); Write('A[',i:2,',',j:2,']='); Read(A[i,j]);

inc(x,15);

Write(' ');

End;

x:=1;

End;

{Преобразов. матрицы к верхней треугольной с выбором "главного" элем.}

For I:=1 To N-1 Do {Организовываем цикл по диагональным элементам.} Begin

If a[i,i]=0 Then {Если диагональный элемент равен 0:}

Begin

max:=a[i,i]; {в МАХ заносим диагональный,}

L:=i; {запоминаем строку,}

For j:=i+1 To N Do {организовываем цикл по столбцу с}

{диагональным элементом,}

If abs(a[j,i])>max Then {находим максимальный элемент в столбце,}

Begin

max:=abs(a[j,i]); {запоминаем в МАХ,}

L:=j; {в L запоминаем номер строки с максимальным элементом.}

End; {Конец условия.}

For j:= 1 To N Do {Организовываем цикл для перестановки строк}

Begin {(строки с диагональным и строки с максимальным).}

Buf:=a[i,j]; {Запоминаем эл. строки с диагон.}

a[i,j]:=a[L,j]; {На диаг. эл. пишем эл. из строки с МАХ.}

a[L,j]:=Buf; {Возвращаем диаг. в строку с МАХ.}

End; {Конец цикла перестановки эл. строк.}

End; {Конец условного оператора (если диагон. Равен 0).}

For J:=i+1 to N Do {Организовываем цикл по строкам под диаг. эл.}

Begin {Начало цикла по строкам под диаг. эл.}

k:=a[j,i]/a[i,i]; {Находим коэффициент.}

For L:=i To N Do {Организовываем цикл по эл. строки.}

a[j,L]:=a[j,L]-a[i,L]*k;{Преобразовываем строки под диагональным элементом.}

End; {Конец цикла по строкам.}

End; {конец цикла по диагональным элементам}

{Нахождение определителя.}

opr:=a[1,1];

For I:=2 To N Do

opr:=opr*a[i,i];

{Организация вывода треугольной матрицы и определителя.}

Writeln;

For I:=1 To N Do

Begin

For J:=1 to N Do

Begin

If (i=j) Then TextColor(4)

Else TextColor(7);

Write('A[',i:2,',',j:2,']=',a[i,j]:6:3,' ');

End;

Writeln;

End;

Writeln;

TextColor(7);

Writeln('ОПРЕДЕЛИТЕЛЬ МАТРИЦЫ -',opr:6:3);

Readkey;

END.

3. СТРОКИ

3.1Теоретические сведения

Один из разновидностей одномерного массива - массив символов, или строка, занимает особое место во многих языках программирования. И это не случайно, ведь алгоритмы преобразования строк применяются для решения широкого круга задач: для редактирования и перевода текстов, алгебраических преобразований формул, в информационно-поисковых системах, электронных словарях и т. д.

В языке Paskal со всех зарезервированных типов массивов только для строк был зарезервирован стандартный структурированный тип данных -String, а так же разработана мощная библиотека процедур и функций обработки данных строкового типа.

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

Но для строки различают понятия общей и текущей длины:

ѕ общая длина строки определяется объемом оперативной памяти, которая была отведена строке во время ее оглашения;

ѕ текущая длина строки определяется количеством символов в ней в конкретный момент выполнения программы и никогда не превышает общей длины.

Способ определения текущей длины строки зависит от способа оглашения строковой переменной. В языке Paskal есть 2 способа оглашения переменной - строки:

ѕ оглашение переменной специального структурированного типа String (Var st: String[15];);

ѕ оглашение переменной типа символьного массива (Var Mas_St: array[1..15] Of char;).

В первом случае текущая длина строки сохраняется в элементе с нулевым индексом st[0]. В этот элемент записывается символ, код которого равняется значению длины.

Например:

Пусть строка описана, как: Var st: String[15];

После ввода с клавиатуры или присвоения St:='TURBO PASCAL';, ее:

Текущая длина 12 храниться в st[0], как символ +

+	T	U	R	B	O		P	A	S	C	A	L
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15

Общая длина 16 байт.

При выводе строки мы не видим этот символ, но в программе можно прочитать или изменить его значение. Но не следует забывать, что это символ, а не число, и поэтому для получения числового значения следует использовать встроенную функцию ORD(<символ>).

Во втором случае текущая длина фиксируется специальным символом, расположенным после последнего информационного символа строки. Этот символ называется символом конца строки или ноль - символом, его ASCII - код равняется нулю.

Например.

При описании через массив символов

Var

Mas_St: array[1..15] Of char;

Текущая длина 12 фиксируется



T	U	R	B	O		P	A	S	C	A	L	0
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15

Общая длина 15 байт.

Подпрограммы обработки строк:

1) Функция Length(S: String); - определяет динамическую длину строки S.

Зачастую эту функцию используют в цикле For i:= 1 to Length(S) do {…}

2) Функция Concat(S1 ,S2,… : String): String; - объединение (конкатенация) последовательности строк S1 ,S2,…

S1:='ХАИ'; S2:=' - это здорово!';

После выполнения: S:=Concat(S1,S2); или S:=S1+S2;

Результат: S='ХАИ - это здорово!'.

3) Функция Pos (SubStr, S: String):Byte; - поиск подстроки SubStr в строке S.

Пусть имеем строку: S:='ХАИ - это здорово!';

После выполнения оператора I:= Pos(` `, S);

Результат: I = 4 (первый найденный пробел в строке).

Зачастую эту функцию используют в цикле While (Pos(' ',S)<>0) do {…}

4) Функция Copy (Source: String; Pos, Count: Integer): string; - копирует из строки Source, начиная из позиции Pos число копируемых символов Count.

Пусть Source:= 'ХАИ - это здорово!';

После выполнения оператора S:= Copy (Source, 1, 3);

Результат: S ='ХАИ '.

5) Процедура Delete(Var Source: String; Pos, Count: Integer); - удаляет из строки Source, начиная из позиции Pos число удаляемых символов Count.

Пусть Source:= 'ХАИ - это здорово!',

После выполнения оператора Delete(Source,1,3);

Результат: Source=' - это здорово!'.

6) Процедура Insert(Source:String; Var S: String; Pos: Integer); - вставляет подстроку Source в позицию Pos строки S.

Пусть S:= 'ХАИ - это здорово!';

После выполнения оператора Insert( ' ', S, 1);

Результат: S= ' ХАИ - это здорово!';

7) Процедура Str(X :<целый или вещественный тип>; Var S: string); - преобразует численное значение X в строку S.

Пусть X:=125;

После выполнения оператора Str(X ,S);

Результат: S='125';

Процедура Val (S: String; Var X:<целый или вещественный тип>; Var ErrorCode: Integer); преобразует строку S в число X. ErrorCode - код ошибки. Возвращает позицию, где встретился в строке недопустимый символ.

3.2. Задачи.

Задача № 1. Изменить число типа Integer, поменяв местами первую и последнюю цифры числа.

Первый способ.

Алгоритм:

ѕ ввести число;

ѕ введенное число преобразовать в строку,

ѕ проанализировать первый символ строки, т.к. число может быть

отрицательным;

ѕ в зависимости от наличия знака поменять местами первый и последний символы строки или второй и последний символы строки;

- преобразовать строку в число;

- вывести результат.

Справка:

1). Для перевода числа в строку использовать процедуру STR( , ), которая имеет 2 параметра:

- что переводим (в нашем случае A - введенное число);

- во что переводим (в нашем случае в ST - строку);

2). Для перевода строки в число использовать процедуру VAL( , , ), которая имеет 3 параметра:

- что переводим (в нашем случае ST - строку);

- во что переводим (в нашем случае в A - число);

- третим параметром является переменная типа Integer, куда

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

Например: VAL('123',a,code); (число - 123; code - 0)

VAL('1a23',a,code);(code - 2, т.к.2 символ недопустим)

Uses Crt;

Var

a:Integer; {a - вводимое число.}

st:String; {st - для перевода числа в строку.}

ch:Char; {ch - как буфер для временного хранения знака "минус".}

code:Integer; {code - параметр процедуры VAL.}

BEGIN

ClrScr; {Чистим экран.}

Write('Введите число >'); {Выводим запрос на ввод числа.}

Readln(a); {Вводим число.}

Str(a,st); {Преобразуем число в строку.}

If st[1]='-' Then {Если первый символ строки "-"}

Begin

ch:=st[2]; {Запомним второй символ.}

st[2]:=st[Length(st)]; {Вместо второго запишем последний.}

st[Length(st)]:=ch; {В последний вернем второй.}

End Else {Если первый символ строки не "-"}

Begin

ch:=st[1]; {Запомним первый символ.}

st[1]:=st[Length(st)]; {Вместо первого запишем последний.}

st[Length(st)]:=ch; {В последний вернем первый.}

End;

VAL(st,a,code); {Преобразуем строку в число.}

Writeln(a); {Выводим результат.}

Readkey; {Задержка результата на экране.}

END.

Второй способ.

Решим задачу другим способом. После преобразования числа в строку, анализируя первый символ строки на знак, устанавливаем признак наличи знака "минус" в TRUE. Удаляем знак из строки и меняем местами первый и последний символы (без всяких проверок). Анализируем признак и, если о TRUE, вставляем знак "-" в строку, преобразовываем строку в число.

Алгоритм:

- ввести число;

- преобразовать число в строку;

- проанализировать первый символ строки, т.к. число может быть

отрицательным;

- избавиться от знака минус в строке;

- поменять местами первый и последний символы строки;

- добавить знак, если он был;

- преобразовать строку в число и вывести результат.

Справка:

1). Для перевода числа в строку использовать процедуру STR( , ), которая имеет 2 параметра:

- что переводим (в нашем случае A - введенное число);

- во что переводим (в нашем случае в ST - строку);

2). Для перевода строки в число использовать процедуру VAL( , , ), которая имеет 3 параметра:

- что переводим (в нашем случае ST - строку);

- во что переводим (в нашем случае в A - число);

- третьим параметром является переменная типа Integer, куда

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

Например:

VAL('123',a,code); (число - 123; code - 0)

VAL('1a23',a,code);(code - 2, т.к. символ 'a' недопустим в числе).

3). Для удаления символа из строки использовать процедуру Delete( ,, ), которая имеет 3 параметра:

- откуда удаляем (в нашем случае из строки - ST);

- с какой позиции (в нашем случае из 1-ой);

- сколько символов (в нашем случае - 1).

4). Для вставки символа в строку использовать процедуру INSERT( , , ), которая имеет 3 параметра:

- что вставляем (в нашем случае - пробел);

- куда вставляем (в нашем случае - в строку);

- в какую позицию строки (в нашем случае - в 1-ую).

Uses Crt;

Var

a:Integer; {a - вводимое число.}

st:String; {st - для перевода числа в строку .}

ch:Char; {ch - как буфер для временного хранения знака "минус".}

code:Integer; {code - параметр процедуры VAL.}

n:Boolean; {n - для признака наличия знака "минус" в числе.}

BEGIN

ClrScr; {Чистим экран.}

Write('Введите число >'); {Выводим запрос на ввод числа.}

Readln(a); {Вводим число.}

N:=False; {Признак - знака "минус" в числе нет.}

Str(a,st); {Преобразовываем число в строку.}

If st[1]='-' Then Begin {Если в первый символ строки "-"}

n:=True; {Фиксируем это.}

Delete(st,1,1); {Удаляем знак из строки.}

End;

ch:=st[1]; {Запомним первый символ строки.}

st[1]:=st[Length(st)]; {Вместо первого запишем последний символ строки.}

st[Length(st)]:=ch; {Вместо последнего символа вернем первый.}

If n=True Then {Если знак был,}

INSERT('-',st,1); {вставим знак в начало строки.}

VAL(st,a,code); {Преобразуем строку в число.}

Writeln(a); {Выводим результат.}

Readkey; {Задержка результата на экране.}

END.

Задача №2. Разработать программу подсчета пробелов в строке.

Спрособ первый:

Алгоритм решения.

- ввести строку;

- организовать цикл по длине строки;

- используя условие, проверять символы строки на соответствие их пробелу и накапливать счетчик слов.

Справка:

1). Длину строки возвращает функция Length(st), параметром которой есть строка.

Uses Crt;

Var

st:String; {Строка для ввода.}

i:Byte; {Параметр цикла - позиция в строке.}

s:Byte; {Счетчик пробелов.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку'); {Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

For i:=1 to Length(st) do {Строим цикл до конца строки.}

If st[i]=' ' Then {Проверяем каждый символ строки}

{на соответствие его пробелу.}

s:=s+1; {Если условие выполняется, увеличиваем счетчик пробелов.}

Writeln('Кол-во пробелов - ',s); {Выводим результат.}

Readkey; {Пустой оператор ввода задержит выдачу на}

{экране до нажатия любой клавиши.}

END.

Второй способ.

Алгоритм решения:

ѕ ввести строку;

ѕ используя функцию поиска подстроки в строке организовать цикл,

который будет работать до тех пор, пока будут встречаться пробелы в

строке.

Справка:

1). Функция Pos(' ',st) - возвращает позицию вхождения подстроки в строку, в (противном случае результат - 0);

2). После того, как пробел найден, его нужно удалить из строки, используя стандартную процедуру Delete(st,i,1), параметрами которой являются:

- откуда удаляем (из строки);

- с какой позиции (с позиции, где встретился);

- сколько (один ).

Это нужно для того, что бы программа "не циклила", т.к. будет все время находить один и тот же пробел.

Uses Crt;

Var

st:String; {Строка для ввода.}

i:Byte; {Место расположения пробела в строке.}

s:Byte; {Счетчик пробелов.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку'); {Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

s:=0; {Обнуляем счетчик пробелов.}

While Pos(' ',st)<>0 do {Цикл работает, пока есть пробелы в строке.}

Begin

s:=s+1; {Если пробел есть, увеличиваем счетчик пробелов.}

i:=Pos(' ',st); {Находим место расположения пробела в строке.}

Delete(st,i,1); {Удаляем пробел из строки (с позиции, где найден).}

End;

Writeln('Кол-во пробелов-',s);{Выводим результат.}

Readkey;

END.

Задача №3. Разработать программу позволяющую удалить все пробелы в строке.

Алгоритм решения:

ѕ ввести строку;

ѕ организовать цикл по строке;

ѕ проверять строку на наличие пробелов в ней;

ѕ если пробел есть, удалять его.

Справка:

1). Необходимо использовать цикл "с предусловием", используя в условии функцию

Pos(,), которая имеет 2 параметра:

- что ищем (в данном случае - пробел);

- где ищем (в строке).

Результат работы функции:

- равен нулю, если искомого в строке нет;

- номеру позиции, если искомое есть.

2). Для удаления пробелов использовать процедуру Delete( , , ), которая

имеет 3 параметра:

- откуда удаляем (из строки);

- с какой позиции (позиции, в которой пробел);

- сколько (в данной ситуации по одному).

Uses Crt;

Var

st:String; {Строка для ввода.}

i:Byte; {Параметр цикла.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку');{Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

While Pos(' ',st)<>0 do {Организовываем цикл поиска пробелов в строке.}

Delete(st,Pos(' ',st),1);{Если пробел есть - удаляем его из строки}

{с позиции, где он найден.}

Writeln(st); {Выводим строку после удаления пробелов.}

Readkey; {Задержка результата до нажатия ENTER.}

END.

Задача №4 Разработать программу позволяющую удвоить пробелы в строке.

Алгоритм решения:

- ввести строку;

- организовать цикл по строке;

- используя, условный оператор, проверять каждый символ строки

на соответствие его пробелу и, если такой найден, вставлять

еще один и «перешагнуть» через вставленный.

Справка:

1). Необходимо использовать цикл с предусловием, т.к. позицию в строке необходимо будет менять с разным шагом.

2). Для вставки пробела в позицию, где уже один найден, использовать процедуру Insert( , , ), которая имеет 3 параметра:

- что вставляем (в данном случае - пробел);

- куда вставляем (в строку);

- в какую позицию (рядом с той, в которой найден пробел).

3). Чтобы избежать многократного дублирования пробелов и "зацикливания" программы, после вставки пробела в строку, "перешагните" через него, то есть, измените позицию в строке шагом 2.

Uses Crt;

Var

st:String; {Строка для ввода.}

i:Byte; {Позиция в строке.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку'); {Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

i:=1; {Строку "на пробел" исследуем с первого символа.}

While i<=Length(st) do {Организовываем цикл по строке.}

Begin

If st[i]=' ' Then {Если символ строки - пробел,}

Begin

Insert(' ',st,i); {вставляем еще один,}

Inc(i,2); {меняем позицию строки, "перешагнув" через вставленный пробел.}

End Else {Если символ строки - не пробел,}

Inc(i); {переходим на соседний символ строки.}

End;

Writeln(st); {Выводим строку после того, как удвоили пробелы.}

Readkey; {Задержка результата до нажатия ENTER.}

END.

Задача №5. Разработать программу подсчета слов в строке.

Способ первый.

Алгоритм решения:

ѕ ввести строку;

ѕ организовать цикл по длине строки;

ѕ используя условие, проверять два рядом стоящие символа строки (пробел - не пробел), т.к. слово зачастую идет сразу после пробела, за исключением первого слова строки (строка может начинаться с пробела, а может - прямо с буквы);

ѕ если один символ - пробел, а рядом стоящий - не пробел, то накапливать счетчик слов.

Справка:

1). Длину строки возвращает функция Length(st).

2). Обратить внимание, как задать исходное значение счетчика слов, т.к. строка может начинаться:

- с пробелов (счетчик -0);

- с символа (счетчик - 1).

Uses Crt;

Var

st:String; {Строка для ввода.}

i:Byte; {Параметр цикла.}

s:Byte; {Счетчик слов.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку'); {Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

If st[1]=' ' Then s:=0 {Если строка начинается с пробела (слова нет)}

{- счетчик устанавливаем в 0.}

Else s:=1; {Если строка начинается с символа (слово есть)}

{- счетчик устанавливаем в 1.}

For i:=1 to Length(st) do {Организовываем цикл "по строке".}

If (st[i]=' ') And (st[i+1]<>' ') {Проверяем I-ый символ строки на}

{соответствие его пробелу, а рядом}

{стоящий символ строки на соответствие символу.}

Then s:=s+1; {Если условие выполняется, увеличиваем счетчик слов.}

Writeln('Кол-во слов - ',s); {Выводим результат.}

Readkey;

END.

Второй способ.

Алгоритм решения:

ѕ ввести строку;

ѕ преобразовать строку к "удобному" для обработки виду "слово - пробел, слово - пробел";

ѕ организовать цикл, используя функцию поиска подстроки в строке и подсчитать кол-во слов.

Справка:

1). Функция поиска Pos(' ',st) имеет 2 параметра:

- что ищем (пробел);

- где ищем (в строке).

Результат работы этой функции:

- место расположения пробела, если таковой есть;

- ноль, если пробел не найден.

2). Обратить внимание на то, что если не удалить пробел из строки, то

программа будет "циклить".

3). Для того, что бы привести строку к "удобному" виду, нужно:

- оставить по одному пробелу в строке (избавиться от "лишних");

- если в начале строки остался пробел - удалить и его;

- если в конце строки пробела нет - добавить пробел.

Uses Crt;

Var

st:String; {Строка для ввода.}

i:Byte; {Параметр цикла.}

s:Byte; {Счетчик слов.}

BEGIN

ClrScr; {Чистим экран}

Writeln('Введите строку'); {Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

{Приводим строку к удобному виду " слово - пробел, слово - пробел"}

While Pos(' ',st)<>0 do {В цикле ищем 2 пробела в строке}

Delete(st,Pos(' ',st),1); {и по одному удаляем из строки (избавляемся}

{от "лишних").}

If st[1]=' ' then {Если первый символ строки пробел,}

Delete(st,1,1); {удаляем его из строки.}

If st[length(st)]<>' ' {Если в конце строки нет пробела,}

then st:=st+' '; {добавляем пробел.}

{Количество слов и количество пробелов после преобразований равно, а} {значит ищем пробелы}

s:=0; {Счетчик слов устанавливаем в 0.}

While Pos(' ',st)<>0 do {В цикле пока есть пробелы,}

Begin

s:=s+1; {считаем их}

Delete(st,Pos(' ',st),1);{и удаляем.}

End;

Writeln('Кол-во слов - ',s);{Выводим результат.}

Readkey; {Задержка результата до нажатия Enter.}

END.

Задача №6 В режиме диалога "Вопрос - ответ" ввести строку и ввести слово. Определить, сколько раз встречается искомое слово в строке.

Алгоритм решения.

- ввести строку;

- ввести слово, которое будем искать;

- подготовить счетчик слов;

- организовать цикл поиска , в котором:

- увеличивать счетчик слов, если слова найдены,

- удалять его из строки, иначе функция поиска будет возвращать

одну и ту же позицию, что приведет к "зацикливанию" программы;

- вывести результат.

Справка.

1). Лучше использовать цикл с предусловием While и функцию поиска подстроки в строке Pos( , ), которая имеет два параметра:

- что ищем (слово);

- где ищем (в строке).

2). Результат работы функции Pos( , ) есть позиция вхождения слова в строку. Если слово не найдено, результат - ноль.

Uses Crt;

Var

st:String; {Строка для ввода.}

sl:String; {Искомое слово.}

s:Byte; {Счетчик слов.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку'); {Выводим запрос на ввод строки.}

Readln(st); {Вводим строку.}

Writeln('Введите слово'); {Выводим запрос на ввод слова.}

Readln(sl); {Вводим слово.}

s:=0; {Счетчик слов устанавливаем в ноль.}

While Pos(sl,st)<>0 Do {Пока результат работы функции}

Begin {не равен нулю (слово есть),}

s:=s+1; {увеличиваем счетчик слов,}

Delete(st,Pos(sl,st),Length(sl)); {удаляем слово из строки.}

End;

Writeln('слово ',sl,' встретилось - ',s,' раз(а)');{Выводим результат.}

ReadKey; {Задержка результата на экране.}

END.

Задача №7. Найти самое длинное слово в строке.

Алгоритм решения.

- ввести строку;

- занести в максимум «пустую» строку (max:='';);

- организовать внешний цикл "по строке", в котором:

- организовать один цикл"по пробелам", в котором просто изменять позицию строки - "добираться до слова",

- организовать второй цикл"по слову", в котором формировать само слово и изменять позицию строки,

- получив слово, проверить длиннее ли оно предыдущего и если да - запомнить его;

- вывести результат.

Справка:

1). Т. к. для решения этой задачи необходимо использовать вложенные циклы, в каждом из которых предусмотрено изменение позиции в строке, то необходимо использовать циклы While.

2). Цикл While называется циклом с предусловием, потому что работает до тех пор, пока выполняется условие.

Например цикл по строке будет иметь следующий вид:

i:=1; {Начиная с первой позиции строки,}

While i<= Length(st) Do {пока не дойдем до конца строки }

Begin

... {что-то будем делать...}

End;

3). Цикл "по пробелам" необходим для того, чтобы, минуя пробелы, "добраться"

к слову.

4). Цикл "по слову" необходим для того, чтобы, используя конкатенацию, сформировать слово.

5). Переменную, зарезервированную для слова перед каждым циклом "по слову" нужно чистить.

Uses Crt;

Var

st:String; {Исходная строка.}

max:String; {Слово максимальной длины.}

sl:String; {Слово, которое получаем из строки.}

i:Byte; {Позиция строки.}

BEGIN

ClrScr; {Чистим экран.}

Writeln('Введите строку');{Выводим запрос на ввод строки.}

Readln(st); {Вводим исходную строку.}

{Находим в строке слово максимальной длины.}

max:=''; {Чистим строку для слова максимальной длины.}

i:=1; {Обработку строки начинаем с первой позиции.}

While i<=Length(st) do {Организовываем цикл "по строке".}

Begin

While (st[i]=' ') And (i<=Length(st)) do {Пока пробелы,}

Inc(i); {изменяем позицию в строке.}

sl:=''; {Чистим строку для слова.}

While (st[i]<>' ') And (i<=Length(st)) do{Пока символы (цикл "по слову"),}

Begin

sl:=sl+st[i]; {Формируем слово из рядом стоящих символов.}

Inc(i); {Изменяем позицию в строке.}

End;

If Length(sl)>Length(max) Then {Сравниваем полученное слово,}

...