ZS/Testy/Test 12

Z Pascal
Prejsť na: navigácia, hľadanie

Záverečný test v zimnom semestri 2012/2013



  1. Grafický robot kreslí rekurzívnu krivku a ako výsledok tejto rekurzívnej funkcie počíta nejaký súčet dĺžok úsečiek:
function TMojRobot.Rekurzia(N, D: Integer): Integer;
begin
  if (N > 0) and (D > 0) then
  begin
    Result := D;
    FD(D);
    Inc(Result, Rekurzia(N - 2, D - 1));
    Lt(30);
    Inc(Result, Rekurzia(N - 1, D div 2));
    Rt(30);
    Inc(Result, Rekurzia(N, D div 4));
    Fd(-D);
  end
  else
    Result := 0;
end;
Zistite, akú hodnotu vráti pre volanie Rekurzia(5, 10).


  1. Do poľa A ukladáme celé aj reálne čísla tak, že každý prvok obsahuje informáciu, akého je typu (položka Typ) a smerník do vyhradenej pamäte Mem (globálna premenná). Procedúra Pridaj pridáva do poľa A nový prvok: hodnotu čísla uloží do tejto pamäte a adresu si zapamätá v položke P. Premennú Mem potom posunie za túto použitú časť, aby sa mohla použiť pre ďalšie pridávanie prvkov do poľa. Doplňte vyznačené časti:
type
  TTyp = (Cele, Realne);
var
  A: array of record
    Typ: TTyp;
    P: Pointer;
  end;
  Mem: Pointer;
 
procedure Pridaj(T: TTyp; Cislo: Real);
begin
  SetLength(A, Length(A) + 1);
  with _________________ do
  begin
    Typ := T;
    P := Mem;
    if T = Cele then
    begin
      _____________ := Round(Cislo);
      Mem := _____________________;
    end
    else
    begin
      _____________ := Cislo;
      Mem := _____________________;
    end;
  end;
end;


  1. Inšpirovali sme sa Turingovým strojom a zapísali sme tento program:
var
  Paska:PChar;
begin
  Paska := '#1001100_';
  Inc(Paska);
  while Paska^ <> '_' do
    Inc(Paska);
  Dec(Paska);
  while Paska^ = '0' do
  begin
    Paska^ := '1';
    Dec(Paska);
  end;
  if Paska^ <> '#' then
    Paska^ := '0';
  while Paska^ <> '#' do
    Dec(Paska);
  WriteLn(Paska);
end.
Zistite, čo sa vypíše. Popíšte slovami, ako sa zmení ľubovoľná postupnosť znakov '0' a '1', uzavretá medzi '#' a '_'.


  1. Zistite, čo vypíše tento program:
type
  Enum = (A, B, C, D, E, F, G);
var
  Pole: array [Enum, Enum] of set of Enum;
  M: set of Enum;
  I, J: Enum;
begin
  for I in Enum do
    for J in Enum do
      Pole[I, J] := [I, J];
  M := [];
  for I := Pred(High(Enum)) downto Succ(Low(Enum)) do
    if Ord(I) mod 2 = 0 then
      M := M + Pole[Succ(I), Pred(I)]
    else
      M := M - Pole[Succ(I), Pred(I)];
  for I in M do
    Write(I);
end.


  1. Pomocou znakového zásobníka (trieda TStack) chceme zistiť, či vstupný reťazec obsahuje rovnaký počet znakov 'a' a 'b'. Predpokladáme, že vstup sa skladá len zo znakov 'a' a 'b'. Doplňte vyznačené časti tak, aby program vypísal True alebo False, podľa toho, či je na vstupe rovnaký počet výskytov 'a' a 'b':
var
  Stack: TStack;
  Z: Char;
begin
  Stack := TStack.Create;
  Write('zadaj: ');
  Read(Z);
  while Z <> #13 do
  begin
    if ________________________________________ then
      Stack.Pop(Z)
    else
      Stack.Push(Z);
    Read(Z);
  end;
  WriteLn(________________________________);
  Stack.Free;
end.


  1. Nasledovný program vytvára premennú A dynamické pole dynamických polí (array of array of Integer):
SetLength(A, 1, 9);
for I := 0 to High(A[0]) do
  A[0, I] := I + 1;
while Length(A[High(A)]) > 2 do
begin
  SetLength(A, Length(A) + 1);
  A[High(A)] := Copy(A[High(A) - 1], 1, Length(A[High(A) - 1]) - 2);
end;
Sucet := 0;
for I := 0 to High(A) do
begin
  for J := 0 to High(A[I]) do
  begin
    Inc(Sucet, A[I, J]);
    Write(A[I, J]:3);
  end;
  WriteLn;
end;
WriteLn('sucet = ', Sucet);
Zistite, čo vypíše tento program.


  1. Nasledujúci program testuje bežný algoritmus binárneho vyhľadávania, do ktorého sme pridali počítadlo Pocet:
const
  N = 5;
var
  Pole: array [1..N] of Integer;
  I, Pocet: Integer;
 
function Hladaj(Hodnota: Integer): Integer;
var
  Zac, Kon: Integer;
begin
  Zac := 1;
  Kon := N;
  while Zac <= Kon do
  begin
    Inc(Pocet);
    Result := (Zac + Kon) div 2;
    if Pole[Result] = Hodnota then
      Exit;
    if Pole[Result] < Hodnota then
      Zac := Result + 1
    else
      Kon := Result - 1;
  end;
  Result := 0;
end;
 
begin
  for I := 1 to N do
    Pole[I] := 2 * I - 1;
  for I := 1 to N do
    Hladaj(I);
  WriteLn(Pocet);
end.
Zistite, aký počet vyjde pre N=5; pre N=8 a odhadnite pre N=1000.


  1. Zapíšte do postfixovej aj prefixovej formy tento infixový aritmetický výraz:
35 - (2 + 7) / 3 + 22 / (5 + 2 * 3) - (4 * 5 - 2 * 3) / (5 * 5) / (1 / 4)
Uvedomte si, že operácie s rovnakou prioritou vyhodnocujeme zľava doprava, napr. 1 / 2 / 3 znamená (1 / 2) / 3.


  1. Chceli sme zadefinovať triedu na prácu s textovým súborom, ale urobili sme niekoľko chýb - opravte ich.
type
  TSubor = class(TextFile)
  public
    T: TextFile;
    Citat: Boolean;
    function Precitaj: string;
    procedure Zapis(S: string);
  private
    constructor Create(Meno: string; B: Boolean);
    destructor Destroy; override;
    property Veta: string read Precitaj write Zapis;
  end;
 
constructor TSubor.Create(Meno: string; B: Boolean);
begin
  AssignFile(T, Meno);
  B := Citat;
  if Citat then
    Rewrite(T)
  else
    Reset(T);
end;
 
function TSubor.Precitaj: string; private;
begin
  if not Citat and Eof(T) then
    Result := '###'
  else
    Readln(T, Result);
end;
 
procedure TSubor.Zapis(S: string); private;
begin
  if not Citat then
    Writeln(S, T);
end;
 
destructor TSubor.Destroy; override;
begin
  T.Free;
end;


  1. V nasledovnom programe (nie v deklaráciách) doplňte všetky chýbajúce znaky ^ strieška:
type
  TPole = array of ^string;
var
  Pole: array [1..5] of ^TPole;
  I, J: Integer;
begin
  for I := 1 to 5 do
    New( Pole [I] );
  for I := 1 to 5 do
  begin
    SetLength( Pole [I] , 2 * I);
    for J := 0 to High( Pole [I] ) do
    begin
      New( Pole [I] [J] );
      ReadLn( Pole [I] [J] );
    end;
  end;
end.
Zistite ešte, koľko riadkov textu bude tento program čítať zo vstupu.