Laba3_3 concept

Program Lab3_3;

Uses
    System.SysUtils;

Type
    TMatrix = Array of Array of Integer;

Procedure PrintCondition();
Begin
    Writeln('Программа сортирует двумерный массив по количеству делителей каждого элемента.');
End;

Function ReadNum(Min, Max: Integer): Integer;
Var
    Num: Integer;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Try
            Readln(Num);
        Except
            Write('Некорректный ввод!');
            IsCorrect := False;
        End;
        If (IsCorrect) And ((Num < Min) Or (Num > Max)) Then
        Begin
            Write('Недопустимое значение!  ');
            IsCorrect := False;
        End;
    Until IsCorrect;
    ReadNum := Num;
End;

Function ReadMatrixRows(Min: Integer): Integer;
Var
    Rows, Cols : Integer;
    IsCorrect : Boolean;
Begin
    Repeat
        IsCorrect := True;
        Write('Введите количество строк матрицы(от 2 до 10): ');
        Try
            Readln(Rows);
        Except
            Writeln('Некорректный ввод!');
            IsCorrect := False;
        End;

        If (IsCorrect) And ((Rows < 2) Or (Rows > 10 )) Then
        Begin
            Writeln('Недопустимое значение! ');
            IsCorrect := False;
        End;
    Until IsCorrect;
    ReadMatrixRows := Rows;
End;

Function ReadMatrixCols(Min: Integer): Integer;
Var
    Rows, Cols : Integer;
    IsCorrect : Boolean;
Begin
    Repeat
        IsCorrect := True;
        Write('Введите количество столбцов матрицы(от 2 до 10):');
        Try
            Readln(Cols);
        Except
            Writeln('Некорректный ввод! Введите значение ещё раз:');
            IsCorrect := False;
        End;

        If (IsCorrect) And ((Rows < 2) Or (Rows > 10 )) Then
        Begin
            Write('Недопустимое значение! Введите значение ещё раз: ');
            IsCorrect := False;
        End;
    Until IsCorrect;
    ReadMatrixCols := Cols;
End;

Function CountDivisors(N: Integer): Integer;
Var
    Count, I: Integer;
Begin
    Count := 0;
    For I := 1 To N Do
        If N Mod I = 0 Then
            Count := Count + 1;
    CountDivisors := Count;
End;

Procedure SortMatrixByDivisors(Var Matrix: TMatrix; Rows, Cols: Integer);
Var
    I, J, K, L, Temp: Integer;
Begin
    For I := 0 To High(Rows) Do
        For J := 0 To High(Cols) Do
            For K := 0 To High(Rows) Do
                For L := 0 To High(Cols) Do
                    If CountDivisors(Matrix[I, J]) < CountDivisors(Matrix[K, L]) Then
                    Begin
                        Temp := Matrix[I, J];
                        Matrix[I, J] := Matrix[K, L];
                        Matrix[K, L] := Temp;
                    End;
End;

Procedure FillMatrixFromKeyboard(Var Matrix: TMatrix; Rows, Cols: Integer);
Var
    I, J: Integer;
    IsCorrect: Boolean;
    Temp1, Temp2 : Integer;
Begin
    Rows := ReadMatrixRows(Rows);
    Cols :=  ReadMatrixCols(Cols);
    SetLength(Matrix, Rows, Cols);

    Temp1 := Rows - 1;
    Temp2 := Cols - 1;
    For I := 0 To Temp1 Do
    Begin
        For J := 0 To Temp2 Do
        Begin
            Write('Введите элемент [', I + 1, ',', J + 1, ']: ');
            Repeat
                IsCorrect := True;
                Try
                    Readln(Matrix[I][J]);
                Except
                    IsCorrect := False;
                End;

                // Проверка корректности введенного числа
                If (Not IsCorrect) Or (Matrix[I][J] < 1) Or (Matrix[I][J] > 10000) Then
                Begin
                    IsCorrect := False;
                    Writeln('Некорректное значение! Введите натуральное число от 1 до 10000.');
                End;
            Until IsCorrect;
        End;
    End;
End;


Function CheckFile(Path: String): Boolean;
Var
    IsFileCorrect: Boolean;
    InputFile: TextFile;
    Line: String;
    MatrixRows, MatrixCols: Integer;
    TempValue, I, J: Integer;
Begin
    IsFileCorrect := True;

    If FileExists(Path) Then
    Begin
        AssignFile(InputFile, Path);

        If (ExtractFileExt(Path) = '.txt') Then
        Begin
            IsFileCorrect := True;
            Try
                Reset(InputFile);
            Except
                Writeln('Не удалось открыть файл!');
                IsFileCorrect := False;
            End;

            If IsFileCorrect Then
            Begin
                Try
                    Readln(InputFile, MatrixRows);
                    Readln(InputFile, MatrixCols);
                Except
                    Writeln('Ошибка при чтении данных матрицы!');
                    IsFileCorrect := False;
                End;

                If IsFileCorrect And ((MatrixRows < 2) Or (MatrixRows > 10) Or (MatrixCols < 2) Or (MatrixCols > 10)) Then
                Begin
                    Writeln('Размеры матрицы выходят за допустимые пределы (от 2 до 10 строк и столбцов)');
                    IsFileCorrect := False;
                End;

                If IsFileCorrect And (Not Eof(InputFile)) Then
                Begin
                    Writeln('Файл содержит лишние данные после матрицы!');
                    IsFileCorrect := False;
                End;
            End;

            Try
                CloseFile(InputFile);
            Except
            End;

        End
        Else
        Begin
            IsFileCorrect := False;
            Writeln('Файл не является текстовым (.txt)!');
        End;
    End
    Else
    Begin
        Writeln('Файл по данному пути не существует!');
        IsFileCorrect := False;
    End;

    CheckFile := IsFileCorrect;
End;




Procedure FillMatrixFromFile(Var Matrix: TMatrix; Rows, Cols: Integer; FilePath: String);
Var
    InputFile: TextFile;
    I, J: Integer;
    IsCorrect: Boolean;
    PathFile : String;
Begin
    SetLength(Matrix, Rows, Cols);
     Repeat
        Write('Введите путь к файлу с его расширением: ');
        Readln(PathFile);
    Until CheckFile(PathFile);

    AssignFile(InputFile, FilePath);
    Reset(InputFile);

    For I := 0 To High(Rows) Do
    Begin
        For J := 0 To High(Cols) Do
        Begin
            Repeat
                IsCorrect := True;
                Try
                    Read(InputFile, Matrix[I][J]);
                Except
                    IsCorrect := False;
                End;

                If (Not IsCorrect) Or (Matrix[I][J] < 1) Or (Matrix[I][J] > 10000) Then
                Begin
                    IsCorrect := False;
                    Writeln('Ошибка: элемент матрицы [', I + 1, ',', J + 1, '] некорректен. Введите натуральное число от 1 до 10000.');
                End;
            Until IsCorrect;
        End;
    End;

    CloseFile(InputFile);
End;


Function InputMatrix(Var Rows, Cols: Integer): TMatrix;
Var
    Matrix: TMatrix;
    Choice: Integer;
    Path: String;
    InputFile: TextFile;
    I, J: Integer;
Begin
    Write('Выберите способ ввода:', #10, '1. Ввод с консоли', #10, '2. Ввод из файла', #10, 'Ваш выбор: ');
    Choice := ReadNum(1, 2);

    If Choice = 1 Then
    Begin
        FillMatrixFromKeyboard(Matrix, Rows, Cols);
    End
    Else
    Begin
        FillMatrixFromFile(Matrix, Rows, Cols, Path);
    End;
    InputMatrix := Matrix;
End;

Procedure OutputMatrix(Matrix: TMatrix; Rows, Cols: Integer);
Var
    Choice: Integer;
    Path: String;
    OutputFile: TextFile;
    I, J: Integer;
Begin
    Write('Выберите способ вывода:', #10, '1. Вывод в консоль', #10, '2. Сохранение в файл', #10, 'Ваш выбор: ');
    Choice := ReadNum(1, 2);

    If Choice = 1 Then
    Begin
        Writeln('Отсортированная матрица:');
        For I := 0 To High(Rows) Do
        Begin
            For J := 0 To High(Cols) Do
                Write(Matrix[I, J]:5);
            Writeln;
        End;
    End
    Else
    Begin
        Write('Введите путь для сохранения файла: ');
        Readln(Path);
        AssignFile(OutputFile, Path);
        Rewrite(OutputFile);
        For I := 0 To High(Rows) Do
        Begin
            For J := 0 To High(Cols) Do
                Write(OutputFile, Matrix[I, J]:5);
            Writeln(OutputFile);
        End;
        CloseFile(OutputFile);
        Writeln('Матрица успешно сохранена в файл.');
    End;
End;

Var
    Rows, Cols: Integer;
    Matrix: TMatrix;
Begin
    PrintCondition();
    Matrix := InputMatrix(Rows, Cols);
    SortMatrixByDivisors(Matrix, Rows, Cols);
    OutputMatrix(Matrix, Rows, Cols);
    Readln;
End.