ZS/Testy/Test 09: Rozdiel medzi revíziami

Z Pascal
Prejsť na: navigácia, hľadanie
 
(2 intermediate revisions by the same user not shown)
Riadok 1: Riadok 1:
{{Nadpis|Záverečný test v letnom semestri 2009/2010}}
+
{{Nadpis|Záverečný test v zimnom semestri 2009/2010}}
  
  
<ol><li value="1">Pre binárny netypový súbor sme napísali procedúru, ktorá zapíše postupnosť nejakých reťazcov do súboru. Každý reťazec bude v súbore uložený tak, že najprv sa zapíše 4-bajtová dĺžka a za ňou bude obsah reťazca:</li></ol>
+
<ol><li value="1">Máme dané pole smerníkov na celé a reálne čísla. Doprogramujte telo cyklu vo funkcii '''Priemer''', ak viete, že na nepárnych indexoch poľa sú smerníky na celé čísla a na párnych sú smerníky na reálne čísla. Niektoré prvky poľa môžu byť '''nil''' a vtedy sa nezapočítavajú do priemeru:</li></ol>
 
{{Prog}}
 
{{Prog}}
  procedure Zapis(Pole: array of string);
+
  type
 +
  TPole = array of Pointer;
 +
&nbsp;
 +
function Priemer(P: TPole): Real;
 
  var
 
  var
  F: ^file;
+
   I, N: Integer;
  S: ^string;
+
  D: ^Integer;
+
   I: Integer;
+
 
  begin
 
  begin
   New(S);
+
   Result := 0;
  D := @I;
+
   N := Length(P);
   F := file.Create('a.dat');
+
   for I := 0 to High(P) do
  Rewrite(F^);
+
   for I := 1 to Length(Pole) do
+
 
   begin
 
   begin
    S^ := Pole[I];
+
&nbsp;
    D^ := Length(S^);
+
&nbsp;
    F.BlockWrite(D, 4);
+
    if D <> 0 then
+
      F.BlockWrite(S, D);
+
 
   end;
 
   end;
   F.CloseFile;
+
   if N <> 0 then
 +
    Result := Result / N;
 
  end;
 
  end;
 
|}
 
|}
:: V programe je niekoľko chýb. Opravte ich. Deklarácie lokálnych premenných neopravujte.
 
  
  
<ol><li value="2">Pre dvojsmerný spájaný zoznam sme vytvorili metódy na vyhodenie prvkov zo zoznamu. Doplňte chýbajúce časti:</li></ol>
+
<ol><li value="2">Dopíšte chýbajúce časti programu tak, aby sa vytvorila takáto trojuholníková štruktúra: prvý riadok má 1 prvok so smerníkom na hodnotou 0, druhý má 2 prvky so smerníkmi na hodnoty 10 a 11, tretí má 3 prvky so smerníkmi na hodnoty 20, 21, 22, atď. až 10 riadok má 10 prvkov so smerníkmi na hodnoty 90, 91, ..., 99:</li></ol>
 
{{Prog}}
 
{{Prog}}
type
 
  TVrchol = class
 
    Prev, Next: TVrchol;
 
  end;
 
  TZoznam = class
 
    Z, K: TVrchol;
 
    procedure Vyhod(V: TVrchol);
 
    procedure Vyhod(V: array of TVrchol);
 
  end;
 
 
procedure TZoznam.Vyhod(V: TVrchol);
 
begin
 
  if V.Prev = nil then
 
    Z := V.Next
 
  else
 
    ________________________;
 
  if V.Next = nil then
 
    K := V.Prev
 
  else
 
    _________________________;
 
  V.Free;
 
end;
 
 
procedure TZoznam.Vyhod(V: array of TVrchol);
 
 
  var
 
  var
   I: Integer;
+
  P: array of array of ^Integer;
 +
   I, J: Integer;
 
  begin
 
  begin
   for I := 0 to High(V) do
+
  _________________________;
     _____________________________;
+
   for I := 0 to High(P) do
 +
  begin
 +
     _____________________;
 +
    for J := 0 to __________ do
 +
    begin
 +
      ________________;
 +
      ___________ := I * 10 + J;
 +
    end;
 +
  end;
 
  end;
 
  end;
 
|}
 
|}
  
  
<ol><li value="3">Pre binárny strom sme zadefinovali metódu '''Urob''' aj globálnu funkciu '''Urob''':</li></ol>
+
<ol><li value="3">V infixovom zápise aritmetických výrazov sa operácie s rovnakou prioritou vyhodnocujú zľava doprava. Prepíšte daný výraz do prefixového aj postfixového zápisu:</li></ol>
 +
::: '''1 + 2 * 3 / 4 * 5 / 6 * 7 / 8 / 9 – 1 / 2 / 3 – 4 / 5 / 6'''
 +
:: Výraz neupravujte ani nevyhodnocujte.
 +
 
 +
 
 +
<ol><li value="4">Daná funkcia nejako pracuje s množinami:</li></ol>
 
{{Prog}}
 
{{Prog}}
 
  type
 
  type
   TStrom = class;
+
   TSet = set of Byte;
  TFunkcia = function (S: TStrom): string;
+
&nbsp;
  TStrom = class
+
function Urob(A: array of TSet): TSet;
    Info: Integer;
+
  var
    L, P: TStrom;
+
  I: Integer;
    function Urob(F: TFunkcia): string;
+
  end;
+
   
+
function TStrom.Urob(F: TFunkcia): string;
+
 
  begin
 
  begin
   if (L = nil) or (P = nil) then
+
   Result := A[0];
    Result := F(Self)
+
   for I := 1 to High(A) do
   else
+
    if I mod 2 = 0 then
    Result := L.Urob(F) + F(Self) + P.Urob(F);
+
      Result := Result + A[I]
end;
+
    else
+
      Result := Result - A[I];
function Urob(S: TStrom): string;
+
begin
+
  if (S.L = nil) and (S.P = nil) then
+
    Result := IntToStr(S.Info)
+
  else
+
    Result := '*';
+
 
  end;
 
  end;
 
|}
 
|}
::: {{Obr|LS_Test_09_1.png}}
+
:: Zistite, čo vráti volanie:
:: Čo vypíše nasledovné volanie, ak '''Strom''' má uvedený tvar:
+
::: '''Urob([[1], [5, 8, 9], [2, 4, 6], [], [4, 8, 16], [1, 2, 3]])'''
{{Prog}}
+
WriteLn(Strom.Urob(@Urob));
+
|}
+
  
  
 
+
<ol><li value="5">Daná funkcia '''Spoj''' by mala zreťaziť všetky reťazce, ktoré sú v parametri otvorené pole reťazcov. Napr. '''Spoj'''(['abc','xyz','ahoj']) by malo vrátiť reťazec 'abcxyzahoj'. Doplňte vyznačené chýbajúce časti programu (nedopisujte nové premenné ani príkazy). Štandardná procedúra '''Move''' kopíruje z nejakej časti pamäte (prvý parameter), do inej (druhý parameter), kde v treťom parametri je počet kopírovaných bajtov.</li></ol>
<ol><li value="4">Do lexikografického stromu (prefixový strom) sme vložili tieto slová:</li></ol>
+
 
{{Prog}}
 
{{Prog}}
  pes, pas, pos, posol, osol, sol, eso, pasy, osly, esa, osa,  
+
  function Spoj(S:___________________________): string;
  osy, pel, pol, pal, paly, polo, les, posly, lesy, lese, osla
+
var
 +
  I, D: Integer;
 +
begin
 +
  D := 0;
 +
  for I := 0 to High(S) do
 +
    Inc(D, _____________________);
 +
  __________________ Result ________________;
 +
  D := 1;
 +
  for I := 0 to High(S) do
 +
    if S[I] <> {{''}} then
 +
    begin
 +
      Move(_________________ Result _________________);
 +
      Inc(D, ________________);
 +
    end;
 +
  end;
 
|}
 
|}
:: Koľko všetkých vrcholov a koľko listov bude mať tento strom, ak bol na začiatku úplne prázdny?
 
  
  
<ol><li value="5">Pre binárny vyhľadávací strom sme zapísali nerekurzívnu metódu na pridávanie novej hodnoty do stromu:</li></ol>
+
<ol><li value="6">Máme danú triedu '''TStack''', ktorá pracuje so znakovým  zásobníkom ('''TPrvok''' = '''Char''') a takúto funkciu:</li></ol>
 
{{Prog}}
 
{{Prog}}
  procedure TBVStrom.Vloz(X: Integer);
+
  function Test: Boolean;
 
  var
 
  var
   S: TVrchol;
+
   Zas: TStack;
 +
  Znak: Char;
 
  begin
 
  begin
   if Koren = nil then
+
   Zas := TStack.Create;
    Koren := TVrchol.Create(X)
+
  Read(Znak);
   else
+
   while Znak in ['a', 'b'] do
 
   begin
 
   begin
     S := Koren;
+
     if _______________ Zas.Top _________ then
     while _________________ do
+
     begin
       if S.Info > X then
+
       if Znak = 'b' then
         if S.L = nil then
+
         _______________________________;
          _________________________
+
      Zas.Push(Znak);
        else
+
    end
          S := ____________________
+
    else
       else
+
      __________________________
        if S.P = nil then
+
       __________________________
          _________________________
+
      __________________________;
        else
+
    Read(Znak);
          S := ____________________;
+
 
   end;
 
   end;
 +
  Result := (Znak = #13) ________________;
 +
  Zas.Free;
 
  end;
 
  end;
 
|}
 
|}
:: Doplňte chýbajúce časti riadkov programu.
+
:: Dopíšte chýbajúce časti tak, aby funkcia vrátila '''True''' len vtedy, keď reťazec na vstupe obsahuje presne dvojnásobok písmen '''a''', ako písmen '''b'''. Inak by na vstupe nemali byť iné znaky. Znak #13 označuje koniec riadka. Môžete používať metódu triedy '''TStack Top''', ktorá vráti hodnotu na vrchu zásobníka – z vrchu zásobníka ju ale neodoberie ako '''Pop'''.
  
  
<ol><li value="6">Hodnotami operandov aritmetického stromu budú množiny celých čísel. Takto sme upravili definície príslušných tried:</li></ol>
+
<ol><li value="7">Táto funkcia kreslí nejakú známu krivku a okrem toho aj niečo počíta:</li></ol>
 
{{Prog}}
 
{{Prog}}
  type
+
  var
   TMnozina = set of Byte;
+
   R: TRobot;
  TAStrom = class
+
&nbsp;
    function Hodnota: TMnozina; virtual; abstract;
+
function Kresli(N: Integer): Integer;
     function Prefix: string; virtual; abstract;
+
&nbsp;
 +
  procedure Otoc(Uhol: Integer);
 +
  begin
 +
     Inc(Result, Uhol);
 +
    R.Lt(Uhol);
 
   end;
 
   end;
   
+
  &nbsp;
   TAOperacia = class(TAStrom)
+
begin
     Op: Char;
+
   Result := 0;
     L, P: TAStrom;
+
  if N > 0 then
     constructor Create(Z: Char; LL, PP: TAStrom);
+
  begin
     function Hodnota: TMnozina; override;
+
    R.Fd(30);
     function Prefix: string; override;
+
     Otoc(40);
 +
     Inc(Result, Kresli(N - 1));
 +
     Otoc(270);
 +
    Inc(Result, Kresli(N - 1));
 +
     Otoc(50);
 +
     R.Fd(-30);
 
   end;
 
   end;
   
+
  end;
  TAOperand = class(TAStrom)
+
    Hod: TMnozina;
+
    constructor Create(H: TMnozina);
+
    function Hodnota: TMnozina; override;
+
    function Prefix: string; override;
+
  end;
+
|}
+
:: Zistite, akú hodnotu vráti aritmetický strom ('''AS.Hodnota'''), ak jeho '''AS.Prefix''' vyzerá nasledovne:
+
{{Prog}}
+
+ [3 5 7 8] * - [1 2 4 7] [2 3 4 5] [1 5 7 9]
+
 
|}
 
|}
 +
:: Zistite, aké hodnoty vrátia volania:
 +
<blockquote>
 +
<ol type="a">
 +
<li>'''Kresli'''(1)</li>
 +
<li>'''Kresli'''(4)</li>
 +
<li>'''Kresli'''(10)</li>
 +
</ol>
 +
</blockquote>
  
  
<ol><li value="7">Pomocou triedenia Heap-sort sa bude triediť toto 20 prvkové pole:</li></ol>
+
<ol><li value="8">V nasledujúcej časti programu je niekoľko chýb. Textový súbor v každom riadku obsahuje celé číslo od 1 do 30 a za ním je medzera a nejaký reťazec. Program by mal z tohto súboru vypísať tie reťazce, pred ktorými je najčastejšie sa vyskytujúce číslo. Opravte chyby v programe.</li></ol>
<blockquote><blockquote>
+
{| border="1"  cellspacing="0"
+
| width="30" align="center"| 10
+
| width="30" align="center"| 9
+
| width="30" align="center"| 8
+
| width="30" align="center"| 7
+
| width="30" align="center"| 6
+
| width="30" align="center"| 5
+
| width="30" align="center"| 4
+
| width="30" align="center"| 3
+
| width="30" align="center"| 2
+
| width="30" align="center"| 1
+
| width="30" align="center"| 20
+
| width="30" align="center"| 19
+
| width="30" align="center"| 18
+
| width="30" align="center"| 17
+
| width="30" align="center"| 16
+
| width="30" align="center"| 15
+
| width="30" align="center"| 14
+
| width="30" align="center"| 13
+
| width="30" align="center"| 12
+
| width="30" align="center"| 11
+
|}
+
</blockquote></blockquote>
+
:: Do prvého riadku nasledujúcej tabuľky vpíšte, ako bude vyzerať halda po prvom kroku algoritmu (VytvorHaldu) a do ďalšieho zapíšte výsledok jedného kroku triedenia (výmena dvoch konkrétnych prvkov a znovu vytvorenie haldy).
+
<blockquote><blockquote>
+
{| border="1"  cellspacing="0"
+
| width="30" align="center"| &nbsp;
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
| width="30" align="center"|
+
|-
+
|| &nbsp; || || || || || || || || || || || || || || || || || || ||
+
|}
+
</blockquote></blockquote>
+
 
+
 
+
<ol><li value="8">Naprogramovali sme algoritmus triedenia, ktorý usporiada prvky typového binárneho súboru celých čísel. Algoritmus vychádza z MinSortu, ale museli sme ho trochu upraviť:</li></ol>
+
 
{{Prog}}
 
{{Prog}}
type
 
  TSubor = file of Integer;
 
 
procedure Sort(var F: TSubor);
 
 
  var
 
  var
   I, X, Min: Integer;
+
  P: array [1..30] of Integer;
 +
  T: FileText;
 +
   I, M: Integer;
 +
  S: string;
 
  begin
 
  begin
   I := -1;
+
   AssignText(T, 'subor.txt');
   while I < FileSize(F)-1 do
+
   try
  begin
+
    Reset(T);
     Reset(F);
+
    for I := 1 to 30 do
     while not Eof(F) do
+
      P[I] := 0;
 +
     M := 0;
 +
     while Eof(T) do
 
     begin
 
     begin
       if FilePos(F) < I then
+
       Read(T, I);
        Read(F, X)
+
       Inc(P[I]);
      else if FilePos(F) = I then
+
       if P[M] < P[I] then
        Write(F, Min)
+
         I := M;
       else if FilePos(F) = I + 1 then
+
        Read(F, Min)
+
       else
+
      begin
+
        Read(F, X);
+
        if X < Min then
+
         begin
+
          Seek(F, FilePos(F) - 1);
+
          Write(F, Min);
+
          Min := X;
+
        end;
+
      end;
+
 
     end;
 
     end;
     Inc(I);
+
     Rewrite(T);
 +
    while Eof(T) do
 +
    begin
 +
      ReadLn(T, M, S);
 +
      if I = M then
 +
        Memo1.Lines.Append(S)
 +
    end;
 +
  finally
 +
    CloseText(T);
 
   end;
 
   end;
 
  end;
 
  end;
 
|}
 
|}
:: Tento algoritmus niekoľkokrát prechádza všetky prvky súboru (vnútorný while-cyklus) a po každom prechode sa niečo v súbore zmení. Na začiatku súbor obsahoval týchto 10 celých čísel:
 
<blockquote><blockquote>
 
{| border="1"  cellspacing="0"
 
| width="40" align="center"| 11
 
| width="40" align="center"| 15
 
| width="40" align="center"| 19
 
| width="40" align="center"| 15
 
| width="40" align="center"| 11
 
| width="40" align="center"| 13
 
| width="40" align="center"| 7
 
| width="40" align="center"| 8
 
| width="40" align="center"| 9
 
| width="40" align="center"| 7
 
|}
 
</blockquote></blockquote>
 
:: Postupne vypíšte obsah všetkých prvkov súboru po každom prechode vnútorného cyklu (tam, kde sa robí '''Inc(I)'''):
 
<blockquote><blockquote>
 
{| border="1"  cellspacing="0"
 
| width="40" align="center"| &nbsp;
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
| width="40" align="center"|
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|-
 
| || || || || || || || || ||&nbsp;
 
|}
 
</blockquote></blockquote>
 
  
  
<ol><li value="9">Graf sme reprezentovali metódou pole množín susedov. Napísali sme metódu, ktorá o danom grafe zistí, či je orientovaný alebo neorientovaný. Metóda '''Test ''' má vrátiť '''True''' vtedy, keď je graf neorientovaný (každá hrana je definovaná v oboch smeroch):</li></ol>
+
<ol><li value="9">Nasledujúca procedúra nejako spracováva dátovú štruktúru rad ('''TQueue''') v globálnej premennej '''Q''':</li></ol>
 
{{Prog}}
 
{{Prog}}
  type
+
  procedure Spracuj;
  TGraf = class
+
    G: array [1..N] of set of 1..N;
+
    function Test: Boolean;
+
  end;
+
+
function TGraf.Test: Boolean;
+
 
  var
 
  var
   I, J: Integer;
+
   I1, I2: Integer;
  M: set of 1..N;
+
 
  begin
 
  begin
   Result := True;
+
   Q.Append(-1);
   for I := 1 to N do
+
   Q.Serve(I1);
 +
  while I1 > 0 do
 
   begin
 
   begin
     M := [];
+
     Q.Serve(I2);
     for J := 1 to N do
+
     if I2 > I1 then
      if I in G[J] then
+
      Q.Append(I2)
        M := _____________________;
+
    else
     Result := __________________________________;
+
    begin
 +
      Q.Append(I1);
 +
      I1 := I2;
 +
     end;
 
   end;
 
   end;
 
  end;
 
  end;
 
|}
 
|}
:: Dopíšte chýbajúce časti riadkov programu.
+
:: Zistite, aký bude obsah radu po vykonaní procedúry Spracuj, ak jeho počiatočné hodnoty boli:
 +
::: '''(8, 5, 20, 4, 9, 13, 2, 3, 5, 12, 1, 3, 5, 13)'''.
  
  
<ol><li value="10">Do algoritmu prehľadávania grafu do šírky sme pre neorientovaný graf pridali označovanie prechádzaných vrcholov písmenami abecedy (každý vrchol má pridaný atribút '''Znak'''):</li></ol>
+
<ol><li value="10">Chceli sme zadefinovať triedu na prácu s dynamickým poľom celých čísel. '''Property''' by malo zabezpečiť indexovanie tohto poľa pomocou znakových reťazcov a tiež hodnotou takéhoto prvku poľa ('''property''') by mal byť reťazec. V programe sme urobili niekoľko chýb - opravte ich.</li></ol>
 
{{Prog}}
 
{{Prog}}
  procedure TGraf1.Dosirky(V: Integer);
+
  type
 +
  TSPole = class
 +
  private
 +
    FPole: array of Integer;
 +
    function GetPole: string; virtual;
 +
    procedure SetPole(Hodnota: string); override;
 +
  public
 +
    property Pole [X: string]: string read GetPole write SetPole;
 +
  end;
 +
&nbsp;
 +
function TSPole.GetPole: string; virtual;
 
  var
 
  var
 
   I: Integer;
 
   I: Integer;
  Z: Char;
 
  Queue: TQueue;
 
 
  begin
 
  begin
   Queue := TQueue.Create;
+
   I := IntToStr(X);
   Queue.Append(V);
+
   if (I < 0) or (I > High(Pole)) then
  Z := 'A';
+
    Result := {{''}}
   repeat
+
   else
     Queue.Serve(V);
+
     Result := StrToInt(Pole[I]);
    if not (V in Visited) then
+
end;
    begin
+
&nbsp;
      Visited := Visited + [V];
+
procedure TSPole.SetPole(Hodnota: string); override;
      '''G[V].Znak := Z;'''
+
var
      Inc(Z);
+
  I: Integer;
      for I := 0 to High(G) do
+
begin
        if not (I in Visited) and JeHrana(V, I) then
+
  I := IntToStr(X);
          Queue.Append(I);
+
  if I >= High(Pole) then
     end;
+
  begin
   until Queue.Empty;
+
    if I > 0 then
  Queue.Free;
+
      SetLength(Pole, I + 1);
 +
     Pole[I] := Hodnota;
 +
   end;
 
  end;
 
  end;
 
|}
 
|}
:: Máme daný nasledovný graf so 16 vrcholmi. Tieto sú zoradené v poli G postupne po "riadkoch" zľava doprava (v prvom riadku sú vrcholy s indexmi 0 až 3, v druhom 4 až 7, ...). Algoritmus '''Dosirky''' naštartujeme z 9. vrcholu (druhý vrchol v treťom riadku). Zapíšte do každého vrcholu písmeno, ktoré mu pridelí tento algoritmus do šírky.
 
::: {{Obr|LS_Test_09_2.png}}
 

Aktuálna revízia z 18:32, 19. marec 2013

Záverečný test v zimnom semestri 2009/2010



  1. Máme dané pole smerníkov na celé a reálne čísla. Doprogramujte telo cyklu vo funkcii Priemer, ak viete, že na nepárnych indexoch poľa sú smerníky na celé čísla a na párnych sú smerníky na reálne čísla. Niektoré prvky poľa môžu byť nil a vtedy sa nezapočítavajú do priemeru:
type
  TPole = array of Pointer;
 
function Priemer(P: TPole): Real;
var
  I, N: Integer;
begin
  Result := 0;
  N := Length(P);
  for I := 0 to High(P) do
  begin
 
 
  end;
  if N <> 0 then
    Result := Result / N;
end;


  1. Dopíšte chýbajúce časti programu tak, aby sa vytvorila takáto trojuholníková štruktúra: prvý riadok má 1 prvok so smerníkom na hodnotou 0, druhý má 2 prvky so smerníkmi na hodnoty 10 a 11, tretí má 3 prvky so smerníkmi na hodnoty 20, 21, 22, atď. až 10 riadok má 10 prvkov so smerníkmi na hodnoty 90, 91, ..., 99:
var
  P: array of array of ^Integer;
  I, J: Integer;
begin
  _________________________;
  for I := 0 to High(P) do
  begin
    _____________________;
    for J := 0 to __________ do
    begin
      ________________;
      ___________ := I * 10 + J;
    end;
  end;
end;


  1. V infixovom zápise aritmetických výrazov sa operácie s rovnakou prioritou vyhodnocujú zľava doprava. Prepíšte daný výraz do prefixového aj postfixového zápisu:
1 + 2 * 3 / 4 * 5 / 6 * 7 / 8 / 9 – 1 / 2 / 3 – 4 / 5 / 6
Výraz neupravujte ani nevyhodnocujte.


  1. Daná funkcia nejako pracuje s množinami:
type
  TSet = set of Byte;
 
function Urob(A: array of TSet): TSet;
var
  I: Integer;
begin
  Result := A[0];
  for I := 1 to High(A) do
    if I mod 2 = 0 then
      Result := Result + A[I]
    else
      Result := Result - A[I];
end;
Zistite, čo vráti volanie:
Urob([[1], [5, 8, 9], [2, 4, 6], [], [4, 8, 16], [1, 2, 3]])


  1. Daná funkcia Spoj by mala zreťaziť všetky reťazce, ktoré sú v parametri otvorené pole reťazcov. Napr. Spoj(['abc','xyz','ahoj']) by malo vrátiť reťazec 'abcxyzahoj'. Doplňte vyznačené chýbajúce časti programu (nedopisujte nové premenné ani príkazy). Štandardná procedúra Move kopíruje z nejakej časti pamäte (prvý parameter), do inej (druhý parameter), kde v treťom parametri je počet kopírovaných bajtov.
function Spoj(S:___________________________): string;
var
  I, D: Integer;
begin
  D := 0;
  for I := 0 to High(S) do
    Inc(D, _____________________);
  __________________ Result ________________;
  D := 1;
  for I := 0 to High(S) do
    if S[I] <> '' then
    begin
      Move(_________________ Result _________________);
      Inc(D, ________________);
    end;
end;


  1. Máme danú triedu TStack, ktorá pracuje so znakovým zásobníkom (TPrvok = Char) a takúto funkciu:
function Test: Boolean;
var
  Zas: TStack;
  Znak: Char;
begin
  Zas := TStack.Create;
  Read(Znak);
  while Znak in ['a', 'b'] do
  begin
    if _______________ Zas.Top _________ then
    begin
      if Znak = 'b' then
        _______________________________;
      Zas.Push(Znak);
    end
    else
      __________________________
      __________________________
      __________________________;
    Read(Znak);
  end;
  Result := (Znak = #13) ________________;
  Zas.Free;
end;
Dopíšte chýbajúce časti tak, aby funkcia vrátila True len vtedy, keď reťazec na vstupe obsahuje presne dvojnásobok písmen a, ako písmen b. Inak by na vstupe nemali byť iné znaky. Znak #13 označuje koniec riadka. Môžete používať metódu triedy TStack Top, ktorá vráti hodnotu na vrchu zásobníka – z vrchu zásobníka ju ale neodoberie ako Pop.


  1. Táto funkcia kreslí nejakú známu krivku a okrem toho aj niečo počíta:
var
  R: TRobot;
 
function Kresli(N: Integer): Integer;
 
  procedure Otoc(Uhol: Integer);
  begin
    Inc(Result, Uhol);
    R.Lt(Uhol);
  end;
 
begin
  Result := 0;
  if N > 0 then
  begin
    R.Fd(30);
    Otoc(40);
    Inc(Result, Kresli(N - 1));
    Otoc(270);
    Inc(Result, Kresli(N - 1));
    Otoc(50);
    R.Fd(-30);
  end;
end;
Zistite, aké hodnoty vrátia volania:
  1. Kresli(1)
  2. Kresli(4)
  3. Kresli(10)


  1. V nasledujúcej časti programu je niekoľko chýb. Textový súbor v každom riadku obsahuje celé číslo od 1 do 30 a za ním je medzera a nejaký reťazec. Program by mal z tohto súboru vypísať tie reťazce, pred ktorými je najčastejšie sa vyskytujúce číslo. Opravte chyby v programe.
var
  P: array [1..30] of Integer;
  T: FileText;
  I, M: Integer;
  S: string;
begin
  AssignText(T, 'subor.txt');
  try
    Reset(T);
    for I := 1 to 30 do
      P[I] := 0;
    M := 0;
    while Eof(T) do
    begin
      Read(T, I);
      Inc(P[I]);
      if P[M] < P[I] then
        I := M;
    end;
    Rewrite(T);
    while Eof(T) do
    begin
      ReadLn(T, M, S);
      if I = M then
        Memo1.Lines.Append(S)
    end;
  finally
    CloseText(T);
  end;
end;


  1. Nasledujúca procedúra nejako spracováva dátovú štruktúru rad (TQueue) v globálnej premennej Q:
procedure Spracuj;
var
  I1, I2: Integer;
begin
  Q.Append(-1);
  Q.Serve(I1);
  while I1 > 0 do
  begin
    Q.Serve(I2);
    if I2 > I1 then
      Q.Append(I2)
    else
    begin
      Q.Append(I1);
      I1 := I2;
    end;
  end;
end;
Zistite, aký bude obsah radu po vykonaní procedúry Spracuj, ak jeho počiatočné hodnoty boli:
(8, 5, 20, 4, 9, 13, 2, 3, 5, 12, 1, 3, 5, 13).


  1. Chceli sme zadefinovať triedu na prácu s dynamickým poľom celých čísel. Property by malo zabezpečiť indexovanie tohto poľa pomocou znakových reťazcov a tiež hodnotou takéhoto prvku poľa (property) by mal byť reťazec. V programe sme urobili niekoľko chýb - opravte ich.
type
  TSPole = class
  private
    FPole: array of Integer;
    function GetPole: string; virtual;
    procedure SetPole(Hodnota: string); override;
  public
    property Pole [X: string]: string read GetPole write SetPole;
  end;
 
function TSPole.GetPole: string; virtual;
var
  I: Integer;
begin
  I := IntToStr(X);
  if (I < 0) or (I > High(Pole)) then
    Result := ''
  else
    Result := StrToInt(Pole[I]);
end;
 
procedure TSPole.SetPole(Hodnota: string); override;
var
  I: Integer;
begin
  I := IntToStr(X);
  if I >= High(Pole) then
  begin
    if I > 0 then
      SetLength(Pole, I + 1);
    Pole[I] := Hodnota;
  end;
end;