Программа

CONST QuantityString=4;   { Количество строк матрицы }
      QuantityColumn=4;   { Количество солбцов матрицы }
      QuantityStringD=4;                  { Количество строк матрицы }
      QuantityColumnD=3;                  { Количество солбцов матрицы }
      QuantityStringE=QuantityColumnD;    { Количество строк матрицы }
      QuantityColumnE=2;                  { Количество солбцов матрицы }
      QuantityStringF=QuantityStringD;    { Количество строк матрицы }
      QuantityColumnF=QuantityColumnE;    { Количество солбцов матрицы }
TYPE Matrix4x4Type=array [1..QuantityString,1..QuantityColumn] of integer;
     MatrixDType=array [1..QuantityStringD,1..QuantityColumnD] of integer;
     MatrixEType=array [1..QuantityStringE,1..QuantityColumnE] of integer;
     MatrixFType=array [1..QuantityStringF,1..QuantityColumnF] of integer;
VAR
    A:Matrix4x4Type; { Матрица }
    B:Matrix4x4Type; { Матрица }
    C:Matrix4x4Type; { Матрица }

    D:MatrixDType; { Матрица }
    E:MatrixEType; { Матрица }
    F:MatrixFType; { Матрица }

    Min,Max:integer; { Минимальный и максимальный элементы }

PROCEDURE AddMatrix (A,B:Matrix4x4Type;var C:Matrix4x4Type);
                                          { Процедура сложения матриц }
  Var i,j:word; { Счетчики }
  Begin
    for i:=1 to QuantityString do { Цикл просмотра строк матрицы }
      for j:=1 to QuantityColumn do { Цикл прсмотра элементов матрицы }
        C[i,j]:=A[i,j]+B[i,j]
  End;

PROCEDURE Swap(var A,B:integer); { Процедура взаимного обмена }
  Var Buf:integer;  { Буфер переноса }
  Begin
    Buf:=A;
    A:=B;
    B:=Buf
  End;

PROCEDURE ChangeColumnMatrix(var B:Matrix4x4Type; Column1, Column2:word);
                                  { Процедура перестановки столбцов матрицы }
  Var i:word;   { Счетчик }
  Begin
    for i:=1 to QuantityString do { Цикл перестановки элементов матрицы }
      Swap(B[i,Column1],B[i,Column2])    { Перестановка элементов }
  End;

PROCEDURE ChangeStringMatrix (var B:Matrix4x4Type; String1, String2:word);
                                     { Процедура перестановки строк матрицы }
  Var j:word;   { Счетчик }
  Begin
    for j:=1 to QuantityColumn do { Цикл перестановки элементов матрицы }
      Swap (B[String1,j],B[String2,j])     { Перестановка элемента }
  End;

PROCEDURE GetMinMaxElementMatrix (B:Matrix4x4Type;var Min, Max:integer);
          { Процедура поиска максимального и минимального элементов матрицы }
  Var i,j:word;  { Счетчики }
  Begin
    Max:=B[1,1];  { Начальное определение максимального элемента }
    Min:=B[1,1];  { Начальное определение минимального элемента }
    for i:=1 to QuantityString do { Цикл просмотра строк матрицы }
      for j:=1 to QuantityColumn do { Цикл прсмотра элементов матрицы }
        if B[i,j]>Max
          then Max:=B[i,j]  { Если текущий элемент превосходит максимальный,
                               то - переопределение максимального }
          else if B[i,j]<Min then Min:=B[i,j] { иначе - если текущий элемент
                     меньше минимального, то - переопределение минимального }
  End;

PROCEDURE InputMatrix (var B:Matrix4x4Type); { Процедура ввода матрицы }
  Var i,j:word;  { Счетчики }
  Begin
    for i:=1 to QuantityString do { Цикл ввода строк матрицы }
      for j:=1 to QuantityColumn do { Цикл ввода элементов матрицы }
        begin
{          Write('Введите элемент [',i,',',j,'] ');
                                 { Вывод приглашения ввести элемент матрицы }
 {         ReadLn(B[i,j]);   { Ввод элемента матрицы }
          B[i,j]:=i*10+j
        end
  End;

PROCEDURE InputMatrixD (var B:MatrixDType); { Процедура ввода матрицы }
  Var i,j:word;  { Счетчики }
  Begin
    for i:=1 to QuantityStringD do { Цикл ввода строк матрицы }
      for j:=1 to QuantityColumnD do { Цикл ввода элементов матрицы }
        begin
{          Write('Введите элемент [',i,',',j,'] ');
                                 { Вывод приглашения ввести элемент матрицы }
 {         ReadLn(B[i,j]);   { Ввод элемента матрицы }
          B[i,j]:=i*10+j
        end
  End;

PROCEDURE InputMatrixE (var B:MatrixEType); { Процедура ввода матрицы }
  Var i,j:word;  { Счетчики }
  Begin
    for i:=1 to QuantityStringE do { Цикл ввода строк матрицы }
      for j:=1 to QuantityColumnE do { Цикл ввода элементов матрицы }
        begin
{          Write('Введите элемент [',i,',',j,'] ');
                                 { Вывод приглашения ввести элемент матрицы }
 {         ReadLn(B[i,j]);   { Ввод элемента матрицы }
          B[i,j]:=i*10+j
        end
  End;

PROCEDURE MultiplyMatrix (D:MatrixDType;E:MatrixEType;var F:MatrixFType);
                                               { Процедура умножения матриц }
  Var i,j,k:word; { Счетчики }
  Begin
  for i:=1 to QuantityStringD do { Цикл просмотра строк матрицы }
    for j:=1 to QuantityColumnE do { Цикл прсмотра элементов матрицы }
      begin
        F[i,j]:=0;   { Обнуление элемента }
        for k:=1 to QuantityColumnD do
                          { Цикл формирования элементов матрицы произведения }
          F[i,j]:=F[i,j]+D[i,k]*E[k,j]
      end
  End;

PROCEDURE OutputMatrix (B:Matrix4x4Type); { Процедура вывода матрицы }
  Var i,j:word;   { Счетчики }
  Begin
    for i:=1 to QuantityString do { Цикл вывода строк матрицы }
      begin
        for j:=1 to QuantityColumn do { Цикл вывода элементов матрицы }
          Write (B[i,j],'  ');  { Вывод элемента матрицы }
        WriteLn  { Вывод конца строки }
      end
  End;

PROCEDURE OutputMatrixD (B:MatrixDType); { Процедура вывода матрицы }
  Var i,j:word;   { Счетчики }
  Begin
    for i:=1 to QuantityStringD do { Цикл вывода строк матрицы }
      begin
        for j:=1 to QuantityColumnD do { Цикл вывода элементов матрицы }
          Write (B[i,j],'  ');  { Вывод элемента матрицы }
        WriteLn  { Вывод конца строки }
      end
  End;

PROCEDURE OutputMatrixE (B:MatrixEType); { Процедура вывода матрицы }
  Var i,j:word;   { Счетчики }
  Begin
    for i:=1 to QuantityStringE do { Цикл вывода строк матрицы }
      begin
        for j:=1 to QuantityColumnE do { Цикл вывода элементов матрицы }
          Write (B[i,j],'  ');  { Вывод элемента матрицы }
        WriteLn  { Вывод конца строки }
      end
  End;

PROCEDURE OutputMatrixF (B:MatrixFType); { Процедура вывода матрицы }
  Var i,j:word;   { Счетчики }
  Begin
    for i:=1 to QuantityStringF do { Цикл вывода строк матрицы }
      begin
        for j:=1 to QuantityColumnF do { Цикл вывода элементов матрицы }
          Write (B[i,j],'  ');  { Вывод элемента матрицы }
        WriteLn  { Вывод конца строки }
      end
  End;

PROCEDURE TransponatorMatrix (var B:Matrix4x4Type);
                                        { Процедура транспонирования матрицы }
  Var i,j:word;   { Счетчики }
  Begin
    for i:=1 to QuantityString do { Цикл просмотра строк матрицы }
      for j:=i to QuantityColumn do { Цикл прсмотра элементов матрицы }
        Swap (B[i,j],B[j,i])      { Перестановка элементов }
  End;

PROCEDURE ProcessMatrix (var B:Matrix4x4Type); { Процедура просмотра матрицы }
  Var i,j:word;   { Счетчики }
  Begin
    for i:=1 to QuantityString do { Цикл просмотра строк }
      for j:=1 to QuantityColumn do { Цикл просмотра элементов }
        begin
        end
  End;

BEGIN
  WriteLn; { Пропуск строки }
  InputMatrix(A); { Ввод матрицы }
  WriteLn; { Пропуск строки }
  WriteLn(' Исходная матрица: ');  { Вывод заголовка }
  OutputMatrix(A); { Вывод матрицы }
  ChangeStringMatrix(A,1,4); { Перемена строк в матрице }
  WriteLn; { Пропуск строки }
  WriteLn(' Перемена строк: ');  { Вывод заголовка }
  OutputMatrix(A); { Вывод матрицы }
  ChangeColumnMatrix(A, 2, 1); { Перемена столбцов в матрице }
  WriteLn; { Пропуск строки }
  WriteLn(' Перемена столбцов: ');  { Вывод заголовка }
  OutputMatrix(A);  { Вывод матрицы }
  TransponatorMatrix(A); { Транспонирование матрицы }
  ReadLn;

  WriteLn; { Пропуск строки }
  WriteLn( ' Транспонированная матрица: ');  { Вывод заголовка }
  OutputMatrix(A);  { Вывод матрицы }
  GetMinMaxElementMatrix(A,Min,Max);
                  { Получение минимального и максимального элементов матрицы }
  WriteLn; { Пропуск строки }
  WriteLn('Min=',Min,'  Max=',Max);
                      { Вывод минимального и максимального элементов матрицы }
  B:=A; { Копирование матрицы }
  TransponatorMatrix(B); { Транспонирование матрицы }
  WriteLn; { Пропуск строки }
  WriteLn(' Транспонированная матрица: ');  { Вывод заголовка }
  OutputMatrix(B); { Вывод матрицы }
  AddMatrix(A,B,C); { Сложение матриц }
  WriteLn; { Пропуск строки }
  WriteLn(' Сумма матриц: ');  { Вывод заголовка }
  OutputMatrix(C);  { Вывод матрицы }
  ReadLn;

  InputMatrixD(D);  { Ввод матрицы }
  WriteLn; { Пропуск строки }
  WriteLn(' Матрица D: ');  { Вывод заголовка }
  OutputMatrixD(D);  { Вывод матрицы }
  InputMatrixE(E); { Ввод матрицы }
  WriteLn; { Пропуск строки }
  WriteLn(' Матрица E: ');  { Вывод заголовка }
  OutputMatrixE(E);  { Вывод матрицы }
  MultiplyMatrix(D,E,F); { Умножение матриц }
  WriteLn; { Пропуск строки }
  WriteLn(' Произведение матриц: ');  { Вывод заголовка }
  OutputMatrixF(F)  { Вывод матрицы }
END.