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

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

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

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;

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;

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.

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]])

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;

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.

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:

Kresli(1)

Kresli(4)

Kresli(10)

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;

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).

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;

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

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

Navigačné menu

Osobné nástroje

Menné priestory

Varianty

Zobrazení

Viac

Hľadať

Navigácia

Nástroje

@@ 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}}
-  procedure Zapis(Pole: array of string);
+  type
+   TPole = array of Pointer;
+ &nbsp;
+ function Priemer(P: TPole): Real;
   var
-   F: ^file;
+    I, N: Integer;
-   S: ^string;
-   D: ^Integer;
-    I: Integer;
   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
-     S^ := Pole[I];
+ &nbsp;
-     D^ := Length(S^);
+ &nbsp;
-     F.BlockWrite(D, 4);
-     if D <> 0 then
-       F.BlockWrite(S, D);
     end;
-    F.CloseFile;
+    if N <> 0 then
+     Result := Result / N;
   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}}
- 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
-    I: Integer;
+   P: array of array of ^Integer;
+    I, J: Integer;
   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;
 |}
-<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}}
   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
-    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;
 |}
-::: {{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}}
-  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}}
-  procedure TBVStrom.Vloz(X: Integer);
+  function Test: Boolean;
   var
-    S: TVrchol;
+    Zas: TStack;
+   Znak: Char;
   begin
-    if Koren = nil then
+    Zas := TStack.Create;
-     Koren := TVrchol.Create(X)
+   Read(Znak);
-    else
+    while Znak in ['a', 'b'] do
     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;
+   Result := (Znak = #13) ________________;
+   Zas.Free;
   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}}
-  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;
+  &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;
-   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}}
- type
-   TSubor = file of Integer;
- procedure Sort(var F: TSubor);
   var
-    I, X, Min: Integer;
+   P: array [1..30] of Integer;
+   T: FileText;
+    I, M: Integer;
+   S: string;
   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
-        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;
-      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;
 |}
-:: 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}}
-  type
+  procedure Spracuj;
-   TGraf = class
-     G: array [1..N] of set of 1..N;
-     function Test: Boolean;
-   end;
- function TGraf.Test: Boolean;
   var
-    I, J: Integer;
+    I1, I2: Integer;
-   M: set of 1..N;
   begin
-    Result := True;
+    Q.Append(-1);
-    for I := 1 to N do
+    Q.Serve(I1);
+   while I1 > 0 do
     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;
 |}
-:: 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}}
-  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
     I: Integer;
-   Z: Char;
-   Queue: TQueue;
   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;
 |}
-:: 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||}}