ZS/Testy/Test 07

Z Pascal
Revízia z 22:11, 29. november 2012; Andrej (Diskusia | príspevky)

(rozdiel) ← Staršia verzia | Aktuálna úprava (rozdiel) | Novšia verzia → (rozdiel)
Prejsť na: navigácia, hľadanie

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



  1. Táto funkcia kreslí nejakú známu krivku a okrem toho aj niečo počíta:
function Rekurzia(N: Integer; D: Real): Real;
const
  Uhol: array [1..4] of Integer = (-60, 120, -60, 0);
var
  I: Integer;
begin
  Result := 0;
  if N = 0 then
  begin
    Robot.Fd(D);
    Result := D;
  end
  else
    for I := 1 to 4 do
    begin
      Result := Result + Rekurzia(N - 1, D / 3);
      Robot.Rt(Uhol[I]);
    end;
end;
Zistite aké hodnoty vrátia volania
  1. Rekurzia(1, 243)
  2. Rekurzia(3, 243)
  3. Rekurzia(5, 243)


  1. Daná časť programu číta z textového súboru, ktorý obsahuje len celé čísla a niektoré z nich zapisuje do druhého súboru:
for I := 1 to 10 do
begin
  for J := 1 to i do
    Read(Subor1, K);
  Writeln(Subor2, K);
  if Odd(I) then       // ak I je nepárne
    Readln(Subor1)
  else
    Reset(Subor1);
end;
Zistite, aké hodnoty sa objavia vo výstupnom súbore, ak vstupný súbor bol:
1 3 5 7 9
2 4 6 8 10
11 12
13 14 15
16 17 18 19
20 21 22 23 24


  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. Trochu sme vylepšili algoritmus binárneho vyhľadávania: namiesto delenia na rovnako veľké polovice delíme na dve časti v pomere 1/3 ku 2/3. Takto opravený algoritmus tiež funguje - niekedy mu to ale trvá dlhšie ako pri pôvodnej verzii. Ak predpokladáme, že v 1000 prvkovej tabuľke pôvodný algoritmus vyhľadal nejaký prvok za maximálne 10 "pozretí" do tabuľky (dvojkový logaritmus 1000), zistite koľko maximálne pozretí potrebuje tento opravený algoritmus.
function Hladaj(M: Integer; const Tab: array of Integer): Integer;
var
  Z, K, S: Integer;
begin
  Z := Low(Tab);
  K := High(Tab);
  while Z <= K do
  begin
    S := Z+(K-Z) div 3;        // S := (Z+K) div 2;
    if Tab[S] < M then
      Z := S+1
    else if Tab[S] > M then
      K := S-1
    else
      Z := K+1;
  end;
  if Tab[S] = M then
    Result := S
  else
    Result := 0;
end;


  1. Dopíšte funkciu Vloz (len výraz v priraďovacom príkaze) tak, aby táto funkcia vrátila pôvodné pole A, do ktorého je vsunutá nová hodnota na pozíciu Kam. Napr. ak vstupné pole P obsahovalo hodnoty [11, 22, 33, 44, 55, 66, 77] tak volanie Vloz(9, P, 3) vráti pole [11, 22, 33, 9, 44, 55, 66, 77]. Využite funkciu Spoj(pole, pole) a štandardnú funkciu Copy(pole, odkiaľ, koľko).
type
  Tpole = array of Integer;
 
function Spoj(const A, B: array of Integer): TPole;
var
  I: Integer;
begin
  SetLength(Result, Length(A) + Length(B));
  for I := 0 to High(Result) do
    if I <= High(A) then
      Result[I] := A[I]
    else
      Result[I] := B[I - Length(A)];
end;
 
function Vloz(Hodnota: Integer; const A: TPole; Kam: Integer): TPole;
begin
  Result := ____________________________________________________________
end;


  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): Char;
var
  S: TStack;
  Z: Char;
begin
  S := TStack.Create;
  Read(T, Z);
  Result := '#';
  while Z in ['a', 'b', 'c'] do
  begin
    case Z of
      'a':
        S.Push(Z);
      'b':
        if S.Empty then
          S.Push(Result)
        else
          S.Pop(Z);
      'c':
        if S.Empty then
          S.Push(Z)
        else
          S.Pop(Result);
    end;
    Read(T, Z);
  end;
  S.Free;
end;
Zistite, čo bude výsledkom funkcie, ak vstupný súbor obsahuje tento jeden riadok:
abcbcaabbccbbcc


  1. V dynamickom poli R už máme priradené nejaké hodnoty: niektoré sú nil, niektoré sú smerníky na rôzne dynamické celočíselné premenné. Procedúra CistiPole vyhádže z tohto poľa všetky nil-ové prvky ale aj prvky, ktorých hodnota je menšia ako 2. Dopíšte chýbajúce časti programu:
var
  R: array of ^Integer;
 
procedure CistiPole;
var
  I, J: Integer;
begin
  I := 0;
  while I <= High(R) do
    if (R[I] = nil) or (_________________) then
    begin
      if R[I] <> nil then
        ___________________;
      for J := I to High(R) - 1 do
        R[J] := ____________________;
      SetLength(________________);
    end
    else
      _______________________;
end;


  1. Pracujeme s jednorozmerným poľom množín:
type
  Farba = (modra, cervena, biela, zelena, zlta, cierna, seda);
var
  Mn: array [Farba] of set of Farba;
Vyrobili sme si tieto dve pomocné procedúry:
procedure Pridaj(F1, F2: Farba); overload;
begin
  Mn[F1] := Mn[F1] + [F2];
  Mn[F2] := Mn[F2] + [F1];
end;

procedure Pridaj(F1, F2: array of Farba); overload;
var
  I, J: Integer;
begin
  for I := 0 to High(F1) do
    for J := 0 to High(F2) do
      Pridaj(F1[I], F2[J]);
end;
Zistite, aký počet sa vypíše
Pridaj([modra, cervena, zelena], [biela, zelena, seda]);
Pridaj([zelena, cierna, zlta, seda], [cierna]);
Pocet := 0;
for A := modra to seda do
  for B := modra to seda do
    if B in Mn[A] then
      Inc(Pocet);
Memo1.Lines.Append(IntToStr(Pocet));


  1. Máme takúto funkciu:
function Urob(S: string): Integer;
const
  R = ')]}\';
var
  I, J, K: Integer;
begin
  Result := 0;
  for I := 1 to Length(S) do
  begin
    J := Pos(S[I], '([{/');
    if J <> 0 then
    begin
      K := StrToInt(Copy(S, I + 1, Pos(R[J], Copy(S, I + 1, MaxInt)) - 1));
      case J of
        1: Inc(Result, K);
        2: Dec(Result, K);
        3: Result := Result div K;
        4: Result := Result * K;
      end;
    end;
  end;
end;
Zistite, čo vráti volanie:
Urob('pocitaj[42]*(12)[5]urob(37)*3(33){7}/5\(1)/5\;')


  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)
    T: TextFile;
    Citaj: Boolean;
    constructor Create(Meno: string; B: Boolean);
    destructor Destroy; override;
    procedure Citaj(S: string); virtual;
    procedure Zapis(S: string); virtual;
  end;
 
constructor TSubor.Create(Meno: string; B: Boolean);
begin
  AssignFile(T, Meno);
  B := Citaj;
  if Citaj then
    Rewrite(T)
  else
    Reset(T);
end;
 
destructor TSubor.Destroy; override;
begin
  T.Free;
end;
 
procedure TSubor.Citaj(S: string); virtual;
begin
  if not Citaj and Eof(T) then
    S := '###'
  else
    Readln(T, S);
end;
 
procedure TSubor.Zapis(S: string); virtual;
begin
  if not Citaj then
    Writeln(T, S);
end;