Algoritmi elementari

1. Interschimb
a) Cu auxiliar
aux=a;a=b;b=aux;

b) Fara auxiliar
a=a+b;
b=a-b;
a=a-b;
2. Maxime și minime
Să rezolvăm următoarea problemă: Se dau n numere întregi. Calculaţi cel mai
mic dintre cele n numere date.
a) inițializăm min cu prima dintre cele n valori; celelalalte n-1 valori se
vor compara cu min
3. cin >> n >> x;
4. min = x;
5. for(int i =2 ; i <=n ; i ++)
6. {
7. cin >> x;
8. if(x < min)
9. min = x;
10. }

b) initializam minimul cu o valoare foarte mare

cin >> n;
min = INT_MAX;
for(int i =1 ; i <= n ; i ++)
{
cin >> x;
if(x < min)
min = x;
}

Să rezolvăm următoarea problemă: Se citesc numere întregi până la apariția lui 0,

care nu se ia în considerare. Calculaţi maximul lor.
a) inițializăm maxi cu prima valoare; celelalalte  valori se vor compara
cu maxi
11. cin >> x;
12. maxi = x;
13. cin >> x;
14. while(x != 0)
15. {
16. if(x >maxi)
17. maxi = x;
18. cin >> x;
19. }

b) initializam maximul cu o valoare foarte mica

20. maxi = INT_MIN;
21. cin >> x;
22. while(x != 0)
 23. {
24. if(x >maxi)
25. maxi = x;
26. cin >> x;
27. }

Se dau n numere întregi. Să se determine valoarea minimă și de câte ori apare

printre cele n numere.
Rezolvare:
● fie min valoarea minimă și nr_min numărul de apariții ale valorii minime
● citim n și primul dintre cele n numere, x
● inițializăm min cu x și nr_min cu 1 – minimul a apărut o singură dată până acum
● citim pe rând cele n-1 valori rămase în variabila x
o dacă x < min, actualizăm min cu x și nr_min cu 1
o dacă nu, verificăm dacă x == min. În caz afirmativ, îl incrementăm
pe nr_min.
#include <iostream>
using namespace std;
int n,x,nr_min,mini,i;
int main()
{
cin>>n;
cin>>x;
mini=x;
nr_min=1;
for(i=2;i<=n;i++)
{
cin>>x;
if(x<mini)
{
mini=x;
nr_min=1;
}
else
if(x==mini)
nr_min++;
}
cout<<mini<< ' '<<nr_min;
return 0;
}

Problemă: Se citesc numere întregi, mai mici decât 1.000.000.000 până la apariția

lui 0, care nu se ia în considerare. Să se determine cele mai mari două numere dintre
ele.

Rezolvare:

● fie max1 cel mai mare număr și max2 următorul cel mai mare număr

 ● inițializăm max1 și max2 cu două valori mici, astfel: max1 = -1000000001, max2
=- 1000000002
● citim un număr x
● cât timp x != 0
o prelucrăm pe x; se disting cazurile:
▪ x > max1: se actualizează ambele maxime,
astfel: max2 devine max1, iar max1 devine x
▪ x <= max1, dar x > max2: se actualizează numai , max2 = x
o citim următoarea valoare pentru x

#include <iostream>

using namespace std;

int x,max1,max2;
int main()
{
max1=-10000000001;
max2=-10000000002;
cin>>x;
while(x!=0)
{
if(x>max1)
{
max2=max1;
max1=x;
}
else
if(x>max2)
max2=x;
cin>>x;
}
cout<<max1<<' '<<max2;
return 0;
}
3. Prelucrarea cifrelor unui numar dat
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
while(n != 0) // cat timp n este nenul - mai are cifre
{
int uc = n % 10; //determinam ultima cifra a lui n
cout << uc << " "; // prelucram ultima cifra
n =n/10; // eliminam ultima cifra (trunchiem numarul)
}
return 0;
}
a) suma cifrelor unui numar
#include <iostream>
using namespace std;
int n,s;
int main()
{
cin >> n;
s=0;
while(n != 0) // cat timp n este nenul - mai are cifre
{
s=s+n%10;// adaugam ultima cifra la suma
n=n/10;// eliminam cifra prelucrata
}
cout<<s;
return 0;
}
b) determinarea numarului de cifre
#include <iostream>
using namespace std;
int n,k;
int main()
{
cin >> n;
k=0;//initializam contorul de cifre cu 0
do
{
k=k+1;// marim contorul de cifre
n=n/10;// eliminam cifra prelucrata
}
while(n != 0);// cat timp n este nenul - mai are cifre
cout<<k;
return 0;
}
c) oglinditul unui numar
#include <iostream>
using namespace std;
int n,ogl;
int main()
{
cin >> n;
ogl=0;//initializam oglinditul
while(n != 0) // cat timp n este nenul - mai are cifre
{
ogl=ogl*10+n%10;// construieste inversul
n=n/10;// eliminam cifra prelucrata
}
cout<<ogl;
return 0;
}

d) verificarea proprietatii de palindrom( egal cu oglinditul)

#include <iostream>
using namespace std;
int n,ogl,c;
int main()
 {
cin >> n;
c=n;//fac o copie lui n in c
ogl=0;//initializam oglinditul
while(n != 0) // cat timp n este nenul - mai are cifre
{
ogl=ogl*10+n%10;// construieste inversul
n=n/10;// eliminam cifra prelucrata
}
if(ogl==c)
cout<<”palindrom”;
else
cout<<”nu e palindrom”;
return 0;
}
e) construirea unui numar din cifrele unui alt numar dat, in ordinea in care
apar
Problema: Se da un numar natural n cu maxim 9 cifre. Sa se formeze un alt
numar doar cu cifrele impare ale lui n. (eliminare cifre pare)
Ex.n=12345
nr=135
- pentru costruirea numarului cu cifrele in ordinea in care apar, vom
folosi puterile lui 10
- astfel, la fiecare cifra gasita, care respecta cerinta p=p*10 unde p
s-a initializat cu 1
#include <iostream>

using namespace std;

int n,nr=0,p=1;
int main()
{
cin>>n;
while(n>0)
{
if(n%2==1)
{
nr=nr+n%10*p;
p=p*10;
}
n=n/10;
}
cout<<nr;
return 0;
}
Aplicatie
#871
#include <iostream>
using namespace std;
int n,c1,c2, x=0,p=1;
int main()
{
cin>>n>>c1>>c2;
if(n==0 && c1==0)
x=c2;
else
 {
while(n>0)
{
if(n%10==c1)
x=x+c2*p;
else
x=x+n%10*p;
p=p*10;
n=n/10;
}
}
cout<<x;
return 0;
}

f) cifra de control
Cifra de control a unui număr se obține efectuând suma cifrelor sale, apoi suma
cifrelor acestei sume, până când suma obținută este un număr format dintr-o
singură cifră. Această ultimă cifră poartă numele de cifră de control.
while (n>9) // algoritmul continua pana cand se obtine o singura cifra
{
s=0;
while (n>0) //calculul sumei cifrelor lui n
{
s=s+n%10;
n=n/10;
}
n=s; // n preia valoarea sumei cifrelor
}
cout<<s;// s obtinut astfel reprezinta cifra de control
Obs. Putem afla cifra de control calculând restul împărțirii numărului la 9. Dacă restul
este 0 atunci cifra de control este 9, altfel este acel rest.
if(n%9==0)
c=9;
else
c=n%9;
cout<<c;

4. Divizibilitate
a) afisarea (prelucrarea) divizorilor unui numar
#include <iostream> int main() if(n%d==0)
using namespace std; { cin>>n; cout<<d<<' ';
int n,d; for(d=1;d<=n;d++) return 0;
 } cout<<d<<' '; for(d=1;d*d<n;d++)
cout<<n; if(n%d==0)
return 0; cout<<d<<' '<<n/d<<' ';
} if(d*d==n)
cout<<d;
return 0;
}

#include <iostream>
using namespace std;
int n,d; #include <iostream>
int main() using namespace std;
{ cin>>n; int n,d;
Aplicatii:
for(d=1;d<=n/2;d++) int main()
#376
if(n%d==0) { cin>>n;

#include <iostream>
using namespace std;
int n,d;
long long int s=0;
int main()
{ cin>>n;
for(d=1;d*d<n;d++)
if(n%d==0)
s=s+d+n/d;
if(d*d==n)
s=s+d;
cout<<s;
return 0;
}

#377

#include <iostream>
using namespace std;
int n,d,a,b;
int main()
{ cin>>n;
for(d=1;d*d<n;d++)
if(n%d==0)
{a=d;b=n/d;}

if(d*d==n)
cout<<d<<' '<<d;
else
cout<<a<<' '<<b;
return 0;
}
 #include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
long long int n,s=0,k=0,d;
double ma;
int main()
{
cin>>n;
for(d=1; d*d<n; d++)
if(n%d==0)
{
s=s+d+n/d;
k=k+2;
}
if(d*d==n)
{
s=s+d;k++;
}
ma=(float)s/k;
ma=(floor(ma*100))/100;
cout<<fixed<<setprecision(2)<<ma;
return 0;
}

b) verificarea proprietatii de numar prim

prin suma de divizori

#include <iostream>
using namespace std;
int n,d,s=0;
int main()
{ cin>>n;
for(d=1;d<=n;d++)
if(n%d==0)
s=s+d;
if (s==n+1)
cout<<”este prim”;
else
cout<<”nu este prim”;
return 0;
}

prin numarul de divizori proprii

#include <iostream>
using namespace std;
int n,d,k=0;
 int main()
{ cin>>n;
for(d=2;d<=n/2;d++)
if(n%d==0)
k=k+1;
if(k==0 && n!=1)
cout<<”este prim”;
else
cout<<”nu este prim”;
return 0;
}

eficient
#include <iostream>
using namespace std;
int n,d,prim;
int main()
{ cin>>n;
prim=1; //presupun ca numarul este prim
if(n<2 || n%2==0 && n!=2) //numerele 0,1 sau numerele pare diferite de 2 nu sunt numere prime
prim=0; //comuta pe 0
d=3; //se porneste cu verficarea numerelor impare cu primul divizor impar
while(d*d<=n && prim==1) // cat timp nu am ajuns cu d la radical de n si prim este 1
if(n%d==0) // daca d il divide pe n
prim=0; //numarul nu e prim
else
d=d+2; //se cauta alti divizori posibili impari
if (prim==1)
cout<<”este prim”;
else
cout<<”nu este prim”;
return 0;
}
#373
#include <iostream>

using namespace std;

int n,d,x, prim, k=0;//n numarul de numere prime
//d divizor posibil
//x numarul pe care il verific daca este prim
//k contorul de numere prime (creste pana ajunge egal cu n)
int main()
{
cin>>n;
x=2;
while(k<n)
{
prim=1;
if(x<2 || x%2==0 && x!=2)
prim=0;
d=3;
while(d*d<=x && prim==1)
if(x%d==0)
prim=0;
else
d=d+2;
if(prim==1)
{cout<<x<<' ';k++;}
x++;
}
return 0;
}

#375
#include <iostream>
using namespace std;
int n, x, d, prim;
int main()
{
cin>>n;
x=n+1;
prim=0;
while(prim==0)
{
prim=1;
if(x<2 || x%2==0 && x!=2)
prim=0;
d=3;
while(d*d<=x && prim==1)
if(x%d==0)
 prim=0;
else
d=d+2;
if(prim==1)
cout<<x;
else
x=x+1;
}
return 0;
}

c) determinarea celui mai mare divizor comun dintre doua numere date
(cmmdc)

// euclid
#include <iostream>
using namespace std;
int a,b,r;
int main()
{
cin>>a>>b; //p=a*b
do
{
r=a%b;
a=b;
b=r;
}
while(b!=0);
cout<<a; //cmmmc=p/a
return 0;
}
//prin scaderi
#include <iostream>
using namespace std;
int a,b,r;
int main()
{
cin>>a>>b; //p=a*b
while(a!=b)
if(a>b)
a=a-b;
 else
b=b-a;
cout<<a; //cmmc=p/a
return 0;
}
// prin impartiri
#include <iostream>
using namespace std;
int a,b;
int main()
{
cin>>a>>b; //p=a*b
while(a*b!=0)
if(a>b)
a=a%b;
else
b=b%a;
if(a+b!=0)
cout<<a+b; //cmmc=p/(a+b);
else
cout<<”eroare”;
return 0;
}

OBS. Pentru determinarea celui mai mic multiplu comun (cmmmc) dintre doua numere se imparte
produsul lor la cmmdc dintre ele a*b/(cmmdc(a,b));

d) Descompunerea in factori primi

#include <iostream>

using namespace std;

int n, d, p;
int main()
{
cin>>n;
d=2;
while(n>1)
{
p=0;
while(n%d==0)

{n=n/d;
p=p+1;
 }
if(p>0)
cout<<d<<" la puterea: "<<p<<endl;
d=d+1;
}
return 0;
}

//mai eficient
#include <iostream>
using namespace std;
int n, d, p;
int main()
{
cin>>n;
d=2;
while(n>1)
{
p=0;
while(n%d==0)
{
n=n/d;
p=p+1;
}
if(p>0)
cout<<d<<" la puterea: "<<p<<endl;
if(d*d>n)
d=n;
else
d=d+1;
}
return 0;
}

5. Trecerea dintr-o baza de numeratie in alta

//trecere din baza 10 in baza mai mica decat 10
//se imparte nr la baza in mod repetat pana cand
obtinem catul 0
//resturile impartirilor luate in ordine inversa
reprezinta cifrele numarului in baza mica
//trecere din baza mai mica decat 10 in baza 10
//se descompune nr dat dupa puterile bazei
//se fac calculele si nr obtinut va fi nr in baza 10

#include <iostream> #include <iostream>

using namespace std; using namespace std;
int n10, nb=0, b,p=1; int n10=0, nb, b,p=1;
int main() int main()
{ {
cin>>n10; cin>>nb;
cin>>b; cin>>b;
while(n10>0) while(nb>0)
{ {
nb=nb+(n10%b)*p; n10=n10+(nb%10)*p;
p=p*10; p=p*b;
n10=n10/b; nb=nb/10;
} }
cout<<nb; cout<<n10;
return 0; return 0;
} }

6. Siruri recurente - sirul lui Fibbonacci

Sirurile recurente sunt sirurile in termenii se construiesc dupa o anumita regula in functie
de termenii anteriori.

Sirul lui Fibbonacci: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...

a0=1;

a1= 1;

an=an-1+an-2

Problema: Sa se genereze primii n termeni ai sirului Fibbonacci. Se da n, si sa se afiseze

primii n termeni.
#include <iostream>
using namespace std;
int n, a,b,c,i;
int main()
{
cin>>n;
if(n==1)
cout<<1;
else
{
a=1;b=1;
cout<<a<<' '<<b<<' ';
for(i=3;i<=n;i++)
{
c=a+b;
cout<<c<<' ';
a=b;
b=c;
}
}
return 0;
}