program Bla_bla;

const
  n = 20;

var
  arr: array [1..n] of Integer;
  middle: Integer;				{средний элемент}
  min, min_2, min_pos, min_2_pos: Integer;	{мин и 2-й мин зл-ты и их позиции}
  temp: Integer;					{буферная перем. для обмена 2-х знач. в массиве}
  sp: Integer;					{указатель на вершину стека}
  i, j: Integer;
  stackl, stackr: array [1..n] of Integer;		{стеки границ фрагментов}
  left, right: Integer;				{границы сортируемого фрагмента}

begin
  writeln('Введите 20 элементов массива');

  for i := 1 to n do
    read(arr[i]);

  sp := 1;
  stackl[1] := 1;
  stackr[1] := n;

  while sp > 0 do
    begin
      {выборка границ фрагмента из стека}

      left := stackl[sp];
      right := stackr[sp];

      dec(sp);

      while left < right do
        begin
          {разделение фрагмента arr[left]..arr[right]:}

          i := left;
          j := right;
          middle := arr[(left + right) div 2];

          while i < j do
            begin
              while arr[i] < middle do
                inc(i);

              while middle < arr[j] do
                dec(j);

              if i <= j then
                begin
                  temp := arr[i];
                  arr[i] := arr[j];
                  arr[j] := temp;

                  inc(i); dec(j);
                end;
            end;

            if i < right then
              begin
                {запись в стек границ правой части фрагмента}

                inc(sp);
                stackl[sp] := i;
                stackr[sp] := right;
              end;

            right := j;

            {теперь left и right ограничивают левую часть}
        end;
  end;

  writeln('Упорядоченный массив: ');

  for i := 1 to n do
     write(arr[i]:8);

  readln;

  {До этого был код из учебника и он выполняется. Далее то, что дописывал сам}

  min := 1;

  for i := n downto 1 do
    if (arr[i] mod 2 <> 0) and (arr[i] > 0) then
      begin
        min := arr[i];
        i := min_pos;
      end;


  min_2 := 1;


  for i := n to min do
    if (arr[i] mod 2 <> 0) and (arr[i] > 0) then
      begin
        min_2 := arr[i];
        min_2_pos := i;
      end;

  writeln('Второй мин положительный элемент: ', min_2);

  writeln('Его позиция в массиве: ', min_2_pos);
end.

{$APPTYPE CONSOLE}

program TestApp;

uses
  uPoints, uMetricProcs, uMetricLessProcs, uSorting;

const
  cRand_max = 32767;
  cArraySize = 10000000;

type
  TLargeInteger = Int64;
  
function QueryPerformanceCounter(var ALargeInteger: TLargeInteger): Boolean;
  stdcall; external 'kernel32.dll' name 'QueryPerformanceCounter';

function QueryPerformanceFrequency(var ALargeInteger: TLargeInteger): Boolean;
  stdcall; external 'kernel32.dll' name 'QueryPerformanceFrequency';

function OldPointInit: TOldPoint;
begin
  with Result do
    begin
      fX := Random(cRand_max);
      fY := Random(cRand_max);
    end;
end;

function NewPointInit(const AOldPoint: TOldPoint): TNewPoint;
begin
  with Result do
    begin
      fX := AOldPoint.fX / cRand_max;
      fY := AOldPoint.fY / cRand_max;
    end;
end;

var
  iCount: Integer;
  
  fOldPoint: array of TOldPoint;
  fNewPoint: array of TNewPoint;

  perfBegin: TLargeInteger;
  perfRandomized: TLargeInteger;
  perfConverted: TLargeInteger;
  perfSorted: TLargeInteger;
  perfFreq: TLargeInteger;

begin
  Randomize;

  QueryPerformanceCounter(perfBegin);

  SetLength(fOldPoint, cArraySize);

  for iCount := Low(fOldPoint) to High(fOldPoint) do
    fOldPoint[iCount] := OldPointInit;

  QueryPerformanceCounter(perfRandomized);

  SetLength(fNewPoint, cArraySize);

  for iCount := Low(fNewPoint) to High(fNewPoint) do
    fNewPoint[iCount] := NewPointInit(fOldPoint[iCount]);

  QueryPerformanceCounter(perfConverted);

  QuickSort(fNewPoint, Low(fNewPoint), High(fNewPoint), MetricLess);

  QueryPerformanceCounter(perfSorted);

  QueryPerformanceFrequency(perfFreq);

  perfFreq := perfFreq div 1000;

  with fNewPoint[Low(fNewPoint)] do
    Writeln('Min: ', Metric(fNewPoint[Low(fNewPoint)]), ' [', fX, '; ', fY, ']');

  with fNewPoint[High(fNewPoint)] do
    Writeln('Max: ', Metric(fNewPoint[High(fNewPoint)]), ' [', fX, '; ', fY, ']');

  Writeln('Randomization: ', (perfRandomized - perfBegin) div perfFreq, ' ms');
  Writeln('Conversion:    ', (perfConverted - perfRandomized) div perfFreq, ' ms');
  Writeln('Sort:          ', (perfSorted - perfConverted) div perfFreq, ' ms');
  Writeln('Overall:       ', (perfSorted - perfBegin) div perfFreq, ' ms');

  Readln;
end.

unit uPoints;

interface

type
  TOldPoint = record
    fX, fY: Integer;
  end;

  TNewPoint = record
    fX, fY: Double;
  end;

implementation

initialization

finalization

end.

unit uMetricProcs;

interface

uses
  uPoints;

function Metric(const ANewPoint: TNewPoint): Double;

implementation

function Metric(const ANewPoint: TNewPoint): Double;
begin
  with ANewPoint do
    Result := fX * fX + fY * fY;
end;

initialization

finalization

end.

unit uMetricLessProcs;

interface

uses
  uPoints;

function MetricLess(const ALeftPart, ARightPart: TNewPoint): Boolean;

implementation

uses
  uMetricProcs;

function MetricLess(const ALeftPart, ARightPart: TNewPoint): Boolean;
begin
  Result := Metric(ALeftPart) < Metric(ARightPart);
end;

initialization

finalization

end.

unit uSorting;

interface

uses
  uPoints, uMetricLessTypes;

procedure QuickSort(var ANewPoint: array of TNewPoint;
  const ALoPoint, AHiPoint: Integer; AMetricLess: TMetricLess);

implementation

procedure QuickSort(var ANewPoint: array of TNewPoint;
  const ALoPoint, AHiPoint: Integer; AMetricLess: TMetricLess);
var
  LoPoint: Integer;
  HiPoint: Integer;

  Middle: TNewPoint;
  Temp: TNewPoint;

begin
  LoPoint := ALoPoint;
  HiPoint := AHiPoint;

  Middle := ANewPoint[(LoPoint + HiPoint) div 2];

  repeat
    while AMetricLess(ANewPoint[LoPoint], Middle) do
      Inc(LoPoint);

    while AMetricLess(Middle, ANewPoint[HiPoint]) do
      Dec(HiPoint);

    if LoPoint <= HiPoint then
      begin
        Temp := ANewPoint[LoPoint];
        ANewPoint[LoPoint] := ANewPoint[HiPoint];
        ANewPoint[HiPoint] := Temp;
        Inc(LoPoint);
        Dec(HiPoint);
      end;

  until LoPoint > HiPoint;

  if HiPoint > ALoPoint then
    QuickSort(ANewPoint, ALoPoint, HiPoint, AMetricLess);

  if LoPoint < AHiPoint then
    QuickSort(ANewPoint, LoPoint, AHiPoint, AMetricLess);
end;

initialization

finalization

end.