LUCRARE DE CURS DISCIPLINA: INFORMATICA

TEMA: ALGORITMI DE REZOLVARE A UNOR PROBLEME MATEMATICE

Elevul : Ciobanu Mihail S.Clasa : a XI-a “Real”

Carahasani 2009

Liceul Teoretic “Mihai Viteazul”

Ministerul Învăţămîntului al Republicii Moldova

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

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

§ 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 MoldovaC={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ă

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

2. Forma constructorului de mulţime

set ofTipul

elementelor mulţimii(tipu

l de bază)

Să trecem la limbajul PASCAL.1.Declararea tipului mulţime

[ ]

Expresie

.. Expresie

,

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;

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 : 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}BEGINA:=[‘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}

1

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 doif 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ă:

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;

2

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ă : 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

write(‘Scrie textul: ’); readln(text); diferit:=[]; {la început mulţimea este vidă}

3

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.

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);

§ 6.2 ANALIZA COMBINATORIE

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.

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;

4

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 }

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.

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.

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;

5

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}

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:

= = .

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.

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);

6

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

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.

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.

Concluzii

Test de evaluare la tema “Operaţii cu mulţimi” - 45 min1)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

Anexa nr. 1

Test de evaluare la tema “Analiya combinatorie” - 45 min1)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 }.

Anexa nr. 2

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.

Anexa nr. 3

Î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).

GRAFICUL FUNCTIEI FACTORIAL

Anexa nr. 4

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

Anexa nr. 5

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

Anexa nr. 6VALORILE 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

VALORILE FUNCŢIEI FACTORIAL

BIBLIOGRAFIE1.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%D0%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)

BRĂŢĂRI

MULŢIME CONVEXĂ