program zh;
{Szamoskozi Peter
gyakorlat-vezeto: HBV}
uses newdelay,crt;
const evfmax=4;

type adat=record {diak}
       szak:string[30];
       evfolyam:string[4];
       tantargy:string[10];
       osztalyzat:byte;
       nev:string[30];
   end;
   Tfile=file of adat;
   Tfilenev=string[12];

var fofile:Tfile;
fofilenev:Tfilenev;
kimenet:text;

Procedure miboldolgoz(var afile:Tfilenev);
{Mi legyen a fofile?}
var be:string;
begin
  repeat
    writeln('Mi legyen az alapfile? '); readln(be);
  until (length(be)<=8);
  afile:=be+'.dat';
end; {-Alapfile def. vege-}

Procedure nyit(var f:Tfile; fn:Tfilenev; melyik:boolean);
{Ha melyik=1 akkor olvas kul. ir}

  Function Letezik_e(FileName: tfilenev): Boolean;
  {Letezik-e a FileName file?}
  Var f: Tfile;
  Begin
    {$I-} Assign(f, FileName);
    Reset(f); Close(f); {$I+}
    Letezik_e:= ( (IOResult=0) and (FileName<>'') );
  End; {--letezik_e vege--}

Begin
 {$I-}
 If melyik then begin
   if letezik_e(fn) then begin
       assign(f,fn); reset(f); end
   end
   else begin
     assign(f,fn);
     rewrite(f);
   end;
 {$I+}
End;

Procedure zar(var f:Tfile);
Begin
  {$I-} close(f); {$I+}
End;

Procedure letrehoz(var s:Tfilenev);
{Az "s" file letrehozasa}
var  {segedvaltozok}
       f:Tfile;
       i,j:integer;
       be:string; {a beolvasas valtozoja}
       ok:integer; {a val() muvelet rendben volt-e}
       db:integer; {az osszletszam}
     {fovaltozok}
       a:adat;
       evf:string[4]; {evfolyam}
       szakok:string[30]; {szak}
       neve:string[30]; {nev}
       oszt:byte; {osztalyzat}
       targy:string[30]; {tantargy}

  procedure Egybe(var b:adat; szakok:string; evf:string;
       targy:string; oszt:byte; neve:string);
  begin
   b.szak:=szakok; b.evfolyam:=evf;
   b.tantargy:=targy; b.osztalyzat:=oszt; b.nev:=neve;
  end;

Begin
 nyit(fofile,fofilenev,false);
 repeat
   Writeln('Osszletszam /adatsor-db/? ');
   readln(be);
   val(be,db,ok)
 until (ok=0) and ((db>=1) and (db<=evfmax));
 For i:=1 to db do
    Begin
       repeat
         Writeln('Mi a(z) ',i,'. adat neve? ');
         readln(be);
       until length(be)<=40;
       neve:=be;
       repeat
         Writeln('Mi a(z) ',neve,' szakja? ');
         readln(be);
       until length(be)<=30;
       szakok:=be;
       repeat
         Writeln('Mi a(z) ',neve,' evfolyama? ');
         readln(be);
       until length(be)<=4;
       evf:=be;
       repeat
         Writeln('Mi a(z) ',neve,' tantargya? ');
         readln(be);
       until length(be)<=30;
       targy:=be;
       repeat
         Writeln('Mi a(z) ',neve,' osztalyzata? ');
         readln(be);
         val(be,oszt,ok);
       until ( (ok=0) and (oszt in [1..5]) );
    egybe(a,szakok,evf,targy,oszt,neve);
    write(fofile,a);
  End; {-egy sor feltoltesenek vege-}
  zar(f);
End; {-A feltolt eljaras vege-}

procedure kilistaz(var f:tfile);
Var {segedvaltozok}
    sor:integer;
    ok:integer; {val()}
    be:string;
    i,j,szam:integer;
    {fovaltozok}
    a:adat;
    kov:adat;
    elso:boolean;
    szaknev:string;

Begin
  repeat
    Writeln('Sorok szama? ');
    readln(be);
    val(be,sor,ok)
  until (ok=0) and ((sor>=3) and (sor<=20));
  miboldolgoz(fofilenev);
  nyit(f,fofilenev,true);
  read(f,a);
  szaknev:=a.szak; {melyik szaknal vagyunk}
  elso:=true; {szakkezdes}
  While not(eof(f)) do
    Begin
      j:=1;
      Writeln('ллллллллллллллллл A(z) ',szaknev,'. adatai ллллллллллллллллллл ');
      read(f,kov);
      While (a.szak=kov.szak) do begin
        While (j<=sor) and (a.szak=kov.szak) do
          Begin
             GotoXY(1,j+2); Write(a.evfolyam);
             GotoXY(45,j+2); Write(a.tantargy);
             GotoXY(60,j+2); Write(a.osztalyzat);
             GotoXY(75,j+2); Write(a.nev);
             a:=kov; {leptetes}
             read(f,kov); {kovetkezo be}
             inc(j); {ujsorba}
          End;
          If j>sor then Begin
            GotoXY(1,25); Write('Nyomjon meg egy billentyut a folytatashoz!');
            readkey;
          End;
      End; {a while(azonos_szak) vege}
  zar(f);
  End; {a while(filevege) vege}
end; {-A kilistaz vege-}

procedure uvk_utan(var modfile:Tfile; var kifile:text);
const elvalaszto='/';
var {fovaltozok}
    b:adat;
    akt,kov:adat; {pozicionalashoz}
    xvar:adat; {kereseshez}
    vdb:byte; {hanyszor vizsgazott eddig}

    procedure kiir(var kifile:text;xvar:adat);
    begin
    write(kifile,xvar.szak); write(elvalaszto); write(kifile,xvar.evfolyam);
    write(elvalaszto); write(kifile,xvar.tantargy); write(elvalaszto); write(kifile,xvar.osztalyzat);
    write(elvalaszto); writeln(kifile,xvar.nev);
    end;
begin
   rewrite(kimenet);
   While not(EOF(modfile)) do begin
     read(modfile,kov); akt:=kov;
     read(modfile,kov);
     xvar.szak:=kov.szak; vdb:=0;
     if kov.szak<>akt.szak then begin
       while ( (akt.szak<>kov.szak) and (vdb<=2) ) do begin
         read(modfile,akt);
         if ( (akt.nev=xvar.nev) and (akt.evfolyam=xvar.evfolyam) and
           (akt.tantargy=xvar.tantargy) ) then begin
           inc(vdb); xvar.osztalyzat:=akt.osztalyzat end;
         read(modfile,akt);
         kiir(kifile,xvar);
       end; {while}
     end; {if}
     read(modfile,kov)
  end; {eof}
close(kimenet);
close(modfile);
end; {-Modosit vege-}

begin
letrehoz(fofilenev);
kilistaz(fofile);
assign(kimenet,'kimenet.dat');

uvk_utan(fofile,kimenet);
end.