ZS/Testy/Test 10

Z Pascal
Revízia z 18:34, 19. marec 2013; 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 2010/2011



  1. Dané funkcie pracujú s množinami:
type
  TMnozina = set of Byte;
 
function Rob(P: array of TMnozina): TMnozina;
var
  I: Byte;
begin
  Result := [];
  for I := 0 to High(P) do
    if I mod 2 = 0 then
      Result := Result + P[I]
    else
      Result := Result - P[I];
end;
 
function Rob(P: array of Byte): TMnozina;
var
  I: Byte;
begin
  Result := [];
  for I := 0 to High(P) do
    if I mod 2 = 0 then
      Result := Result + [P[I]]
    else
      Result := Result - [P[I]];
end;
Zistite, čo vráti takéto volanie:
Rob([Rob([4, 8, 4, 9]), [4, 5], Rob([[1, 2], [2, 3, 4]])])


  1. Funkcia Hviezda kreslí známu krivku snehová vločka a okrem toho aj niečo počíta:
var
  R: TRobot;
 
function Hviezda(N, D, U: Integer): Real;
begin
  if N = 0 then
  begin
    Result := D;
    Robot.Fd(D);
  end
  else
    Result := Hviezda(N - 1, D div 3, -60) +
              Hviezda(N - 1, D div 3, 120) +
              Hviezda(N - 1, D div 3, -60) +
              Hviezda(N - 1, D div 3, 0);
  Robot.Rt(U);
end;
Zistite, aké hodnoty vrátia volania:
  1. Hviezda(1, 108, 0)
  2. Hviezda(3, 108, 0)
  3. Hviezda(5, 108, 0)


  1. V nasledujúcom programe sa postupne generuje 20 robotov, ktoré kreslia nejaké čiary. Po nejakom čase tento program spadne. Zistite, akú celkovú dráhu tieto roboty stihnú prejsť, kým program nespadne.
var
  Pole: array [1..20] of TRobot;
  I, J, N: integer;
begin
  Pole[1] := TRobot.Create;
  N := 1;
  while True do
  begin
    Pole[N].Rt(10);
    J := N;
    for I := 1 to N do
    begin
      Pole[I].Fd(N);
      Inc(J);
      Pole[J] := TRobot.Create;
    end;
    N := J;
  end;


  1. Daná časť programu číta z textového súboru, ktorý obsahuje len celé čísla a niektoré z nich vypisuje:
for I := 1 to 10 do
  begin
    for J := 1 to I do
      Read(Subor, K);
    WriteLn(K);
    if I mod 2 = 1 then
      Readln(Subor)
    else
      Reset(Subor);
  end;
Zistite, aké hodnoty sa vypísali, ak vstupný súbor bol takýto:
1 2 3
4 5 6 7
8 9 10 11 12
13 14 15 16 17 18
19 20 21 22 23 24 25


  1. Zistite, ktoré prvky bude obsahovať množina M na konci tohto programu:
type
  TVymenovany = (a, b, c, d, e, f, g);
var
  M: set of TVymenovany;
  I: integer;
  J: TVymenovany;
begin
  M := [];
  for I := 100 to 150 do
  begin
    J := TVymenovany(I mod (Ord(High(TVymenovany)) + 1));
    if J in M then
      M := M - [J]
    else
      M := M + [J];
  end;


  1. Aritmetické výrazy sme doplnili o operáciu priradenia := (prvý operand musí byť meno premennej a táto operácia priradí druhý operand do tejto premennej - výsledkom operácie je priraďovaná hodnota) a operáciu celočíselného de-lenia div:
- div * - := c + := a 7 2 3 + := b 4 3 5 div * c b a
Prepíšte tento prefix do postfixu a tiež zistite jeho hodnotu. Napr. infixový zápis ((a := 3) + a) by mal hodnotu 6. Ak sa vo výraze pri vyhodnocovaní vyskytne nedefinovaná premenná, tak tato ma hodnotu 0.


  1. Máme danú triedu TStack, ktorá vie pracovať s celočíselným zásobníkom (TPrvok = Integer) a takúto časť programu:
 while not Stack.Empty do
 begin
   Stack.Pop(I);
   if (I mod 5 > 2) or Stack.Empty then
     Write(I, ', ')
   else
   begin
     Stack.Pop(J);
     Write(J, ', ');
     Write(I, ', ');
   end;
 end;
Zistite, čo sa nachádzalo v zásobníku pred cyklom, keď sme dostali takýto výstup:
5, 7, 4, 3, 5, 6, 4, 6, 5, 5,
Pôvodný obsah zásobníka uveďte v poradí od najspodnejšieho prvku až po vrch zásobníka.


  1. Chceli sme zadefinovať triedu na prácu so znakovým zásobníkom, ale urobili sme niekoľko chýb - opravte ich. Do zásobníka vkladáme znaky na začiatok reťazca znakov (zásobníka) a vyberáme ich zo začiatku.
type
  TStack = class
    Pole: string;
    procedure Push(var Z: Char); virtual;
    procedure Pop(Z: Char); override;
    function Empty: Boolean;
  end;
 
procedure TStack.Push(var Z: Char);
begin
  inherited;
  Insert(Z, Pole);
end;
 
procedure TStack.Pop(Z: Char);
begin
  if Empty then
    except Exception.Create('zla operacia Pop');
  Z := Copy(Pole, 1, 1);
  Delete(Pole, 1);
end;
 
function TStack.Empty: Boolean;
begin
  Result := Pole[1] = '';
end;


  1. Do poľa smerníkov chceme prečítať riadky textového súboru. Každý smerník bude odkazovať do dynamickej pamäte na postupnosť znakov jedného riadka súboru. Na koniec každého takéhoto riadka pridáme ešte aj znak '#'. Program na záver vypíše prečítané riadky súboru (aj s ukončovacími znakmi '#'). Doprogramujte chýbajúce časti programu. Štandardná procedúra Move kopíruje z nejakej časti pamäte (prvý parameter), do inej (druhý parameter), kde v treťom parametri je počet kopírovaných bajtov.
var
  Pole: array of Pointer;
  I: Integer;
  S: string;
  T: TextFile;
begin
  AssignFile(T, 'text.txt');
  Reset(T);
  while not Eof(T) do
  begin
    ReadLn(T, S);
    S := S + '#';
    SetLength(Pole, Length(Pole) + 1);
    GetMem(___________________________________);
    Move(_____________________________________);
  end;
  CloseFile(T);
  for I := 0 to High(Pole) do
    WriteLn(__________________________________);


  1. Dopíšte chýbajúce časti programu tak, aby sa v dynamickom poli A vytvorila takáto trojuholníková štruktúra: prvý riadok má 1 prvok so smerníkom na prvý prvok poľa Pole, druhý má 2 prvky so smerníkmi na druhý a tretí prvok poľa Pole, tretí má 3 prvky so smerníkmi na ďalšie tri prvky poľa Pole, atď. až 10 riadok má 10 prvkov so smerníkmi na prvky poľa Pole:
var
  Pole: array [1..1000] of Integer;
  P: ^Integer;
  A: array of array of Pointer;
  I, J: Integer;
begin
  P := ________________________;
  SetLength(__________________);
  for I := 0 to High(A) do
  begin
    SetLength(__________________);
    for J := 0 to ______________ do
    begin
      A[I, J] := P;
      __________________;
    end;
  end;