===================ПРОСТЫЕ ВСТАВКИ===============
program VstavkiProstSort;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
   TIntArray = array of Integer;

procedure InsertionSort(var Arr: TIntArray);
var
   i, j, buf: Integer;
begin
   for i := Low(Arr) + 1 to High(Arr) do
   begin
      buf := Arr[i];
      j := i - 1;
      while (j >= Low(Arr)) and (Arr[j] > buf) do
      begin
         Arr[j + 1] := Arr[j];
         Dec(j);
      end;
      Arr[j + 1] := buf;
   end;
end;

var
   Arr: TIntArray;
   i, N: Integer;
begin
   WriteLn('N:');
   ReadLn(N);
   WriteLn('Massive:');
   SetLEngth(Arr, N);
   for i := 0 to High(Arr) do
      Read(Arr[i]);
   InsertionSort(Arr);
   for i := 0 to High(Arr) do
      Write(Arr[i], ' ');
   Readln;
   Readln;
end.
=================================================

================СЛИЯНИЕ============================
program SliianSort;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
    TArray =  array of Integer;

procedure MergeArrays(var Arr: TArray; leftPoint, midPoint, rightPoint: Integer);
var
   it1, it2: Integer;
   result: TArray;
   i: Integer;
begin
   it1 := 0;
   it2 := 0;
   SetLength(result, rightPoint - leftPoint);
   while (leftPoint + it1 < midPoint) and (midPoint + it2 < rightPoint) do
      if Arr[leftPoint + it1] < Arr[midPoint + it2] then
      begin
         result[it1 + it2] := Arr[leftPoint + it1];
         Inc(it1);
      end
      else
      begin
         result[it1 + it2] := Arr[midPoint + it2];
         Inc(it2);
      end;
   while leftPoint + it1 < midPoint do
   begin
      result[it1 + it2] := Arr[leftPoint + it1];
      Inc(it1);
   end;
   while midPoint + it2 < rightPoint do
   begin
      result[it1 + it2] := Arr[midPoint + it2];
      Inc(it2);
   end;
   for i := 0 to it1 + it2 - 1 do
      Arr[leftPoint + i] := result[i];
end;

procedure OutputArray(arr: TArray);
var
   i, maxIndex: Integer;
begin
   maxIndex := Length(arr) - 1;
   for i := 0 to maxIndex do
      Write(arr[i], ' ');
end;

procedure NaturalMergeSort(var initArray: TArray);
var
   leftPoint, middlePoint, rightPoint, i: Integer;
   isCorrect: Boolean;
begin
   isCorrect := True;
   while isCorrect do
   begin
      rightPoint := 0;
      while rightPoint < High(initArray) do
      begin
         i := rightPoint;
         leftPoint := rightPoint;
         while (initArray[i] <= initArray[i + 1]) and
            (i + 1 <= High(initArray)) do
            Inc(i);
         Inc(i);
         middlePoint := i;
         isCorrect := middlePoint < Length(initArray);
         if (leftPoint <> 0) and (i + 1 <= High(initArray)) then
            isCorrect := True;
         rightPoint := middlePoint + 1;
         while (initArray[i] <= initArray[i + 1]) and
            (i + 1 <= High(initArray)) do
         begin
            Inc(rightPoint);
            Inc(i);
         end;
         if middlePoint < Length(initArray) then
            MergeArrays(initArray, leftPoint, middlePoint, rightPoint);

      end;
   end;
end;

var
    Arr: TArray;
    Quantity, i: Integer;
begin
    Writeln('N:');
    Readln(Quantity);
    SetLength(Arr, Quantity);
    Dec(Quantity);
    for i := 0 to Quantity do
        Read(Arr[i]);
    NaturalMergeSort(Arr);
    for i := 0 to Quantity do
        Write(Arr[i], ' ');
    Readln;
    Readln;
end.
=================================================

============ШЕЙКЕРНАЯ============================
program ShakerSort;

{$APPTYPE CONSOLE}

uses
  SysUtils;

procedure Swap(var Arr: array of Integer; i : Integer);
var
    buff: Integer;
begin
    buff := Arr[i];
    Arr[i] := Arr[i - 1];
    Arr[i - 1] := buff;
end;

procedure Main;
var
    i, markLeft, markRight: Integer;
    Arr: array of Integer;
begin
    Readln(markRight);
    SetLength(Arr, markRight);
    markLeft := 1;
    Dec(markRight);
    for i := 0 to markRight do
        Read(Arr[i]);
    while markLeft <= markRight do
    begin
        for i := markRight downto markLeft do
            if Arr[i - 1] > Arr[i] then
                Swap(Arr, i);
        Inc(markLeft);
        for i := markLeft to markRight do
            if Arr[i - 1] > Arr[i] then
                Swap(Arr, i);
        Dec(markRight);
    end;
    for i := 0 to High(Arr) do
        Write(Arr[i], ' ');
    Readln;
    Readln;
end;

begin
    Main;
end.
=================================================

==============ПОРАЗРЯДНАЯ========================
program RadixSort;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  Math;

type
   TIntArray = array of Integer;

function GetMaxOrder(DataArray: TIntArray): Integer;
var
   i: Byte;
   MaxEl: Integer;
begin
   MaxEl := DataArray[0];
   for i := 1 to High(DataArray) do
      if DataArray[i] > MaxEl then
         MaxEl := DataArray[i];
   GetMaxOrder := Length(IntToStr(MaxEl));
end;

function RadixSort(DataArr: TIntArray): TIntArray;
var
   i, j, k: Byte;
   PosArr: array [0 .. 9] of array of Integer;
   TempArray: TIntArray;
   Dev: Integer;
   MaxOrder: Integer;
begin
   MaxOrder := GetMaxOrder(DataArr);
   Dev := 1;
   Setlength(TempArray, Length(DataArr));
   repeat
      for i := 0 to High(DataArr) do
      begin
         Setlength(PosArr[(DataArr[i] div Dev) mod 10],
            Length(PosArr[(DataArr[i] div Dev) mod 10]) + 1);
         PosArr[(DataArr[i] div Dev) mod 10]
           [ High(PosArr[(DataArr[i] div Dev) mod 10])] := i;
      end;
      Dev := Dev * 10;
      k := 0;
      for i := 0 to High(PosArr) do
         if Length(PosArr[i]) <> 0 then
         begin
            for j := 0 to High(PosArr[i]) do
            begin
               TempArray[k] := DataArr[PosArr[i][j]];
               Inc(k);
            end;
            Setlength(PosArr[i], 0);
         end;
      for i := 0 to High(DataArr) do
         DataArr[i] := TempArray[i];
   until Dev = Power(10, MaxOrder);
   RadixSort := DataArr;
end;

var
   Arr: TIntArray;
   i, N: Integer;
begin
   WriteLn('N:');
   ReadLn(N);
   SetLength(Arr, N);
   for i := 0 to high(arr) do
      read(arr[i]);
   RadixSort(Arr);
   for i := 0 to High(Arr) do
      Write(Arr[i], ' ');
   Readln;
   Readln;
end.
============================================
===============ХОАРА(QUICKSORT)=============
program QSort;

{$APPTYPE CONSOLE}

uses
  SysUtils;

procedure quickSort(var Arr: array of Integer; first, last: Integer);
var
    i, j, x, help: Integer;
begin
    x := Arr[(first + last) div 2];
    i := first;
    j := last;
    while i<=j do
    begin
        while Arr[i] < x do
            Inc(i);
        while x < Arr[j] do
            Dec(j);
        if i <= j then
        begin
            help := Arr[i];
            Arr[i] := Arr[j];
            Arr[j] := help;
            i := i+1;
            j := j-1;
        end;
    end;
    if first < j then quickSort(Arr, first, j);
    if i < last then quickSort(Arr, i, last);
end;


procedure Main;
var
    Arr: array of Integer;
    i, Quantity: Integer;
begin
    Readln(Quantity);
    SetLength(Arr, Quantity);
    Dec(Quantity);
    for i := 0 to Quantity do
        Read(Arr[i]);
    quickSort(Arr, 0, Quantity);
    for i := 0 to Quantity do
        Write(Arr[i], ' ');
    Readln;
    Readln;
end;

begin
    Main;
end.
===========================================
======ПРОСТОЙ ВЫБОР========================
program prostVibor;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
    min, least, help, j, N: Integer;
    Arr: array of Integer;

begin
    Writeln('N:');
    Read(N);
    SetLength(Arr, N);
    for j := 0 to High(Arr) do
        Read(Arr[j]);
    for min := 0 to High(Arr) do
    begin
        least := min;
        for j := min + 1 to High(Arr) do
            if (arr[j] < arr[least]) then
                least := j;
        help := Arr[min];
        Arr[min] := Arr[least];
        Arr[least] := help;
    end;
    for j := 0 to High(Arr) do
        Write(Arr[j], ' ');
    Readln;
    Readln;
end.
============================================
===========ПОДСЧЕТ==========================
program Podschet;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
   i, j, k, N: integer;
   countingArray, answer: array of Integer;
   ArrayOfNumbers : array of Integer;
begin
   WriteLn('N:');
   ReadLn(N);
   SetLength(ArrayOfNumbers, N);
   WriteLn('Massive:');
   for i := 0 to High(ArrayOfNumbers) do
      Read(ArrayOfNumbers[i]);
   Setlength(countingArray, N);
   Setlength(answer, N);
   for j := 0 to (Length(countingArray) - 1) do
      CountingArray[j] := 0;
   for j := 0 to (Length(ArrayOfNumbers) - 2) do
      for k := (j + 1) to (Length(ArrayOfNumbers) - 1) do
         if ArrayOfNumbers[j] > ArrayOfNumbers[k] then
            Inc(CountingArray[j])
         else
            Inc(CountingArray [k]);
   for j := 0 to (Length(CountingArray) - 1) do
      for k := 0 to (Length(CountingArray) - 1) do
         if j = CountingArray[k] then
            Answer[j] := ArrayOfNumbers[k];
   for i := 0 to High(ArrayOfNumbers) do
      ArrayOfNumbers[i] := answer[i];
   for i := 0 to High(ArrayOfNumbers) do
        Write(ArrayOFNumbers[i], ' ');
   Readln;
   Readln;
end.