1/7

Cmmdc/cmmmc prof. Mariana IVAN

Cuprins
Cmmdc/cmmmc dintre două numere ------------------------------------------------------------------------------------------ 1
Cmmdc2Numere ------------------------------------------------------------------------------------------------------------------ 1
Cmmdc3Numere ------------------------------------------------------------------------------------------------------------------ 2
VerificăPrimalitate --------------------------------------------------------------------------------------------------------------- 3
simplificăFracție/Ireductibilă --------------------------------------------------------------------------------------------------- 3
primelePerechiCmmdcKCitit --------------------------------------------------------------------------------------------------- 4
Indicatorul lui Euler-------------------------------------------------------------------------------------------------------------- 4
Cmmmc ---------------------------------------------------------------------------------------------------------------------------- 5
ÎnmulţireaFărăOperator-PrinAdunăriRepetate ------------------------------------------------------------------------------ 6
ÎmpărţireaFărăOperatori- PrinScăderiRepetate ----------------------------------------------------------------------------- 7
restulÎmpărțiriiFărăModulo-prinPermutareCircularăLaStg --------------------------------------------------------------- 7

Cmmdc/cmmmc dintre două numere

Calculul pentru cel mai mare divizor comun se realizează prin 2 algoritmi specifici: Euclid și
Nicomachus.

Cel mai mare divizor comun este factorul comun la puterea cea mai mică.
Sau prin aplicaţia Microsoft Excel funcţia este:
GCD (a,b) cu semnificaţia Greatest Common Divisor (a,b)

Cmmdc2Numere
1. Scrieţi un program în C/C++ care calculează cel mai mare divizor comun dintre 2 numere
naturale, x şi y citite .

Exemplu: x=27, y=15; va afișa: cmmdc=3

Varianta1: Cmmdc prin scăderi repetate (algoritmul lui Nicomachus)

#include <iostream>
using namespace std;int main(){int x, y; cout<<"x:";cin>>x; cout<<"y:";cin>>y;
while (x!=y){if(x>y)x=x-y; else y=y-x;} cout<<"cmmdc:"<<x;}

TABELUL DE VARIAŢIE A VALORILOR

x y while (x≠y) if (x>y) x=x-y y=y-x cout<<x

 2/7
Cmmdc/cmmmc prof. Mariana IVAN

27 15 27≠15A 27>15A x=27-15 -

12≠15A 12>15F - y=15-12
12≠3A 12>3A x=12-3 -
9≠3A 9>3A x=9-3 -
6≠3A 6>3A x=6-3 -
3≠3F - - - 3

Varianta2: Cmmdc prin împărţiri succesive (algoritmul lui Euclid), folosește structura while.

Algoritmul lui Euclid determină cmmdc a două numere naturale prin împărțiri succesive până
când se obține restul 0.
Cmmdc este ultimul rest diferit de 0.
De exemplu: a=720 și b=495, cmmdc prin Euclid se obține astfel:
Deîmpărțit Împărțitor Cât Rest
720 495 1 225
495 225 2 45
225 45 5 0
#include <iostream>
using namespace std;int main(){int x, y; cout<<"x:";cin>>x; cout<<"y:";cin>>y;
while (y) // cat timp y≠0
{r=x%y; //restul impartirii
x=y; //primul numar devine al doilea
y=r;} //al doilea devine rest
cout<<"cmmdc="<<x;}//ultimul rest nenul
TABELUL DE VARIAŢIE A VALORILOR
x y while (y≠0) r=x%y x= y y=r cout<<x
27 15 15≠0A r=27%15 x=15 y=12
12≠0A r=15%12 x=12 y=3
3≠0A r=12%3 x=3 y=0
0≠0F - - - 3

Varianta3: Cmmdc prin împărţiri succesive (algoritmul lui Euclid), folosește structura do
while.

#include <iostream>
using namespace std;int main(){int x, y; cout<<"y:"; cin>>y;
do{ r=x%y; x=y; y=r; //repeta
}while(r); //pana cand r≠0
cout<<"cmmdc:"<<x;} //ultimul rest nenul

Cmmdc3Numere
2. Scrieţi un program în C/C++ care calculează cel mai mare divizor comun dintre 3 numere
naturale x, y şi z citite .
 3/7
Cmmdc/cmmmc prof. Mariana IVAN

Exemplu: x=12, y=32, z=28; va afișa: cmmdc=4

#include <iostream>
using namespace std;int main(){int x, y, z;cin>>x>>y>>z;
while (x!=y) {if(x>y)x=x-y; else y=y-x;}
while (x!=z){if(x>z)x=x-z;else z=z-x;} cout<<"cmmdc:"<<x; }

Programul calculează cmmdc dintre primele 2 numere citite, continuă cu rezultatul obținut
împreună cu următorul afișează răspunsul.

VerificăPrimalitate
1. Se citesc două numere, x și y. Scrieţi un program în C/C++ care verifică dacă cele două numere
citite sunt prime între ele cu afișarea mesajului "da" altfel "nu" .

Exemplu:
x=5, y=7; va afișa: cmmdc=1 da
x=15, y=5; va afișa: cmmdc=5 nu

#include <iostream>
using namespace std;int main(){int x, y, r;cin>>x>>y;
while (y!=0){r=x%y; x=y; y=r;}cout<<"cmmdc:"<<x;
if(x==1) cout<<"da";else cout<<"nu";}

Dacă cele 2 numere citite sunt prime între ele cmmdc este 1!

simplificăFracție/Ireductibilă
2. Se citesc numărătorul și numitorul unei fracții, de tip întreg. Scrieţi un program în C/C++ care
simplifică fracţia citită cu afişare altfel fracţie ireductibilă.

Exemplu:
a=27, b=18; va afișa: cmmdc=9 dupa simplificare:3/2
a=11, b=5; va afișa: cmmdc=1 fractie ireductibila:11/5

#include <iostream>
using namespace std;int main(){ int a, b, x, y, r; cout<<"a=";cin>>a; cout<<"b=";cin>>b;
x=a; y=b;
do{r=x%y; x=y; y=r;}while (r!=0);
cout<<"\ncmmdc:"<<x;
if(x==1) cout<<"\nfractie ireductibila:"<<a<<"/"<<b;
else cout<<"\ndupa simplificare:"<<a/x<<"/"<<b/x;}

Dacă cmmdc este==1, cele 2 numere sunt prime între ele și ca urmare fracția este ireductibilă
altfel cele 2 numere se pot simplifica.
 4/7
Cmmdc/cmmmc prof. Mariana IVAN

primelePerechiCmmdcKCitit
3. Se citesc două numere de tip întreg, n și k. Scrieţi un program în C/C++ care afişează toate
perechile de elemente până la numărul citit care au cel mai mare divizor comun pe k.
Exemplu: n=9, k=3; va afișa: (3, 6) (3, 9) (6, 9)

Varianta1: implementare iterativă

#include <iostream>
using namespace std;int main(){ int n, i, j, x, y, r, k; cin>>n>>k;
for(i=1;i<=n-1;i++)
for(j=i+1;j<=n;j++)
{x=i; y=j; while (y!=0){r=x%y; x=y; y=r;}
if(x==k) cout<<" ( "<<i<<" , "<<j<<" ) "<<" "; }}

Varianta2: implementare prin funcții iterative

#include <iostream>
using namespace std;
int cmmdc(int &x, int &y){while(x!=y)if(x>y)x-=y;else y-=x; return x;}
void perechi(int k, int n){int x, y;
for(int i=1;i<=n-1;i++) for(int j=i+1;j<=n;j++)
{x=i; y=j; cmmdc(x, y);
if(x==k)cout<<"( "<<i<<" , "<<j<<" )"<<" ";}}
int main(){ int n, k; cout<<"n:";cin>>n; cout<<"k:";cin>>k; cout<<"\nperechi:";perechi(k, n);}

Parametrii sunt referințe deoarece valoarea lor în funcție se modifică!

Indicatorul lui Euler

Indicatorul lui Euler (funcţia lui Euler), notat 𝜑(n) unde n∈N*, reprezintă numărul de numere mai
mici sau egale cu n şi prime cu acesta.
𝜑(p)=p-1, unde p=este număr prim.
Primele valori ale lui 𝜑(n):
𝜑(n) +0 +1 +2 +3 +4 +5 +6 +7 +8 +9
0+ 1 1 2 2 4 2 6 4 6
10+ 4 10 4 12 6 8 8 16 6 18
20+ 8 12 10 22 8 20 12 18 12 28
30+ 8 30 16 20 16 24 12 36 18 24
40+ 16 40 12 42 20 24 22 46 16 42
Exemple: 𝜑(1)=1, 𝜑(15)=8, 𝜑(28)=12, 𝜑(30)=8, 𝜑(36)=12 etc.
4. Se citește n, număr de tip întreg. Scrieţi un program în C/C++ care afişează primele numerele
naturale mai mici sau egale cu n şi prime cu acesta şi deasemeni contorul lor (Indicatorul lui
Euler).

Exemplu:
n=16; va afișa: 1 3 5 7 9 11 13 15; nr=8
n=30; va afișa: 1 7 11 13 17 19 23 29; nr=8
Varianta1: implementare iterativă
 5/7
Cmmdc/cmmmc prof. Mariana IVAN

#include <iostream>
using namespace std;int nr; int main(){int n, i, r, x, y;cout<<"n: ";cin>>n;
cout<<"\nnumere mai mici sau egale cu n si prime cu acesta\n";
for (i=1; i<n; i++)//sirul numere lor prime
{x=i; //memorez primul element pt a nu-l pierde in prelucrare
y=n; //memorez ultimul element pt a nu-l pierde in prelucrare
while (y!=0) {r=x%y; x=y; y=r;} // calculez cmmdc
if (x==1) {nr++; cout<<i<<" ";}}//daca au in comun numai div 1 il afisez
cout<<"\nsunt:"<<nr<<"\tnr prime cu n";}

TABELUL DE VARIAŢIE A VALORILOR

for while if scrie
n i=1 i<n x=i y=n y≠0 r=x%y x=y y=r x==1 i
5 i=1 1<5A x=1 b=5 5≠0A r=1%5 x=5 y=1
1≠0A r=5%1 x=1 y=0
0≠0F - - 1==1A 1
i=2 2<5A x=2 y=5 5≠0A r=2%5 x=5 y=2
2≠0A r=5%2 x=2 y=1
1≠0A r=2%1 x=1 y=0
0≠0F - - 1==1A 2
i=3 3<5A x=3 y=5 5≠0A r=3%5 x=5 y=3
3≠0A r=5%3 x=3 y=2
2≠0A r=3%2 x=2 y=1
1≠0A r=2%1 x=1 y=0
0≠0F - - 1==1A 3
i=4 4<5A x=4 y=5 5≠0A r=4%5 x=5 y=4
4≠0A r=5%4 x=4 y=1
1≠0A r=4%1 x=1 y=0
0≠0F - - - 1==1A 4
i=5 5<5F - - - - - - - -
Varianta2: implementare prin funcții iterative
#include <iostream>
using namespace std;int nr;
int cmmdc(int &x, int &y){while(x!=y)if(x>y)x-=y;else y-=x; return x;}
void euler( int n){int x, y;
for(int i=1;i<n;i++)
{x=i; y=n; cmmdc(x, y);
if(x==1){nr++;cout<<i<<" ";}}
cout<<"\nsunt:"<<nr<<"\tnr prime cu n";}
int main(){ int n; cout<<"n:";cin>>n; cout<<"\neuler:";euler( n);}

Cmmmc

Cel mai mic multiplu comun este dat factorii comuni şi necomuni la puterea cea mai mare.
 6/7
Cmmdc/cmmmc prof. Mariana IVAN

Regula: x*y=(x,y)*[x,y ] sau p=cmmdc*cmmmc

Sau prin aplicaţia Microsoft Excel funcţia este:
LCM (a,b) cu semnificaţia Least Common Multiple (a,b) .

5. Se citesc două numere de tip întreg, x şi y. Scrieţi un program în C/C++ care calculează cel
mai mic multiplu comun dintre 2 numere naturale, citite de la tastatură.

Exemplu:x=27, y=15; va afișa: 135

Varianta1: implementare iterativă
#include <iostream>
using namespace std;int main(){int x, y, r, p;cout<<"\nx:";cin>>x; cout<<"\ny:";cin>>y;
p=x*y; //calculeaza produsul celor 2 numere
while (y!=0){r=x%y; x=y; y=r;} cout<<"\ncmmdc:"<<x;
cout<<"\ncmmmc:"<< p/x ;}
TABELUL DE VARIAŢIE A VALORILOR
while cmmdc cmmmc
x y p=x*y (y≠0) r=x%y x= y y=r cout<<x cout<<p/x
27 15 p=405 15≠0A r=27%15 x=15 y=12
12≠0A r=15%12 x=12 y=3
3≠0A r=12%3 x=3 y=0
0≠0F - - - 3 135
Varianta2: implementare prin funcții iterative
#include <iostream>
using namespace std;int nr;
int cmmdc(int x, int y){while(x!=y)if(x>y)x-=y;else y-=x; return x;}
int main(){ int a, b, p; cout<<"a:";cin>>a; cout<<"b:"; cin>>b; p=a*b;
cout<<"\ncmmc:"<<p/cmmdc(a,b);}

ÎnmulţireaFărăOperator-PrinAdunăriRepetate

6. Se citesc două numere de tip întreg, a şi b. Scrieţi un program în C/C++ care afişează
înmulţirea a două numere citite, fără a folosi operatorul de înmulţire.
Exemplu:x=3, y=4; va afișa: 12
#include <iostream>
using namespace std;int s; int main(){int a, b;
cout<<"\nnumar a, a:";cin>>a; cout<<"\nde b ori, b: ";cin>>b;
while (b!=0){ b=b-1; s=s+a;} cout<<"\nprodusul:"<<s;}
TABELUL DE VARIAŢIE A VALORILOR
a b while (b!=0) b=b-1 s=s+a cout<<s
3 4 4!=0A b=4-1 s=0+3
3!=0A b=3-1 s=3+3
2!=0A b=2-1 s=3+3+3
1!=0A b=1-1 s=3+3+3+3
0!=0F - - 12
 7/7
Cmmdc/cmmmc prof. Mariana IVAN

ÎmpărţireaFărăOperatori- PrinScăderiRepetate

7. Se citesc două numere de tip întreg, a şi b. Scrieţi un program în C/C++ care afişează
împărţirea a două numere citite de la tastatură fără a folosi operatorii de împărţire (modulo şi
div).

Exemplu:x=16, y=3; va afișa: rest=1; cat=5

#include <iostream>
using namespace std;int cat; int main(){int a, b, rest;
cout<<"numarul a, a="; cin>>a; cout<<" numarul b, b=”; cin>>b;
while (a>=b){ a=a-b; cat++;}rest=a;
cout<<"\nrestul:"<<rest<<"\tcatul:"<<cat;}
TABELUL DE VARIAŢIE A VALORILOR
a b while (a>=b) a=a-b cat++ rest=a rest cat
16 3 16>=3A a=16-3 cat=0+1
13>=3A a=13-3 cat=1+1
10>=3A a=10-3 cat=2+1
7>=3A a=7-3 cat=3+1
4>=3A a=4-3 cat=4+1
1>=3F - - rest=1 1 5

restulÎmpărțiriiFărăModulo-prinPermutareCircularăLaStg
8. Se citește n, număr de tip întreg. Scrieţi un program în C/C++ care afişează restul împărţirii
numărului citit la 4 fără a folosi operatorul modulo.

Exemplu:n=35; va afișa: rest 3;

#include <iostream>
using namespace std;int main(){ int n, i, a, b, c, d, aux; cin>>n;
a=0; b=1; c=2; d=3; //sunt clase de resturi 0, 1, 2, 3
for (i=1; i<=n; i++)
{ aux=a; a=b; b=c; c=d; d=aux ; } //permutarea circ. a val. de n ori
cout<<"\nrestul impart lui:"<<n<<"\tla 4 este:"<<a;}

Clasele de resturi ϵ (0, n)!

Variabilele reţin resturile de la 0 la 3, iar prin rotirea de n ori a valorilor spre stânga se obţine în
a restul căutat.