ZS/Testy/Test 07
Z Pascal
Záverečný test v zimnom semestri 2007/2008
- 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
- Rekurzia(1, 243)
- Rekurzia(3, 243)
- Rekurzia(5, 243)
- 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
- Zistite, aké hodnoty sa objavia vo výstupnom súbore, ak vstupný súbor bol:
- 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.
- 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; |
- 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; |
- 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
- Zistite, čo bude výsledkom funkcie, ak vstupný súbor obsahuje tento jeden riadok:
- 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; |
- 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)); |
- 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\;')
- Zistite, čo vráti volanie:
- 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; |