ZS/Testy/Test 06

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

Záverečný test v zimnom semestri 2006/2007



  1. Máme definované dve pomocné množinové funkcie:
type
  TMnoz = set of 0..31;
 
function P(M: array of TMnoz): TMnoz;
var
  I: Integer;
begin
  Result := M[0];
  for I := 1 to High(M) do
    Result := Result * M[I];
end;
 
function D(M: array of TMnoz): TMnoz;
var
  I: Integer;
begin
  Result := [0..31];
  for I := 0 to High(M) do
    Result := Result - M[I];
end;
Zistite, aká množina vznikne volaním:
P([D([[5..10], [25..30]]), D([[0..8], [20..28]]), D([[7], [12..15], [18..24]])])


  1. Nasledujúca funkcia nejako spracováva celočíselné pole:
type
  TPole = array [1..15] of 1..255;
 
function Prerob(A: TPole): TPole;
var
  C: array [1..255] of Integer;
  I: Integer;
begin
  for I := 1 to 255 do
    C[I] := 0;
  for I := 1 to High(a) do
    Inc(C[A[I]]);
  for I := 2 to 255 do
    Inc(C[I], C[I - 1]);
  for I := High(A) downto 1 do
  begin
    Result[C[A[I]]] := A[I];
    Dec(C[A[I]]);
  end;
end;
Zistite, aké pole bude výsledkom pre vstupné pole:
(3, 5, 20, 4, 3, 13, 2, 1, 3, 5, 12, 1, 3, 5, 13)


  1. Daný výraz v postfixe, ktorý obsahuje číselné konštanty aj identifikátory premenných treba prepísať do prefixového tvaru ale tak, aby sa pritom vyhodnotili všetky konštantné podvýrazy, napr. výraz a 3 4 + * sa prepíše na * a 7.
    Výrazy pred vyhodnocovaním konštantných podvýrazov neupravujte (nepoužite komutatívny ani distributívny zákon). Úlohu riešte pre obidva tieto výrazy:
a 9 + 8 2 - / b 3 4 * + * 5 6 * 7 - c d - / -
a b * c 1 - * 2 + d 3 + / e 4 + * f 5 / /


  1. Dopíšte funkciu znamka tak, aby pre body od 91 do 100 bola výsledná známka A, pre body od 81 do 90 bola známka B, atď. a pre menej ako 51 bodov vyšla známka Fx.
type
  TZnamka = (A, B, C, D, E, Fx);
  TBody = 0..100;
 
function Znamka(Body: TBody): TZnamka;
begin
  if __________________ then
    Result := ___________________________
  else
    Result := ___________________________;
end;


  1. Nasledujúci program bude na základe nejakého znakového reťazca generovať nových robotov a aj s nimi nejako hýbať:
const
  S: string = 'mama ma emu a ema ma mamu';
var
  G: TRobotGroup;
  I: Integer;
begin
  G := TRobotGroup.Create;
  for I := 1 to Length(S) do
    case S[I] of
      'm': G.NewRobot(Random(200), Random(200));
      'a': G.Fd(i);
      'e': G.Rt(90);
      'u': G.Lt(90);
    end;
  G.Free;
end;
Zistite celkovú dráhu, ktorú prejdú všetky roboty.


  1. Máme dve verzie rekurzívnej funkcie, ktoré počítajú presne to isté:
function Fun1(N: Integer): string;
begin
  if N < 1 then
    Result := '*'
  else
    Result := Fun1(N - 1) + Fun1(N - 1);
end;
 
function Fun2(N: Integer): string;
begin
  if N < 1 then
    Result := '*'
  else
  begin
    Result := Fun2(N - 1);
    Result := Result + Result;
  end;
end;
Predpokladajte, že mechanizmus volania funkcie Fun1 alebo Fun2 a tiež operácia zreťazenia "stojí počítač" 0.001 sekundy a všetky ostatné operácie a príkazy zanedbáme. Zistite, koľko bude trvať výpočet Fun1(12) a Fun2(12) a tiež, aký dlhý znakový reťazec sa pri tom vygeneruje.


  1. Vymysleli sme nový štruktúrovaný typ TZaznam a aj pomocnú funkciu, ktorá vytvára hodnoty tohto typu:
type
  TZaznam = record
    Typ: (Cele, Realne);
    P: Pointer;
  end;
  PZaznam = ^TZaznam;

function Smernik(R: Real): PZaznam;
var
  I: Integer;
begin
  New(Result);
  try
    I := Trunc(R);
    if I = R then
    begin
      Result.Typ^ := Cele;
      GetMem(Result.P, 2);
      Move(Result.P, I, 2);
    end
    else
    begin
      Result.Typ^ := Realne;
      GetMem(Result.P, 6);
      Move(Result.P, R, 6);
    end;
  finally
    Dispose(Result);
  end;
end;
Táto funkcia dostáva ako parameter reálne číslo a ak by sa toto číslo dalo reprezentovať pomocou celého čísla (nemá desatinnú časť), tak je v štruktúre TZaznam uložené ako smerník na celé číslo. V opačnom prípade je v TZaznam smerník na reálne číslo. V položke Typ je informácia o tom, či je to reprezentované ako celé alebo reálne číslo. Opravte chyby v programe (deklarácie nemeňte)!


  1. Máme danú triedu TStack, ktorá vie pracovať so znakovým zásobníkom (TPrvok = Char) a funkciu Test:
function Test(var T: TextFile): Boolean;
var
  S: TStack;
  Z: Char;
begin
  S := TStack.Create;
  Read(T, Z);
  Result := True;
  while (Z = 'a') or (Z = 'b') and S.Empty or (Z = 'c') and not S.Empty do
  begin
    case Z of
      'a': S.Push(Z);
      'b': Result := not Result;
      'c': S.Pop(Z);
    end;
    Read(T, Z);
  end;
  Result := Result and S.Empty and (Z = #13);
  s.Free;
end;
Nájdite 4 rôzne vstupné reťazce dĺžky 10, na ktorých táto funkcia vráti True a pritom obsahuje aspoň 3 znaky 'a', aspoň 3 znaky 'b', aspoň 3 znaky 'c'.


  1. Máme dané deklarácie tried, v ktorých sú nejaké chyby. Vašou úlohou je opraviť všetky chyby ale, čo nie je chybou, sa opravovať nesmie!
type
  class = TZver
  private
    FVel: Integer;
  end;
 
  class(TZver) = TMedved
  private
    procedure ZmenVel(V: Integer); overload;
  public
    property Velky: Integer write FVel read Zmenvel;
  end;
 
  class(TMedved) = TGrizly
  private
    procedure ZmenVel(V: Integer); overload;
  end;
 
procedure TMedved.ZmenVel(V: Integer); overload;
begin
  Velky := V;
end;
 
procedure TGrizly.ZmenVel(V: Integer); overload;
begin
  if Random(2) = 0 then
    inherited
  else
    Velky:= 2 * V;
end;
Rozdiel medzi TMedved a TGrizly je v tom, že keď potrebujeme zmeniť veľkosť (property Velky), tak u TGrizly sa táto môže s pravdepodobnosťou 0.5 nastaviť dvojnásobná. Metóda ZmenVel je virtuálna.


  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 ______________ do
  begin
    SetLength(_____________________);
    for J := 0 to _____________________ do
    begin
      SetLength(_____________________);
      _____________________;
      _____________________ := I * 10 + J;
    end;
  end;
end;