лаба2н4

Program laba4;

Uses
    Windows, SysUtils;

Type
    TArrOI = Array Of Integer;

Procedure OutputCondition();
Begin
    Writeln('Данная программа находит элемент массива, состоящего из N натуральных чисел, сумма цифр которого наибольшая.');
End;

Procedure OutputInputChoice();
Begin
    Writeln('Введите 0, если хотите ввести данные из консоли, и 1 - из файла:');
End;

Function IsUserChoice(): Boolean;
Const
    MIN = 0;
    MAX = 1;
Var
    IsCorrect, IsChoice: Boolean;
    K: Byte;
Begin
    Repeat
        IsCorrect := True;
        Try
            Readln(K);
        Except
            Writeln('Введены некорректные данные. Повторите ввод:');
            IsCorrect := False;
        End;
        If IsCorrect And ((K > MAX) Or (K < MIN)) Then
        Begin
            Writeln('Число вне допустимого диапазона. Повторите ввод:');
            IsCorrect := False;
        End;
    Until IsCorrect;
    If (K = MIN) Then
        IsChoice := False
    Else
        IsChoice := True;
    IsUserChoice := IsChoice;
End;

Procedure OutputPathInputCondition();
Begin
    Writeln('Введите путь к файлу, содержащему массив:');
End;

Function IsFileCorrect(Path: String): Boolean;
Var
    F: TextFile;
    IsCorrect: Boolean;
Begin
    IsCorrect := True;
    If Not FileExists(Path) Then
    Begin
        IsCorrect := False;
        Write('Файл по заданному пути отсутствует. ');
    End
    Else If ExtractFileExt(Path) <> '.txt' Then
    Begin
        IsCorrect := False;
        Write('Недопустимое расширение файла. ');
    End;
    If IsCorrect Then
    Begin
        AssignFile(F, Path);
        Try
            Reset(F);
        Except
            IsCorrect := False;
            Write('Файл недоступен для открытия. ');
        End;
        CloseFile(F);
    End;
    IsFileCorrect := IsCorrect;
End;

Function IsNumberOfElementsCorrect(Var InputF: TextFile): Boolean;
Const
    MIN = 2;
Var
    N: Integer;
    IsCorrect: Boolean;
Begin
    IsCorrect := True;
    Try
        Read(InputF, N);
    Except
        IsCorrect := False;
        Write('Размер массива введён некорректно. ');
    End;
    If IsCorrect And (N < MIN) Then
    Begin
        IsCorrect := False;
        Write('Слишком малый размер массива. ');
    End;
    IsNumberOfElementsCorrect := IsCorrect;
End;

Function IsDataForArrayCorrect(Var InputF: TextFile): Boolean;
Const
    NUM_MIN = 1;
Var
    N, Count, X: Integer;
    IsCorrect: Boolean;
Begin
    Count := 0;
    IsCorrect := True;
    Reset(InputF);
    Read(InputF, N);
    While Not EoF(InputF) Do
    Begin
        Try
            Read(InputF, X);
        Except
            IsCorrect := False;
        End;
        If IsCorrect And (X < NUM_MIN) Then
            IsCorrect := False;
        Inc(Count);
    End;
    If Not IsCorrect Then
        Write('Файл содержит некорректные данные. ')
    Else If (Count < N) Then
    Begin
        IsCorrect := False;
        Write('Недостаточно данных в файле. ');
    End;
    IsDataForArrayCorrect := IsCorrect;
End;

Function IsDataInFileCorrect(Path: String): Boolean;
Var
    InputF: TextFile;
    IsCorrect: Boolean;
Begin
    AssignFile(InputF, Path);
    Reset(InputF);
    IsCorrect := IsNumberOfElementsCorrect(InputF);
    If IsCorrect Then
        IsCorrect := IsDataForArrayCorrect(InputF);
    CloseFile(InputF);
    IsDataInFileCorrect := IsCorrect;
End;

Function InputPathToFileIn(): String;
Var
    Path: String;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Readln(Path);
        IsCorrect := IsFileCorrect(Path);
        If IsCorrect Then
            IsCorrect := IsDataInFileCorrect(Path);
        If Not IsCorrect Then
            Writeln('Повторите ввод пути к файлу:');
    Until IsCorrect;
    InputPathToFileIn := Path;
End;

Function InputNumberFromFile(Var InputF: TextFile;
  Var IsCorrect: Boolean): Integer;
Var
    N: Integer;
Begin
    Try
        Readln(InputF, N);
    Except
        Writeln('Проверьте ваше значение длины массива');
        IsCorrect := False;
    End;
    If (N < 2) Then
    Begin
        IsCorrect := False;
        Writeln('Массив должен включать от двух элементов');
    End;
    InputNumberFromFile := N;
End;

Function InputArrayFromFile(Var InputF: TextFile; N: Integer;
  Var IsCorrect: Boolean): TArrOI;
Var
    I: Integer;
    A: TArrOI;
Begin
    SetLength(A, N);
    I := 0;
    While (I < Length(A)) And IsCorrect Do
    Begin
        Try
            Read(InputF, A[I]);
        Except
            Writeln('Неправильное значение для элемента массива');
            IsCorrect := False;
        End;
        If (A[I] < 1) Then
        Begin
            IsCorrect := False;
            Writeln('Значения массива должны быть натуральными');
        End;
        Inc(I);
    End;
    InputArrayFromFile := A;
End;

Procedure OutputSuccessfulInput();
Begin
    Writeln('Данные из файла считаны успешно.');
End;

Procedure OutputNumberConditionForConsole();
Begin
    Writeln('Введите количество элементов массива N:');
End;

Function InputNumberFromConsole(): Integer;
Const
    MIN = 2;
Var
    N: Integer;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Try
            Readln(N);
        Except
            Writeln('Введены некорректные данные. Повторите ввод:');
            IsCorrect := False;
        End;
        If IsCorrect And (N < MIN) Then
        Begin
            Writeln('Введено недопустимое число элементов. Повторите ввод:');
            IsCorrect := False;
        End;
    Until IsCorrect;
    InputNumberFromConsole := N;
End;

Procedure OutputInputConditionForConsole();
Begin
    Writeln('Поочерёдно введите натуральные числа, являющиеся элементами массива.');
End;

Function InputArrayFromConsole(A: TArrOI): TArrOI;
Const
    NUM_MIN = 1;
Var
    I: Integer;
    IsCorrect: Boolean;
Begin
    For I := 0 To High(A) Do
    Begin
        Repeat
            Writeln('Введите ', I + 1, ' элемент массива:');
            IsCorrect := True;
            Try
                Readln(A[I]);
            Except
                Writeln('Введены некорректные данные. Повторите ввод.');
                IsCorrect := False;
            End;
            If IsCorrect And (A[I] < NUM_MIN) Then
            Begin
                Writeln('Введённые данные не соответствуют условию. Повторите ввод.');
                IsCorrect := False;
            End;
        Until IsCorrect;
    End;
    InputArrayFromConsole := A;
End;

Function InputDataFromFile(): TArrOI;
Var
    InputF: TextFile;
    Path: String;
    IsCorrect: Boolean;
    N: Integer;
    A: TArrOI;
Begin
    Repeat
        IsCorrect := True;
        Path := InputPathToFileIn();
        AssignFile(InputF, Path);
        Reset(InputF);
        IsCorrect := True;
        N := InputNumberFromFile(InputF, IsCorrect);
        If IsCorrect Then
            A := InputArrayFromFile(InputF, N, IsCorrect);
        CloseFile(InputF);
    Until IsCorrect;
    InputDataFromFile := A;
End;

Function InputArray(IsInput: Boolean): TArrOI;
Var
    N: Integer;
    A: TArrOI;
    IsCorrect: Boolean;
Begin
    If IsInput Then
    Begin
        OutputPathInputCondition();
        A := InputDataFromFile();
        OutputSuccessfulInput();
    End
    Else
    Begin
        OutputNumberConditionForConsole();
        N := InputNumberFromConsole();
        SetLength(A, N);
        OutputInputConditionForConsole();
        A := InputArrayFromConsole(A);
    End;
    InputArray := A;
End;

Function SumNumbers(Num: Integer): Integer;
Var
    Sum: Integer;
Begin
    Sum := 0;
    While Num > 0 do
    Begin
        Sum := Sum + Num Mod 10;
        Num := Num Div 10;
    End;
    SumNumbers := Sum;
End;

Function MaxSumNumbers(A: Array Of Integer): Integer;
Var
    MaxSum: Integer;
    MaxNum: Integer;
    I, CurrentSum: Integer;
Begin
    MaxSum := 0;
    MaxNum := 0;
    For I := 0 To High(A) Do
    Begin
        CurrentSum := SumNumbers(A[I]);
        If CurrentSum > MaxSum Then
        Begin
            MaxSum := CurrentSum;
            MaxNum := A[I];
        End;
    End;
    MaxSumNumbers := MaxNum;
End;

Procedure OutputOutputChoice();
Begin
    Writeln('Введите 0, если хотите вывести данные в консоль, и 1 - в файл:');
End;

Procedure OutputPathOutputCondition();
Begin
    Writeln('Введите путь к файлу, в который вы хотите вывести результат:');
End;

Function InputPathToFileOut(): String;
Var
    Path: String;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Readln(Path);
        IsCorrect := IsFileCorrect(Path);
        If Not IsCorrect Then
            Writeln('Повторите ввод пути к файлу:');
    Until IsCorrect;
    InputPathToFileOut := Path;
End;

Procedure OutputInFile(Var OutputF: TextFile; MaxNum: Integer);
Begin
    Write(OutputF, 'Число с наибольшей суммой равно ', MaxNum);
End;

Procedure OutputSuccessfulOutput();
Begin
    Writeln('Данные записаны в файл успешно.');
End;

Procedure OutputInConsole(MaxNum: Integer);
Begin
    Writeln('Число с наибольшей суммой равно ', MaxNum);
End;

Procedure OutputMaxNum(IsOutput: Boolean; MaxNum: Integer);
Var
    Path: String;
    OutputF: TextFile;
Begin
    If IsOutput Then
    Begin
        OutputPathOutputCondition();
        Path := InputPathToFileOut();
        AssignFile(OutputF, Path);
        Rewrite(OutputF);
        OutputInFile(OutputF, MaxNum);
        CloseFile(OutputF);
        OutputSuccessfulOutput();
    End
    Else
        OutputInConsole(MaxNum);
End;

Var
    MaxNum: Integer;
    A: TArrOI;
    IsInput, IsOutput: Boolean;

Begin
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    OutputCondition();
    OutputInputChoice();
    IsInput := IsUserChoice();
    A := InputArray(IsInput);
    MaxNum := MaxSumNumbers(A);
    OutputOutputChoice();
    IsOutput := IsUserChoice();
    OutputMaxNum(IsOutput, MaxNum);
    Readln;

End.