1. Pentru urmatoarele functii, se cere:

1. Evaluati timpul T(n) de executie a functiei, in termenii functiei O (f(n)).
2. Masurati timpii de executie pentru diferite valori ale lui n. Se va realiza un tabel al dependentei timpului de executie masurat, in functie de n, si se va compara forma functiei de crestere a timpului de executie in functie de cresterea dimensiunii datelor asupra carora opereaza, cu forma functiei determinata teoretic f(n). Pentru masurarea timpilor se vor utiliza functiile din modulul timer ( timer.h, timer.c) ( timer.pas)sau clasa durata ( durata.h, durata.cpp).

 procedure inmultire_matrici(n:integer); {inmulteste doua matrici
					   patratice a si b}
    var i,j,k:integer;
    begin
      for i:=1 to n do
	for j:=1 to n do begin
	  c[i,j]:=0;
	  for k:=1 to n do
	    c[i,j]:=c[i,j]+a[i,k]*b[k,j]
	end
    end;

B.

procedure numere_impare(n:integer;var x,y:integer);
    var i,j:integer;
    begin
      for i:=1 to n do
	if odd(i) then begin
	  for j:=i to n do
	    x:=x+1;
	  for j:=1 to i do
	    y:=y+1
	end
    end;

C.

    function recursiva(n:integer):integer;
    begin
      if n<=1 then recursiva:=1
      else recursiva:=recursiva(n-1)+recursiva(n-2)
    end;

D. Functia max(i,n) returneaza cel mai mare element dintre cele n aflate intre pozitiile i si i+n-1 ale vectorului a.

   function max(i,n:integer):integer;
    var m1,m2:integer;
    begin 
      if n=1 then max:=a[i]
      else begin
	m1:=max(i,n div 2);
	m2:=max(i+n div 2,n div 2+ n mod 2);
	if m1 < m2 then max:=m2
	else max:=m1
      end
    end;

E.

   int CautareBinara(int A[], int X, int N) {
     int Jos=0, Sus=N-1;
     int Mijl;
     while (Jos<=Sus) {
         Mijl=(Jos+Sus)/2;
         if (A[Mijl]X) 
                   Sus=Mijl-1;
              else return Mijl;
          }
      return Inexistent;
     }     

F.

  int CMMDC(int M, int N) {
     int R;
     while (N>0) {
        R= M % N;
        M=N;
        N=R;
       }
      return M;
     }

G.

 
   longint Putere(longint X, int N) {
       if (N==0)
          return 1;
       if (N==1)
          return X;
       if (! odd(N)) 
          return Putere(X*X, N/2);
       else
          return X * Putere(X*X, N/2);
       }

H. Se considera secventa care implementeaza algoritmul "ciurul lui Eratostene" pentru determinarea tuturor numerelor prime mai mici ca N:

  for i:=1 to n do
  a[i]:=true;

  i:=2;
  while i < sqrt(N) do begin
     for j:=2 to N div i do
           a[j*i]:=false;
     i:=i+1;
     while not a[i]  do i:=i+1;
     end;

I.

   void QuickSort(int v[], int stanga, int dreapta) {
       int i, ultim;
       if (stanga>=dreapta)
            return;
       schimba(v[stanga], v[(stanga+dreapta)/2]);
       ultim=stanga;
       for (i=stanga+1; i<=dreapta; i++)  
         if (v[i] < v[stanga])
                     schimba(v[++ultim], v[i]);
       schimba(v[stanga], v[ultim]);
       QuickSort(v, stanga, ultim-1);
       QuickSort(v, ultim+1, dreapta);
       }

   ......  se apeleaza:
   QuickSort(v, 1, N)