program MatrixProcessing;

{$MODE DELPHI}

uses
  SysUtils;

const
  N = 6;  // строки
  M = 7;  // столбцы

type
  TMatrix = array[1..N, 1..M] of Real;

// процедура заполнения матрицы
procedure FillMatrix(var Matrix: TMatrix);
var
  i, j: Integer;
begin
  Randomize;
  for i := 1 to N do
    for j := 1 to M do
      Matrix[i, j] := Random * 100; // числа от 0 до 100
end;

// процедура вывода матрицы на экран
procedure PrintMatrix(const Matrix: TMatrix; const Caption: string);
var
  i, j: Integer;
begin
  Writeln(Caption);
  for i := 1 to N do
  begin
    for j := 1 to M do
      Write(Matrix[i, j]:8:2);
    Writeln;
  end;
  Writeln;
end;

// функция поиска минимального элемента в строке и его индекса столбца
function FindMinInRow(const Row: array of Real; RowSize: Integer): Integer;
var
  i, MinIndex: Integer;
  MinValue: Real;
begin
  MinIndex := 0;
  MinValue := Row[0];
  for i := 1 to RowSize - 1 do
    if Row[i] < MinValue then
    begin
      MinValue := Row[i];
      MinIndex := i;
    end;
  Result := MinIndex + 1; // +1 тк индексы в массиве начинаются с 0, а в матрице — с 1
end;

// процедура поиска наибольшего среди минимальных элементов строк и его индексов
procedure FindMaxAmongMins(const Matrix: TMatrix; var RowIndex, ColIndex: Integer);
var
  i: Integer;
  CurrentMinCol: Integer;
  CurrentMin, MaxAmongMins: Real;
begin
  MaxAmongMins := -MaxInt; // начальное значение очень маленькое число

  for i := 1 to N do
  begin
    // создаём временный массив для строки
    CurrentMinCol := FindMinInRow(Matrix[i], M);
    CurrentMin := Matrix[i, CurrentMinCol];

    if CurrentMin > MaxAmongMins then
    begin
      MaxAmongMins := CurrentMin;
      RowIndex := i;
      ColIndex := CurrentMinCol;
    end;
  end;
end;

// процедура сортировки матрицы по убыванию 
procedure SortMatrixDescending(var Matrix: TMatrix);
var
  FlatArray: array of Real;
  i, j, k: Integer;
  Temp: Real;
begin
  // преобразуем матрицу в одномерный массив
  SetLength(FlatArray, N * M);
  k := 0;
  for i := 1 to N do
    for j := 1 to M do
    begin
      FlatArray[k] := Matrix[i, j];
      Inc(k);
    end;

  // сортировка пузырьком
  for i := 0 to High(FlatArray) - 1 do
    for j := 0 to High(FlatArray) - i - 1 do
      if FlatArray[j] < FlatArray[j + 1] then
      begin
        Temp := FlatArray[j];
        FlatArray[j] := FlatArray[j + 1];
        FlatArray[j + 1] := Temp;
      end;

  // возвращаем отсортированные значения в матрицу
  k := 0;
  for i := 1 to N do
    for j := 1 to M do
    begin
      Matrix[i, j] := FlatArray[k];
      Inc(k);
    end;
end;

var
  Matrix: TMatrix;
  RowIndex, ColIndex: Integer;

begin
  try
    // заполняем матрицу
    FillMatrix(Matrix);

    // выводим исходную матрицу
    PrintMatrix(Matrix, 'Original matrix:');

    // находим наибольший среди минимальных элементов строк
    FindMaxAmongMins(Matrix, RowIndex, ColIndex);
    Writeln('The largest among the minimum elements is in the row ',
            RowIndex, ', col ', ColIndex, '.');
    Writeln('Value: ', Matrix[RowIndex, ColIndex]:8:2);
    Writeln;

    // сортируем матрицу по убыванию
    SortMatrixDescending(Matrix);

    // выводим отсортированную матрицу
    PrintMatrix(Matrix, 'Matrix after sorting in descending order:');

  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

  Readln; 
end.