ZS/Testy/Test 11

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

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



  1. Dátovú štruktúru rad sme definovali pomocou dvoch zásobníkov:
type
  TQueue = class
    S1, S2: TStack;
    constructor Create;
    destructor Destroy; override;
    procedure Serve(var P: Integer);
    function Serve: Integer;
    procedure Append(P: Integer);
    function Empty: Boolean;
  end;
 
constructor TQueue.Create;
begin
  _______________________________________
  _______________________________________
end;
 
destructor TQueue.Destroy;
begin
  S1.Free;
  S2.Free;
end;
 
procedure TQueue.Serve(var P: Integer);
begin
  if Empty then
    raise Exception.Create('Rad je prazdny');
  while _______________________ do
    S2.Push(S1.Pop);
  ___________________________________________
end;
 
function TQueue.Serve: Integer;
begin
  Serve(_______________________);
end;
 
procedure TQueue.Append(P: Integer);
begin
  while _______________________ do
    S1.Push(S2.Pop);
  ___________________________
end;
 
function TQueue.Empty: Boolean;
begin
  Result := ____________________________;
end;
Dopíšte vyznačené časti.


  1. Opravte všetky chyby v definícii triedy TMojRobot. Takýto robot by mal automaticky všetky čiary kresliť (Fd) v mierke R. Okrem toho by mala fungovať aj metóda StaryFd, pomocou ktorej vie kresliť čiary bez zmeny mierky.
type
  TMojRobot = class(TRobot)
  public
    R: Real;
  private
    constructor Create(RR: Real); virtual;
    procedure Fd(D: Real); virtual;
    procedure StaryFd(D: Real); override;
  end;
 
constructor TMojRobot.Create(RR: Real);
begin
  TRobot.Create;
  R := RR;
end;
 
procedure TMojRobot.Fd(D: Real);
begin
  StaryFd(R * D);
end;
 
procedure TMojRobot.StaryFd;
begin
  Fd(D);
end;


  1. Funkcia Spoj dostáva parameter pole smerníkov. Tieto smerníky odkazujú striedavo na celé čísla a na reťazce (string). Funkcia vytvorí nový reťazec, ktorý bude obsahovať reťazce z pôvodného poľa, pričom celé čísla pred týmito reťazcami označujú počet opakovaní nasledujúceho reťazca. Ak namiesto smerníku na celé číslo je v poli nil, príslušný reťazec sa preskočí. Doplňte vyznačené časti:
function Spoj(Pole: array of Pointer): string;
var
  I, J: Integer;
begin
  Result := ;
  I := 0;
  while I < High(Pole) do
  begin
    if Pole[I] <> nil then
      for J := 1 to ___________________ do
        Result := Result + ________________________;
    Inc(I, 2);
  end;
end;


  1. Funkcia Vyrob generuje nejaké prefixové aritmetické výrazy, v ktorých delenie / označuje celočíselné delenie div:
function Vyrob(N: Integer): string;
var
  I: Integer;
  Z: string = '-+*/';
begin
  Result := ;
  for I := 1 to N - 1 do
    Result := Result + Z[I mod 4 + 1] + ' ';
  for I := 1 to N do
    Result := Result + IntToStr(I) + ' ';
end;
Zistite hodnotu týchto 4 výrazov:
  • Vyrob(4)
  • Vyrob(5)
  • Vyrob(6)
  • Vyrob(7)
Okrem toho výraz Vyrob(7) zapíšte v postfixovom tvare.


  1. Procedúra Zmen pracuje s dvoma zásobníkmi:
type
  TStacks = array [Boolean] of TStack;
 
procedure Zmen(S: TStacks; var Kde: Boolean);
var
  C, D: Integer;
  V: Boolean;
begin
  repeat
    V := True;
    S[Kde].Pop(C);
    while not S[Kde].Empty do
    begin
      S[Kde].Pop(D);
      if (C > D) = Kde then
      begin
        S[not Kde].Push(D);
        V := False;
      end
      else
      begin
        S[not Kde].Push(C);
        C := D;
      end;
    end;
    Kde := not Kde;
    S[Kde].Push(C);
  until V;
end;
procedúru voláme s dvoma zásobníkmi, pričom S[False] je prázdny zásobník, a S[True] je zásobní s týmito 10 hodnotami:
1 2 3 4 5 5 4 3 2 1
a Kde má hodnotu True. Zistite, čo bude hodnotou parametra Kde a aký bude obsah zásobníka S[Kde] po skončení tejto procedúry (čísla vypíšte od vrchu zásobníka).


  1. Nasledovný program vytvára premennú A dynamické pole dynamických polí (array of array of Integer):
SetLength(A, 1, 1);
A[0, 0] := 1;
for I := 2 to 7 do
begin
  SetLength(A, Length(A) + 1);
  A[High(A)] := A[High(A) - 1];
  SetLength(A[High(A)], Length(A[High(A)]) + 1);
  A[High(A), High(A[High(A)])] := I;
end;
Sucet := 0;
for I := 0 to High(A) do
  for J := 0 to High(A[I]) do
    Inc(Sucet, A[I, J]);
WriteLn(Sucet);
Zistite, akú hodnotu vypíše.


  1. Nasledujúca procedúra binárne vyhľadá prvok s hodnotou P v utriedenom poli A. V algoritme X označuje dolnú hranicu úseku a Y dĺžku (nie hornú hranicu) tohto úseku. Doplňte vyznačené časti tak, aby program pracoval korektne:
var
  A: array [1..1000] of Integer;
 
function Hladaj(P: Integer): Integer;
var
  X, Y, Z: Integer;
begin
  X := 1;
  Y := 1000;
  while Y > 1 do
  begin
    Z := (Y + 1) div 2 - 1;
    if P = A[X + Z] then
    begin
      X := X + Z;
 
      Y := ________________;
    end
    else if P < A[X + Z] then
 
      Y := ________________
    else
    begin
      X := X + Z + 1;
 
      Y := ________________;
    end;
  end;
  if (Y = 1) and (A[X] = P) then
    Result := X
  else
    Result := 0;
end;


  1. Máme definovanú rekurzívnu procedúru Rekurzia. Zistite, koľko hviezdičiek vypíše volanie Rekurzia(3, 5). Tiež zistite, pre aké najmenšie N volanie Rekurzia(N, 0) vypíše aspoň 100 hviezdičiek.
procedure Rekurzia(N, P: Integer);
var
  I: Integer;
begin
  if N < 1 then
    WriteLn('*')
  else
  begin
    for I := 1 to P do Write('*');
    Rekurzia(N - 1, P div 2);
    for I := 1 to P do Write('*');
    Rekurzia(N - 1, P div 2);
    for I := 1 to P do Write('*');
  end;
end;


  1. Nasledujúca trieda TMnozina definuje dátovú štruktúru množina dvojíc znakov. Dopíšte vyznačené časti:
type
  TChar2 = array [1..2] of Char;
  TMnozina = class
    M: array [Char] of set of Char;
    procedure Pridaj(CC: TChar2);
    procedure Vyhod(CC: TChar2);
    function Prvok(CC: TChar2):boolean;
    function Text: string;
  end;
 
procedure TMnozina.Pridaj(CC: TChar2);
begin
  _______________________________________;
end;
 
procedure TMnozina.Vyhod(CC: TChar2);
begin
  _______________________________________;
end;
 
function TMnozina.Prvok(CC: TChar2): boolean;
begin
  Result := CC[2] in M[CC[1]];
end;
 
function TMnozina.Text: string;
var
  C1, C2:char;
begin
  Result := ;
  for C1:=#0 to #255 do
    for C2 _________________________ do
      Result := Result + C1 + C2 + ' ';
end;


  1. V nasledovnom programe (nie v deklaráciách) doplňte všetky chýbajúce znaky ^ strieška:
type
  Typ1 = record A: ^string; B: string; end;
  Typ2 = array [1..10] of ^Typ1;
  Typ3 = record A: ^Typ2; B: Typ2; end;
 
var
  A: ^Typ3;
  I: Integer;
 
begin
  New(A ); New(A . A );
  for I := 1 to 10 do
  begin
    New(A . A [I] ); New(A . B [I] );
    New(A . A [I] .A ); New(A . B [I] . A );
  end;
  for I := 1 to 10 do
  begin
    A . A [I] . A := 'haha';
    A . A [I] . B := 'hoho';
    A . B [I] . A := 'hihi';
    A . B [I] . B := 'hehe';
  end;