{$DEFINE NoInput}

{Writes the first l numbers that contain prime numbers p1, p2, p3 as deviders}

{$A+,B-,D+,E+,F-,G+,I+,L+,N+,O-,P-,Q-,R+,S+,T-,V+,X+,Y+}

{$M 16384,0,655360}

uses queue;

 

Function Min(a, b, c: LongInt): LongInt;

 

begin

  if a >= b then

    begin

      if b >= c then

        min := c

      else

        min := b;

    end

  else

    begin

      if c <= a then

        min := c

      else

        min := a;

    end;

end;

 

Procedure Primes(p1, p2, p3, l: LongInt);

 

var

  q1, q2, q3: TQueue;

  x, y, z, a, i: LongInt;

 

begin

  q1.Init;

  q2.Init;

  q3.Init;

  q1.Push(p1);

  q2.Push(p2);

  q3.Push(p3);

  i := 0;

  while i < l do

    begin

      x := q1.Top;

      y := q2.Top;

      z := q3.Top;

      a := min(x, y, z);

      write(a, ' ');

      q1.Push(a * p1);

      q2.Push(a * p2);

      q3.Push(a * p3);

      if x = a then q1.Pop;

      if y = a then q2.Pop;

      if z = a then q3.Pop;

      Inc(i);

    end;

  q1.Done;

  q2.Done;

  q3.Done;

end;

 

var

  p1, p2, p3, l: LongInt;

 

begin

{$IFNDEF NoInput}

  WriteLn('Enter first prime: ');

  ReadLn(p1);

  WriteLn('Enter second prime: ');

  ReadLn(p2);

  WriteLn('Enter third prime: ');

  ReadLn(p3);

{$ELSE}

  p1 := 2; p2 := 3; p3 := 5;

{$ENDIF}

  WriteLn('Enter number of primes: ');

  ReadLn(l);

  Primes(p1, p2, p3, l);

end.

{Queue of Integer}

{$A+,B-,D+,E+,F-,G+,I+,L+,N+,O-,P-,Q-,R+,S+,T-,V+,X+,Y+}

{$M 16384,0,655360}

unit Queue;

 

interface

 

Type

  PNode = ^TNode;

  TNode = object

    private

      data: LongInt;

      pNext: pNode;

  end;

 

  PQueue = ^TQueue;

  TQueue = object

    private

      pTop : pNode;

      pLast: pNode;

    public

      Constructor Init;

      Destructor Done;

      Procedure Push(x: LongInt);

      Function  Pop: LongInt;

      Function  Top: LongInt;

      Function  Empty: Boolean;

      Procedure Show;

  end;

 

implementation

 

Constructor TQueue.Init;

 

begin

  pTop := nil;

  pLast := nil;

end;

 

Destructor TQueue.Done;

 

var

  tmp: PNode;

 

begin

  while pTop <> nil do

    begin

      tmp := pTop;

      pTop := pTop^.pNext;

      Dispose(tmp);

    end;

end;

 

Procedure TQueue.Push(x: LongInt);

 

var

  tmp: PNode;

 

begin

  New(tmp);

  tmp^.pNext := nil;

  tmp^.Data := x;

  if pLast = nil then

    pTop := tmp

  else

    pLast^.pNext := tmp;

  pLast := tmp;

end;

 

Function TQueue.Pop: LongInt;

 

var

  tmp: PNode;

 

begin

  if Empty then

    begin

      WriteLn('Error in Queue.Pop: Queue is empty');

      Halt;

    end

  else

    begin

      Pop := pTop^.Data;

      tmp := pTop;

      pTop := pTop^.pNext;

      Dispose(tmp);

      if pTop = nil then pLast := nil;

    end;

end;

 

Function TQueue.Top: LongInt;

 

begin

  if Empty then

    begin

      WriteLn('Error in Queue.Top: Queue is empty');

      Halt;

    end

  else

    Top := pTop^.Data;

end;

 

Function TQueue.Empty: Boolean;

 

begin

  Empty := pTop = nil;

end;

 

Procedure TQueue.Show;

 

var

  tmp: pNode;

 

begin

  write('Queue: ');

  tmp := pTop;

  while tmp <> nil do

    begin

      Write(tmp^.data, ' ');

      tmp := tmp^.pNext;

    end;

  Writeln;

end;

end.

procedure TForm1.Button1Click(Sender: TObject);

const HVATIT_ZA_GLAZA = 100;

var x,y,z, h: integer;

    Kx,Ky,Kz: double;

    HemSeq : Array of double;

begin

  Kx := ln(2);

  Ky := ln(3);

  Kz := ln(5);

 

  SetLength(HemSeq, HVATIT_ZA_GLAZA*HVATIT_ZA_GLAZA*HVATIT_ZA_GLAZA);

  h := -1;

  for x:=0 to HVATIT_ZA_GLAZA-1 do

   for y:=0 to HVATIT_ZA_GLAZA-1 do

     for z:=0 to HVATIT_ZA_GLAZA-1 do

       begin

         inc(h);

         HemSeq[h] := Kx*x + Ky*y + Kz*z;

       end;

 

  qsort(HemSeq);

  

  ShowMessage(IntToStr(Round(exp(HemSeq[1000]))));

end;

procedure qsort(var A: array of double);

    procedure sort(l,r: integer);

      var i,j: integer;

          x,y: double;

    begin

      i := l;

      j := r;

      x := A[ (l + r) div 2 ];

      repeat

        while A[i] < x do inc(i);

        while x < A[j] do dec(j);

        if not (i>j) then

          begin

            y    := A[i];

            A[i] := A[j];

            A[j] := y;

            inc(i);

            dec(j);

          end;

      until i>j;

      if l < j then sort(l,j);

      if i < r then sort(i,r);

    end;

begin

  sort(0,High(A));

end;