Program L2_4_D;

uses
  System.SysUtils;

Type
    TArray = Array of Integer;


Function InputSizeFromConsole() : Integer;
Var
    IsCorrect : Boolean;
    Size : Integer;
Begin
    Repeat
        IsCorrect := True;
        Writeln('Введите количество элементов в массиве');
        Try
            Readln(Size);
        Except
            IsCorrect := False;
        End;
        If ((Size < 1) Or Not IsCorrect) Then
        Begin
            IsCorrect := False;
            Writeln('Неверный тип данных');
        End;
    Until IsCorrect;

    InputSizeFromConsole := Size;
End;

Function ExceptionRead(I : Integer) : Integer;
Var
    Number : Integer;
    IsCorrect : Boolean;
Begin
    Repeat
        IsCorrect := True;
        Writeln('Введите ', (I+1), ' элемент массива: ');
        Try
            Readln(Number);
        Except
            IsCorrect := False;
            Writeln('Неверный тип данных!');
        End;
    Until IsCorrect;

    ExceptionRead := Number;
End;

Procedure OutputTaskEssence();
Begin
     Writeln('Данная программа сортирует числа в массиве путем подсчета.');
End;

Function PathChoice() : String;
Var
    TextF : TextFile;
    Path : String;
    IsCorrect : Boolean;

Begin
    Repeat
        IsCorrect := True;
        Writeln('Введите путь файла: ');
        Try
            Readln(Path);
            AssignFile(TextF, Path);
            Reset(TextF);
        Except
            IsCorrect := False;
            Writeln('Неверный путь файла!');
        End;
        If (Not IsCorrect  Or (Length(Path) < 1)) Then
        Begin
            Writeln('Неверный путь файла!');
            IsCorrect := False;
        End
        Else
        Begin
            If (Path[Length(Path)] <> 't') And (Path[Length(Path) - 1] <> 'x') And (Path[Length(Path) - 2] <> 't') And (Path[Length(Path) - 3] <> '.') then
            Begin
                Writeln('Неверный путь файла!');
                IsCorrect := False;
            End;

        End;
    Until IsCorrect;
    Writeln('Файл успешно открыт!');
    PathChoice := Path;
    CloseFile(TextF);
End;

Function InputSizeFromFile(Path : String; var TextF : TextFile) : Integer;
Var
    Size : Integer;
    IsCorrect : Boolean;

Begin
    AssignFile(TextF, Path);
    Reset(TextF);
    IsCorrect := True;
    Writeln('Запись количества строк...');
    Try
        Readln(TextF, Size);
    Except
        IsCorrect := False;
    End;
    If ((Size < 1) Or (IsCorrect = False)) Then
    Begin
        Writeln('Ошибка! Неверный ввод размера! Впишите данные с клавиатуры.');
        Size := InputSizeFromConsole();
    End;

    Writeln('Количество элементов массива: ', Size);
    CloseFile(TextF);
    InputSizeFromFile := Size;

End;

Function ArrayReadingFromFile(Path : String; Size : Integer; var TextF : TextFile; Arr : TArray) : TArray;
Var
    I : Integer;
    Line : String;
    IsCorrect : Boolean;

Begin
    AssignFile(TextF, Path);
    Reset(TextF);
    Dec(Size);
    IsCorrect := True;
    Readln(TextF, Line);

    Writeln('Запись матрицы...');
    For I := 0 To Size Do
    Begin
        Try
            Read(TextF, Arr[I])
        Except
            Writeln(' Неверный ввод данных! Введите данные с клавиатуры.');
            Arr[I] := ExceptionRead(I);
        End;
    End;
    CloseFile(TextF);

    ArrayReadingFromFile := Arr;

End;

Function SortArray(Arr : TArray) : TArray;
Var
    I, J, K : Integer;
    MinVal, MaxVal : Integer;
    Count : TArray;
Begin
    MinVal := Arr[0];
    MaxVal := Arr[0];

    For I := 1 To High(Arr) Do
    Begin
        If Arr[I] < MinVal Then
            MinVal := Arr[I];
        If Arr[I] > MaxVal Then
            MaxVal := Arr[I];
    End;

    SetLength(Count, MaxVal - MinVal + 1);
    For I := 0 To High(Count) Do
        Count[I] := 0;

    For I := 0 To High(Arr) Do
    Begin
        Inc(Count[Arr[I] - MinVal]);
    End;

    K := 0;
    For I := 0 To High(Count) Do
    Begin
        For J := 1 To Count[I] Do
        Begin
            Arr[K] := I + MinVal;
            Inc(K);
        End;
    End;

    SortArray := Arr;
End;

Procedure Output(SortedArray : TArray);
Var
    TextF : TextFile;
    Path : String;
    IsCorrect : Boolean;
    I : Integer;

Begin
    Writeln;
    Writeln('Отсортированный массив: ');
    For I := 0 To High(SortedArray) Do
        Write(SortedArray[I], ' ');
    Writeln;
    Repeat
        IsCorrect := True;
        Writeln('Введите путь файла для вывода: ');
        Try
            Readln(Path);
            AssignFile(TextF, Path);
            Reset(TextF);
        Except
            IsCorrect := False;
            Writeln('Неверный путь файла!');
        End;
        If (Not IsCorrect  Or (Length(Path) < 1)) Then
        Begin
            Writeln('Неверный путь файла!');
            IsCorrect := False;
        End
        Else
        Begin
            If (Path[Length(Path)] <> 't') And (Path[Length(Path) - 1] <> 'x') And (Path[Length(Path) - 2] <> 't') And (Path[Length(Path) - 3] <> '.') then
            Begin
                Writeln('Неверный путь файла!');
                IsCorrect := False;
            End;

        End;
    Until IsCorrect;

    Append(TextF);
    Writeln(TextF);
    Writeln(TextF, 'Отсортированный массив: ');
    For I := 0 To High(SortedArray) Do
        Write(TextF, SortedArray[I], ' ');
    CloseFile(TextF);
    Writeln('Данные записаны в файл.');
    Readln;

End;

Function InputFromFile() : TArray;

Var
    Path : String;
    Size, MaxRes : Integer;
    TextF : TextFile;
    Arr : TArray;

Begin
    Writeln('При записи данных из файла, учтите, что на первой строке написано количество элементов массива, а с новой строки сам массив чисел.');
    Path := PathChoice();
    Size := InputSizeFromFile(Path, TextF);
    SetLength(Arr, Size);
    Arr := ArrayReadingFromFile(Path, Size, TextF, Arr);

    InputFromFile := Arr;
End;

Function ArrayReadingFromConsole(Size : Integer; Arr : TArray) : TArray;
Var
    IsCorrect : Boolean;
    I, J : Integer;
Begin
    Dec(Size);

    For I := 0 To Size Do
    Begin
        Repeat
            IsCorrect := True;
            Writeln('Введите элемент с индексом ', I+1);
            Try
                Readln(Arr[I]);
            Except
                IsCorrect := False;
                Writeln('Неверный тип данных');
            End;
        Until IsCorrect;
    End;

    ArrayReadingFromConsole := Arr;
End;

Function InputFromConsole() : TArray ;

Var
    Size, MaxSum : Integer;
    Arr : TArray;

Begin
    Size := InputSizeFromConsole();
    SetLength(Arr, Size);
    Arr := ArrayReadingFromConsole(Size, Arr);

    InputFromConsole := Arr;
End;

Function SourceChoice() : TArray;
Var
    ChoiceNumber : Integer;
    Arr : TArray;
    IsCorrect : Boolean;

Begin
    Writeln('Выберите, откуда будут вводиться данные:');
    Repeat
        IsCorrect := True;
        Writeln('Введите 0, если с консоли; введите 1, если с файла.');
        Try
            Readln(ChoiceNumber);
        Except
            IsCorrect := False;
        End;
        If ((IsCorrect = False) Or ((ChoiceNumber <> 1) And (ChoiceNumber <> 0))) Then
        Begin
            Writeln('Неверный ввод данных!');
            IsCorrect := False;
        End;
    Until IsCorrect;
    If (ChoiceNumber = 0) Then
        Arr := InputFromConsole()
    Else
        Arr := InputFromFile();

    SourceChoice := Arr;

End;

Var
    SortedArray : TArray;
    Arr : TArray;

Begin
    OutputTaskEssence();
    Arr := SourceChoice();
    SortedArray := SortArray(Arr);
    Output(SortedArray);

End.