uses crt;
{(43. feladat) viz:0.0 - szfold: >0}
const e=1; {Mi legyen az egyseg?}
      Tmax=10; {Legfeljebb hany meresunk lehet a tengeren?}
      tulszel=20; {A tulso partot jelzo ertek a mereseknel}
type tindex=integer;
     telem=integer;
     TmeresInt=array[1..Tmax] of telem;
     Tigaztomb=array[1..Tmax] of boolean;
var Tomb:tmeresint;
    szgdb:integer; {ennyi sziget van}
    be:char; {"megegyszer?"}
    igaztomb:array[1..1] of boolean;
    tenyleg:boolean; {Ez a lenyegi valasz a feladat kerdesere}
    csucsmaxhely:integer; {a legmagasabb csucs merete}
    legmaghelysvlog:boolean; {a legmaghelygyujt-elj. kimenetenek sv-je}
    csucsdb:tindex;
    csucsvoltlg:boolean;
    szgcsucsigaze:tigaztomb;

procedure igaze(var x:tmeresint);
var igazei:integer;
{Biz. be: minden sziget legmagasabb pontja egyben csucs is!}
  function szigetkezdet(const T:tmeresint; i:integer):boolean;
  begin
    if (T[i]>0) then begin dec(i);
           if (T[i]=0) then
              begin
                 inc(szgdb);
                 szigetkezdet:=true;
               end; inc(i); end
       else begin szigetkezdet:=false; end
  end;

  function szigetvege(const T:tmeresint; var i:integer):boolean;
  var sve,svv:boolean;
  begin
    sve:=(T[i]=0); dec(i);
    svv:=(T[i]>0); inc(i);
    szigetvege:=((sve=true) and (svv=true));
  end;

  function tulsopart(const T:tmeresint;i:integer):boolean;
  begin
    tulsopart:=(T[i]=tulszel);
  end;

  function csucse(const x:tmeresint; var i:tindex):boolean;
  var sve,svv:boolean;
  begin
    sve:=(x[i]>x[i-1]); inc(i);
    svv:=(x[i]<x[i-1]); dec(i);
    csucse:=((sve=true) and (svv=true));
  end;

  procedure legmaghelygyujt(const x:tmeresint; var i:tindex; volte:boolean);
  begin
    if (volte=false) then begin csucsmaxhely:=i; tenyleg:=false; volte:=true; end;
    if not(szigetvege(x,i)) then begin
      if not(csucsvoltlg) then begin
        if ( x[csucsmaxhely]<x[i] ) then begin
           csucsmaxhely:=i; igaztomb[1]:=csucse(x,csucsmaxhely); inc(i);
           csucsvoltlg:=igaztomb[1];
           legmaghelygyujt(x,i,volte); end
         else begin
               igaztomb[1]:=csucse(x,csucsmaxhely); inc(i);
               csucsvoltlg:=igaztomb[1];
               legmaghelygyujt(x,i,volte); end;
      end;
    end; {if not(szigetvege)}
  end; {- Legmaghelygyujt -}
  procedure igazemindig(const x:tmeresint; i:tindex);
  var voltee:boolean;
  begin
    if szigetkezdet(x,i) then begin
      write('A(z) ',szgdb,'. szigetnel igaz az allitas? ');
      voltee:=false; legmaghelygyujt(x,i,voltee);
      legmaghelysvlog:=csucsvoltlg;
      inc(csucsdb);
      szgcsucsigaze[szgdb]:=csucsvoltlg;
      writeln(legmaghelysvlog); end;
    inc(i);
    if not(tulsopart(x,i)) then igazemindig(x,i);
  end; {- Igazemind -}

  function ellenoriz(n:tindex;t:tigaztomb):boolean;
  begin
    if t[n]=true then begin
        if (n>1) then begin
            dec(n); ellenoriz:=ellenoriz(n,t); end
          else begin
            ellenoriz:=t[n]; end
        end
     else begin ellenoriz:=false; end; {ha hamis erteket talalt}
 {...ha nem talat hamis erteket}
  end; {- ellenoriz -}
begin {- Igaze -}
  igazei:=2; tenyleg:=false;
  igazemindig(x,igazei);
  writeln('--- Osszesegeben a(z) allitas: ',ellenoriz(csucsdb,szgcsucsigaze));
end; {- Igaze -}

procedure tombfeltolt(var t:tmeresint; i:tindex; hogyan:boolean);
  procedure manfeltolt(var t:tmeresint; i:tindex);
  var svmer,j:integer;
  begin
    for j:=3 to (i-2) do begin
      write('A(z) ',j,'. meres eredmenye? ');
      readln(svmer);
      t[j]:=svmer;
    end;
  end;
  procedure autofeltolt(var t:tmeresint; i:tindex);
  var j:integer;
  begin
    for j:=3 to (i-2) do begin
      t[j]:=(random(i) mod 3);
    end;
  end;
begin
  if hogyan=true then manfeltolt(t,i)
         else autofeltolt(t,i);
end;

procedure foprogram;
var svbe:char; svlogp:boolean;
  procedure adatbeker;
  begin
    write('Automata legyen a feltoltes? ');
    readln(svbe);
    if upcase(svbe)='N' then svlogp:=true
        else svlogp:=false;
      tombfeltolt(tomb,10,svlogp);
  end;
begin
  writeln;
  szgdb:=0;
  tomb[1]:=tulszel; tomb[2]:=0; tomb[tmax-1]:=0; tomb[tmax]:=tulszel;
  adatbeker;
  igaze(tomb);
  write('Folytassam? ');
  readln(be);
  if ( upcase(be)<>'N' ) then foprogram;
end;

begin
{randomize;}
foprogram;
end.