Обработка матриц в Паскале

{Тип данных massiv будет использоваться при описании процедур.}
type
massiv=array [ 1.. 200 ] of word;
{Функция prostoe проверяет, является ли число N простым (true) или нет}
{(false).}
function prostoe (N: word ) : boolean;
var pr : boolean; i : word;
begin
	if N>0 then
	begin
{Предполагаем, что число N - простое (pr=true).}
		pr := true;
{Проверяем, делится ли число N на какое либо из чисел от 2 до N/2.}
		for i :=2 to n div 2 do
{Если встречается число i, на которое делится N, то}
		if N mod i =0 then
		begin
{число N не является простым (pr=false) и}
			pr := false;
{выходим из цикла.}
			break;
		end
	end
	else pr := false;
{Имени функции присваиваем значение переменной pr.}
	prostoe := pr;
end;
{Процедура udal удаляет из массива x элементы, которые встречаются}
{более одного раза. Х, N являются параметрами-переменными, так как эти}
{значения возвращаются в головную программу при вызове процедуры udal.}
procedure udal ( var x : massiv; var n : word );
var i, j,m: word;
begin
	i : = 1;
{Просматриваем все элементы, начиная с первого i=1,2,...,N;i-й элемент}
{сравниваем с последующими j=i+1,i+2,...,n.}
	while ( i<=n ) do
	begin
		j := i +1;
		while ( j<=N) do
{Если x[i] равно x[j], то встретился повторяющийся элемент -}
		if x [ i ]=x [ j ] then
		begin
{удаляем его (x[j]) из массива.}
			for m:= j to N _1 do
			x [m] : = x [m+ 1 ];
{После удаления элемента количество элементов уменьшаем на 1, при этом}
{не переходим к следующему элементу, так как после удаления под j-м}
{номером находится уже другой элемент.}
			N:=N-1;
		End
{Если x[i] не равно x[j], то переходим к следующему элементу.}
		else j := j +1;
		i := i +1;
	end;
end;
{Функция nalichie возвращает true, если число a встречается в массиве}
{b, false - в противном случае.}
function nalichie ( a : word; b : massiv; n : word ) : boolean;
var
	pr : boolean;
	i : word;
begin
{Предполагаем, что в массиве b не встречается значение a - pr=false}
	pr := false;
{Перебираем все элементы массива.}
	for i :=1 to N do
{Если очередной элемент массива b равен значению a, то в pr записываем}
{true}
	if b [ i ]=a then
		begin
		pr := true;
{и выходим из цикла.}
		break
	end;
{Имени функции присваиваем значение переменной pr.}
	nalichie := pr
end;
{Процедура vozr упорядочивает массив x по возрастанию.}
procedure vozr ( var x : massiv; n : word );
{X является параметром-переменной, именно массив и возвращается в}
{головную программу при вызове процедуры vozr.}
var i, j, b : word;
begin
	for i :=1 to N -1 do
		for j :=1 to N -i do
			if x [ j ]>x [ j +1] then
			begin
				b:=x [ j ];
				x [ j ] : = x [ j + 1 ];
				x [ j +1]:=b;
			end
	end;
//Начинается основная программа.
var
	N, M, i, j, k, max : word;
	A: array [ 1.. 20, 1.. 20 ] of word;
	pr, L : boolean;
	mas, b : massiv;
begin
{Вводим элементы матрицы А.}
	write ( ’N= ’ ); readln (N);
	write ( ’M= ’ ); readln (M);
writeln ( ’   Matrica  A ’ );
	for i :=1 to N do
	for j :=1 to M do
		read (A[ i, j ] );
{Предполагаем, что в матрице нет простых чисел.}
	Pr:= false;
{Количество элементов, равных максимальному, равно 0.}
	k : = 0;
{Перебираем все элементы в матрице.}
	for i :=1 to N do
	for j :=1 to M do
	begin
{Обращаемся к функции, которая проверяет, является ли число A[i,j]}
{простым.}
		L:= Prostoe (A[ i, j ] );
{Если число простое, и}
		if L then
{если простое число встретилось первый раз,}
		if not Pr then
		begin
{записывем в pr true,}
			Pr:= true;
{увеличиваем количество максимумов на 1, можно было просто написать}
{k:=1.}
			k:=k+1;
{Это число записываем в переменную max. Это первое простое число, и}
{предполагаем, что оно максимальное.}
			max:=A[ i, j ];
{В mas[k] записываем номер строки, где хранится число A[i,j].}
			mas [ k ] : = i
		end
	else
{Если A[i,j] - не первое простое число, то сравниваем max и текущее}
{простое значение матрицы А.}
		if A[ i, j ]>max then
{Если A[I,j]> max, то}
		begin
{количество максимумов равно 1, т. к. встретился наибольший в данный}
{момент элемент.}
			k : = 1;
{В переменную max записываем A[i,j],}
			max:=A[ i, j ];
{в mas[k] записываем номер строки, где хранится число A[i,j]}
			mas [ k ] : = i
		end
	else
{Если A[i,j]=max (встретился элемент, равный максимуму), то}
if A[ i, j ]=max then
			begin
{количество максимумов увеличиваем на 1,}
				k:=k+1;
{в mas[k] записываем номер строки, где хранится число A[i,j].}
				mas [ k ] : = i
			end
	end;
{Если в pr осталось значение false,то выводим сообщение, что в матрице}
{нет простых чисел,}
	if not Pr then writeln ( ’В матрице A нет простых чисел ’ )
	else
	begin
{иначе удаляем из массива mas номера строк, где хранятся максимумы,}
{повторяющиеся элементы.}
		Udal ( mas, k );
{Перебираем все строки матрицы.}
		for i :=1 to N do
		begin
			L:= Nalichie ( i, mas, k );
{Если номер строки присутствует в массиве mas,}
			if L then
			begin
{то переписываем строку в массив b,}
				for j :=1 to M do
				b [ j ] : =A[ i, j ];
{упорядочиваем массив b по возрастанию.}
				Vozr ( b,M);
{Упорядоченный массив записываем на место i-й строки матрицы A.}
				for j :=1 to M do
				A[ i, j ] : = b [ j ];
			end
		end;
	writeln ( ’Преобразованная матрица A ’ );
	for i :=1 to N do
	begin
		for j :=1 to M do
		write (A[ i, j ], ’   ’ );
		writeln;
		end
	end
end.

{Описываем тип данных massiv как массив 1000 вещественных чисел.}
type massiv=array [ 1.. 1000 ] of real;
{Указатель на массив.}
din_massiv=^massiv;
{Тип данных matrica - статический массив указателей, каждый элемент}
{которого является адресом массива вещественных чисел.}
matrica=array [ 1.. 100 ] of din_massiv;
var
Nmax, Nmin, i, j, n,m, k : word;
{Описана динамическая матрица b.}
b : matrica;
a, max, min : real;
begin
{Вводим число строк N и число столбцов M.}
write ( ’N= ’ ); readln (N);
write ( ’M= ’ ); readln (M);
{Выделяем память под матрицу вещественных чисел размером N на M.}
for i :=1 to N do
getmem( b [ i ],M * sizeof ( real ) );
{ Вводим Матрицу B. }
writeln ( ’ Matrica B ’ );
for i :=1 to N do
for j :=1 to M do
read ( b [ i ] ^ [ j ] );
{В каждой строке находим максимальный, минимальный элементы и их номера}
{и элементы, расположенные между ними, упорядочиваем "методом}
{пузырька".}
for i :=1 to N do
begin
{Поиск минимального, максимального элемента в i-й строке матрицы и их}
{номеров.}
max:=b [ i ] ^ [ 1 ];
Nmax: = 1;
min:=b [ i ] ^ [ 1 ];
Nmin : = 1;
for j :=2 to M do
begin
if b [ i ] ^ [ j ]>max then
begin
max:=b [ i ] ^ [ j ];
nmax:= j
end;
if b [ i ] ^ [ j ]<min then
begin
min:=b [ i ] ^ [ j ];
nmin:= j
end;
end;
{Если минимальный элемент расположен позже максимального, nmin и nmax}
{меняем местами.}
if nmax<nmin then
begin
j :=nmax;
nmax:=nmin;
nmin:= j;
end;
{В i-той строке упорядочиваем элементы, расположенные между nmin и}
{nmax, "методом пузырька".}
j : = 1;
while nmax-1 - j>=nmin+1 do
begin
for k:=nmin+1 to nmax-1 - j do
if b [ i ] ^ [ k]>b [ i ] ^ [ k+1] then
begin
a:=b [ i ] ^ [ k ];
b [ i ] ^ [ k ] : = b [ i ] ^ [ k + 1 ];
b [ i ] ^ [ k+1]:= a;
end;
j := j +1;
end;
end;
{ Выводим преобразованную матрицу. }
writeln ( ’Упорядоченная матрица B ’ );
for i :=1 to N do
begin
for j :=1 to M do
write ( b [ i ] ^ [ j ] : 6 : 2, ’   ’ );
writeln
end;
{ Освобождаем память. }
for i :=1 to N do
freemem ( b [ i ],M * sizeof ( real ) );
end.