Informatyka MIMUW

const M = 100;
      D = 100;
type Tab = array[0..D-1] of ^array[0..M-1];
     Str = record 
       T:Tab;
       poczD,konD, poczM, konM:integer;
     end;

function Wstaw(var S:Str; liczba: integer):boolean;
//wstawiamy liczbę do struktury S (S.T[S.poczD]^[S.poczM] to pierwsza liczba w ciągu, 
//S.T[S.konD]^[S.konM] to pierwsze wolne miejsce w S
//Wstaw staje się false wtedy i tylko wtedy, gdy struktura S jest pełna 
begin 
  if (S.konD=S.poczD and S.konM+1=S.poczM) or ((S.konD+1) mod D = S.poczD and S.konM=M-1 and S.poczM=0) then 
    Wstaw:=false
  else begin 
    Wstaw:=true;
    if S.konM = 0 and S.poczD <>S.konD then New(S.T[S.konD]);
    S.T[S.konD]^[S.konM]:=liczba;
    S.komM:=(S.komM+1) mod M;
    if S.konM=0 then S.konD:=(S.konD+1) mod D;
  end;
end;

function Pobierz(var S:Str; var liczba: integer):boolean;
//pobieramy liczbę ze struktury S (S.T[S.poczD]^[S.poczM] to pierwsza liczba w ciągu, 
//S.T[S.konD]^[S.konM] to pierwsze wolne miejsce w S
//Pobierz staje się false wtedy i tylko wtedy, gdy struktura S jest pusta 
begin 
  if (S.konD=S.poczD and S.konM=S.poczM) then 
    Pobierz:=false
  else begin 
    Pobierz:=true;
    liczba:=S.T[S.poczD]^[S.poczM];  
    S.poczM:=(S.poczM+1) mod M;
    if S.poczM=0 then begin 
      if S.konD <> S.pocz then Dispose(S.T[poczD]);
      S.poczD:=(S.poczD+1) mod D;
    end;
  end;
end;

const N = 100;
type rodzaj = (napis, liczba)
     Dane = record 
       case co:rodzaj of
         napis: (s:string)
         liczba: (l:liczba)
       end;
     Eltab = record
       klucz:integer; 
       case co:rodzaj of
         napis: (wsk:^string)
         liczba: (l:liczba)
       end;
var T: array[0..N] of Eltab

procedure Wstaw(klucz: integer; var d: Dane); 
//wstawiamy dane z d do tablicy T na pierwsze wolne miejsce, zaczynając od indeksu klucz mod (N+1)
//zakładamy, że są wolne miejsca w tablicy T 
var k:integer;
begin
  k:=klucz mod (N+1);
  while T[k].klucz <> -1 do k:=(k+1) mod (N+1);
  T[k].klucz:=klucz;
  T[k].co:=d.co;
  case d.co of
    napis: New(T[k].wsk); T[k].wsk^:=d.s;
    liczba: T[k].l:=d.l
  end; 
end;

function Daj(klucz: integer; var d: Dane):boolean;
//pobieramy liczbę lub napis z tablicy T skojarzonych z kluczem klucz
//zakładamy, że są wolne miejsca w tablicy T 
var i:integer;
begin
  k:=klucz mod (N+1); 
  while T[k].klucz <> klucz and T[k].klucz <> -1 do k:=(k+1) mod (N+1);
  if T[k].klucz = -1 then
    Daj:=false
  else begin
    Daj:=true;
    d.co:=T[k].co;
    case d.co of
      napis: d.s:=T[k].wsk^;
      liczba: d.l:=T[k].l;
    end;
  end; 
end;

const N = 100;
type rodzaj = (pełny, pusty); 
     Eltab = record 
       case rodzaj of
         pełny: (d:T)
         pusty: (nast:integer)
       end;
     Str = record 
       T:array[1..N] of Eltab;
       pierwszy:integer;
     end;

procedure InitT(var S:Str);
//wszystkie pola ustawiamy na puste, nast wskazują na następne pole lub zero; pierwszy staje się równy 1
var i:integer;
begin
  for i:=1 to N do S.T[i].nast:=(i+1) mod (N+1);
  S.pierwszy:=1;
end;

function NewT(var S:Str; var nowy:integer):boolean;
//nowy to indeks któregoś z dotychczas pustych pól w S.T; jeśli takich nie ma, to New będzie miało wartość false
begin
  if S.pierwszy = 0 then 
    New:=false
  else begin
    New:=true;
    nowy:=S.pierwszy;
    S.pierwszy:=S.T[S.pierwszy].nast;
  end;
end;

procedure DisposeT(var S:Str; d:integer);
//zwalniamy indeks d w tablicy S.T
begin
  S.T[d].nast:=S.pierwszy;
  S.pierwszy:=d;
end;