ZS/Testy/Test 09

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

Záverečný test v zimnom semestri 2009/2010



  1. Máme dané pole smerníkov na celé a reálne čísla. Doprogramujte telo cyklu vo funkcii Priemer, ak viete, že na nepárnych indexoch poľa sú smerníky na celé čísla a na párnych sú smerníky na reálne čísla. Niektoré prvky poľa môžu byť nil a vtedy sa nezapočítavajú do priemeru:
type
  TPole = array of Pointer;
 
function Priemer(P: TPole): Real;
var
  I, N: Integer;
begin
  Result := 0;
  N := Length(P);
  for I := 0 to High(P) do
  begin
 
 
  end;
  if N <> 0 then
    Result := Result / N;
end;


  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 High(P) do
  begin
    _____________________;
    for J := 0 to __________ do
    begin
      ________________;
      ___________ := I * 10 + J;
    end;
  end;
end;


  1. V infixovom zápise aritmetických výrazov sa operácie s rovnakou prioritou vyhodnocujú zľava doprava. Prepíšte daný výraz do prefixového aj postfixového zápisu:
1 + 2 * 3 / 4 * 5 / 6 * 7 / 8 / 9 – 1 / 2 / 3 – 4 / 5 / 6
Výraz neupravujte ani nevyhodnocujte.


  1. Daná funkcia nejako pracuje s množinami:
type
  TSet = set of Byte;
 
function Urob(A: array of TSet): TSet;
var
  I: Integer;
begin
  Result := A[0];
  for I := 1 to High(A) do
    if I mod 2 = 0 then
      Result := Result + A[I]
    else
      Result := Result - A[I];
end;
Zistite, čo vráti volanie:
Urob([[1], [5, 8, 9], [2, 4, 6], [], [4, 8, 16], [1, 2, 3]])


  1. Daná funkcia Spoj by mala zreťaziť všetky reťazce, ktoré sú v parametri otvorené pole reťazcov. Napr. Spoj(['abc','xyz','ahoj']) by malo vrátiť reťazec 'abcxyzahoj'. Doplňte vyznačené chýbajúce časti programu (nedopisujte nové premenné ani príkazy). Š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.
function Spoj(S:___________________________): string;
var
  I, D: Integer;
begin
  D := 0;
  for I := 0 to High(S) do
    Inc(D, _____________________);
  __________________ Result ________________;
  D := 1;
  for I := 0 to High(S) do
    if S[I] <> '' then
    begin
      Move(_________________ Result _________________);
      Inc(D, ________________);
    end;
end;


  1. Máme danú triedu TStack, ktorá pracuje so znakovým zásobníkom (TPrvok = Char) a takúto funkciu:
function Test: Boolean;
var
  Zas: TStack;
  Znak: Char;
begin
  Zas := TStack.Create;
  Read(Znak);
  while Znak in ['a', 'b'] do
  begin
    if _______________ Zas.Top _________ then
    begin
      if Znak = 'b' then
        _______________________________;
      Zas.Push(Znak);
    end
    else
      __________________________
      __________________________
      __________________________;
    Read(Znak);
  end;
  Result := (Znak = #13) ________________;
  Zas.Free;
end;
Dopíšte chýbajúce časti tak, aby funkcia vrátila True len vtedy, keď reťazec na vstupe obsahuje presne dvojnásobok písmen a, ako písmen b. Inak by na vstupe nemali byť iné znaky. Znak #13 označuje koniec riadka. Môžete používať metódu triedy TStack Top, ktorá vráti hodnotu na vrchu zásobníka – z vrchu zásobníka ju ale neodoberie ako Pop.


  1. Táto funkcia kreslí nejakú známu krivku a okrem toho aj niečo počíta:
var
  R: TRobot;
 
function Kresli(N: Integer): Integer;
 
  procedure Otoc(Uhol: Integer);
  begin
    Inc(Result, Uhol);
    R.Lt(Uhol);
  end;
 
begin
  Result := 0;
  if N > 0 then
  begin
    R.Fd(30);
    Otoc(40);
    Inc(Result, Kresli(N - 1));
    Otoc(270);
    Inc(Result, Kresli(N - 1));
    Otoc(50);
    R.Fd(-30);
  end;
end;
Zistite, aké hodnoty vrátia volania:
  1. Kresli(1)
  2. Kresli(4)
  3. Kresli(10)


  1. V nasledujúcej časti programu je niekoľko chýb. Textový súbor v každom riadku obsahuje celé číslo od 1 do 30 a za ním je medzera a nejaký reťazec. Program by mal z tohto súboru vypísať tie reťazce, pred ktorými je najčastejšie sa vyskytujúce číslo. Opravte chyby v programe.
var
  P: array [1..30] of Integer;
  T: FileText;
  I, M: Integer;
  S: string;
begin
  AssignText(T, 'subor.txt');
  try
    Reset(T);
    for I := 1 to 30 do
      P[I] := 0;
    M := 0;
    while Eof(T) do
    begin
      Read(T, I);
      Inc(P[I]);
      if P[M] < P[I] then
        I := M;
    end;
    Rewrite(T);
    while Eof(T) do
    begin
      ReadLn(T, M, S);
      if I = M then
        Memo1.Lines.Append(S)
    end;
  finally
    CloseText(T);
  end;
end;


  1. Nasledujúca procedúra nejako spracováva dátovú štruktúru rad (TQueue) v globálnej premennej Q:
procedure Spracuj;
var
  I1, I2: Integer;
begin
  Q.Append(-1);
  Q.Serve(I1);
  while I1 > 0 do
  begin
    Q.Serve(I2);
    if I2 > I1 then
      Q.Append(I2)
    else
    begin
      Q.Append(I1);
      I1 := I2;
    end;
  end;
end;
Zistite, aký bude obsah radu po vykonaní procedúry Spracuj, ak jeho počiatočné hodnoty boli:
(8, 5, 20, 4, 9, 13, 2, 3, 5, 12, 1, 3, 5, 13).


  1. Chceli sme zadefinovať triedu na prácu s dynamickým poľom celých čísel. Property by malo zabezpečiť indexovanie tohto poľa pomocou znakových reťazcov a tiež hodnotou takéhoto prvku poľa (property) by mal byť reťazec. V programe sme urobili niekoľko chýb - opravte ich.
type
  TSPole = class
  private
    FPole: array of Integer;
    function GetPole: string; virtual;
    procedure SetPole(Hodnota: string); override;
  public
    property Pole [X: string]: string read GetPole write SetPole;
  end;
 
function TSPole.GetPole: string; virtual;
var
  I: Integer;
begin
  I := IntToStr(X);
  if (I < 0) or (I > High(Pole)) then
    Result := ''
  else
    Result := StrToInt(Pole[I]);
end;
 
procedure TSPole.SetPole(Hodnota: string); override;
var
  I: Integer;
begin
  I := IntToStr(X);
  if I >= High(Pole) then
  begin
    if I > 0 then
      SetLength(Pole, I + 1);
    Pole[I] := Hodnota;
  end;
end;