1.      10   N57
    "".



2.  .

    䠩, ᮤঠ騩 ᫠ ⨯ longint, ᯮ  ந쭮
浪. ॡ ᯮ  ᫠  ⠭, ᯮ  
40  ⨢   ᪮ ࠭⢠   祬  
ࠧ  室 䠩.



3.  (⮤ 襭).

   砫 室 䠩 ࠧ  ᪨  10000 ᥫ,  ᮪
    뢠     ६ 䠩, 祬
⠪,  ⢮ ᪮   䠩 ⫨砥   祬  1( -
ࢮ砫쭠 ஢).

   ⥬, ᪮쪮 ࠧ 믮  "᪫"( 믮
樨 "᪫"  㤥 뢠 "蠣"), .  室
䠩,   室 ஢ ᪨    㣨
䠩,  ⮬   ᪮, 室  ࠧ 䠩  
  ᮧ  ஢ ᮪.  ᮪
뢠   室 䠩 ᫨ 室 ᪨   
  ன, ᫨ 室 ᪨   .



4.   .

    ᠭ ணࠬ ᯮ짮 । Borland Pascal 7.0 
஥ .
    ᪮७   ᪮ ਬ  -뢮, .
ଠ ⠥  뢠 楫묨 ࠬ.  ⢫ ⮣
ᯮᮡ -뢮  ᠭ (Files),   ண -뢮
譥  ⫨砥  筮.
   奬 ணࠬ ।쭮 : ᭠砫 믮 ࢮ쭠
஢(楤 firstsort), ⥬ 뢠 ᪫(楤
ftrans(in1, in2, out1, out2: workfile);),   䠩  ६  
᫥  ᪠ 楤 ஢ ᫮ 室.
   楤 ftrans 뢠  䠩, ⥬ 믮 ᪮쪮 ࠧ
楤 ᫨  ᪠(onestep)  뢠 䠩.


5.   .

{ Files.
   ९ᠭ  楤  㭪樨 室  ࠡ  䠩,
ࠡ騥  .    ⢫ ⠪   
묨 楤ࠬ  System.}

unit Files;
interface
const typesize=4;
const bufsize = 2048;
type using=longint;
type buffer = array[1..bufsize] of using;
type pbuffer = ^buffer;
type filemode = (fread, fwrite, closed);
type tfile = record
 buf: pbuffer;
 mode: filemode;
 f: file;
 count, leng: integer;
end;
procedure fAssign(var w: tfile; name: string);
procedure fReWrite(var w: tfile);
procedure fReset(var w: tfile);
procedure fPut(var w: tfile; d: using);
procedure fGet(var w: tfile; var d: using);
procedure fClose(var w: tfile);
function fEof(var w: tfile): boolean;

implementation
procedure fAssign(var w: tfile; name: string);
begin
 Assign(w.f, name);
 w.mode:=closed;
end;

procedure fReWrite(var w: tfile);
begin
 if w.mode=closed then
 begin
  ReWrite(w.f, typesize);
  new(w.buf);
  w.count:=0;
  w.leng:=0;
  w.mode:=fwrite;
 end;
end;

procedure fReset(var w: tfile);
begin
 if w.mode=closed then
 begin
  Reset(w.f, typesize);
  new(w.buf);
  BlockRead(w.f, w.buf^, bufsize, w.leng);
  w.count:=1;
  w.mode:=fread;
 end;
end;

procedure fPut(var w: tfile; d: using);
begin
 if w.mode=fwrite then
 begin
  w.count:=w.count+1;
  w.buf^[w.count]:=d;
  if w.count=bufsize then
  begin
   BlockWrite(w.f, w.buf^, w.count);
   w.count:=0;
  end;
 end;
end;

procedure fGet(var w: tfile; var d: using);
begin
 if (w.mode=fread) then
 begin
  d:=w.buf^[w.count];
  if w.leng=w.count then
  begin
   BlockRead(w.f, w.buf^, bufsize, w.leng);
   w.count:=1;
  end else w.count:=w.count+1;
 end;
end;

procedure fClose(var w: tfile);
begin
 if w.mode=fwrite then BlockWrite(w.f, w.buf^, w.count);
 dispose(w.buf);
 w.mode:=closed;
 Close(w.f);
end;

function fEof(var w: tfile): boolean;
begin
 if (w.mode=fread) and (w.leng=0) then fEof:=true
 else fEof:=false;
end;

begin
end.
{ files.pas}
{----------------------------------------------------------------------------}


{ sort.pas - ஢  .}
var k: integer;

function SwapTops(no: integer): integer;
var t: longint;
begin
 if (memo^[2*no+1]>memo^[2*no]) then
 begin
  t:=memo^[no];
  memo^[no]:=memo^[2*no+1];
  memo^[2*no+1]:=t;
  SwapTops:=2*no+1;
 end else
 begin
  t:=memo^[no];
  memo^[no]:=memo^[2*no];
  memo^[2*no]:=t;
  SwapTops:=2*no;
 end;
end;

procedure SwapHalf(no: integer);
var t: longint;
begin
 if memo^[no]<memo^[2*no] then
 begin
  t:=memo^[no];
  memo^[no]:=memo^[2*no];
  memo^[2*no]:=t;
 end;
end;

function Reg(no: integer): boolean;
begin
 if (2*no)>k then Reg:=true else
 if (2*no+1)>k then
 begin
  SwapHalf(no);
  Reg:=true;
 end else
 if (memo^[2*no]<=memo^[no]) and (memo^[2*no+1]<=memo^[no]) then Reg:=true
 else Reg:=false;
end;

procedure HalfReg(no: integer);
var next: integer;
begin
 next:=no;
 while (not Reg(next)) do next:=SwapTops(next);
end;

procedure RegTree;
var i: integer;
begin
 for i:=k downto 1 do HalfReg(i);
end;

procedure SwapLeaves(l1, l2: integer);
var t: longint;
begin
 t:=memo^[l1];
 memo^[l1]:=memo^[l2];
 memo^[l2]:=t;
end;

procedure SortMemo(len: integer);
begin
 k:=len;
 RegTree;
 for k:=len-1 downto 1 do
 begin
  SwapLeaves(1, k+1);
  HalfReg(1);
 end;
end;
{ sort.pas}
{----------------------------------------------------------------------------}


{᭮ ࠬ}
uses Dos, Files{祭 , ⢫饣 -뢮.};

const memlen=10000;{ , ࠧ襭  ᯮ짮}

type tmemo = array[0 .. memlen] of longint;
type pmemo = ^ tmemo;{-㪠⥫  ᭮ ᨢ, ᯮ㥬
ணࠬ}

var memo : pmemo;

{$I sort.pas} {祭 䠩, ᮤঠ饣 楤 ஢
ᨢ  ६ n*(log n),  ᯮ ⥫쭮 (஢
ॢ).}

type workfile = record
 main{᭮ 䠩},
 inf{䠩, ᮤঠ騩  ஢ ᪮}: tfile;
end;{tfile - ⨯, ।  unit Files,   䠩 ⨯}

var
 t1, t2, t3, t4,    dest, seur: workfile;
 {६ 䠩}  {室  室 䠩}


{樠}
procedure Init;
var tmp: string;
begin
 tmp:=getenv('TEMP');
 fAssign(t1.main, tmp+'\~fsort-1.tmp');
 fAssign(t2.main, tmp+'\~fsort-2.tmp');
 fAssign(t3.main, tmp+'\~fsort-3.tmp');
 fAssign(t4.main, tmp+'\~fsort-4.tmp');
 fAssign(t1.inf, tmp+'\~finf-1.tmp');
 fAssign(t2.inf, tmp+'\~finf-2.tmp');
 fAssign(t3.inf, tmp+'\~finf-3.tmp');
 fAssign(t4.inf, tmp+'\~finf-4.tmp');
 fAssign(seur.main,ParamStr(1));
 fAssign(dest.main,ParamStr(2));
end;


{ࢮ砫쭠 ஢}
procedure firstsort(var inp, out1, out2: workfile);
var i, k: longint;
begin
 fReset(inp.main);
 fRewrite(out1.main);
 fRewrite(out2.main);
 fRewrite(out1.inf);
 fRewrite(out2.inf);
 new(memo);
 repeat
  for i:=1 to memlen do
   if fEof(inp.main) then
   begin
    i:=i-1;
    break
   end else fGet(inp.main, memo^[i]);
  k:=i;
  sortmemo(k);
  for i:=1 to k do fPut(out1.main, memo^[i]);
  fPut(out1.inf, k);
  if k=memlen then
  begin
   for i:=1 to memlen do
    if fEof(inp.main) then
    begin
     i:=i-1;
     break;
    end
    else fGet(inp.main, memo^[i]);
   k:=i;
   sortmemo(k);
   for i:=1 to k do fPut(out2.main, memo^[i]);
   fPut(out2.inf, k);
  end;
 until fEof(inp.main);
 dispose(memo);
 fClose(inp.main);
 fClose(out1.main);
 fClose(out2.main);
 fClose(out1.inf);
 fClose(out2.inf);
end;


{楤,   ⢮ -⮢   䠩  㣮.
ᯮ  ᫨  ஢ ⠢襩  ᪠(᫨ 㣮
᮪ ).}
procedure Copy(var inp, out: workfile; c0: longint);
var
c, n: longint;
Done: boolean;
begin
 for c:=c0 downto 1 do
 begin
  fGet(inp.main, n);
  fPut(out.main, n);
 end;
end;


{  । ᪠  䠩 in1  in2  뢠  out.}
procedure onestep(var in1, in2, out: workfile; c01, c02: longint);
var n1, n2, c1, c2, c: longint;
Done: boolean;
begin
 Done:=false;
 c1:=c01-1;
 c2:=c02-1;
 c:=0;
 fGet(in1.main, n1);
 fGet(in2.main, n2);
 repeat
  if n1<n2 then
  begin
   fPut(out.main, n1);
   c:=c+1;
   if c1=0 then
   begin
    fPut(out.main, n2);
    c:=c+1;
    Copy(in2, out, c2);
    c:=c+c2;
    Done:=true;
   end else
   begin
    fGet(in1.main, n1);
    c1:=c1-1;
   end;
  end else
  begin
   fPut(out.main, n2);
   c:=c+1;
   if c2=0 then
   begin
    fPut(out.main, n1);
    c:=c+1;
    Copy(in1, out, c1);
    c:=c+c1;
    Done:=true;
   end else
   begin
    fGet(in2.main, n2);
    c2:=c2-1;
   end;
  end;
 until Done;
end;


{楤 ⢫  蠣(..  䠩 in1  in2  out1  out2,
 ⮬ ᪫ ᪨)}
procedure ftrans(var in1,in2,out1,out2: workfile);
var c1, c2, c: longint;
begin
 fReset(in1.main);
 fReset(in2.main);
 fReset(in1.inf);
 fReset(in2.inf);
 fRewrite(out1.main);
 fRewrite(out2.main);
 fRewrite(out1.inf);
 fRewrite(out2.inf);
 while (not fEof(in1.inf)) and (not fEof(in2.inf)) do
 begin
  fGet(in1.inf, c1);
  fGet(in2.inf, c2);
  onestep(in1, in2, out1, c1, c2);
  c:=c1+c2;
  fPut(out1.inf, c);
  if (not fEof(in1.inf)) and (not fEof(in2.inf)) then
  begin
   fGet(in1.inf, c1);
   fGet(in2.inf, c2);
   onestep(in1, in2, out2, c1, c2);
   c:=c1+c2;
   fPut(out2.inf, c);
  end;
 end;
 if fEof(in1.inf) xor fEof(in2.inf) then
  if fEof(in1.inf) then
  begin
   fGet(in2.inf, c2);
   Copy(in2, out2, c2);
   fPut(out2.inf, c2);
  end else
  if fEof(in2.inf) then
  begin
   fGet(in1.inf, c1);
   Copy(in1, out2, c1);
   fPut(out2.inf, c1);
  end;
 fClose(in1.main);
 fClose(in2.main);
 fClose(in1.inf);
 fClose(in2.inf);
 fClose(out1.main);
 fClose(out2.main);
 fClose(out1.inf);
 fClose(out2.inf);
end;


{஢ 䠩 f1  f2.(ᯮ  襭 ࠡ 
஢ 筮 䠩  ६ ४ਨ  㪠).}
procedure FCopy(f1, f2: tfile);
var t: longint;
begin
 write('஢');
 fRewrite(f2);
 fReset(f1);
 while (not fEof(f1)) do
 begin
  fGet(f1, t);
  fPut(f2, t);
 end;
 fClose(f1);
 fClose(f2);
end;


{ਭ 祭 True, ᫨ 䠩 ஢     ᪫.
(᫮ 室)}
function Fin: boolean;
begin
 fReset(t2.main);
 fReset(t4.main);
 if fEof(t2.main) then
 begin
  Fin:=true;
  FCopy(t1.main, dest.main);
 end else
 if fEof(t4.main) then
 begin
  Fin:=true;
  FCopy(t3.main, dest.main);
 end else Fin:=false;
 fClose(t2.main);
 fClose(t4.main);
end;

begin
 writeln;
 if ParamCount<2 then
 begin
  writeln('誮  ࠬ஢.');
  Exit;
 end;
 write('樠...');
 Init;
 writeln('⮢');
 write('ࢮ砫쭠 ஢...');
 firstsort(seur, t1, t2);
 writeln('⮢');
 ReWrite(dest.main.f);
 Close(dest.main.f);
 writeln(':');
 repeat
  ftrans(t1, t2, t3, t4);
  writeln('蠣');
  if (not Fin) then
  begin
   ftrans(t3, t4, t1, t2);
   writeln('蠣');
  end;
 until Fin;
 writeln('⮢');
end.
{----------------------------------------------------------------------------}


6.  .

    ४⭮ ࠡ ணࠬ 室  AT286, 40K ᢮
conventional , 樮 ⥬ MS-DOS 3.0    .
 ᨨ ணࠬ, ᯮ騥  ,  ᫠ 286 
.. ணࠬ ᯮ   ᪥  襥 室 䠩(
 ᠬ 䠩).



7.  .

    ᪥ ணࠬ 易⥫쭮   । ६ । TEMP!
   ଠ ᪠ ணࠬ:

     f_sort[.exe] <室 䠩> <室 䠩>

   ணࠬ     ᮢ,  ᨫ쭮 頥 ࠡ  .
    ࠡ     ਫ ⨫ f_check,
ᮧ 砩 室 䠩 -  ஬ f_make.
   稭 訡  㦨  ᮮ⢥⢨ ⥬ ॡ,
  . 6, 筮   ᪥, ࠧ( ) 室
䠩  ⥭ 4.

      뢠 ᠬ 䥪⨢  ⮩ ணࠬ, 
 ᨨ,  ᯮ騥 -뢮 , ॡ騥 
ᮢ ⥬.



8.  .

   ணࠬ ஢ ⭮,  室 ᯮ짮,  ᭮,
䠩  砩 ᥫ ࠧ筮 .  室 뫨 祭 䠩 ⮩
,  ᮤঠ騥 訡, .. ᫠   䠩   浪
 ண ⠭. ন  䠩  ᮢ 
ࠧ⠬ ࠡ 㣨 ணࠬ ஢    室 䠩, 
ᨫ쭮 ᭨ ⭮ 䥪⮢ ணࠬ.
    ஢ ᯮ짮 樮 ⥬ MS-DOS 6.22,
Windows`95,  PC AT 486DX4-100, 486SX-25, ࠡ騥  
஬, ஡稥 ⠭樨 486DX-40, 386SX, ࠡ騥   Novell.

 ஢( 䠩 ࠧ஬ 4M) ᥭ  ⠡:
    ࠡ       ६ ࠡ
486DX4-100    		3 .
486SX-25      		7 .
486DX-40      
386SX         