Probleme de divizibilitate

și numere prime
Un număr natural d este divizorul lui x, dacă și numai dacă, restul împărțirii lui x la d este egal
cu zero:
dacă x % d = 0
atunci scrie d „îl divide pe ” x
altfel
scrie d „nu îl divide pe ” x
sfârșit_dacă
#include <iostream>
using namespace std;
int main()
{
int d,x;
cin>>x;
cin>>d;
if(x%d==0)
cout<<d<<" il divide pe "<<x;
else
cout<<d<<" nu il divide pe "<<x;
return 0;
}
• Dacă d divide pe x, spunem că d este divizor al lui x, iar x este multiplu al lui
d.
• Dacă vom nota cu Dn mulțimea divizorilor numărului x, atunci pentru
numărul x = 12 putem scrie:
• D12={1, 2, 3, 4, 6, 12},
• unde 1 și 12 se numesc divizori improprii ai lui x, iar 2, 3, 4, 6 sunt
divizorii proprii ai numărului dat.
• Algoritmul pentru determinarea (afișarea) divizorilor unui număr n dat, care
respectă definițiile de mai sus este:
citește numărul x (număr natural)
pentru fiecare posibil divizor d∈[1, 𝑥/2] execută dacă d este
divizorul lui x atunci
afișează divizorul d sfârșit_dacă
sfârșit_pentru
afișează și pe x pentru că și el însuși este divizor
#include <iostream>
using namespace std;
int main()
{
int d,x;
cin>>x;
for(d=2;d<=x/2;d++)
if(x%d==0)
cout<<d<<" ";
cout<<x;
return 0;
}
• Algoritmul de mai înainte este corect, dar neeficient. Testați-l pentru n =
1.000.000.000 și veți vedea că execuția durează 2-3 secunde. Poate nu pare
mult, dar dacă lucrăm cu 1000 de numere cu valori în jurul lui 1.000.000.000,
execuția poate dura aproximativ 45 de minute – prea mult!
• De exemplu, pentru n = 24 obținem divizorii 1, 2, 3, 4, 6, 8, 12, 24
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

1 este divizor 24, atunci și 24/1 = 24 este divizor al lui 24;

2 este divizor al lui 24, atunci 24/2=12 este divizor al lui 24;
3 este divizor 24, atunci și 24/3 = 8 este divizor al lui 24;
4 este divizor al lui 24, atunci și 24/4=6 este divizor al lui 24;
5 nu este divizor al lui 24;
6 este divizor al lui 24, atunci și 24/6=4 este divizor al lui 24;
7 nu este divizor al lui 24
8 este divizor al lui 24, atunci și 24/8=3 este divizor al lui 24;
9 nu este divizor al lui 24;
10 nu este divizor al lui 24;
11 nu este divizor al lui 24;
12 este divizor al lui 24, atunci 24/12=2.
Mai mult, 12*12>24, alți divizori nu vom mai găsi
• Deci divizorii lui 24 sunt: {1, 24, 2, 12, 3, 8, 4,6}. Constatăm astfel că pentru a
determina divizorii lui x este suficient să parcurgem numerele de la 1 la 𝑥.
• Un caz special îl constituie pătratele perfecte. În cazul lor trebuie evitată
analizarea de două ori a lui x si 𝑥 , care este divizor al lui x.
• Pentru x=36 avem divizorii:

1. 1 în pereche cu 36
2. 2 în pereche cu 18
3. 3 în pereche cu 12
4. 4 în pereche cu 9
5. 5 nu este divizor al lui 36
6. 6 în pereche cu 6. Atenție! 6 trebuie luat o singură dată!
7. 7*7 > 36, ne oprim!
Noua variantă a algoritmului care afișează
divizorii lui x este:
C++
#include <iostream>
using namespace std;
int main()
Algoritm determinare divizori {
int x;
citește x (număr natural) cin>>x;
pentru fiecare posibil divizor de la 1 la 𝑥 execută for(int d=1;d*d<=x; d++)
if(x % d==0)
dacă d este divizorul lui x atunci
{
afișează divizorul d
cout<<d<<" ";
dacă d<[ 𝑥] atunci //evităm afișare dublată a lui x, dacă x este pătrat perfect if(d*d<x)
afișează perechea divizorului d: x/d cout<<x/d<<" ";
sfârșit_dacă }
sfârșit_dacă return 0;
sfârșit_pentru }
• Atenție!
Pentru determinarea și prelucrarea divizorilor proprii ai unui număr este nevoie să
modificăm intervalul de căutare a posibililor divizori din interval închis [1, 𝑥] în
intervalul [2, 𝒙], fără a lua în considerare numărul însuși.
 Algoritm determinare divizori proprii C++

#include <iostream> using

citește x (număr natural) namespace std; int main()
{
pentru fiecare posibil divizor de la 2 la [ 𝒙] int x;
execută cin>>x;
for(int d=2;d*d<=x; d++)
dacă d este divizorul lui x atunci {
afișează divizorul d if(x % d==0)
cout<<d<<” ”;
dacă d<[ 𝒙] atunci //evităm afișare dublată a lui x, dacă x este pătrat perfect {
afișează perechea divizorului d: x/d if(d*d<x)
cout<<x/d<<” ”;
sfârșit_dacă }
sfârșit_dacă }
return 0;
sfârșit_pentru }
 Programul este:
#include <iostream> using
Numere prime namespace std; int main()
{
int x;
cin>>x;
if(x<2)
cout<<"0";
• Numere prime : un număr natural este prim dacă else
nu are nici un divizor propriu. {
int d=2, prim=1;
for(d=2;d*d<=x; d++)
if(x % d==0)
prim=0;
cout<<prim;
}
return 0;
}
Se face duma divizorilor. În situația în care numarul
este pătrat perfect, se va aduna la suma divizorilor de #include <iostream>
doua ori rădăcina pătrată din acel număr. #include <math.h>
using namespace std;

int main()
{
int x,d,s=0,r;
cin>>x;
De aceea, d*d<x (strict)
for(d=2;d*d<x;d++)
if(x%d==0)
Se face suma divizorilor și se adună și x/d s=s+d+x/d;
Se atribuie unei variabile r valoarea 𝑥 r=sqrt(x);
Dacă x este pătrat perfect (r*r==x), se adaugă o if(r*r==x)
singură dată r la suma, altfel se va adăuga de două s=s+r;
ori. cout<<s;
return 0;
}
 Relații matematice cu divizori:

• Numărul de numere <=n divizibile cu k este : nr_div_k = n/k

• Numărul de numere din [a, b], divizibile cu k este: nr_div_k = b/k – (a-1)/k
• Numărul de multipli de a și multipli de b din [1,n] nr_mul_a_b=n/cmmmc(a,b)
• Numărul de multipli de a care nu sunt multipli de b din [1,n] este: n/a-n/cmmmc(a,b)