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;
|
