LUCRARE DE CURS LA INFORMATICA

1. Ministerul Învăţămîntului al Republicii Moldova
Elevul : Ciobanu Mihail S.
Clasa : a XI-a “Real”
Liceul Teoretic “Mihai Viteazul”
Carahasani 2009

2. CUPRINS
 Introducere...................................................................................................................................3
 § 6.1.Operaţii cu mulţimi.............................................................................................................4
 § 6.2.Analiza combinatorie..........................................................................................................12
 Concluzii.....................................................................................................................................24
 Anexa nr.1....................................................................................................................................25
 Anexa nr.2....................................................................................................................................26
 Anexa nr.3....................................................................................................................................27
 Anexa nr.4....................................................................................................................................29
 Anexa nr.5....................................................................................................................................30
 Anexa nr.6....................................................................................................................................32
 Bibliografie.................................................................................................................................34
 BRĂŢĂRI.....................................................................................................................................35
 MULŢIME CONVEXĂ..................................................................................................................36

3. INTRODUCERE
 În viaţa de zi cu zi ne întîlnim cu foarte multe probleme, unele mai importante, altele mai puţin
importante şi dorim să le rezolvăm pe toate, însă cu părere de rău sînt unele la care nu ştim răspunsul
şi nici alţi semeni de-ai noştri nu ne pot ajuta.
 Această lucrare vine în ajutorul elevilor, pentru a propune noi metode de înţelegere a materiei, unele
păreri care nu s-au discutat pe parcursul orelor de informatică pentru a-i captiva pe elevi cu
conţinutul său şi a-i motiva să înveţe informatica.
 Temele la această disciplină sînt destul de complicat expuse în manualul de clasa a XI-a, nu sînt pe
înţelesul elevilor sau sînt mai puţin înţelese.
 Iată că aici vom prezenta un capitol din manual: “ALGORITMI DE REZOLVARE A UNOR
PROBLEME MATEMATICE” în care se cuprind temele: “Operaţii cu mulţimi” şi “Analiza
combinatorie” din perspectiva gîndirii autorului lucrării.
 În lucrare se desfăşoară temele, utilizînd diferite exemple de programe, astfel adaptînd limbajul
matematic la limbajul Pascal. Astfel am hotărît ca să fiu mai bine înţeles şi deoarece în instituţiile de
învăţămînt preuniversitare se pune mai mult accent pe manualul be bază, elevii rareori folosesc surse
alternative. M-am stăruit ca la noţiuni să utilizez un limbaj mai simplu pentru a facilita înţelegerea şi
utilizarea lor ulterioară. Sper că lucrarea va putea fi de un real folos.
 Aştept sugestiile, recomandările şi opiniile voastre.
MULT SUCCES! Autorul

4. § 6.1 OPERAŢII CU MULŢIMI
 Ce este o mulţime? Cum putem defini această noţiune?
Să răspundem simplu: o colecţie bine definită de obiecte, considerată ca un întreg. Obiectele unei mulţimi
se numesc elemente. Mulţimile se notează cu litere mari.Elementele unei mulţimi se încadrează în acolade.
De exemplu:
1.Mulţimea numerelor naturale n={1,2,3,4,5,….}
2.Mulţimea culorilor drapelului Republicii Moldova
C={RoşU, GALBEN, Albastru}
Există şi mulţimi fără elemente-mulţimea vidă, notată astfel: Ø.
 Ce este o submulţime?
Un exemplu: Fie F mulţimea femeilor , B-mulţimea bărbaţilor şi O mulţimea oamenilor. Mulţimea F şi
mulţimea B se includ în mulţimea oamenilor O, mulţimile F şi B sînt submulţimi ale mulţimii O.
Deci o submulţime a unei mulţimi este o mulţime care este inclusă în acea mulţime, adică toate
elementele ei aparţin acelei mulţimi.
A este submulţime a lui B
 Fie avem mulţimile
A={cîine,om,pisică,şoarece} şi B={cîine,iepure,şoarece,urs}.
Să efectuăm operaţii cu aceste mulţimi:
 REUNIUNEA-să “adunăm” elementele mulţimilor A şi B :
A∪B={cîine,iepure,om,pisică,şoarece,urs} -elementele nu se repetă

5.  INTERSECŢIA-să scoatem elementele necomune ale mulţimilor A şi B : A∩B={cîine, şoarece} – se iau
elemente comune
 DIFERENŢA-să “scădem” elementele mulţimilor A şi B : A-B={om,pisică}. Să scădem B din A :
B-A={iepure, urs}.
A-B B-A

6.  Să trecem la limbajul PASCAL.
1.Declararea tipului mulţime
Tipul
set of elementelor
mulţimii(tipul
de bază)
2. Forma constructorului de mulţime
[ ]
Expresie
.. Expresie
,

7. 1.Exemple:
var cifre: set of ‘0’ . . ‘9’;
a: set of byte;
b: set of integer;
decor: set of (rosu, galben, albastru, verde, oranj, alb);
Observaţii:
1.Tipul elementelor mulţimii trebuie să fie ordinal.
2.Dacă tipul de bază are n valori, atunci tipul mulţime va avea 2n valori.
2.Exemple:
a:=[1, 2, 5];
b:=[x . . x+9];
cifre:=[‘9’];
décor:=[verde, pred(galben)];
Observaţie: Constructorul [ ] reprezintă mulţimea vidă.
Operaţii cu mulţimi în PASCAL
Var A: set of (ciine,om,pisica,soarece);
B: set of (ciine,iepure,soarece,urs);
C,D,E,F: set of char;
Declararea mulţimii A - A:=[ciine,om,pisica,soarece];
Declararea mulţimii B - B:=[ciine,iepure,soarece,urs];
Reuniunea – C:=A+B;
Intersecţia - D:=A*B;
Diferenţa - E:=A-B; sau F:=B-A;

8. Egalitatea mulţimilor : A=B returnează true, dacă A=B, altfel- false.
Neegalitatea mulţimilor: A<>B returnează true , dacă A≠B, altfel- false.
Incluziunea : A<=B returnează true , dacă A se include în B, altfel- false.
A>=B returnează true, dacă B se include în A, altfel- false.
Apartenenţa : a in A returnează true, dacă a є A, altfel- false.
Să revenim la submulţimi. Cîte submulţimi posibile putem forma dintr-o mulţime dată:
Să scriem submulţimile mulţimii M={1,2,3}.
1.Submulţimi cu niciun element - mulţimea vidă-Ø.
2.Submulţimi cu un element – {1}, {2}, {3}.
3.Submulţimi cu două elemente - {1,2}, {1,3}, {2,3}.
4.Submulţimi cu trei elemente - {1,2,3}.
Am obţinut 8 submulţimi. Deoarece dacă tipul de bază al elementelor mulţimii are n valori, atunci tipul
mulţime va avea 2n valori. Deci numărul submulţimilor posibile este 2n , unde n-numărul elementelor
mulţimii.În cazul nostru n=3 (3 elemente-1,2,3), 23=8, deci trebuia să obţinem 8 submulţimi, aşa cum şi-am
obţinut.
 Să analizăm următorul program :
1 Fie mulţimile A={1,3,a,4,c,d,5,8,2}, B={2,a,c,8,4,9,e,3}. Să se calculeze mulţimea C=(A ∪ B)(A ∩ B)
Rezolvare:
program Set1;
var a,b,c: set of char; {se declară variabilele a,b şi c de tip mulţime,
i:integer; tipul de bază al mulţimilor fiind caracterial}
BEGIN
A:=[‘1’, ’3’, ’a’, ’4’, ‘c’, ‘d’, ‘5’, ‘8’, ‘2’]; {Scriem mulţimea A}
B:=[‘2’, ’a’, ’c’, ’8’, ‘4’, ‘9’, ‘e’, ‘3’]; {Scriem mulţimea B}

9. C:=(A+B)-(A*B); {Scriem operaţiile cu mulţimile A şi B,
rezultatul atribuind mulţimii C }
{În continuare se va afişa mulţimea C}
for i:=1 to 255 do
if chr(i) in C then write(chr(i), ‘ ‘);
readln;
END.
{funcţia chr(i) returnează caracterul cu numărul de ordine i}
 Să rezolvăm o problemă:
2 Se dă un text cu cel mult 255 de caractere. Să se afişeze caracterele diferite din text. De exemplu,
pentru textul “AbraCadabra” se va afişa “ACabdr”
Rezolvare:
program Set2;
uses Crt;
var diferit: set of char;
text: string;
i:byte;
BEGIN
ClrScr;

10. write(‘Scrie textul: ’);
readln(text);
diferit:=[]; {la început mulţimea este vidă}
for i:=1 to length(text) do
diferit:=diferit+[text[i]]; {Elementele diferite se includ în mulţimea diferit}
for i:=1 to 255 do
if chr(i) in diferit then write(chr(i));
readln;
END.
 Să rezolvăm altă problemă :
3 Se dă numărul natural n, n<20. Se citesc de la tastatură n mulţimi de numere naturale mai mici decît 100.
Să se afişeze reuniunea şi intersecţia acestor mulţimi.
Rezolvare:
program Set3;
uses Crt;
type multime=set of byte;
var a: array[1 . . 20] of multime;
reun,inter: multime;
i,n,el:byte;
BEGIN

11. ClrScr;
write(‘Numarul de multimi : ’);
readln(n);
for i:=1 to n do begin
a[i]:=[];
{Scriem elementele multimii i}
writeln(‘Multimea ‘ , i);
repeat
write(‘Elementul : ’);
readln(el);
a[i]:=a[i] +[el];
until not (el in [0 . . 100]);
end;
reun:=[];
inter:=[0 . . 100];
for i:=1 to n do begin
reun:=reun+a[i];
inter:=inter*a[i];
end;
writeln(‘Reuniunea’);
for i:=0 to 100 do
if i in reun then write(i,’ ‘);
writeln;
writeln(‘Intersectia’);
for i:=1 to 100 do
if i in inter then write(i,’ ‘);
readln;
END.

12. § 6.2 ANALIZA COMBINATORIE
 Ce este o combinaţie? Cum putem defini această noţiune?
Combinaţia este o reunire, îmbinare, combinare de elemente diferite,prin procedee diferite în
scopul obţinerii unui tot sau al unui efect unitar.
În rezolvarea multor probleme este necesar de a implementa algoritmii bazaţi pe analiza consecutivă a
soluţiilor posibile ceea ce presupune generarea permutărilor, aranjamentelor sau combinărilor unei
mulţimi.
 Să definim pe rînd şi să studiem aceste noţiuni (permutări, aranjamente, combinări):
1) PERMUTARE - (în expresia Permutare de n elemente a unei mulţimi) – fiecare dintre mulţimile
ordonate care se formează cu cele n elemente ale unei mulţimi finite A
Este cunoscut faptul că numărul de permutări posibile ale unei mulţimi A={a1, a2, a3, a4, ..., an} cu n
elemente se determină ca Pn=n!. Acest număr poate fi calculat cu ajutorul funcţiei factorial,
exprimată în formă iterativă(care exprimă o acţiune repetată) :
Pn=1*2*3*4*...*n
sau recursivă:
Pn=
De exemplu, pentru A={leu,tigru} cele P2=2!=1*2=2 permutări sînt
(leu,tigru) şi (tigru,leu). Pentru B= {roşu,galben,verde} cele P3=3!=1*2*3=6 permutări sînt :
(roşu,galben,verde); (roşu,verde,galben); (galben,roşu,verde);
(galben,verde, roşu); (verde,roşu,galben); (verde,galben,roşu);

13. adică:
(a1,a2,a3); (a1,a2,a3); (a1,a2,a3);
(a1,a2,a3); (a1,a2,a3); (a1,a2,a3).
Notă:Permutarea elementelor mulţimii vide: ().
Fie că se pune problema generării permutărilor oricărei mulţimi A cu n elemente : A={1,2,3,4,…,n},
permutările fiind denumite permutări de grad n. Există mai multe metode ingenioase de generare a
permutărilor de grad n, cea mai des întîlnită fiind metoda lexicografică. Această metodă presupune plecarea
de la permutarea cea mai mică în ordine lexicografică, şi anume de la permutarea identică (1,2,3,4,...,n).
Avînd construită o permutare p=(p1,…,pi-1,pi,pi+1,…,pn), pentru determinarea următoarei permutări p’ care îi
urmează în ordine lexicografică acel indice i care satisface relaţiile:
pi<pi+1; pi+1> pi+2> …> pn.
În continuare, elementul pi este înlocuit cu cel mai mic dintre elementele pi+1,…,pn care este mai mare decît pi ,
fie el pk :
(p1, ..., pi-1, pk , pi+1 ,…, pk-1, pi, pk+1, …, pn).
Permutarea căutată p’ se obţine prin inversarea ordinii ultimilor (n-i) elemente din acest vector, astfel încît ele
să apară în ordine crescătoare. Dacă nu există nici un indice i ca mai sus, înseamnă că s-a ajuns la permutarea
cea mai mare în ordine lexicografică, la (n, (n-1), ..., 1) şi algoritmul se termină.
De exemplu, pentru n=3 se obţin permutările:
(1,2,3); (1,3,2); (2,1,3);
(2,3,1); (3,1,2); (3,2,1).
În prima permutare p1 < p2 < p3 (1<2<3), în a doua- p1 < p2 > p3 (1<3>2), în a treia permutare p1 > p2 < p3 (2>1<3),
în a patra-p1 < p2 > p3 (2<3>1), în a cincea permutare avem p1 > p2 < p3 (3>1<2), în a şasea - p1 > p2 > p3 (3>2>1).
În programul ce urmează metoda lexicografică este realizată cu ajutorul procedurii GenerarePermutari.

14. 4
Program Permutari;
{Generarea permutarilor}
const nmax=100;
type Permutare=array[1 . . nmax] of 1 . . nmax;
var P : Permutare;
n : 2 . . nmax;
Indicator : boolean;
i : integer;
procedure GenerarePermutari (var Indicator : boolean);
label 1;
var i, j, k, aux : integer;
begin
{ permutarea identica }
if not Indicator then
begin
for i:=1 to n do P[i]:=i;
Indicator:=true;
goto 1;
end;
{ cautarea indicelui i }
i:=n-1;

15. while P[i]>P[i+1] do
begin
i:=i-1;
if i=0 then
begin
{ un astfel de indice nu mai exista }
Indicator:=false;
goto 1;
end; { then }
end; { while }
{ cautarea indicelui k }
k:=n;
while P[i]>P[k] do k:=k-1;
{ interschimabrea P[i] - P[k]}
aux:=P[i]; P[i]:=P[k]; P[k]:=aux;
{ ordonarea ultimilor (n-i) elemente }
for j:=1 to (n-i) div 2 do
begin
aux:=P[i+j];
P[i+j]:=P[n-j+1];
P[n-j+1]:=aux;
end; { for }

16. Indicator:=true;
1 : end; { GenerarePermutari }
BEGIN
write(‘Dati n=’); readln(n);
repeat
GenerarePermutari (Indicator);
if Indicator then
for i:=1 to n do write(P[i] : 3);
writeln;
until not Indicator;
readln;
END.
 Pentru a porni de la permutarea iniţială, înainte de primul apel al procedurii
GenerarePermutari, parametrului Indicator i se atribuie valoarea false. La fiecare apel procedura
înscrie în vectorul P permutarea ce urmează în ordine lexicografică şi atribuie parametrului Indicator
valoarea true. După generarea tuturor permutărilor, procedura GenerarePermutari va atribui
parametrului valoarea false.
 Însă, indiferent ce metodă folosim, timpul necesar pentru generarea tuturor permutărilor este minimum
O(n!). Iată de ce algoritmii care se bazează pe căutarea soluţiilor prin generarea tuturor permutărilor
posibile pot fi aplicaţi numai pentru valori mici ale lui n.

17. 2) ARANJAMENT - (în expresia Aranjamente de n elemente luate cîte m) – Submulţimile ordonate cu m
elemente distincte ale unei mulţimi cu n elemente.
Numărul aranjamentelor de m elemente ale unei mulţimi A={a1, a2, a3, a4, ..., an} cu n elemente se află cu
ajutorul formulei :
sau dacă nu dorim să utilizăm factorialul:
 Ca şi la permutări, putem reduce problema generării aranjamentelor unei mulţimi arbitrare A la
generarea aranjamentelor mulţimii I={1,2,3,4,…,n}.De exemplu, pentru I={1,2,3,4} şi m=2 cele =12
aranjamente sînt:
(1,2); (2,1); (1,3); (3,1);
(1,4); (4,1); (2,3); (3,2);
(2,4); (4,2); (3,4); (4,3).
Şi la aranjamente putem folosi metoda lexicografică, pornind de la cel mai mic aranjament : a=(1, 2, 3,...,n).
 Fie a=(a1, a2, …, ai, …, am) un aranjament arbitrar. Pentru a determina succesorul a’ al aranjamentului a
, se caută mai întîi cel mai mare indice i cu proprietatea că ai poate fi mărit. Un element ai poate fi mărit
dacă măcar una din valorile ai +1, ai +2, ..., n cu care ar putea fi înlocuit ai este disponibilă. Pentru a
putea face mai uşor aceste verificări se utilizează vectorul D=(d1, d2, …, di, …, dn), di =0 sau di =1, depinde
de faptul dacă apare sau nu valoarea i în aranjamentul curent a. Cînd i este determinat elementele
ai ,ai+1, …, am vor primi în ordine crescătoare cele mai mici numere care sînt disponibile. Dacă nu există
un indice i cu proprietatea menţionată, înseamnă că am ajuns la ultimul aranjament (n-m+1, n-
m+2, ..., n) , s-a terminat procesul de generare a aranjamentelor. Pentru a semnala acest lucru, programul
următor se utilizează variabila de tip booleean Indicator.

18. 5
program Aranjamente;
{ generarea aranjamentelor }
const nmax=100;
mmax=100;
type Aranjament=array[1 . . mmax] of 1 . . nmax;
var A : Aranjament;
D : array[1 . . nmax] of 0 . . 1;
n : 1 . . nmax;
m : 1 . . mmax;
i : integer;
Indicator : boolean;
procedure GenerareAranjamente (var Indicator : boolean);
label 1;
var i, j, k, l : integer;
begin
{aranjamentul initial}
if not Indicator then
begin
for i:=1 to m do
begin
A[i]:=i; D[i]:=1;
end;
for i:=m+1 to n do D[i]:=0;

19. Indicator:=true;
goto 1;
end;
{succesorul aranjamentului curent}
for i:=m downto 1 do
begin
D[A[i]]:=0;
for j:=A[i]+1 to n do
if D[j]=0 then
begin
A[i]:=j; D[j]:=1; k:=0;
for l:=i+1 to m do
begin
repeat k:=k+1 until D[k]=0;
A[l]:=k; D[k]:=1;
end; {for}
goto 1;
end; {if}
end; {for}
Indicator:=false;
1:end; {GenerareAranjamente}

20. BEGIN
write(‘Dati n=’); readln(n);
write(‘Dati m=’); readln(m);
Indicator:=false;
repeat
GenerareAranjamente(Indicator);
if Indicator then
for i:=1 to m do write(A[i] : 3);
writeln;
until not Indicator;
readln;
END.
 Complexitatea temporală a algoritmilor bazaţi pe generarea tuturor aranjamentelor este cel mult O(n!).
2) COMBINARE – (în expresia Combinări de n elemente luate cîte m) – submulţimile unei mulţimi cu n
elemente, avînd fiecare cîre m elemente. (0≤m≤n).
 Numărul combinărilor de n elemente luate cîte m (0≤m≤n) se calculează astfel:
= = .

21.  Exemplu: pentru I={1,2,3,4} şi m=2 obţinem =6 combinări:
{1;2}; {1;3}; {1;4};
{2;3}; {2;4}; {3;4}.
 Şi generarea combinărilor poate fi făcută în ordine lexicografică, pornind de la combinaţia iniţială
{1, 2, 3, 4, ..., m}.
 Fie o combinare c={c1, c2, …, ci, …, cm}. Combinarea imediat următoare c’ după ordinea lexicografică se
determină astfel:
 se stabileşte indicele i care satisface relaţiile ci<n-m+1, ci+1=n-m+1, cm-1=n-1, cm=cn ;
 se trece la combinarea c’ ={c1, …, ci-1, ci+1, ci+2, ..., ci+n-i+1}.
 Dacă nu există un indice i care satisface aceste condiţii, înseamnă ca s-a ajuns la ultima combinare.
 În programul următor combinările mulţimii I={1, 2, 3, 4, ..., n} se generează consecutiv în vectorul C.
6
program Combinari;
{generarea combinarilor}
const nmax=100;
mmax=100;
type Combinare=array[1 . . mmax] of 1 . . nmax;
var C : Combinare;
n : 1 . . nmax;
m : 1 . . mmax;
Indicator : boolean;
procedure GenerareCombinari (var Indicator : boolean);

22. label 1;
var i, j : integer;
begin
{combinarea initiala}
if not Indicator then
begin
for i:=1 to m do C[i]:=i;
Indicator:=true;
goto 1;
end;
{succesorul combinarii curente }
for i:=m downto 1 do
if C[i]<(n-m+i) then
begin
C[i]:=C[i]+1;
for j:=i+1 to m do C[j]:=C[j-1]+1;
goto 1;
end; {then}
Indicator:=false;
1:end; {GenerareCombinari}
BEGIN

23. write(‘Dati n=’); readln(n);
write(‘Dati m=’); readln(m);
Indicator:=false;
repeat
GenerareCombinari(Indicator);
if Indicator then
for i:=1 to m do write(C[i] : 3);
writeln;
until not Indicator;
readln;
END.
 Timpul cerut de un algoritm bazat pe generarea tuturor combinărilor este de ordinul O(nk),
k=min(m,n-m+1), adică polinomial.
 Comparînd timpul cerut de algoritmele pentru generarea permutărilor, aranjamentelor şi combinărilor
observăm că dacă merge vorba de combinări – algoritmul este polinomial. Însă cînd e cazul
permutărilor -complexitatea temporală este de cel puţin O(n!), la algoritmii pentru generarea
aranjamentelor – cel mult O(n!). Totuşi este necesar de a găsi algoritmi polinomiali, pentru că pentru
valori mari algoritmii exponenţiali devin inutilizabili, ei pot fi folosiţi atunci cînd valorile sînt mici.
Viteza de creştere a funcţiei exponenţiale este foarte mare în comparaţie cu functia polinomială. Putem
să ne aducem aminte doar un exemplu ca să înţelegem aceasta: problema îndoirii a unei foi de hîrtie de
50 de ori şi se pune întrebarea ce grosime va avea .La prima îndoire grosimea se dublează, la a doua -
grosimea este de 8 ori mai mare decît cea iniţială, la a 20-a îndoire grosimea ar fi de circa 20 m, la 39-a
îndoire ar avea grosimea Pămîntului, darmite la a 50-a îndoire?! Aşa-i combinatorica şi mulţimile cu
operaţiile lor, totul este real, trebuie doar să ne imaginăm, să aplicăm ceea ce ştim şi să profităm de asta.

24.  La această lucrare de curs am desfăşurat un capitol din Manualul de clasa a XI-a de informatică-al 6-lea -
“METODE DE REZOLVARE A UNOR PROBLEME MATEMATICE” ( paragrafele incluse în el - §
“6.1.Operaţii cu mulţimi” şi “§ 6.2.Analiza combinatorie”), aceste teme fiind actuale şi la alte
discipline, de aceea sînt destul de importante, deoarece matematica stă la baza informaticii şi este “regina
ştiinţelor”, nu cunosc vreo disciplină unde să nu se utilizeze concepte matematice, teoria ei care ne
stăruim să o punem în practică. Informatica este precursoarea ei. Nu ne putem imagina lumea azi fără
calculatoare, sau mai în general fără aparate electronice.Ele ne fac viaţa mai uşoară.
 Iată de ce am ales aceste teme, pentru că ele sînt foarte des întîlnite, dar pe cît de cunoscute, oricum încă
sînt multe teorii care încă nu sînt demonstrate sau încă n-au aplicaţii practice. Cu această lucrare vreau să
pun la dispoziţia elevilor părerea mea despre aceaste subiecte şi sper să mă poată înţelege. Deoarece ştim
că întotdeauna generaţia tînără va întrece generaţia mai în vîrstă şi-i va lua locul. De aceea cred că şi
această lucrare îşi va găsi locul, importanţa şi valoarea ei.
 Am tratat unele concepte poate într-un limbaj mai dificil, altele pot să fie mai uşor de înţeles.Dar cred că
sugestiile, recomandările şi opiniile cititorilor acestei lucrări , inclusiv şi ale colegilor de clasă vor duce la
îmbunătăţirea ulterioară a calităţii lucrărilor.
 Vreau să fac un sumar la subiectele ce le-am tratat în lucrare în continuare : la “operaţii cu mulţimi”
am atras mai multă atenţie la transformarea din limbaj matematic în limbaj Pascal în ceea ce priveşte
operaţiile cu mulţimi, deoarece am dorit să creez o corespondenţă biunivocă bine diferenţiată între aceste
2 noţiuni(cele cu font îngroşat şi înclinat).Iar la “analiza combinatorie ” m-am stăruit să pun accentul
pe programe şi formule pentru a scoate în evidenţă complexitatea temporală a algoritmilor şi
complexitatea creării acestor genuri de algoritmi(în combinatorică). Făcînd o totalizare, tind să spun că
culorile completează lucrarea, am folosit diverse pentru a crea o imagine deplină despre subiect, anume
culoarea albastră predomină , aceasta - cu scopul de a concentra asupra lucrării. Ceea ce ţine de
vocabularul utilizat – m-am stăruit ca să utilizez un lexic simplu , dar să corespundă măcar parţial cu
lexicul din manual. Sper că această lucrare de curs să fie de un real folos pentru cei ce studiază
informatica.

25. Test de evaluare la tema “Operaţii cu mulţimi” - 45 min
1)Fie declaraţiile: var x : set of 0 . . 15;
y,z : byte;
Considerăm z=4, y=3. Ce valoare va avea x în urma execuţiei instrucţiunii:
a)x:=[y+z, 1 . . 4,sqr(z)] b)x:=[trunc(sqr(y)/z) . . 10] c)x:=[0 . . 3*y, 2 . . sqr(y)-5]?
2)Se dă un text. Să se scrie un program care va afişa pe ecran vocalele care nu apar în text.
3)Submulţimile Ai , Aj ale mulţimii A sînt reprezentate prin vectori caracteristici. Elaboraţi procedurile
necesare pentru efectuarea Următoarelor operaţii: Ai ∩ Aj , Ai ∪ Aj .
4)Să se scrie un program care va afişa pe ecran toate submulţimile mulţimii {1,2,3,...,50}, care au suma
elementelor numărul natural dat n, n<1000

26. Test de evaluare la tema “Analiya combinatorie” - 45 min
1)Care sînt avantajele şi dezavantajele algoritmilor bazaţi pe generarea tuturor permutărilor, aranjamentelor şi
combinărilor posibile?
2)Elaboraţi o procedură recursivă pentru generarea tuturor permutărilor posibile ale mulţimii I={1,2,3,4,...,n}.
3)Se consideră un tablou bidimensional T[1 . . n, 1 . . n] format din numere întregi.Elaboraţi un program care
determină o permutare a coloanelor tabloului astfel încît suma componentelor de pe diagonala principală
să fie minimă
4)Se consideră mulţimea numerelor întregi A={a1,a2,…,an}.Elaboraţi un program care determină o
descompunere a mulţimii A în două submulţimi nevide B şi C astfel încît suma elementelor din
submulţimea B să fie egală cu suma elementelor din submulţimea C.De exemplu, pentru
A={-4,-1,0,1,2,3,9} avem B= {-4,0,9} şi C= {-1,1,2,3 }.

27. CUBUL RUBIK
 Permutări
 Un cub Rubik are opt colţuri şi douăsprezece muchii. Există 8! moduri de aranjare a pieselor din colţ.
Şapte pot fi orientate independent, iar orientarea celui de-al optulea depinde de celelalte şapte, dând în
total 37 posibilităţi. Există 12!/2 moduri de aranjare a muchiilor, deoarece o permutare impară a colţurilor
implică o permutare impară a munchiilor. Unsprezece muchii pot fi puse independent în câte două
orientări, cu orientarea ultimei depinzând de celelalte, ceea ce dă 211 posibilităţi.
 Sunt exact 43.252.003.274.489.856.000 posibilităţi. În reclame, se spune adesea că jocul are doar miliarde
de poziţii, deoarece ordinele mai mari de mărime sunt greu de înţeles de mulţi. Dacă s-ar pune cap la cap
cuburi Rubik de 57 mm fiecare într-o permutare diferită, epuizând toate posibiliţăţile, şirul ar avea
261 ani-lumină ungime.
 Cifra de mai sus se limitează la permutările care pot fi obţinute doar prin rotirea feţelor cubului. Dacă se
consideră şi permutările atinse prin dezasamblarea cubului, numărul este de douăsprezece ori mai mare:
 Numărul complet este de 519.024.039.293.878.272.724 aranjamente posibile ale pieselor care îl compun,
dar numai una din douăsprezece este rezolvabilă. Aceasta pentru că nu există secvenţe de mutări care să
schimbe o pereche de piese sau să rotească un singur cub de pe colţ sau de pe muchie. Astfel, sunt
douăsprezece seturi de configuraţii, numite uneori „universuri” sau „orbite”, în care cubul poate fi plasat
prin dezasamblare şi reasamblare.

28.  În pofida numărului mare de poziţii posibile, toate cuburile se pot rezolva în cel mult douăzeci şi cinci de
mutări. Numărul mare de permutări este adesea dat ca măsură a complexităţii unui cub Rubik.
Dificultatea jocului nu derivă însă în mod necesar din numărul mare de permutări; constrângerea impusă
de mutările permise este factorul cel mai semnificativ. De exemplu, numărul de permutări ale celor 26 de
litere ale alfabetului (26! = 4.03 × 1026) este mai mare decât cel al cubului Rubik, dar o problemă
semnificativ mai simplă decât sortarea unei permutări a celor 26 de litere în ordine alfabetică în condiţiile
în care este permisă orice interschimbare de litere vecine.
 Feţele centrale
 Cubul Rubik original nu are semne de orientare pe feţele centrale, deşi unele aveau cuvintele „Rubik's
Cube” pe pătratul central al feţei albe şi deci rezolvarea lui nu necesită atenţie la orientarea acelor feţe.
Totuşi, cu un marker, se poate, de exemplu, marca pătratele centrale ale unui cub rezolvat cu patru semne
colorate pe fiecare latură, fiecare corespunzătoare culorii feţei adiacente. Unele cuburi au fost produse cu
marcaje pe toate pătratele. Astfel, se poate amesteca şi apoi rezolva cubul, având totuşi marcajele de pe
centre rotite, şi astfel devine un test suplimentar rezolvarea centrelor.
 Marcarea cubului Rubik îi creşte dificultatea mai ales pentru că măreşte numărul de configuraţii diferite
posibile. Când cubul este rezolvat fără interes pentru orientările pătratelor centrale, va exista mereu un
număr par de pătrate care trebuie mai trebuie rotite cu 90°. Astfel, există 46/2 = 2.048 configuraţii posibile
ale pătratelor centrale în poziţia altfel rezolvată, crescând numărul total de permutări ale cubului de la
43.252.003.274.489.856.000 (4.3×1019) la 88.580.102.706.155.225.088.000 (8.9×1022).

29. GRAFICUL FUNCTIEI FACTORIAL

30. GRAFICUL FUNCTIEI EXPONENŢIALE(2x- cu roşu) ŞI A FUNCŢIEI x2 u(cu albastru)

32. VALORILE FUNCŢIEI FACTORIAL
n n!
0 1
1 1
2 2
3 6
4 24
5 120
6 720
7 5,040
8 40,320
9 362,880
10 3,628,800
11 39,916,800
12 479,001,600
13 6,227,020,800
14 87,178,291,200
15 1,307,674,368,000
20 2,432,902,008,176,640,000
25 15,511,210,043,330,985,984,000,000

33. VALORILE FUNCŢIEI FACTORIAL
n n!
50 3.04140932... × 1064
70 1.19785717... × 10100
450 1.73336873... × 101,000
3,249 6.41233768... × 1010,000
25,206 1.205703438... × 10100,000
47,176 8.4485731495... × 10200,001
100,000 2.8242294079... × 10456,573
1,000,000 8.2639316883... × 105,565,708
9.99... × 10304 1 × 103.045657055180967... × 10307

34. 1.CĂRŢI
 1.Anatol Gremalschi.Informatica.Manual pentru clasa a XI-a.Chişinău:Editura Ştiinţa, 2008, 192 p.
 2.Braicov Andrei.TURBO PASCAL.Culegere de probleme.Chişinău:Editura Prut Internaţional, 2005, 232 p.
 DEX ’98 – DICŢIONARUL EXPLICATIV AL LIMBII ROMÂNE,Ediţia a II-a.Bucureşti: Editura Univers
Enciclopedic, 1998, 1208 p.
 3.Enciclopedia elevului.Cultură generală.Bucureşti: Editura Oscar Print, 2003, 1068 p.
 4.Curtui Luminiţa.Memorator de Matematică –Algebra pentru clasele IX-XII, Bucureşti: Editura
Booklet, 2005, 128 p.
2.INTERNET:
 5.http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D
0%BD %D0%B8%D0%B5_%D0%BC%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2
 6.http://upload.wikimedia.org/wikipedia/commons/0/06/Set_union.png
 7.http://ja.wikipedia.org/wiki/%E5%B7%AE%E9%9B%86%E5%90%88
 8.http://upload.wikimedia.org/wikipedia/commons/1/1b/Venn_B_minus_A.png
 9.http://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Set_difference.svg/800px-
Set_difference.svg.png
 10.http://en.wikipedia.org/wiki/Factorial
 11.http://ro.wikipedia.org/wiki/Cubul_Rubik
 12.http://en.wikipedia.org/wiki/Set_(mathematics)
 13.http://ro.wikipedia.org/wiki/Mul%C5%A3ime
 14.http://en.wikipedia.org/wiki/Union_(set_theory)
 15.http://en.wikipedia.org/wiki/Intersection_(set_theory)
 16.http://en.wikipedia.org/wiki/Complement_(set_theory)