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

Для решения данной задачи необходимо найти в каждом столбце максимальный и минимальный элементы, после чего в последний элемент столбца записать их разность. Блок-схема алгоритма решения приведена на рис. 6.20.

Ниже приведён текст консольного приложения с комментариями.

program pr_6_6;
	var a : array [ 1.. 25, 1.. 25 ] of real;
	i, j, n,m: integer;
	max, min : real;
	begin
{Ввод размеров матрицы.}
	writeln ( ’Введите размеры матрицы ’ );
	readln ( n,m);
{Ввод исходной матрицы.}
	writeln ( ’Введите матрицу ’ );
	for i :=1 to n do
		for j :=1 to m do
			read ( a [ i, j ] );
{Последовательно перебираем все столбцы матрицы.}
	for j :=1 to m do
	begin
{Максимальным и минимальным объявляем первый элемент текущего (j-го)}
{столбца матрицы.}
	max:=a [ 1, j ];
	min:=a [ 1, j ];
{Последовательно перебираем все элементы в текущем (j-м) столбце}
{матрицы.}
	for i :=2 to n do
	begin
{Если текущий элемент больше максимального, то его и объявляем}
{максимальным.}
		if a [ i, j ]>max then max:=a [ i, j ];
{Если текущий элемент меньше минимального, то его и объявляем}
{минимальным.}
		if a [ i, j ]<min then min:=a [ i, j ];
	end;
{В последний элемент столбца записываем разность между максимальным и}
{минимальным элементами столбца.}
		a [ n, j ] : =max _min;
	end;
{Вывод преобразованной матрицы.}
	writeln ( ’Преобразованная матрица ’ );
	for i :=1 to n do
		begin
			for j :=1 to m do
				write ( a [ i, j ] : 7 : 3, ’   ’ );
		writeln;
	end;
end.

Теперь давайте создадим визуальное приложение, реализующее рассмотренный алгоритм. За основу возьмём форму (см. рис. 6.9) и проект транспонирования матрицы A(N,M), разработанные для задачи 6.2. Окно формы несколько изменим (рис. 6.9). Кнопку Транспонирование переименуем в Преобразование матрицы, а свойством Caption метки label5 установим Преобразованная матрица A. Кроме того, изменим свойство Caption формы (см. рис. 6.21). Окно изменённой формы представлено на рис. 6.21.

Обработчики кнопок Ввод, Очистить, Выход из программы изменятся мало. Рассмотрим алгоритм работы обработчика кнопки Преобразование матрицы. В этом обработчике будет производиться считывание матрицы из компонента StringGrid1, преобразование матрицы A по алгоритму, представленному на рис. 6.20, вывод преобразованной матрицы в компонент StringGrid2.

Текст модуля визуального приложения решения задачи 6.6 с комментариями приведён ниже.

unit Unit1;
{$mode objfpc}{$H+}
interface
uses
	Classes, SysUtils, LResources, Forms, Controls, Graphics,
	Dialogs, StdCtrls, Grids;
//Описание формы
type
	{ TForm1 }
	TForm1 = class (TForm)
	Button1 : TButton;
	Button2 : TButton;
	Button3 : TButton;
	Button4 : TButton;
	Edit1 : TEdit;
	Edit2 : TEdit;
	Label1 : TLabel;
	Label2 : TLabel;
	Label3 : TLabel;
	Label4 : TLabel;
	Label5 : TLabel;
	StringGrid1 : TStringGrid;
	StringGrid2 : TStringGrid;
	procedure Button1Click ( Sender : TObject );
	procedure Button2Click ( Sender : TObject );
	procedure Button3Click ( Sender : TObject );
	procedure Button4Click ( Sender : TObject );
private
	{private declarations}
public
	{public declarations}
	end;
var
	A: array [ 1.. 2 5, 1.. 2 5 ] of real;
	N,M: integer;
	Form1 : TForm1;
implementation
{ TForm1 }
//Обработчик кнопки "Выход из программы".
procedure TForm1. Button4Click ( Sender : TObject );
begin
	Close;
end;
//Обработчик первой кнопки — кнопки ввода размерности матрицы.
procedure TForm1. Button1Click ( Sender : TObject );
var i : byte; kod_n, kod_m, kod : integer;
begin
//Ввод размерности матрицы.
//Символьная информация преобразовывается в числовую и
//записывается в переменные N и M.
	Val ( Edit1. Text,N, kod_m );
	Val ( Edit2. Text,M, kod_n );
	//Если преобразование прошло успешно и введенные размеры
//удовлетворяют описанию матриц A и B,
	if ( kod_n=0) and (kod_m=0) and (N>0) and (N<26) and (M>0)
		and (M<26)
then
//то
	begin
//визуализируется первая матрица,
	StringGrid1. Visible := true;
//соответствующая ей надпись,
	Label4. Visible := true;
//кнопки "Очистить"
	Button2. Visible := true;
//и "Транспонирование"
	Button3. Visible := true;
	with StringGrid1 do
		begin
			ColCount :=M+1;
			RowCount:=N+1;
//и нумеруются строки и
			for i :=1 to RowCount-1 do
				Cells [ 0, i ] : = IntToStr ( i );
//столбцы первой таблицы.
			for i :=1 to ColCount -1 do
				Cells [ i, 0 ] : = IntToStr ( i );
		end;
		StringGrid2. ColCount :=M+1;
		StringGrid2. RowCount:=N+1;
	end
	else
	begin
//При некорректном вводе выдается соответствующее сообщение.
		MessageDlg ( ’Размеры матрицы введены неверно! ’,
		MtInformation, [ mbOk ], 0 );
//Устанавливаются стартовые параметры в поля ввода.
		Edit1. Text := ’ 4 ’;
		Edit2. Text := ’ 3 ’;
	end;
end;
//Обработчик кнопки "Преобразование матрицы".
procedure TForm1. Button2Click ( Sender : TObject );
var i, j : integer;
	max, min : real;
begin
	StringGrid2. Visible := true;
	label5. Visible := true;
	for i :=1 to N do //Цикл по номерам строк.
		for j :=1 to M do //Цикл по номерам столбцов.
//Считывание элементов матрицы A из компонента StringGrid1,
			A[ i, j ] : = StrToFloat ( StringGrid1.Cells [ j, i ] );
			with StringGrid2 do
			begin
				for i :=1 to RowCount-1 do //и нумеруются
					Cells [ 0, i ] : = IntToStr ( i ); //строки и
				for i :=1 to ColCount -1 do //столбцы второй матрицы.
					Cells [ i, 0 ] : = IntToStr ( i );
			end;
//Решение задачи 6.6.
	for j :=1 to m do
	begin
{Максимальным и минимальным объявляем первый элемент текущего (j-го)}
{столбца матрицы.}
	max:=a [ 1, j ];
	min:=a [ 1, j ];
{Последовательно перебираем все элементы в текущем (j-м) столбце}
{матрицы.}
		for i :=2 to n do
		begin
{Если текущий элемент больше максимального, то его и объявляем}
{максимальным.}
			if a [ i, j ]>max then max:=a [ i, j ];
{Если текущий элемент меньше минимального, то его и объявляем}
{минимальным.}
			if a [ i, j ]<min then min:=a [ i, j ];
		end;
{В последний элемент столбца записываем разность между максимальным и}
{минимальным элементами столбца.}
	a [ n, j ] : =max _min;
	end;
//Элементы преобразованной матрицы A выводятся в ячейки
//таблицы на форме.
	for i :=1 to N do //Цикл по номерам строк.
		for j :=1 to M do //Цикл по номерам столбцов.
//Запись элемента преобразованной матрицы A в ячейку StringGrid2.
		StringGrid2.Cells [ j, i ] : = FloatToStr (A[ i, j ] );
//Делаем первую кнопку невидимой.
	Button1. Visible := False;
end;
//Обработчик кнопки "Очистить"
procedure TForm1. Button3Click ( Sender : TObject );
	var i, j : integer;
begin
//Очистка компонента StringGrid1.
	with StringGrid1 do
	for i :=1 to RowCount-1 do
		for j :=1 to ColCount -1 do
			Cells [ j, i ] : = ’ ’;
//Очистка компонента StringGrid2.
	with StringGrid2 do
		for i :=1 to RowCount-1 do
			for j :=1 to ColCount -1 do
				Cells [ j, i ] : = ’ ’;
//Делаем невидимыми компоненты StringGrid1, StringGrid2,
//labe4, label5.
	StringGrid1. Visible := False;
	StringGrid2. Visible := False;
	label4.Visible := False;
	label5.Visible := False;
//Делаем невидимыми кнопки "Транспонировать" и "Очистить".
	Button2. Visible := False;
	Button3. Visible := False;
//Делаем видимой кнопку "Ввод".
	Button1. Visible :=True;
//Запись начальных значений размеров матрицы (N=4,
//M=3).
	Edit1. Text := ’ 4 ’;
	Edit2. Text := ’ 3 ’;
end;
initialization
	{$I unit1.lrs}
end.

На рис. 6.22 представлено окно с результатами решения задачи.

Задача сводится к обмену $$n$$-го и $$r$$-го элемента во всех строках матрицы.

Блок-схема приведена на рис. 6.23.

Ниже приведён листинг консольного приложения с комментариями.

type matrica=array [ 1.. 15, 1.. 15 ] of real;
var
a : matrica;
i, j, k,m, n, r : byte; b : real;
begin
//Ввод размеров матрицы.
write ( ’ k= ’ ); readln ( k );
write ( ’m= ’ ); readln (m);
//Ввод матрицы A.
writeln ( ’Матрица A ’ );
for i :=1 to k do
for j :=1 to m do
read ( a [ i, j ] );
//Ввод номеров столбцов матрицы, подлежащих обмену.
repeat
write ( ’ n= ’ );
readln ( n );
write ( ’ r= ’ );
readln ( r );
{Ввод считается верным, если n и r не больше m и не равны друг другу.}
until ( n<=m) and ( r<=m) and ( n<>r );
{Элементы столбца с номером r заменить элементами столбца с номером n.}
for i :=1 to k do
begin
b:=a [ i, n ];
a [ i, n ] : = a [ i, r ];
a [ i, r ] : = b
end;
writeln ( ’Преобразованная матрица A ’ );
for i :=1 to k do
begin
for j :=1 to m do
write ( a [ i, j ] : 7 : 3, ’   ’ );
writeln;
end;
end.

Результаты работы программы приведены на рис. 6.24.

Каждая строка матрицы является одномерным массивом. Поэтому для упорядочения строки или столбца можно использовать обычные алгоритмы сортировки массивов. При решении задачи необходимо последовательно просматривать все строки матрицы, если номер строки нечётный, то сортируем строку методом пузырька по убыванию, иначе — по возрастанию. Блок-схема этого алгоритма представлена на рис. 6.25.

Ниже представлено консольное предложение для решения этой задачи с комментариями.

var a : array [ 1.. 15, 1.. 15 ] of real;
	j, i, k,m, n : byte; b : real;
begin
//Ввод размеров матрицы.
	writeln ( ’введите m и n ’ );
readln (m, n );
//Ввод матрицы.
writeln ( ’Матрица А ’ );
for i :=1 to m do
for j :=1 to n do
read ( a [ i, j ] );
//Преобразование матрицы.
for i :=1 to m do
if ( i mod 2)=0 then {Если номер строки четный, то}
begin {упорядочить ее элементы по возрастанию.}
{Упорядочение строки матрицы методом пузырька по возрастанию.}
for k:=1 to n-1 do
for j :=1 to n-k do
if a [ i, j ] > a [ i, j +1] then
begin
b:=a [ i, j ];
a [ i, j ] : = a [ i, j + 1 ];
a [ i, j +1]:=b;
end
end
else {Если номер строки нечетный, то упорядочить ее элементы по}
{убыванию.}
{Упорядочение строки матрицы методом пузырька по убыванию.}
for k:=1 to n-1 do
for j :=1 to n-k do
if a [ i, j ] < a [ i, j +1] then
begin
b:=a [ i, j ];
a [ i, j ] : = a [ i, j + 1 ];
a [ i, j +1]:=b;
end;
//Вывод преобразованной матрицы.
writeln ( ’преобразованная матрица A ’ );
for i :=1 to m do
begin
for j :=1 to n do
write ( a [ i, j ] : 7 : 3, ’   ’ );
writeln
end
end.

На рис. 6.26 приведены результаты работы программы.

Для решения этой задачи нам понадобятся функции проверки, является ли число простым, и перевода целого числа в четверичную систему счисления. Алгоритм проверки, является ли число простым, уже неоднократно рассматривался в книге. Функция этой проверки подробно рассматривалась в главе 5 при решении задачи 5.7. Поэтому здесь просто приведем её текст.

function prostoe (N: integer ) : boolean;
var i : integer;
	pr : boolean;
begin
if N<1 then pr := false
else
begin
	pr := true;
	for i :=2 to N div 2 do
		if (N mod i = 0) then
		begin
			pr := false;
			break;
	end;
end;
prostoe:= pr;
end;

В этой же главе 5 мы рассматривали алгоритм (рис. 5.42) и функцию перевода (function perevod(N:real;P:word;kvo:word):real;) вещественного числа в $$p$$-чную систему счисления (задача 5.10). Нужная нам функция перевода целого числа в четверичную систему счисления является частным случаем рассмотренной ранее функции perevod. Ниже приведён текст функции perevod4, которая переводит целое положительное число в четверичную систему счисления.

{Функция перевода целого числа N в четверичную систему счисления.}
function perevod4 (N: word ) : word;
	var s1, i, q, ost : word;
begin
{В переменной s1 мы будем собирать число в четверичной системе}
{счисления.}
	s1 : = 0;
{В переменной q будем последовательно хранить степени десяти; вначале}
{туда записываем 1 - десять в 0 степени, а затем в цикле будем}
{последовательно умножать q на 10.}
q : = 1;
{Перевод целого числа, пока число не станет равным 0.}
	while (N<>0) do
	begin
{Вычисляем ost - очередной разряд числа, как остаток от деления N на 4}
{(основание системы счисления).}
	ost :=N mod 4;
{Очередной разряд числа умножаем на 10 в степени i и добавляем к}
{формируемому числу s1.}
	s1 := s1+ost * q;
{Уменьшаем число N в 4 раза путем целочисленного деления на 4.}
	N1:=N1 div 4;
{Формируем следующую степень десятки.}
	q:=q * 10;
end;
//Возвращаем число в четверичной системе счисления.
	perevod := s1;
end;

В каждой строке надо найти сумму простых чисел, а затем полученное число перевести в четверичную систему счисления. Поэтому необходимо для каждой строки (i:=1,2,..,n) выполнить следующее: обнулить сумму S (S:=0), организовать цикл по элементам строки (j:=1,2,...,m), внутри которого проверять, является ли текущий элемент Ai,j простым, и если является, добавлять его к сумме S. После выхода из цикла по j необходимо проверить, были ли в строке с номером i простые числа (S>0), и если были, перевести S в четверичную систему счисления и сформировать соответствующий элемент массива P (P[i]:=perevod4(S)).

Блок-схема алгоритма приведена на рис. 6.27.

Полный текст консольного приложения приведён ниже.

program pr_6_9;
function prostoe (N: integer ) : boolean;
var i : integer;
	pr : boolean;
begin
if N<1 then pr := false
else
begin
	pr := true;
	for i :=2 to N div 2 do
		if (N mod i = 0) then
		begin
			pr := false;
			break;
		end;
end;
prostoe := pr;
end;
function perevod4 (N: word ) : word;
	var s1, q, ost : word;
begin
{В переменной s1 мы будем собирать число в четверичной системе}
{счисления.}
	s1 : = 0;
{В переменной q будем последовательно хранить степени десяти, вначале}
{туда записываем 1 - десять в 0 степени, а затем в цикле будем}
{последовательно умножать q на 10.}
q : = 1;
{Перевод целого числа, пока число не станет равным 0.}
		while (N<>0) do
		begin
{Вычисляем ost - очередной разряд числа, как остаток от деления N на 4}
{(основание системы счисления).}
		ost :=N mod 4;
{Очередной разряд числа умножаем на 10 в степени i и добавляем к}
{формируемому числу s1.}
		s1 := s1+ost * q;
{Уменьшаем число N в 4 раза путем целочисленного деления на 4.}
		N:=N div 4;
{Формируем следующую степень десятки.}
		q:=q * 1 0;
	end;
//Возвращаем число в четверичной системе счисления.
	perevod4 := s1;
end;
var S, i, j, n,m: word;
	a : array [ 1.. 2 5, 1.. 2 5 ] of word;
	p : array [ 1.. 2 5 ] of word;
begin
//Ввод размеров матрицы.
	writeln ( ’Введите размеры матрицы ’ );
	readln ( n,m);
//Ввод матрицы.
	writeln ( ’Введите матрицу A ’ );
	for i :=1 to n do
		for j :=1 to m do
			read (A[ i, j ] );
{Последовательно перебираем все строки матрицы для формирования суммы}
{простых чисел каждой строки.}
	for i :=1 to n do
	begin
//Вначале сумма равна нулю.
		S : = 0;
//Перебираем все элементы в i-й строке матрицы.
		for j :=1 to m do
//Если очередной элемент в i-й строке матрицы - простое число,
//то добавляем его к сумме.
			if prostoe (A[ i, j ] ) then s := s+A[ i, j ];
{Если в строке были простые числа, то их сумму переводим в четверичную}
{систему счисления и записываем в p[i].}
			if s >0 then p [ i ] : = perevod4 ( s )
{Если в строке не было простых чисел, то p[i]:=0.}
		else p [ i ] : = 0;
	end;
//Вывод сформированного массива P.
	writeln ( ’Массив P ’ );
	for i :=1 to n do
		write (P [ i ], ’   ’ );
	writeln;
end.

Результаты работы программы представлены на рис. 6.28.

Напомним некоторые сведения из курса математики. Умножать можно только матрицы, у которых количество столбцов в первой матрице совпадает с количеством строк во второй матрице. Матрица-произведение имеет столько строк, сколько было в первой матрице и столько столбцов, сколько было во второй. Таким образом, при умножении матрицы A(N,M) на матрицу B(M,L) получается матрица C(N,L). Каждый элемент матрицы C[i,j] является скалярным произведением i-й строки матрицы A и j-го столбца матрицы B. В общем виде формула для нахождения элемента $$c_{i,j}$$ матрицы имеет вид:

где $$i = 1,..., N$$ и $$j = 1,..., L$$.

Рассмотрим более подробно формирование матрицы C(3,2) как произведения матриц A(3,3) и B(3,2).

Следует помнить, что $$A \cdot B \not = B \cdot A$$.

Блок-схема, реализующая умножение каждого элемента матрицы C по формуле (6.1), приведена на рис. 6.29.

Ниже приведён текст программы умножения двух матриц с комментариями.

type
	matrica=array [ 1.. 15, 1.. 15 ] of real;
var
	a, b, c : matrica;
	i, j,M,N, L, k : byte;
begin
	//Ввод размеров матриц.
	writeln ( ’введите n,m и  l ’ );
	readln (N, M, L );
//Ввод матрицы A.
	writeln ( ’Матрица A ’ );
	for i :=1 to N do
		for j :=1 to M do
			read ( a [ i, j ] );
//Ввод матрицы B.
	writeln ( ’Матрица B ’ );
	for i :=1 to M do
		for j :=1 to L do
			read ( b [ i, j ] );
//Формирование матрицы C.
	for i :=1 to N do
		for j :=1 to L do
		begin
{В C[i,j] будет храниться результат скалярного}
{умножения i-й строки на j-й столбец.}
			c [ i, j ] : = 0;
			for k:=1 to M do
				c [ i, j ] : = c [ i, j ]+a [ i, k ] * b [ k, j ];
		end;
//Вывод матрицы C=AB.
	writeln ( ’матрица C=A*B ’ );
	for i :=1 to N do
	begin
		for j :=1 to L do
			write ( c [ i, j ] : 7 : 3, ’   ’ );
		writeln;
	end;
end.

Результат работы представлен на рис. 6.30.

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

При решении задачи нам понадобятся следующие подпрограммы:

function Prostoe (P : word ) : Boolean;

procedure Udal ( var X: massiv; var N: word );

function Nalichie ( a : word; b : massiv; N: word );

procedure Vozr ( var x : massiv; N: word );

Рассмотрим более подробно алгоритм решения задачи 6.11, который приведён на рис. 6.33—6.34.

После ввода матрицы (блоки 1—4) предполагаем, что простых чисел нет. В логическую переменную Pr записываем false, как только встретится простое число, в переменную Pr запишем true. Количество максимальных значений среди простых чисел равно 0 (k:=0) (блок 5).

Для проверки, является ли простым числом каждый элемент матрицы, обращаемся к функции Prostoe. Если число простое (блок 8), проверяем, первое ли это простое число в матрице (блок 9). Если это первое простое число, то переписываем его в переменную max, в переменную k записываем число 1 (количество максимумов равно 1), номер строки, в которой находится максимум, записываем в массив mas под номером k В массиве mas будут храниться номера строк, в которых находится максимум. . В связи с тем, что в матрице есть простые числа, в переменную Pr записываем true (блок 10). Если это не первое простое число, сравниваем A[i,j] с переменной max. Если A[i,j]>max (блок 11), то в переменную max запишем A[i,j], в переменную k запишем 1 (есть один максимум), в mas[k] записываем i — номер строки, где находится максимальный элемент (блок 12). Если A[i,j]=max (блок 13), то встретилось число, равное переменной max. В этом случае значение k увеличиваем на 1 и в mas[k] записываем номер строки, где находится элемент, равный max. В результате двойного цикла обработки всех элементов матрицы (блоки 6—14) в переменной max будет храниться максимальное из простых чисел, в переменной k — количество максимумов, в массиве mas из k элементов будут храниться номера строк, где находятся максимальные значение среди простых чисел матрицы. В переменной Pr хранится true, если в матрице есть простые числа, false — в противном случае. Если в матрице нет простых чисел (блок 15), выводим соответствующее сообщение (блок 16), в противном случае с помощью процедуры Udal (блок 17) удаляем из массива mas элементы, встречающиеся более одного раза Если некоторые максимальные элементы находятся в одной строке, то в массиве mas есть повторяющиеся элементы. . Затем просматриваем все строки матрицы (цикл начинается блоком 18). Если номер этой строки присутствует в массиве mas (блок 19), то переписываем текущую строку матрицы в массив b (блоки 20—21) и обращаемся к процедуре упорядочения массива по возрастанию Vozr (блок 22). Упорядоченный массив b переписываем в i-ю строку матрицы А (блоки 23—24). На последнем этапе выводим на экран матрицу А после преобразования (блоки 25—27).

Ниже приведён листинг всей программы с подробными комментариями.

{Тип данных 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.

Результаты работы программы приведены на рис. 6.35.

Авторы рекомендуют читателю по рассмотренным алгоритмам и консольным приложениям задач 6.7—6.11 разработать визуальные приложения, аналогичные тем, которые были разработаны для задач 6.2 и 6.6.

В завершении этой главы рассмотрим "динамические матрицы".

6.3 Динамические матрицы

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

Рассмотрим описание динамической матрицы. Пусть есть типы данных massiv и указатель на него din_massiv.

type massiv=array [ 1.. 1000 ] of real;

din_massiv=^massiv;

Динамическая матрица X будет представлять собой массив указателей.

var X: array [ 1.. 100 ] of din_massiv;

Работать с матрицей надо следующим образом:

for i :=1 to N do

getmem(X[ i ],M * sizeof ( real ) );

Каждый элемент статического массива X[i] — указатель на динамический массив, состоящий из M элементов типа real. В статическом массиве Х находится N указателей.

for i :=1 to N do

freemem ( b [ i ],M * sizeof ( real ) );

Рассмотрим работу с динамической матрицей на следующем примере.

ЗАДАЧА 6.12. В каждой строке матрицы вещественных чисел B(N, M ) упорядочить по возрастанию элементы, расположенные между максимальным и минимальным значениями.

Алгоритмы упорядочения рассматривались в главе 5, основные принципы работы с матрицами — в предыдущих параграфах текущей главы, поэтому в комментариях к тексту программы основное внимание уделено особенностям работы с динамическими матрицами.

{Описываем тип данных 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.

Результаты работы программы представлены на рис. 6.36.

Динамическая матрица может быть достаточно большой, фактически её размер ограничен только объемом свободной памяти.

В заключении главы приведём задачи для самостоятельного решения.