Culegere de ALGORITMI elementari la INFORMATICA

Coșniță Emilia-Felicia

Culegere de

algoritmi

elementari la

disciplina

informatică

Iași

2022

Coșniță Emilia-Felicia

Culegere de algoritmi

elementari

la disciplina informatică

Iași

2022

Descrierea CIP a Bibliotecii Naționale a României

COȘNIȚĂ, EMILIA-FELICIA

Culegere de algoritmi elementari la disciplina informatică

Iași, 2022

ISBN 978-973-0-36613-6

Prefață

Actualele abordări mondiale în domeniu accelerate de progresul rapid al noilor

tehnologii, cum ar fi inteligența artificială, robotica, tehnologiile de tip cloud computing și

blockchain, aduc cu sine noi provocări și pentru elevii, studenții și cadrele didactice din

România.

Expunerea zilnică la date digitale, în mare parte, create de algoritmi de

nepătruns pentru tinerii nativi digitali, solicită acestora o gândire logică, analitică. O

nouă abilitate devine astfel absolut necesară în soluționarea problemelor din viața

reală, această abilitate se numește "gândire computațională" (computational thinking).

Pentru cineva novice în domeniu care trebuie să îmbrățișeze capacitatea de a

gândi algoritmic (algorithmically), termeni de descompunere (decomposition),

generalizare (generalization), abstractizare (abstractions) și evaluare (evaluation) pot fi

înfricoșători.

Concepută ca un instrument operaţional - suport pentru activităţile de instruire şi

autoinstruire, lucrarea Culegere de algoritmi elementari la disciplina informatică

propune un evantai larg de aplicații şi demersuri teoretice, însoţite de implementări în

C++ fundamentate pe dimensiunea teoretică.

Lucrarea se adresează în primul rând elevilor, dar poate în același timp să

constituie un instrument de lucru și pentru studenţii care urmează modulul de pregătire

psihopedagogică, pentru profesorii debutanți și subliniază importanța algoritmului în

programare, care trebuie înțeles cu atenție, mai ales că gândirea computațională nu se

rezumă doar la găsirea în mod mecanic (prin calcul) a unor rezultate, ci formează

mecanismul de gândire prin care cititorul descoperă cea mai eficientă variantă a codului

în condițiile datelor de intrare, a constrângerilor, dar și a ierarhizării priorităților.

Așadar, sinteză a preocupărilor de debut în implementările de codare, culegerea

reunește algoritmii scriși alfabetic , constituind etapa de pornire pentru programe din

ce în ce mai mari şi mai complicate.

Publicația Culegere de algoritmi elementari la disciplina informatică se

dovedește a fi un mijloc inspirat pentru transmiterea unor informații și transformarea

acestora în abilități, pentru optimizarea competențelor profesionale, mijloc ce conduce

la creșterea randamentului școlar. În același timp, culegerea se poate identifica și ca

“unealtă” în procesul sistematic de predare pentru profesorii de informatică.

Prof. Pădurariu Emanuela Tatiana

Inspector școlar pentru informatică

Cuprins

Algoritmul lui EUCLID ................................................... Eroare! Marcaj în document nedefinit.

Algoritmul de INTERSCHIMBARE ............................................................................................. 10

CĂUTARE BINARĂ .................................................................................................................... 11

CĂUTARE SECVENȚIALĂ ........................................................................................................ 12

CIFRA de CONTROL ................................................................................................................... 14

CIURUL lui ERATOSTENE ........................................................................................................ 15

CONJECTURA lui GOLDBACH ................................................................................................. 15

CONJECTURA complementarului NUMĂRULUI PAR ............................................................. 18

DESCOMPUNERE în FACTORI PRIMI ..................................................................................... 21

DETERMINAREA MINIMului unui șir ....................................................................................... 23

DETERMINAREA MAXIMului unui șir .................................................................................... 23

DETERMINAREA DIVIZORILOR proprii ai unui NUMĂR ..................................................... 24

FUNCȚIA lui EULER .................................................................................................................. 25

INTERCLASARE ......................................................................................................................... 26

NUMĂR APROAPE PRIM .......................................................................................................... 28

NUMĂR CIURUIT ....................................................................................................................... 29

NUMĂR CORECT ........................................................................................................................ 30

NUMĂR DUBLIC ........................................................................................................................ 31

NUMĂR ECHILIBRAT ................................................................................................................ 32

NUMĂR FERICIT ........................................................................................................................ 33

NUMĂR GENEROS ..................................................................................................................... 34

NUMĂR GREU ÎNCERCAT........................................................................................................ 35

NUMĂR IMPERFECT ................................................................................................................. 36

NUMĂR LEGAT .......................................................................................................................... 37

NUMĂR MUNTE ......................................................................................................................... 38

NUMĂR NEVRICOS ................................................................................................................... 39

NUMĂR NOROCOS .................................................................................................................... 40

NUMĂR OPTIM ........................................................................................................................... 41

NUMĂR PALINDROM ................................................................................................................ 42

NUMĂR PĂTRAT PERFECT ...................................................................................................... 43

NUMĂR PERFECT ...................................................................................................................... 44

Cuprins

NUMĂR PITIC ............................................................................................................................. 44

NUMĂR PRIM .............................................................................................................................. 45

NUMĂR PUTERNIC .................................................................................................................... 46

NUMĂR ROTUND ....................................................................................................................... 48

NUMĂR SEMIPALIDROM ......................................................................................................... 49

NUMĂR SUBȚIRE ....................................................................................................................... 50

NUMĂR SUPERPALINDROM ................................................................................................... 51

NUMĂR SUPERPERFECT .......................................................................................................... 52

NUMĂR SUPERPRIM ................................................................................................................. 53

NUMĂR VALE ............................................................................................................................. 54

NUMERE în ECHER .................................................................................................................... 56

NUMERE PITAGOREICE ........................................................................................................... 56

NUMERE PRIETENE .................................................................................................................. 57

OGLINDITUL unui număr............................................................................................................ 58

METODA BULELOR ................................................................................................................... 58

SORTARE prin INSERTIE ........................................................................................................... 60

SORTARE prin NUMĂRARE ...................................................................................................... 61

SORTARE prin SELECTIE .......................................................................................................... 63

REZOLVARE ecuație de GRAD I ................................................................................................ 64

REZOLVARE ecuatie de GRAD II .............................................................................................. 64

SIMPLIFICAREA unei FRACTII ................................................................................................. 65

SIRUL lui FIBONACCI ................................................................................................................ 67

SISTEM de 2 ecuatii liniare cu 2 NECUNOSCUTE .................................................................... 68

SISTEM de 3 ecuatii liniare cu 3 NECUNOSCUTE .................................................................... 69

SEPARAREA CIFRELOR UNUI NUMĂR ................................................................................. 70

SUMĂ ARMONICĂ ..................................................................................................................... 71

TRANSFORMARE A UNUI NUMĂR DIN BAZA 10 IN BAZA B........................................... 71

TRANSFORMARE A UNUI NUMĂR DIN BAZA B IN BAZA 10........................................... 72

VERIFICARE laturi TRIUNGHI .................................................................................................. 73

Coșniță Emilia - Felicia

Algoritmul lui EUCLID

Algoritmul lui Euclid este o metodă eficientă de calcul al celui mai mare divizor

comun, metodă simplu de implementat într-un program. Algoritmul are două variante:

A. Prin scăderi repetate

Pseudocod

citește a, b (numere naturale nenule)

cât timp b != a execută

| dacă a > b atunci a ← a - b;

| | altfel b ← b - a;

| └■ sf dacă

└■sf Cât timp

SCRIE a

Implementare C++

#include <iostream>

using namespace std;

int a, b;

int main()

{

cin >> a >> b;

while(b != a){

if(a > b) a = a - b;

else b = b -a;

}

cout << a;

return 0;

}

B. Prin împărțiri repetate

Pseudocod

citește a,b

cât timp b != 0 execută

| r ← a%b;

| a ← b;

| b ← a;

└■sf Cât timp

SCRIE a

Implementare C++

#include <iostream>


int a, b, r;

int main()

{

cin >> a >> b;

while(b != 0)

{

r = a % b;

a = b;

b = r;

}

cout << a << endl;

return 0;

}

9 Culegere de algoritmi elementari la informatică


Algoritmul de INTERSCHIMBARE

În diverse probleme este necesară comutarea simultană a valorilor a două

variabile. Se mai numește metoda paharelor, explicarea procedeului făcându-se

exemplificând interschimbarea conținutului a două pahare. Pornind de la variabila a ce

conține un număr a și variabila b conține un număr b.

Problemă

Se citesc de la consolă două numere întregi a și b. Să se interschimbe valorile celor

două numere.

Pseudocod

Pentru a interschimba conținutul a două variabile a și b putem folosi 3 metode:

A. Folosind o variabilă auxiliară, pe care o vom nota cu aux:

citește a, b

aux ← a

a ← b

b ← aux

SCRIE a, b

Implementare C++

#include <iostream>


int a,b,aux;

int main ( )

{

cin>>a>>b;

aux=a;

a=b;

b=aux;

cout<<a<< " " <<b;

return 0;

}

B. Folosind adunarea si scaderea:

citește a, b

a ← a+b

b ← a-b

a ← a-b

SCRIE a, b

Implementare C++

#include <iostream>


int a,b;

int main ( )

{ cout<<“Citește val in var a”;

cin>>a;

cout<<“Citește val in var b”;

cin>>b;

a=a+b;

b=a-b;

a=a-b;

cout<<“afiseaza val din variabila a”<<a<<endl;

cout<<“afiseaza val din variabila b”<<b;

return 0;

}



C. Folosind înmulțirea și împărțirea:

citește a, b

a ← a*b

b ← a/b

a ← a/b

SCRIE a, b

Implementare C++

#include <iostream>


int a,b;

int main ()

{

cin>>a>>b;

a=a*b;

b=a/b;

a=a/b;

cout<<a<<" "<<b;

return 0;

}

CĂUTARE BINARĂ

Algoritmul de căutare binară este un algoritm de căutare folosit pentru a găsi un

element într-o listă ordonată (implementat cu un tablou unidimensional/vector).

Căutarea binară este o metodă de căutare eficientă care se aplică doar

vectorilor ordonați.

Dacă vrem să căutăm în vectorul v, ordonat crescător, de lungime n, indexat de la

0, un element x, căutarea binară presupune:

• să calculăm poziția din mijloc

• să verifică dacă elementul căutat este egal cu elementul de pe poziția din mijloc

- dacă da, algoritmul s-a încheiat

- dacă nu, verificăm cum este elementul căutat față de elementul de pe poziția din

mijloc.

- Dacă este mai mic, căutarea se va continua în partea stângă (se modifică limita

superioară), iar dacă este mai mare, vom continua la dreapta elementului de pe

poziția din mijloc (se modifică limita inferioară).

• Algoritmul se va repeta de la primul pas

• căutarea se va încheia fie când am găsit elementul, fie când limitele se depășesc

(nu l-am găsit)

Problemă

Se citește un șir ordonat crescător cu n numere întregi, indexat de la 0. Să se

verifice dacă în acest șir se găsește un număr x.

Pseudocod

citește n, x

poz ← -1



pentru i=0,n-1,1 execută

| citește v[i]

└■sf pentru

m ← n/2

cât timp poz != m execută

| Dacă x = v[m] atunci poz ← m

| └■sf dacă

| Dacă x < v[m] atunci m ← m/2

| └■sf dacă

| Dacă x > v[m] atunci m ← (n+m)/2

| └■sf dacă

└■sf Cât timp

dacă poz != -1 atunci

| SCRIE elementul se afla pe pozitia:(poz+1)

| altfel

| SCRIE elementul nu se afla in sir

└■sf dacă

Implementare C++

#include<iostream>


int n,x,v[10],m,i, poz = -1;

int main()

{

cout<<"dati numarul de elemente: ";

cin>>n;

cout << "dati numarul cautat ";

cin >> x;

cout<<"introduceti elementele in ordine crescatoare " << endl;

for (i=0;i<n;i++) cin>>v[i];

m = n/2;

while(poz != m)

{

if (x==v[m]) poz = m;

if (x < v[m]) m = m/2;

if (x > v[m]) m =(n+m)/2;

}

if(poz != -1)

cout<<"elementul "<<x<<" a fost gasit pe pozitia:

"<<poz+1;

else

cout << "elementul nu exista";

return 0;

}

CĂUTARE SECVENȚIALĂ

Algoritmul de căutare secvențială este un algoritm de căutare folosit pentru a

găsi un element într-o listă aleatoare (implementat cu un tablou

unidimensional/vector).

Dacă vrem să căutăm în vectorul v, indexat de la 0, de lungime n, un element x,

căutarea secvențială presupune:



- să parcurgem vectorul, pornind de la primul element

- să testăm element cu element, dacă elemenul căutat se află în șir,

- căutarea se va încheia fie când am găsit elementul, fie când am verificat toate

elementele vectorului și nu l-am găsit

Din păcate, algoritmul nu este eficient.

Problemă

Se citește un șir cu n numere întregi, ce nu sunt ordonate. Să se verifice dacă în

acest șir se găsește un număr x.

Pseudocod

citește n, x (numere naturale nenule)


| citește v[i]

└■sf pentru

i ← 0

gasit ← 0

cât timp i<n și gasit=0 execută

| dacă x = v[i] atunci gasit ← 1

| └■sf dacă

| i ← i+1

└■sf pentru

dacă gasit = 1 atunci

| SCRIE este în sir

| altfel

| SCRIE Nu l-am gasit

└■sf dacă

Implementare C++

#include<iostream>


int n,x,v[10],m,i, gasit=0;

int main()

{

cout<<"dati numarul de elemente: ";

cin>>n;

cout << "dati numarul cautat ";

cin >> x;

cout<<"introduceti elementele aleatoare " << endl;

for (i=0;i<n;i++) cin>>v[i];

i=0;

while(i<n && gasit==0)

{

if (x==v[i]) gasit=1;

i++;

}

if(gasit)

cout<<"elementul "<<x<<" a fost gasit pe pozitia: "<<i-

1;

else cout << "elementul nu exista";

return 0;

}



CIFRA de CONTROL

Cifra de control a unui număr întreg pozitiv se obține prin însumarea iterativă

cifrelor sale, apoi a cifrelor sumei sale, până se ajunge, în cele din urmă, la un număr de

o singură cifră.

Exemple: n=628317101 S=6+2+8+3+1+7+1+0+1=29, S=2+9=11, S=1+1=2.

Numerologii folosesc acest procedeu pentru a calcula numărul destinului făcând

suma cifrelor care formează data de naştere, până când rămâne o singură cifră.

Problemă

Se citește de la consolă un număr natural n cu mai multe cifre (n<2 000 000 000).

Să se determine cifra de control a acestui număr.

Pseudocod

citește n (număr natural nenul)

Repetă

| S ← 0

| cât timp(n!=0) execută

| | S ← S+(n%10)

| | n ← n/10

| └■sf Cât timp

| n ← S

└■Până cand S<10

Implementare C++

#include <iostream>


int n,S;

int main()

{

cout<<"dati numarul ";

cin>>n;

do

{

S=0;

while(n!=0)

{

S=S+(n%10);

n=n/10;

}

n=S;

}while(S>9);

cout<<“cifra de control este “<<S;

return 0;

}



CIURUL lui ERATOSTENE

Ciurul lui Eratostene reprezintă o metodă de determinare a tuturor numerelor

prime mai mici sau egale cu o valoare dată, n. În practică, valoarea lui n trebuie să fie

una rezonabilă, ea depinzând de restricțiile de timp și memorie aplicate problemei.

sursa: www.pbinfo.ro

Pseudocod

e[0] ← 1

e[1] ← 1

Citește n (număr natural nenul)

pentru i ← 2,sqrt(n) execută

| dacă e[i] = 0 atunci

| | pentru j ← 2, [n/i] execută

| | | e[i*j] ← 1

| | └■ sf_pentru

| └■ sf_dacă

└■sf_pentru

Implementare C++

#include <iostream>


bool e[1000000];

int main()

{

int i,j;

e[0]=1;

e[1]=1;

for(i=2; i*i<=1000000; i++)

{

if(e[i]==0)

{

for(j=2; j<=1000000/i; j++)

{

e[i*j]=1;

}

}

}

return 0;

}

CONJECTURA lui GOLDBACH

Conjectura lui Goldbach este o presupunere din partea matematicianului german

Christian Goldbach, formulată astfel:

Orice întreg mai mare decât 2 poate fi scris ca sumă de 2 numere prime.

La vremea aceea, 1 era considerat număr prim. El a observat că în toate cazurile pe

care le-a încercat, orice număr par (cu excepția lui 2, care este el însuși un număr prim)

poate fi reprezentat ca suma a două numere prime.



De exemplu, 4=2+2, 6=3+3, 8=5+3, 10=5+5=3+7, 12=5+7, 14=7+7=3+11,

16=13+3=11+5, ... , 100=97+3 etc.

sursa: www.wikipedia.org

Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze acest număr ca

sumă de două numere prime.

Pseudocod

citește n

dacă n >=4 si n%2 = 0 atunci

| x ← 2

| cât timp ( x<= n/2 ) execută

| | primx ← 1

| | dacă x =2 sau x=3 atunci primx ← 1

| | | altfel

| | | dacă x%2 = 0 atunci primx ← 0

| | | | altfel d← 3

| | | | Cât timp (d*d<= x și x % d!=0) execută

| | | | | d← d+2

| | | | └■sf. cât timp

| | | | dacă x % d = 0 atunci primx ← 0

| | | | └■sf. dacă

| | | └■sf. dacă

| | └■sf. dacă

| | y ← n - x

| | primy ← 1

| | dacă y =2 sau y=3 atunci primy ← 1

| | | altfel

| | | dacă y%2 = 0 atunci primy ← 0

| | | | altfel d← 3

| | | | cât timp (d*d<= y și y % d!=0) execută

| | | | | d ← d+2

| | | | └■sf. Cât timp

| | | | dacă y % d = 0 atunci primy ← 0

| | | | └■sf. dacă

| | | └■sf. dacă

| | └■sf. dacă

| | dacă primx=1 si primy=1 atunci SCRIE x,‘ ‘, y

| | x ← x + 1

| └■sf. cât timp

| altfel

| SCRIE “ nu se poate aplica conjectura lui Goldbach”

└■sf. dacă

sfarsit

Implementare C++

#include <iostream>


int main()

{

int n,x=2,primx,primy,d,y;

cin>>n;

if(n>=4 && n%2==0)

{



while( x<=n/2)

{

primx=1;

if(x==2 || x==3) primx=1;

else

{

if (x%2==0) primx=0;

else

{

d=3;

while(d*d<=x && x%d!=0) d=d+2;

if( x%d==0) primx=0;

}

}

y=n-x;

primy=1;

if(y==2 || y==3) primy=1;

else

{

if (y%2==0) primy=0;

else

{

d=3;

while(d*d<=y && y%d!=0) d=d+2;

if( y%d==0) primy=0;

}

}

if(primx==1 && primy==1) cout<<x<<" "<<y<<" ";

x=x+1;

}

}

else cout<<" nu se poate aplica conjectura lui Golbach ";

return 0;

}

Conjectura lui Goldbach – implementare cu subprograme

#include <iostream>


int prim(int n)

{

int d=2,ok=1;

if(n==2 || n==3) ok=1;

else

if(n%2==0) ok=0;

else

{

for(d=3;d*d<=n;d++)

if(n%d==0)

{ok=0;

break;

}

}

return ok;

}



int main()

{

int n,i;

cout<<"dati numarul ";

cin>>n;

for(i=2;i<=n/2;i++)

if(prim(i)==prim(n-i)&& prim(i))

cout<<i<<" + "<<n-i <<" = "<<n<<endl;

return 0;

}

CONJECTURA complementarului NUMĂRULUI PAR

Fie n un numar arbitrar - dacă pentru fiecare număr par mai mic egal cu n si mai

mare egal cu 8 se găsesc primele 3 numere prime care nu se găsesc în descompunerea

acestuia, în aproximativ ¼ din cazuri cel putin unul dintre cele 3 numere formate din

diferența numărului inițial cu primele care nu intră în descompunerea lui este număr

prim.

Nota: n trebuie să fie foarte mare (raportul tinde la ¼ odată cu creșterea la infinit

a lui n).

Pseudocod

subprogram prim(x)

d←2

k←1

cât timp(x>1)

| p←0

| cât timp(x%d==0)

| | x ← x/d

| | p ← p+1


| dacă(p>0) atunci k←k*(p+1)

| └■sf. dacă

| d ← d+1

| dacă(x>1 Si d*d>x) atunci d←x

| └■sf. dacă

└■sf. cât timp

Dacă(k=2) atunci Returneaza 1

| altfel Returneaza 0

└■sf. dacă

sf. subprogram

început

mx←1000000

k←1

e[0]←1

e[1]←1

pentru i←2,mx execută

| dacă(e[i]=0) atunci

| | prim[k]←i

| | k←k+1

| | pentru j←2,mx/i execută



| | | e[i*j]=1

| | └■sf. pentru

| └■sf. dacă

└■sf. pentru

citește n

cnt←0

pentru i←8,n,2 execută

| x←i

| d←1

| y←0

| cât timp(x>1)

| | p←0

| | Cât timp(x%prim[d]==0)

| | | x ← x/prim[d]

| | | p ← p+1

| | └■sf. Cât timp

| | dacă (p=0) atunci

| | | dacă (y=0) atunci a←prim[d], y←y+1

| | | └■sf. dacă

| | | dacă (y=1) atunci b←prim[d], y←y+1

| | | └■sf. dacă

| | | dacă (y=2) atunci c←prim[d], y←y+1

| | | └■sf. dacă

| | └■sf. dacă

| | d ← d+1

| └■sf. Cât timp

| dacă (y=0) atunci a←prim[d], y←y+1

| └■sf. dacă

| dacă (y=1) atunci d←d+1,b←prim[d], y←y+1

| └■sf. dacă

| dacă (y=2) atunci d←d+1,c←prim[d], y←y+1

| └■sf. dacă

| dacă(prim(x-a)=1 SAU prim(x-b)=1 SAU prim(x-c)=1) atunci

| | cnt ←cnt+1

| └■sf. dacă

└■sf. pentru

SCRIE cnt/n

sfârșit

Implementare C++

//Programul calculează raportul amintit în conjectura

#include <iostream>

#include <iomanip>


bool e[7000000];

unsigned long long prim[7000000];

bool primal(int x)

{

int d=2,k=1,p;

while(x>1)

{

p=0;



}

while(x%d==0)

{

x/=d;

p++;

}

if(p) k*=(p+1);

d++;

if(d*d>x && x>1) d=x;

}

return k==2;

void descompunere(int x, int &f1, int &f2, int &f3)

{

// se gasesc primele 3 numere prime care nu se afla in

descompunerea in factori primi a numarului

int d=1,p,cnt=0;

while(x>1)

{

p=0;

while(x%prim[d]==0)

{

x/=prim[d];

p++;

}

if(p==0)

{

if(cnt==0)

{

f1=prim[d];

cnt++;

}

else if(cnt==1)

{

f2=prim[d];

cnt++;

}

else if(cnt==2)

{

f3=prim[d];

cnt++;

}

}

d++;

}

if(cnt==0)

{

f1=prim[d];

cnt++;

}

if(cnt==1)

{

d++;

f2=prim[d];

cnt++;

}



}

if(cnt==2)

{

d++;

f3=prim[d];

cnt++;

}

int main()

{

int i,j,k=0;

// Se construieste Ciurul lui Eratostene

for(i=2; i<=7000000; i++)

{

if(!e[i])

{

prim[++k]=i;

for(j=2; j<=7000000/i; j++) e[i*j]=1;

}

}

int n;

k=0;

cin >> n;

// verificam cate dintre numerele mai mici egale cu n nu

respecta conjunctura

for(i=8; i<=n; i+=2)

{

int a,b,x=i,c;

descompunere(i,a,b,c);

if(primal(x-a) || primal(x-b) || primal(x-c))

{

k++;

}

}

//cu cât n este mai mare, cu atat raportul dintre k si n tinde

la 1/4

cout << fixed << setprecision(3) << (double)k/n;

return 0;

}

DESCOMPUNERE în FACTORI PRIMI

Descompunerea în factori primi a unui număr compus n este procesul prin care

se găsesc divizorii primi prin a căror înmulțire se obține numărul n. (Un număr

compus este un număr întreg pozitiv care are cel puțin un divizor pozitiv în afară de 1

și el însuși. )

Orice număr natural n mai mare decât 1 se poate SCRIE în mod unic sub forma

unde

Exemple: n = 5544



Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze descompunerea în

factori primi a acestui număr.

Pseudocod


d ← 2

cât timp (n%d=0) execută

| n←n/d;

| p←p+1;

└■sf. cât timp

dacă(p>0) SCRIE d ’^ ’ p ’*’

└■ sf. dacă

d ← 3

cât timp (n!=1) execută

| p←0;

| cât timp (n%d=0) execută

| | n←n/d;

| | p←p+1;

| └■sf. Cât timp

| dacă(p!=0) SCRIE d ’^ ’ p ’ * ’

| └■

| d←d+2

└■sf. cât timp

Implementare C++

#include <iostream>


int main()

{

int n,d,p=0;

cin>>n;

d=2;

while(n%d==0)

{

n=n/d;

p++;

}

if(p>0) cout<<d<<" "<<p<<" * ";

d=3;

while(n>1)

{

p=0;

while(n%d==0)

{

n=n/d;

p++;

}

if(p>0) cout<<d<<" "<<p<<" * ";

d=d+2;

}

return 0;

}



DETERMINAREA MINIMului unui șir

Algoritmul prin care aflăm minimul elementelor unui șir de numere are pașii:

- presupunem că primul element din șir este cel mai mic,

- comparăm acest element cu celelalte n-1 elemente de după el,

- dacă găsim un element mai mic decât cel presupus, acesta devine noul minim al

șirului.

Problemă

Se citește de la consolă un șir cu n numere întregi (n>2). Să se determine și să se

afișeze cel mai mic număr din acest șir.

Pseudocod

citește n, x // x e primul numar din sir

min ← x

pentru i = 2,n,1 execută

| citește x

| dacă (x < min) atunci min ← x

| └■ sf. dacă

└■ sf. pentru

SCRIE min

Implementare C++

#include <iostream>


int n,minim,i,nr;

int main ()

{

cin >> n >> minim;

for (i=2 ; i<=n ; i++)

{

cin >> nr;

if ( nr < minim) minim = nr;

}

cout << "Minimul sirului este " << minim;

return 0;

}

DETERMINAREA MAXIMului unui șir

Algoritmul prin care aflăm maximul elementelor unui șir de numere are pașii:

- presupunem că primul element din șir este cel mai mare,

- comparăm acest element cu celelalte n-1 elemente de după el,

- dacă găsim un element mai mare decât cel presupus, acesta devine noul maxim

al șirului.

Problemă

Se citește de la consolă un șir cu n numere întregi (n>2). Să se determine și să se

afișeze cel mai mare număr din acest șir.

Pseudocod

citește n, x // x e primul numar din sir

max ← x



pentru i = 2,n,1 execută

| citește x

| dacă (x>max) atunci max ← x

| └■ sf. dacă

└■ sf. pentru

SCRIE max

Implementare C++

#include <iostream>


int n,maxim,i,nr;

int main ()

{

cin >> n >> maxim;

for (i=2 ; i<=n ; i++)

{

cin >> nr;

if (nr > maxim) maxim = nr;

}

cout << "maximul sirului este " << maxim;

return 0;

}

DETERMINAREA DIVIZORILOR proprii ai unui NUMĂR

Determinarea divizorilor se poate face în 3 intervale:

A. de la 2 la n-1

Din păcate această abordare nu este eficientă, mai ales atunci când numărul

pentru care se determină divizorii are valoare foarte mare.

B. de la 2 la n / 2

Se bazează pe observația că divizorii unui număr sunt în pereche: dacă cel mai mic

divizor propriu este 2, cel mai mare ar fi n/2, dacă 3 este divizor, atunci n/3 este

divizor de asemenea, ...

C. de la 2 la

Știind că divizorii unui număr sunt în pereche: atunci e suficient să determinăm

divizorul d, iar perechea lui se va calcul cu expresia n/d. Din acest interval cel mai mare

divizor pe care ar trebui să-l determinăm ar fi .

Exemplu: pentru 24 divizorii proprii afișați 2, 3, 4, 6, 8, 12

Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze toți divizorii

proprii ai acestui număr.

Pseudocod

citește n;

pentru d=2,sqrt(n),1 execută

| dacă n%d=0 atunci

| | SCRIE d, ’ ‘,d/n,’ ‘

| └■sf. dacă

└■ sf. pentru



Implementare C++

#include <iostream>


int main()

{

int n,d;

cin>>n;

for (d=2;d*d<n;d++)

{

if(n%d==0)

cout <<d<<" "<<n/d<<" ";

}

return 0;

}

FUNCȚIA lui EULER

Funcția lui Euler sau indicatorul lui Euler pentru un număr natural nenul n este

dată de numărul de numere mai mici sau egale cu n care sunt prime cu n.

Exemple: pentru n = 12, se afișează 4

deoarece sunt 4 numere ce sunt prime cu 12. Acestea sunt 1, 5, 7, 11.

Problemă

Se citește de la consolă un număr natural n ( n>2). Să se determine și să se afișeze

indicatorului lui Euler a acestui număr.

Pseudocod

citește n (numar intreg)

Dacă n%2=0 atunci

| Pentru i=3,n,2 execută

| | ci ← i

| | cn ← n

| | cât timp ci!=0 execută

| | | r ←ci

| | | ci ←cn%ci

| | | cn ←r

| | └■sf. cât timp

| | Dacă r=1 atunci SCRIE i

| | └■sf. dacă

| └■ sf. pentru

| altfel


| | ci ← i

| | cn ← n

| | Cât timp ci!=0 execută

| | | r ←ci

| | | ci ←cn%ci

| | | cn ←r


| | Dacă r=1 atunci SCRIE i

| | └■sf. dacă

| └■ sf. pentru

└■sf. dacă



Implementare C++

#include <iostream>


int main()

{ int n,i,ci,cn,r;

cin>>n;

if(n%2==0)

{

for(i=3;i<n;i=i+2)

{

ci=i;

cn=n;

while (ci!=0)

{

r=ci;

ci=cn%ci;

cn=r;

}

if(r==1) cout<<i<<" ";

}

}

else

{

for(i=2;i<n;i++)

{

ci=i;

cn=n;

while (ci!=0)

{

r=ci;

ci=cn%ci;

cn=r;

}

if(r==1) cout<<i<<" ";

}

}

return 0;

}

INTERCLASARE

Interclasarea este o metodă prin care, pornind de la două șiruri de elemente

ordonate, se poate obține un al treilea șir ordonat care conține elemente ale acestora.

Printre aplicațiile realizate cu ajutorul interclasării se poate face reuniunea și

intersecția a două mulțimi, dar și sortare prin interclasare.

Problemă

Se citesc elementele ordonate crescător a două șiruri: vectorul a cu n elemente și

vectorul b cu m elemente, cu indexare ce începe cu 1. Să se interclaseze crescător

elementele acestora în vectorul c.



Pseudocod

citește n,m (numere naturale nenule)

pentru i=1,n,1 execută

| citește a i

└■ sf. pentru

pentru j=1,m,1 execută

| citește b j

└■ sf. pentru

i ← 1

j ← 1

k ← 0

cât timp (i<=n și j<=m) execută

| k ← k + 1

| dacă (a i < b j ) atunci

| | c k ← a i

| | i←i+1

| | altfel

| | dacă (a i > b j ) atunci

| | | c k ← b j

| | | j←j+1

| | | altfel

| | | c k ← a i

| | | i ← i + 1

| | | j ← j + 1

| | └■ sf. dacă

| └■

└■ sf. cât timp

cât timp (i<=n)

| k ← k + 1

| c k ← a i

| i ← i + 1


cât timp (j<=m)

| k ← k + 1

| c k ← b j

| j ← j + 1


Pentru k=1,n+m,1 execută

| SCRIE c k ‘’ ‘’

└■ sf. pentru

Implementare C++

#include <iostream>


int a[100001],b[100001], c[200002], i, j, k, n, m ;

int main()

{ cin>>n>>m;

for(i=1;i<=n;i++)

{

cin>>a[i];

}

for(j=1;j<=m;j++)

{

cin>>b[j];

}



i=1;j=1;k=0;

while(i<=n && j<=m)

{ k++;

if (a[i]<b[j])

{

c[k]=a[i];

i++;

}

else

if (a[i]>b[j])

{

c[k]=b[j];

j++;

}

else

{

c[k]=a[i];

i++;

j++;

}

}

while(i<=n)

{

c[k++]=a[i++];

}

while (j<=m)

{

c[k++]=b[j++];

}

for(i=1;i<=k;k++)

{

cout<<c[i]<<" ";

}

return 0;

}

NUMĂR APROAPE PRIM

Un număr este aproape prim dacă se poate scrie ca produs de două numere

prime distincte.

Exemple: 6 = 2*3, 10=2*5, 14=2*7, 15=3*5

Problemă

Se citește de la consolă un număr natural nenul n (n>2). Să se verifice dacă este

număr aproape prim.

Pseudocod


pentru i=1, i<=sqrt(n),1 execută

| dacă (i*(n/i)=n) atunci nr←nr+2

| └■sf. dacă

| dacă (i*i=n) atunci nr←nr-1

| └■sf. dacă

└■sf. pentru



Dacă (nr=4) atunci SCRIE “este NUMĂR aproape prim”

| altfel SCRIE “nu este NUMĂR aproape prim”

└■sf. dacă

Implementare C++

#include <iostream>


int n,nr=0,i;

int main ()

{

cin >> n;

for (i=1;i*i<=n;i++)

{

if (i*(n/i)==n) nr+=2;

if (i*i==n) nr--;

}

if (nr==4) cout <<"este NUMĂR aproape prim";

else cout <<"nu este NUMĂR aproape prim";

return 0;

}

NUMĂR CIURUIT

Un număr ciuruit este un număr întreg pozitiv cu proprietatea că are minim două

zerouri.

Exemple: 5090, 6000, 10062, 300500.

Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze toate numere

ciuruite până la cel de-al n-lea număr.

Pseudocod

citește n (numar natural nenul)

nr ← 0 // numarul de numere ciuruite

i ← 0

c0 ← 0 // numarul de cifre de 0

cât timp (nr < n-1) execută

| ci←i

| c0←0

| cât timp (ci!=0) execută

| | dacă (ci%10 = 0) atunci c0←c0+1

| | └■sf. dacă

| | ci←ci/10


| dacă ( c0>1) atunci

| | nr←nr+1

| | SCRIE i “ “

| └■sf. dacă

| i←i+1

└■sf. cât timp



Implementare C++

#include <iostream>


int main()

{

int n, nr = 0, i = 0, ci, c0 = 0;

cin >> n;

while (nr < n-1)

{

ci = i;

c0 = 0;

while (ci != 0)

{

if (ci % 10 == 0) c0++;

ci /= 10;

}

if ( c0 >= 2)

{

nr++;

cout << i << endl;

}

i++;

}

return 0;

}

NUMĂR CORECT

Numărul corect este un număr întreg cu proprietatea că suma şi produsul cifrelor

sunt pătrate perfecte.

Exemple: 1, 4, 9, 10, 22, 40, 88, 90, 100

Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze toate numerele

corecte până la numărul n.

Pseudocod



| x ← i

| s ← 0

| p ← 1

| cât timp (x!=0) execută

| | s ← s+(x%10)

| | p ← p*(x%10)

| | x ← x/10

| └■ sf. cât timp

| ok ← 1

| d ← SQRT(s)

| dacă (d*d!=s) atunci ok ← 0

| └■sf.dacă

| d ← SQRT(p)



| dacă (d*d!=p) atunci ok ← 0

| └■sf.dacă

| dacă ok>0 atunci SCRIE “NUMĂRul corect”, i, “ ”,

| └■sf.dacă

└■sf.pentru

Implementare C++

#include<iostream>

#include<cmath>


int n,s,p,d,i,ok,x;

int main()

{

cin>>n;

for(i=1;i<=n;i++)

{

x=i; s=0; p=1;

while(x!=0)

{

s=s+(x%10);

p=p*(x%10);

x/=10;

}

ok=1;

d=sqrt(s);

if(d*d!=s) ok=0;

d=sqrt(p);

if(d*d!=p) ok=0;

if(ok) cout<<"este numar corect "<<i<<endl;

}

return 0;

}

NUMĂR DUBLIC

Un număr dublic este un număr întreg pozitiv cu proprietatea că are două cifre

alăturate egale.

Exemple: 1122, 900, 6332, 300500.

Problemă

Se citește de la consolă un număr natural n care are cel puțin două cifre. Să se

verifice dacă este un număr dublic.

Pseudocod


ok←0

c1←n%10

n←n/10


| c2←n%10



| Dacă (c1=c2) atunci ok←1

| └■sf.dacă

| n←n/10

| c1←c2

└■sf. cât timp

dacă (ok) atunci SCRIE “NUMĂRul este dublic”

| altfel SCRIE “ NUMĂRul nu e dublic”

└■ sf.dacă

Implementare C++

#include <bits/stdc++.h>


int main()

{

int c1,n,ok=0,c2,n1;

cin>>n;

c1=n%10;

n=n/10;

while (n!=0)

{ c2=n%10;

if (c1==c2) ok=1;

n=n/10;

c1=c2;

}

if(ok) cout<<"numarul este dublic";

else cout<<"numarul nu este dublic";

return 0;

}

NUMĂR ECHILIBRAT

Un număr echilibrat este un număr întreg pozitiv cu proprietatea că numărul de

cifre pare este egal cu numărul de cifre impare.

Exemple: 7232, 81, 12344321.

Problemă

Se citește de la consolă un număr natural n (n>2) cu cel puțin două cifre. Să se

verifice dacă este un număr echilibrat.

Pseudocod

citește n ;

nri←0;

nrp←0;


| Dacă (n%10%2=0) atunci nrp←nrp+1;

| | altfel nri←nri+1;

| └■sf.dacă

| n←n/10;

└■sf. cât timp

dacă(nrp=nri) atunci SCRIE “NUMĂRul este echilibrat”

| altfel SCRIE “NUMĂRul nu e echilibrat”

└■sf. dacă



Implementare C++

#include <iostream>


int main()

{

int nri=0,nrp=0,n;

cin>>n;

while (n!=0)

{ if(n%10%2==0) nrp++;

else nri++;

n=n/10;

}

if (nrp==nri) cout<<"numarul este echilibrat";

else cout<<"numarul nu e echilibrat";

return 0;

}

NUMĂR FERICIT

Un număr fericit este un număr întreg pozitiv cu proprietatea că prin însumarea

iterativă a pătratelor cifrelor lor, se ajunge în cele din urmă la 1.

Exemplu: 23 e număr fericit, deoarece 2²+3²=4+9=13, 1²+3²=1+9=10,

1²+0²=1+0=1.

Numere fericite până la 500: 1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82,

86, 91, 94, 97, 100, 103, 109, 129, 130, 133, 139, 167, 176, 188, 190, 192, 193, 203, 208,

219, 226, 230, 236, 239, 262, 263, 280, 291, 293, 301, 302, 310, 313, 319, 320, 326, 329,

331, 338, 356, 362, 365, 367, 368, 376, 379, 383, 386, 391, 392, 397, 404, 409, 440, 446,

464, 469, 478, 487, 490, 496.

Numerele la care acest tip de calcul duce la un rezultat diferit de 1 se numesc

numere nefericite.


Problemă

Se citește de la consolă un număr natural nenul n. Să se determine și să se afișeze

cel de-al n-lea număr fericit.

Pseudocod

citește n

nr←0

y←0

cât timp(nr != n) execută

| y ← y + 1

| x ← y

| repetă

| | s←0

| | cât timp(x != 0)execută

| | | c← x % 10

| | | s← s + c*c

| | | x← x / 10


| | x←s



| └■până când (s <= 9)

| dacă(s = 1) atunci

| | nr ← nr + 1

| └■sf. dacă

└■sf. cât timp

SCRIE y

Implementare C++

#include <iostream>

#include <cmath>


int main()

{

int x, s = 0, c, n, nr = 0, y = 0;

cin >> n;

while (nr != n)

{

y++;

x = y;

do {

s = 0;

while (x != 0)

{

c = x % 10;

s = s + pow(c, 2);

x = x / 10;

}

x = s;

} while (s > 9);

if (s == 1) nr++;

}

cout << y;

return 0;

}

NUMĂR GENEROS

Un număr generos este un număr întreg pozitiv n cu proprietatea că suma

cifrelor lui este mai mare decât n+2.

Problemă

Se citește de la consolă un număr natural nenul n. Să se verifice dacă acesta este un

număr generos.

Pseudocod

citește n

cn←n

S←0


| S←S+(n%10)

| n←n/10

└■sf. cât timp

Dacă (S>=n+2) atunci SCRIE “NUMĂR generos”

| altfel SCRIE “nu este NUMĂR generos”

└■sf. dacă



Implementare C++

#include <iostream>


int n,cn,S=0;

int main()

{

cin>>n;

cn=n;

while(n!=0)

{

S=S+(n%10);

n=n/10;

}

if(S>=cn+2) cout<<"numar generos";

else cout<<"nu este numar generos";

return 0;

}

NUMĂR GREU ÎNCERCAT

Un număr greu încercat este un număr întreg pozitiv cu proprietatea că are două

cifre între care diferența este 9.

Exemple: 89120, 5602009.

Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze toate numere greu

încercate până la cel de-al n-lea număr.

Pseudocod

citește n (numar natural)

nr←0

i←0

cât timp (nr < n-1)

| ci←i

| c9←0

| c0←0

| cât timp (ci!=0) execută

| | dacă(ci%10 = 0) atunci c0←c0+1

| | └■sf.dacă

| | dacă(ci%10 = 9) atunci c9←c9+1

| | └■ sf.dacă

| | ci←ci/10


| dacă (c9>0 && c0>0) atunci

| | nr←nr+1

| | SCRIE i “ “

| └■sf.dacă

| i←i+1

└■sf. cât timp



Implementare C++

#include <iostream>


int main()

{

int n, nr = 0, i = 0,ci, c9 = 0, c0 = 0;

cin >> n;

while (nr < n-1)

{

ci = i;

c9 = 0;

c0 = 0;

while (ci != 0)

{

if (ci % 10 == 0) c0++;

if (ci % 10 == 9) c9++;

ci /= 10;

}

if (c9 >= 1 && c0 >= 1)

{

nr++;

cout << i << endl;

}

i++;

}

return 0;

}

NUMĂR IMPERFECT

Numărul imperfect este un număr întreg pozitiv cu proprietatea că suma

divizorilor săi (exceptând numărul însuşi) este mai mică decât numărul dat.

Exemple: numerele 62, 70, 77, 95 au suma divizorilor mai mică decât ele însele.

Problemă


imperfecte până la numărul n.

Pseudocod



| s←1

| pentru d=2,sqrt(i),1 execută

| | dacă (i%d=0) atunci s←s+d+(n/d)

| | └■sf. dacă

| | dacă (s<n) atunci SCRIE i

| | └■sf. dacă

| └■sf. pentru

└■sf. pentru



Implementare C++

#include<iostream>


int n,s,i,d;

int main()

{

cin >> n;

for (i=1; i<=n; i++)

{ s=1;

for (d=2; d*d<=i; d++)

if (i%d==0) s=s+d+(n/d);

if (s<n) cout<<i<<" ";

}

return 0;

}

NUMĂR LEGAT

Numărul legat este un număr întreg cu proprietatea că diferenţa dintre oricare

două cifre consecutive este 1.

Exemple: 2343, 6765

Problemă

Se citește de la consolă un număr natural n (n>2) cu cel puțin două cifre. Să se

afișeze toate numerele legate până la numărul n.

Pseudocod


i←10

cât timp( i < n) execută

| ci← i

| legat ←1

| c1←ci%10

| cât timp( ci % 100 >= 10 si legat=1) execută

| | c2 ←ci/10%10

| | ci ←ci/10

| | dacă( c2-c1 !=1 si c2-c1 >0) atunci

| | | legat←0

| | └■sf.dacă

| | dacă( c1-c2 !=1 si c1-c2 >0) atunci

| | | legat ←0

| | └■sf.dacă

| | c1←c2


| dacă(legat=1) atunci SCRIE i, “ “

| └■sf. dacă

| i←i+1




Implementare C++

#include <iostream>


int main()

{

int n, i=2,ci, c1, c2,legat=0;

cin >> n;

while (i < n)

{ ci = i;

if (ci > 10)

{

while (ci%100>= 10)

{ legat = 1;

c1 = ci % 10;

c2 = ci / 10 % 10;

if (abs(c2 - c1) != 1)

{

legat = 0;

break;

}

ci /= 10;

}

}

if (legat == 1) cout << i << " ";

i++;

}

return 0;

}

NUMĂR MUNTE

Numărul munte este un număr natural nenul care are cifrele în ordine

crescătoare (de la stânga la dreapta) până la o cifră de la care cifrele sale sunt în ordine

descrescătoare.

Exemple: 2578631, 241

Se pot verifica și secvențe de tip “munte” din cadrul unui șir de n numere naturale,

cu n>=3. În acest caz, prima secvență conține numere vecine crescătoare, până la o

poziție poz, de la care numerele vecine sunt descrescătoare. Elementul xpoz se consideră

vârful muntelui.

Problemă

Se citește de la consolă un număr natural n (n>2). Să se verifice dacă acesta are

aspect de tip “munte”.

Pseudocod


x ← n

munte ← 1

cât timp (n>9 si n%10<(n/10)%10) execută

| n←n/10




dacă (n=x sau n<10) atunci

| munte ← 0

└■ sf.dacă

cât timp (n>9 si n%10>(n/10)%10) execută

| n←n/10


dacă (n>9) atunci

| munte ← 0

└■ sf.dacă

dacă (munte=1) atunci Scrie numarul are apect munte de tip

munte

| altfel Scrie numarul NU are apect munte de tip

munte

└■ sf.dacă

Implementare C++

#include <iostream>


int main()

{

int n,x,c,munte=1;

cout<<"n="; cin>>n;

x=n;

while(n>9 && n%10<(n/10)%10)

n=n/10;

if(n==x || n<10) munte=0;

while(n>9 && n%10>(n/10)%10)

n=n/10;

if(n>9) munte=0;

if (munte) cout<<"numărul are aspect de munte";

else cout<<"numărul nu are aspect de munte";

return 0;

}

NUMĂR NEVRICOS

Numărul nevricos este un număr natural nenul care este egal cu triplul

produsului cifrelor sale.

Exemple: 15 are triplul produsului cifrelor este 5*1*3 = 15,

24 are triplul produsului cifrelor 2*4*3 = 24 .

Problemă


nevricoase până la numărul n.

Pseudocod


pentru i=1, n, 1 execută

| x ← i

| p ← 1

| cât timp (x!=0) execută

| | p←p*x/10

| | x←x/10




| dacă 3*p=i atunci Scrie i, ‘ ‘

| └■ sf. dacă

└■ sf. pentru

Implementare C++

#include<iostream>


int n, p,cx,x,i;

int main()

{

cin >> n;

for(i=1; i<=n;i++)

{

x=i; p=1;

while (x!=0)

{

p*= (x%10);

x/=10;

}

if (3*p==i) cout<<i<<" ";

}

return 0;

}

NUMĂR NOROCOS

Numărul norocos este un număr natural nenul n, pentru care pătratul lui este o

sumă de n numere naturale consecutive.

Exemple: 3 este norocos pentru că 3 * 3 = 2 + 3 + 4

7 este număr norocos pentru că 7 * 7 = 4 + 5 + 6 + 7 + 8 + 9 + 10

Problemă

Se citește de la consolă un număr natural n (n>2). Să se verifice dacă acesta este

număr norocos și dacă da, afișați cele n numere consecutive care adunate dau pătratul

acestuia.

Pseudocod


dacă (n%2=1) atunci

| t ← (n+1)/2

| cât timp (n!=0) execută

| | scrie t,’ + ‘

| | t←t+1

| | n←n-1


| altfel

| scrie numarul nu e norocos

└■ sf. dacă

Implementare C++

#include <iostream>




int main()

{

int n,t;

cin>>n;

if(n%2)

{

t=(n+1)/2;

while(n!=0)

{

cout<<t<<" + ";

t++;

n--;

}

}

else

cout<<"numarul nu este norocos";

return 0;

}

NUMĂR OPTIM

Un număr optim este un număr întreg pozitiv cu proprietatea că suma cifrelor lui

este 8 sau conţine cifra 8.

Exemple: 1232, 80, 62, 300500.

Problemă

Se citește de la consolă un număr natural nenul n. Să se determine cel de-al n-lea

număr optim.

Pseudocod


i←1

coptim←0

nr←0

cât timp (nr<n) execută

| ci←i

| s←0

| coptim←0

| cât timp (ci !=0)

| | c←ci%10

| | s←s+c

| | ci←ci/10

| | Dacă(c=8) atunci coptim←8

| | └■sf. dacă

| └■sf.cât timp

| dacă(s=8 sau coptim=8) atunci nr←nr+1

| └■ sf.dacă

| i←i+1

└■ sf.cât timp

SCRIE i-1

└■ sf.dacă



Implementare C++

#include <iostream>


int main()

{

int n, ci , i = 1, c, s = 0, coptim = 0, nr = 0;

cin >> n;

}

while (nr < n)

{

ci = i;

s = 0;

coptim = 0;

while (ci != 0)

{

c = ci % 10;

s = s + c;

ci /= 10;

if (c == 8) coptim = 8;

}

if (s == 8 || coptim == 8) nr++;

i++;

}

cout << endl << i - 1;

return 0;

PALINDROM

Numărul palindrom este un număr întreg pozitiv egal cu oglinditul său.

Oglinditul unui număr natural se obține din numărul inițial citind cifrele acestuia

de la dreapta la stânga (în ordine inversă).

Exemple: 67876, 953359.

Problemă


palindrom până la numărul n.

Pseudocod

citire n (numar natural)


| ci←i

| oglindit←0

| cât timp (ci!=0)execută

| | oglindit ← oglindit *10+ci%10

| | ci←ci/10


| dacă oglindit =i atunci

| | scrie i ,‘ ‘

| └■ sf. dacă

└■ sf. pentru



Implementare C++

#include <iostream>


int n,oglindit,i,ci;

int main()

{

cin>>n;

for(i=10;i<=n;i++)

{

ci=i;

oglindit=0;

while(ci!=0)

{

oglindit=oglindit*10+ci%10;

ci=ci/10;

}

if(oglindit==i) cout<<oglindit<<" ";

}

return 0;

}

NUMĂR PĂTRAT PERFECT

Un pătrat perfect este un număr întreg care este pătratul unui alt

număr. Rădăcina pătrată a unui pătrat perfect este un număr întreg.

Exemple: 9 = 3 2 , 16 = 4 2 , 25 = 5 2

Problemă

Se citește de la consolă un număr natural n (n>9). Să se verifice dacă este sau

nu, un număr pătratic (pătrat perfect).

Pseudocod

citire n (numar natural)

dacă sqrt(n)=int(sqrt(n)) atunci

| scrie DA, este numar pătrat

| altfel

| scrie NU este număr pătrat

└■ sf. dacă

Implementare C++

#include<iostream>

#include<cmath>


int main()

{ int n;

cin>>n;

if(sqrt(n)==int(sqrt(n)))

cout<<"DA, este numar pătrat";

else

cout<<"NU este număr pătrat";

return 0;

}



NUMĂR PERFECT

Numărul perfect este un număr întreg egal cu suma divizorilor săi, din care se

exclude numărul însuși.

Exemple:

6=1+2+3

28=1+2+4+7+14

496=1+2+4+8+16+31+62+124+248

8.128=1+2+4+8+16+32+64+127+254+508+1016+2032+4064


Problemă

Se citește de la consolă un număr natural n. Să se verifice dacă este număr perfect.

Pseudocod

citire n (număr întreg)

S ← 0

pentru d=1,n/2,1 execută

| Dacă (n%d=0) atunci S←S+d

| └■ sf. dacă

└■ sf. pentru

Dacă (S=n) atunci

| SCRIE “număr perfect”

| altfel

| SCRIE “nu este număr perfect”

└■ sf. dacă

Implementare C++

#include<iostream>


int n,d,S=0;

int main()

{

cin>>n;

for(d=1;d<=n/2;d++)

{

if(n%d==0)

S=S+d;

}

if(n==S)

cout<<"numarul este perfect";

else

cout<<"numarul nu este perfect";

return 0;

}

NUMĂR PITIC

Un număr pitic este un număr întreg pozitiv cu toate cifrele mai mici decât cifra 4.

Problemă

Se citește un număr n de la consola. Să se verifice dacă este sau nu, număr pitic.



Pseudocod

citește n

ok ← 1

cât timp (n!=0 si ok=1)

| c←n%10

| dacă(c>4) atunci

| | ok←0

| └■sf. dacă

| n←n/10

└■sf. cât timp

dacă(ok=1) atunci

| SCRIE “ este numar pitic “

| altfel

| SCRIE “nu este numar pitic “

└■sf. dacă

Implementare C++

#include <iostream>


int n,ok=1,c;

int main()

{

cin>>n;

while(n!=0 && ok)

{

c=n%10;

if(c>4) ok=0;

n/=10;

}

if(ok) cout<<"este numar pitic";

else cout<<"nu este numar pitic"

return 0;

}

NUMĂR PRIM

Un număr prim este un număr natural, mai mare decât 1, care are exact doi

divizori pozitivi: numărul 1 și numărul în sine. Acești divizori sunt improprii. Un număr

prim este deci nefactorizabil.

Opusul noțiunii de număr prim este cel de număr compus.

Exemple: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,...


Problemă

Se citește de la consolă un număr natural n, (n>2). Să se afișeze toate numerele

prime până la numărul n.

Pseudocod

citește n

i ← 2

cât timp(i < n) execută

| dacă(i=2 || i=3) atunci

| | SCRIE i “ “

| | altfel



| | d←2

| | prim←1

| | cât timp (d<=sqrt(i) si

prim=1)execută

| | | dacă(i%d=0) atunci prim←0

| | | └■sf. dacă

| | | d←d+1


| └■sf. dacă

| dacă(prim=1) atunci SCRIE i , “ “

| └■sf. dacă

| i←i+1

└■sf. cât timp

Implementare C++

#include <iostream>


int main()

{

int n, prim, d, i = 2;

cin >> n;

while (i < n)

{ d = 2;

if (i == 2 || i==3)

cout << i << " ";

else

{ prim = 1;

while (d*d <= i && prim)

{

if (i % d == 0) prim = 0;

d++;

}

}

if (prim == 1) cout << i << " ";

i++;

}

return 0;

}

NUMĂR PUTERNIC

Numărul puternic este un număr întreg pozitiv cu proprietatea că, dacă este

divizibil cu numărul prim p, atunci este divizibil și cu p 2 .

O listă a numerelor puternice cuprinse între 1 și 1000:

1, 4, 8, 9, 16, 25, 27, 32, 36, 49, 64, 72, 81, 100, 108, 121, 125, 128, 144, 169, 196,

200, 216, 225, 243, 256, 288, 289, 324, 343, 361, 392, 400, 432, 441, 484, 500, 512, 529,

576, 625, 648, 675, 676, 729, 784, 800, 841, 864, 900, 961, 968, 972, 1000, ..


Problemă


puternice până la numărul n.



Pseudocod

citește n


| x←i

| ok←1

| d←2

| cât timp(x!=1 si ok=1) execută

| | p←0

| | cât timp(x%d=0) execută

| | | x←x/d

| | | p←p+1

| | |


| | dacă(p=1) atunci

| | | ok←0

| | └■sf. dacă

| | d←d+1


| dacă(ok=1) atunci

| | SCRIE i, “ “

| └■sf. dacă

└■sf pentru

Implementare C++

#include<iostream>


int n,i,x,ok,d,p;

int main()

{

cin>>n;

for(i=4;i<=n;i++)

{

x=i;

ok=1;

d=2;

while(x!=1 && ok==1)

{

p=0;

while(x%d==0)

{ x=x/d;

p++;

}

if(p==1) ok=0;

d++;

}

if(ok==1) cout<<i<<” “;

}

return 0;

}



NUMĂR ROTUND

Numărul rotund este un număr întreg nenul care nu are niciun factor prim mai

mare decât rădăcina sa pătrată.

Numărul rotund este un număr compus (are cel puțin un divizor propriu).

Exempu: 24 are divizori pe 2 și 3, niciunul nefiind mai mare decât 4,89 rădăcina sa

pătrată.

Șirul numerelor rotunde este:

1, 4, 8, 9,12, 16, 18, 24, 25, 27, 30, 32, 36, 40, 45, 48, 49, 50, 54, 56, 60, 63, 64, 70,

72, 75, 80, 81, 84, 90, 96, 98, 100, 105, 108, 112, 120, 121, 125, 126, 128, 132, 135, 140,

144, 147, 150, 154, 160, 162, 165, 168, 169, 175, 176, 180, 182, 189, 192, 195, ...


Problemă


rotunde până la cel de-al n-lea.

Pseudocod


y←1

cât timp (y < n) execută

| x←y

| d←2

| ok←1

| cât timp(x>1) execută

| | p←0

| | cât timp (x % d = 0) execută

| | | x←x/d

| | | p←p+1


| | dacă p=1 atunci

| | | dacă (d > sqrt(y)) atunci ok←0

| | | └■sf. dacă

| | └■sf. dacă

| | d ←d+1


| dacă ok=1 atunci

| | scrie y, “ “

| └■sf. dacă

| y←y+1

└■sf. cât timp

Implementare C++

#include <iostream>

#include <cmath>


int main()

{

int n,p,d,y=1,x,k;

bool ok=1;

cin >> n;

while(y<n)

{

d=2;



}

x=y;

ok=1;

while(x>1)

{

p=0;

while(x%d==0)

{

x/=d;

p++;

}

if(p)

if(d> sqrt(y)) ok=0;

d++;

}

if(ok)

cout << y << " ";

y++;

}

return 0;

NUMĂR SEMIPALIDROM

Numărul semipalindrom este un număr natural nenul în care cifrele din prima

jumătate sunt acelaşi cu cele din a doua jumătate.

Exemple: 13813 , 629.629.

Problemă

Se citește de la consolă un număr natural n (n>2). Să se verifice dacă este număr

semipalindrom.

Pseudocod

citește n

cn ← n

execută

| nr ← nr+1

| n ← n/10

└■ Cât timp (n!=0)

p←1

pentru i=0,i<nr/2,1

| p←p*10

└■ sf. pentru

dacă (nr%2=0) atunci

| dacă (cn%p=cn/p) atunci SCRIE "este semipalindrom"

| | altfel SCRIE "nu este semipalindrom"

| └■sf. dacă

└■sf. dacă

dacă (nr%2=1) atunci

| dacă (cn%p=cn/p/10) atunci SCRIE "este semipalindrom"

| | altfel SCRIE "nu este

semipalindrom"

| └■sf. dacă

└■sf. dacă



Implementare C++

#include <iostream>


int n,p,nr=0,cn,c,i;

int main()

{ cin>>n;

cn=n;

}

do

{ nr++;

n=n/10;

} while (n!=0);

p=1;

for(i=0; i<nr/2; i++) p*=10;

if(nr%2==0)

{

if(cn%p==cn/p) cout<<"este semipalindrom";

else cout<<"nu este semipalindrom";

}

if(nr%2==1)

{

if(cn%p==cn/p/10) cout<<"este semipalindrom";

else cout<<" nu este semipalindrom";}

return 0;

NUMĂR SUBȚIRE

Un număr subțire este un număr întreg pozitiv cu proprietatea că este mai mic

decât suma divizorilor săi fără 1 şi el însuşi.

Exemple: 24 are divizorii 2+3+4+6+8+12 = 35 < 24

Problemă

Se citește de la consolă un număr natural n (n>2). Să se afișeze toate numere

subțiri până la cel de-al n-lea.

Pseudocod


pentru x=1, n, 1 execută

| s ← 0

| pentru d=2, x/2,1 execută

| | dacă x%d=0 atunci

| | | s ← s+d

| | └■sf. dacă

| └■sf. pentru

| dacă x < s atunci

| | scrie x, " "

| ■sf. dacă

└■sf. pentru



Implementare C++

#include <iostream>


int main()

{

int n,s,d,y=1,x;

cin >> n;

for(x=1; x<=n; x++)

{

s=0;

for(d=2; d<=x/2; d++)

{

if(x%d==0)

s+=d;

}

if(x<s)

cout << x<<" ";

}

return 0;

}

NUMĂR SUPERPALINDROM

Numărul superpalindrom este un număr natural nenul ce este palindrom atât el,

cât și pătratul lui.

Numărul palindrom este un număr întreg pozitiv egal cu oglinditul său.

Oglinditul unui număr natural se obține din numărul inițial citind cifrele acestuia de la

dreapta la stânga (în ordine inversă).

Exemple:

11 care este palindrom, are pătratul (121) tot palindrom .

22, 26, 101, 111, 121, 202, 212, 264, 307

Problemă

Se citește de la consolă un număr natural n (n>2). Să se verifice dacă este număr

superpalindrom.

Pseudocod

citește n

cn ← n


| inv ← inv*10+n%10

| n ← n/10

└■sf. cât timp

pt ← cn*cn;

cpt ← pt;

cât timp (pt!=0) execută

| invp ←invp*10+pt%10

| pt← pt/10

└■sf. cât timp

dacă (inv=cn si invp=cpt) atunci

| SCRIE "este superpalindrom"

| altfel

| SCRIE "NU este superpalindrom

└■sf. dacă



Implementare C++

#include <iostream>

#include <cmath>


int n,cn=0,pt=0,cpt=0,inv=0,invp=0;

int main()

{

cin>>n;

cn=n;

while(n!=0)

{

inv=inv*10+n%10;

n=n/10;

}

pt=pow(cn,2);

cpt=pt;

while(pt!=0)

{

invp=invp*10+pt%10;

pt=pt/10;

}

if(inv==cn && invp==cpt)

cout << "Este Superpalindrom";

else

cout << "Nu este Superpalindrom ";

return 0;

}

NUMĂR SUPERPERFECT

Un număr supraperfect este un număr întreg pozitiv ce are suma divizorilor săi

(exceptând numărul însuşi) mai mare decât numărul dat.

Problemă

Se citește de la consola un număr n (n>2). Să se verifice dacă acest număr este

supraperfect sau nu.

Pseudocod

citește n

pentru d=1,n/2,1 execută

| dacă (n%d=0) atunci

| | s←s+d

| └■sf. dacă

└■sf. pentru

dacă(s>n) atunci SCRIE “este numar supraperfect “

| altfel SCRIE “nu este numar supraperfect “

└■sf. dacă

Implementare C++

#include<iostream>


int n,d,s=1;



int main()

{

cin>>n;

for(d=2;d<=n/2;d++)

if(n%d==0)

s=s+d;

if(n<s) cout<<"numarul "<<n<<" este supraperfect";

else

return 0;

}

cout<<"numarul "<<n<<" nu este supraperfect";

NUMĂR SUPERPRIM

Numărul superprim este un număr întreg pozitiv cu proprietatea că, dacă el este

prim, și toate prefixele sale sunt de asemeni prime.

Exemple:

313 este superprim pentru că 313 este prim și 31, 3 sunt prime

2339 este superprim pentru că 2339 este prim și 233, 23, 2 sunt prime

Problemă

Se citește de la consolă un număr natural n, (n>2). Să se afișeze toate numerele

superprime până la numărul n.

Pseudocod



| ok←1

| prim←1

| x←i

| dacă(x%2=0) atunci

| | prim←0

| | altfel

| | d←3

| | cât timp(x%d!=0 si d*d<=x) execută

| | | d←d+2


| | dacă(x%d=0) atunci prim←0

| | └■sf. dacă

| └■sf. dacă

| dacă(prim=1) atunci

| | cât timp(x!=0 si ok=1) execută

| | | x←x/10

| | | dacă(x%2=0) atunci

| | | | prim←0

| | | | altfel

| | | | d←3

| | | | cât timp(x%d!=0 si d*d<=x) execută

| | | | | d←d+2

| | | | └■sf Cât timp

| | | | dacă(x%d=0) atunci prim←0

| | | | └■sf dacă

| | | └■sf dacă



| | | dacă(prim=0) atunci ok←0

| | | └■sf dacă


| └■sf. dacă

| dacă (ok=1) atunci

| | x ← i

| | cât timp(x!=0) execută

| | | SCRIE x , “ “

| | | x←x/10


| └■sf. dacă

└■sf. pentru

Implementare C++

#include<iostream>


int n,i,x,ok,d,prim;

int main()

{

cin>>n;

for(i=3;i<=n; i++)

{

ok=1; prim=1; x=i;

if(x%2==0) prim=0;

else

{

d=3;

while(x%d!=0 && d*d<=x) d=d+2;

if(x%d==0) prim=0;

}

if(prim==1)

while(x!=0 && ok)

{ x=x/10;

if(x%2==0) prim=0;

else

{

d=3;

while(x%d!=0 && d*d<=x) d=d+2;

if(x%d==0) prim=0;

}

if(prim==0) ok=0;

}

if(ok==0)

{x=i;

while(x!=0)

{

cout<<x<<" ";

x/=10;

cout<<endl;

}

}

}

return 0;

}



NUMĂR VALE

Numărul vale este un număr natural nenul care are cifrele în ordine

descrescătoare (de la stânga la dreapta) până la o cifră de la care cifrele sale sunt în

ordine crescătoare.

Exemple: 8531246, 947

Se pot verifica și secvențe de tip “vale” din cadrul unui șir de n numere naturale, cu

n>=3. În acest caz, prima secvență conține numere vecine descrescătoare, până la o

poziție poz, de la care numerele vecine sunt crescătoare. Elementul xpoz se consideră

adâncitura văii.

Problemă

Se citește de la consolă un număr natural n>2. Să se verifice dacă acesta are aspect de

vale.

Pseudocod


x ← n

vale ← 1

cât timp (n>9 si n%10>(n/10)%10) execută

| n←n/10


dacă (n=x sau n<10) atunci

| vale ← 0

└■ sf.dacă

cât timp (n>9 si n%10<(n/10)%10) execută

| n←n/10


dacă (n>9) atunci

| vale ← 0

└■ sf.dacă

dacă (vale=1) atunci Scrie numarul are apect munte de tip munte

| altfel Scrie numarul NU are apect munte de tip

munte

└■ sf.dacă

Implementare C++

#include <iostream>


int main()

{

int n,x,c,vale=1;

cout<<"n=";cin>>n;

x=n;

while(n>9&&n%10>(n/10)%10)

n=n/10;

if(n==x || n<10) vale=0;

while(n>9 && n%10<(n/10)%10)

n=n/10;

if(n>9) vale=0;

if(vale) cout<<"numărul are aspect de vale";

else cout<<"numărul nu are aspect de vale";

return 0;

}



NUMERE în ECHER

Numerele în echer sunt perechea de numere care au același număr de cifre, iar

suma cifrelor de pe aceeași poziție este 9.

Problemă

Se citește de la consolă o pereche de două numere naturale nenule. Să se verifice

dacă acestea sunt numere în echer.

Pseudocod

citește x,y

ok←1

cât timp (x!=0 si y!=0) execută

| dacă x%10+y%10!=9 atunci ok←0

| x←x/10

| y←y/10

└■sf. cât timp

dacă (ok=1 si x=0 si y=0) atunci SCRIE “sunt in echer”

| altfel SCRIE “nu sunt in echer”

└■sf. dacă

Implementare C++

#include <iostream>


int x,y,ok=1;

int main()

{ cin>>x>>y;

while(x!=0 && y!=0 && ok)

{ if(x%10+y%10!=9) ok=0;

x=x/10;

y=y/10;

}

if(ok && x==0 && y==0) cout<<"sunt numere in echer";

else cout<<"nu sunt numere in echer";

return 0;

}

NUMERE PITAGOREICE

Numerele pitagoreice sunt triplete de numere naturale ce verifica relatia din

teorema lui Pitagora.

Oricare ar fi trei numere pozitive a, b, c astfel încât a 2 + b 2 = c 2 , există un triunghi

cu laturi de lungimi a, b, c, iar unghiul dintre laturile de lungimi a și b va fi drept.

Exemple:

3 4 5

5 12 13

6 8 10

7 24 25

8 15 17

Problemă

Se citește de la consolă un număr natural n. Să se afișeze toate tripletele

pitagoreice în care valorile laturilor triunghiului sunt până la valoarea n.



Pseudocod

citește n;

pentru a=1,n,1 execută

| pentru b=a+1,n,1 execută

| | f←a*a + b*b

| | c←int(sqrt(a*a + b*b))

| | dacă (f=c*c si c<n) atunci

| | | SCRIE a , b , c /n

| | └■sf. dacă

| └■sf. pentru

└■sf. pentru

Implementare C++

#include <iostream>

#include <cmath>


int main()

{

int n,a,b,c,f;

cin >> n;

for(a=1; a<=n; a++)

{

for(b=a+1; b<=n; b++)

{

f = a*a +b*b;

c = int(sqrt(a*a + b*b));

if(f == c*c && c < n)

cout << "("<< a << "," << b << "," << c <<

")\n";

}

}

return 0;

}

NUMERE PRIETENE

Numerele prietene sau amiabile sunt perechile de numere în care fiecare număr

în parte este suma divizorilor (toți divizorii proprii și 1) celuilalt număr (cu alte cuvinte

fiecare număr este suma alicotă a celuilalt număr).

Primele seturi de numere prietene sunt (220, 284), (1184, 1210), (2620, 2924),

(5020, 5564), (6232, 6368). Se spune că Pitagora la întrebarea cine este Prietenul? a

răspuns: "Acela care este alt eu, ca numerele 220 și 284".

Exemplu: 220 și 284

Divizorii lui 220 sunt 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 și 110, iar suma acestora este

284. Divizorii lui 284 sunt 1, 2, 4, 71 și 142, iar suma acestora este 220.


Problemă

Se citesc de la consolă două numere naturale a și b. Să se verifice dacă sunt

numere prietene.

Pseudocod

citire a,b

Sa ←0



pentru d=1,a/2,1 execută

| dacă(a%d=0) atunci

| | Sa ← Sa+ d

| └■sf. dacă

└■sf. pentru

Sb ←0

pentru d=1,b/2,1 execută

| dacă(b%d=0) atunci

| | Sb ← Sb+ d

| └■sf. dacă

└■sf. pentru

dacă(Sa=b și Sb=a) atunci

| SCRIE “numere prietene”

| altfel

| SCRIE “nu sunt numere prietene”

└■sf. dacă

Implementare C++

#include <iostream>


int a,b,Sa=0,Sb=0,d;

int main()

{

cin>>a>>b;

for(d=1; d<=a/2;d++)

if(a%d==0) Sa=Sa+d;

for(d=1; d<=b/2;d++)

if(b%d==0) Sb=Sb+d;

if(Sa==b && Sb==a) cout<<"Numere prietene";

else cout<<"Nu sunt numere prietene";

return 0;

}

OGLINDITUL unui număr

Oglinditul unui număr natural se obține din numărul inițial parcurgând cifrele

acestuia de la dreapta la stânga (în ordine inversă).

Exemple: n = 5623, oglinditul este 3265

n = 82000, oglinditul este 28

Problemă

Se citește de la consolă un număr natural nenul n (n>2). Să se afișeze oglinditul

(inversul) acestui număr.

Pseudocod

citire n (numar natural nenul)

oglindit←0

cât timp (n!=0)execută

| oglindit ← oglindit *10+n%10

| n←n/10


SCRIE oglindit



Implementare C++

#include <iostream>


int n, oglindit =0;

int main()

{

cin>>n;

while(n!=0)

{

oglindit = oglindit *10+n%10;

n=n/10;

}

cout<< oglindit;

return 0;

}

METODA BULELOR

Metoda bulelor (Bubble Sort) este o metodă de sortare a unui șir de numere.

Dacă vrem să ordonăm crescător vectorul v, de lungime n, indexat de la 1, metoda

bulelor presupune:

- compararea fiecărei perechi de două elemente succesive

- dacă cele două elemente vecine nu sunt în relația dorită (xi<=xi+1, pentru

sortarea crescătoare și xi>=xi+1, pentru sortarea descrescătoare), atunci

elementele se interschimbă între ele

- dacă se ajunge la finalul șirului, parcurgerea șirului se reia, repetând procedeul

până la prima parcurgere fără nicio interschimbare

Problemă

Se citește un șir cu n elemente (n>2). Să se ordoneze crescător șirul, folosind

metoda bulelor.

Pseudocod



| citește x i

└■sf. pentru

repetă

| schimb←0

| pentru i=1,n-1,1 execută

| | Dacă (x i >=x i+1 ) atunci

| | | aux ← x i

| | | x i ← x i+1

| | | x i+1 ← aux

| | | schimb← 1

| | └■sf. dacă

| └■sf. pentru

└■ până când(schimb=0)


| SCRIE x i , ‘ ‘

└■sf. pentru



Implementare C++

#include <iostream>


int x[100],i,schimb,n,aux;

int main()

{

cout<<"Dati n: ";cin>>n;

for(i=1;i<=n;i++)

{

cin>>x[i];

}

do

{

schimb=0;

for(i=1;i<n;i++)

if(x[i]>x[i+1])

{

aux=x[i];

x[i]=x[i+1];

x[i+1]=aux;

schimb=1;

}

} while(schimb!=0);

for(i=1;i<=n;i++)

cout<<x[i]<<" ";

return 0;

}

SORTARE prin INSERTIE

Sortarea prin inserție este o metodă de ordonare a unui șir de numere.


sortării prin inserție presupune:

- presupunem primul element sortat (avem o secvență cu un element ordonat)

- vom insera elementul v2 în secvența sortată, astfel încât aceasta să fie ordonată.

Vom insera în stânga fiecare element vi pe poziția pe care o ocupă în

subsecvența sortată. Pentru a “face loc” elementului vi vom deplasa spre

dreapta toate elementele mai mari decât el. Elementul vi va fi așezat pe prima

poziție de după primul element mai mic decât vi.

- procedeul se repetă pentru fiecare element vi din șir până va fi sortat întregul

șir.

Problemă


sortarea prin inserție.

Pentru implementarea algoritmului vom parcurge vectorul cu indicele i. Vom

obține secvențe de i elemente sortate, valorilor vi făcându-li-se loc în secvențele de la 0

la i-1 (din stânga).



Pseudocod



| citește v i

└■sf. pentru


| x ← v i

| p←i-1

| cât timp ( p >= 0 si v i > x) execută

| | v i+1 ← v i

| | p←p-1


| v i+1 ← x

└■ sf. pentru


| SCRIE v i

└■ sf. pentru

Implementare C++

#include<iostream>


int main()

{

int n, v[100],x,p,i;

cin >> n;

for (int i = 0; i < n; i++)

cin >> v[i];

for (int i = 0; i < n; i++)

{

x = v[i];

p = i - 1;

while (p >= 0 && v[p] > x)

{

v[p + 1] = v[p];

p--;

}

v[p + 1] = x;

}

for (i = 0; i < n; i++)

cout << v[i] << " ";

return 0;

}

SORTARE prin NUMĂRARE

Sortarea prin numărare este o metodă de ordonare a unui șir de numere.


sortării prin numărare presupune să determinăm poziția în care inserăm fiecare

element în șirul ordonat.

Pentru implementare vom folosi 3 vectori:

- vectorul sursă x în care avem elementele nesortate,

- vectorul destinație y în care vom depozita elementele sortate,



- vectorul numărator cnt în care, pentru fiecare element, vom determina poziția

din șirul sortat.

Cei 3 vectori au aceeași lungime.

Parcurgând vectorul sursă vom număra pentru fiecare element xi câte elemente

mai mici decât el sunt în șir. Rezultatul se stochează în vectorul numărător pe aceeași

poziție pe care o are elementul xi în vectorul sursă.

Vom depune în vectorul destinație, pe poziția dată de valoarea din vectorul

numărator, fiecare element din vectorul sursă.

Problemă


sortarea prin numărare.

Pseudocod

citește n


| citește x i

└■sf. pentru


| pentru j=i+1,n-1,1 execută

| | dacă x i < x j atunci cnt j ← cnt j + 1

| | | altfel cnt i ← cnt i + 1


| └■ sf. pentru

└■ sf. pentru


| y[cnt i ] ← x i

└■ sf. pentru


| SCRIE y i

└■ sf. pentru

Implementare C++

#include<iostream>


int x[100], y[100],cnt[100];

int n,i,j;

int main()

{

cin >> n;

for (i = 0; i < n; i++) cin >> x[i];

for (i = 0; i < n-1; i++)

for (j = i+1; j < n; j++)

if ( x[i] < x[j]) cnt[j]++;

else cnt[i]++;

for (i = 0; i < n; i++) y[cnt[i]]=x[i];

}

for (i = 0; i < n; i++) cout << y[i] << " ";

return 0;



SORTARE prin SELECTIE

Sortarea prin selecție este o metodă de ordonare a unui șir de numere.


sortării prin selecție presupune:

- comparăm elementul de pe prima poziție cu toate celelalte de după el,

selectând minimul din șir. Pe prima poziție din vector vom plasa cea mai mică

valoare a șirului. Vom avea o secvență ordonată cu un element.

- pentru a doua poziție procedăm la fel: comparăm elementul de pe poziția doi cu

toate celelalte de după el, selectând al doilea minim din șir. Vom avea astfel,

primele două elemente sortate.

- procedul se repetă pentru toate elementele vectorului, până la penultimul

element pe care-l comparăm cu ultimul.

Pentru implementarea algortimului vom parcurge vectorul cu indicele i, iar

elementele de după cel cu indicele i, le vom parcurge cu indicele j.

Dacă elementele v i și v j nu sunt în relația dorită (v i <=v j , pentru sortarea

descrescătoare) le interschimbăm. Vom obține secvențe de i elemente sortate, indicele i

incrementându-se până la n-1.

Problemă


sortarea prin selecție.

Pseudocod

citește n


| citește v i

└■ sf. pentru


| pentru j=i+1,n,1 execută

| | Dacă v i > v j atunci

| | | aux← v i

| | | v i ← v j

| | | v j ←aux


| └■ sf. pentru

└■ sf. pentru


| SCRIE v i

└■ sf. pentru

Implementare C++

#include<iostream>


int main()

{

int n, v[100],i,aux,j;

cin >> n;

for (i = 1; i <= n; i++)

cin >> v[i];

for (i = 1; i < n; i++)

{



}

for (j = i + 1; j <= n; j++)

if (v[i] > v[j])

{

aux = v[i];

v[i] = v[j];

v[j] = aux;

}

}

for (i = 1; i <= n; i++)

cout << v[i] << " ";

return 0;

REZOLVARE ecuație de GRAD I

Se citesc de la consolă două numere a și b ce reprezintă coeficienții ecuației de

gradul întâi. Să se calculeze și să se afișeze rădăcina acestei ecuații.

a x + b = 0

Pseudocod

citește a,b

dacă (a=0) atunci

| dacă(b=0) atunci SCRIE "o infinitate de solutii"

| | altfel

| | SCRIE"imposoibil"

| └■sf. dacă

| altfel

| x ←-b/a

| SCRIE x

└■sf. dacă

Implementare C++

#include<iostream>


float a,b,x;

int main()

{

cin>>a>>b;

if(a==0)

if(b==0) cout<<"o infinitate de solitii";

else cout<<"imposibil";

else cout<<-b/a;

return 0;

}

REZOLVARE ecuatie de GRAD II

Se citesc de la consolă trei numere a, b și c ce reprezintă coeficienții ecuației de

gradul al II-lea. Să se calculeze și să se afișeze rădăcinile ecuației.

ax 2 + bx + c = 0



Pseudocod

citeste a,b,c

D ← b*b+4*a*c

dacă (D<0) atunci SCRIE "soluții complexe"

| altfel

| dacă(D=0) atunci

| | x1←-b/(2*a)

| | x2←x1

| | SCRIE "soluții reale și egale",x1

| | altfel

| | x1←(-b+sqrt(D))/(2*a)

| | x2←(-b-sqrt(D))/(2*a)

| | SCRIE "soluții reale și

diferite",x1,x2

| └■sf. dacă

└■sf. dacă

Implementare C++

#include <iostream>

#include <cmath>


int a,b,c,D;

float x1,x2;

int main()

{

cin>>a>>b>>c;

D=b*b-4*a*c;

if (D<0) cout<<"soluții complexe";

else if (D==0)

{

x1=-b/(2*a);

x2=x1;

cout<<"soluții reale și egale"<<x1;

}

else

{

x1=(-b+sqrt(D))/(2*a);

x2=(-b-sqrt(D))/(2*a);

cout<<"soluții reale și diferite"<<x1<<"

"<<x2;

}

return 0;

}

SIMPLIFICAREA unei FRACTII

Una dintre metodele de simplificare a unei fracții este determinarea divizorilor

comuni numitorului și numărătorului. Pentru eficientizarea căutării divizorilor, se va

determina minimul acestora.

O altă metodă, mult mai uzuală, este determinarea celui mai mare divizor comun

dintre numărător și numitor, cu ajutorul algoritmului lui Euclid.



Problemă

Se citesc de la consolă două numere naturale nenule ce reprezintă

numărătorul și numitorul unei fracții. Să se afișeze această fracție sub formă

ireductibilă.

Pseudocod

citește nr, nm (numere naturale nenule)

a ← nr

b ← nm

dacă (a<=b) atunci minn ← a

| altfel minn ← b

└■sf. dacă

pentru d=2,minn,1 execută

| dacă (a%d==0 si b%d==0) atunci

| | a ← a/d

| | b ← b/d

| | d ← d-1

| └■sf. dacă

└■sf. pentru

dacă (a!=nr si b!=nm) atunci

| SCRIE fractia simplificata

e,a,’/’,b

| altfel

| SCRIE fractia ireductibila

└■sf. dacă

Implementare C++

#include <iostream>


int main()

{

int a,b,minn,nr,nm,d;

cout<<"dati numaratorul si numitorul";

cin>>nr>>nm;

a=nr;

b=nm;

if(a<b) minn=a;

else minn=b;

for(d=2; d<=minn; d++)

if(a%d==0 && b%d==0)

{ a/=d;

b/=d;

d--;

}

if (a!=nr && b!=nm)

cout<<"fractia simplificata este "<<a<<"/"<<b;

else

cout<<"fractie ireductibila";

return 0;

}



SIRUL lui FIBONACCI

Numerele Fibonacci sunt definite prin următoarea relație de recurență:

Fn = Fn-1 + Fn-2

cu valorile inițiale F1 = 1, F2 = 1 sau F0 = 1, F1 = 1.

Astfel, fiecare număr Fibonacci este suma celor două numere Fibonacci anterioare,

rezultând secvența: 0, 1,1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, …

Problemă

Se citește de la consolă un număr natural nenul n. Să se afișeze termenii șirului lui

Fibonacci până la al n-lea, primul termen fiind 1.

Pseudocod

citește n

dacă (n<=2) atunci SCRIE "1˽1"

| altfel

| F1←1

| F2←1

| SCRIE "1 1 "


| | Fn←F1+F2

| | SCRIE "Fn˽"

| | F1←F2

| | F2←Fn

| └■sf. pentru

└■sf. dacă

Implementare C++

#include <iostream>


int n,F1=1,F2=1,Fn,i;

int main( )

{

cin>>n;

if (n<=2) cout<<"1 1 ";

else

{ F1=1;

F2=1;

cout<<"1 1 ";

for (i=3;i<=n;i++)

{

Fn=F1+F2;

cout<<" "<<Fn;

F1=F2;

F2=Fn;

}

}

return 0;

}



SISTEM de 2 ecuatii liniare cu 2 NECUNOSCUTE

Se dă un sistem de două ecuații cu două necunoscute de forma

a1x + b1y = c1

a2x + b2y = c2

Pentru rezolvarea acestui sistem se poate folosi metoda reducerii sau metoda

substituției. Soluțiile acestui sistem se calculează astfel:

x= Dx / Ds

y = Dy / Ds

Unde dx , dy și ds sunt:

Dx = b2*c1 – b1*c2

Dy = a1*c2 – a2*c1

Ds = a1*b2 – b1*a2

Problemă

Se citesc de la consolă două perechi de câte trei numere întregi ce reprezintă

coeficienții a două ecuații liniare cu două necunoscute. Să se determine și să se afișeze

soluțiile acestui sistem.

Pseudocod

citește a1, b1, c1, a2, b2, c2 (numere întregi)

Dx ← b2*c1 – b1*c2

Dy ← a1*c2 – a2*c1

Ds ← a1*b2 – b1*a2

dacă Ds=0 atunci

| dacă Dx=0 atunci

| | SCRIE sistem nedeterminat

| | altfel

| | SCRIE sistem incompatibil

| └■ sf. dacă

| altfel

| x ← Dx / Ds

| y ← Dy / Ds

| SCRIE solutiile sunt, x, ‘ ‘ , y

└■ sf. dacă

Implementare C++

#include <iostream>


int a1,b1,c1,a2,b2,c2;

float Dx,Dy,Ds,x,y;

int main()

{

cout<<"dati coeficientii primei ecuatii ";

cin>>a1>>b1>>c1;

cout<<"dati coeficientii ecuatii 2 ";

cin>>a2>>b2>>c2;

Dx = b2*c1-b1*c2;

Dy = a1*c2-a2*c1;

Ds = a1*b2-b1*a2;

if (Ds==0)

if(Dx==0) cout<<"sistem nedeterminat";

else cout<<"sistem incompatibil";



}

return 0;

else

{

}

x = Dx / Ds;

y = Dy / Ds;

cout<<" solutiile sunt "<<x<<" "<<y;

SISTEM de 3 ecuatii liniare cu 3 NECUNOSCUTE

Se dă un sistem de trei ecuații cu trei necunoscute de forma

a1x + b1y + c1z = d1

a2x + b2y + c2z = d2

a3x + b3y + c3z = d3

Pentru rezolvarea acestui sistem se poate folosi regula lui Cramer. Aplicând

formulele lui Cramer, soluțiile acestui sistem se calculează astfel:

x= Dx / Ds

y = Dy / Ds

z = Dz / Ds

Unde Dx , Dy, Dz și Ds sunt:

Dx = d1*b2*c3 + d2*b3*c1 + d3*b1*c2 – d3*b2*c1 – d2*b1*c3 – d1*b3*c2

Dy = a1*d2*c3 + a2*d3*c1 + a3*d1*c2 – a3*d2*c1 – a2*d1*c3 – a1*d3*c2

Dz = a1*b2*d3 + a2*b3*d1 + a3*b1*d2 – a3*b2*d1 – a2*b1*d3 – a1*b3*d2

Ds = a1*b2*c3 + a2*b3*c1 + a3*b1*c2 – a3*b2*c1 – a2*b1*c3 – a1*b3*c2

Problemă

Se citesc de la consolă trei perechi de câte patru numere întregi ce reprezintă

coeficienții a trei ecuații liniare cu trei necunoscute. Să se determine și să se afișeze

soluțiile acestui sistem.

Pseudocod

citește a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3 (numere întregi)

Dx ← d1*b2*c3+d2*b3*c1+d3*b1*c2-d3*b2*c1-d2*b1*c3-d1*b3*c2

Dy ← a1*d2*c3+a2*d3*c1+a3*d1*c2-a3*d2*c1-a2*d1*c3-a1*d3*c2

Dz ← a1*b2*d3+a2*b3*d1+a3*b1*d2-a3*b2*d1-a2*b1*d3-a1*b3*d2

Ds ← a1*b2*c3+a2*b3*c1+a3*b1*c2-a3*b2*c1-a2*b1*c3-a1*b3*c2

dacă Ds=0 atunci

| SCRIE sistem nedeterminat

| altfel

| x ← Dx / Ds

| y ← Dy / Ds

| z ← Dz / Ds

| SCRIE solutiile sunt, x, ‘ ‘ , y, ‘ ‘,z

└■ sf. dacă

Implementare C++

#include <iostream>


int a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3;

float Dx,Dy,Dz,Ds,x,y,z;

int main()



{

}

cout<<"dati coeficientii primei ecuatii ";

cin>>a1>>b1>>c1>>d1;


cin>>a2>>b2>>c2>>d2;


cin>>a3>>b3>>c3>>d3;

Dx = d1*b2*c3+d2*b3*c1+d3*b1*c2-d3*b2*c1-d2*b1*c3-d1*b3*c2;

Dy = a1*d2*c3+a2*d3*c1+a3*d1*c2-a3*d2*c1-a2*d1*c3-a1*d3*c2;

Dz = a1*b2*d3+a2*b3*d1+a3*b1*d2-a3*b2*d1-a2*b1*d3-a1*b3*d2;

Ds = a1*b2*c3+a2*b3*c1+a3*b1*c2-a3*b2*c1-a2*b1*c3-a1*b3*c2;

if (Ds==0)

cout<<"sistem nedeterminat";

else

{

x = Dx / Ds;

y = Dy / Ds;

z = Dz / Ds;

cout<<" solutiile sunt "<<x<<" "<<y<<" "<<z;

}

return 0;

SEPARAREA CIFRELOR UNUI NUMĂR

Diverse operații matematice presupun prelucrarea cifrelor unui număr cu mai

multe cifre. Prin împărțirea unui număr la 10 putem să separăm cifrele lui din partea

dreaptă spre stânga, dacă reținem restul împărțirii.

Problemă

Se citește de la consolă un număr natural n. Să se afizeze cifrele acestuia.

Pseudocod

citire n

cât timp (n!=0)

| c ← n%10

| scrie c

| n ← n/10

└■sf. cât timp

Implementare C++

#include <iostream>


int n,c;

int main()

{

cin>>n;

while(n!=0)

{

c=n%10;

cout<<c<<endl;

n/=10;

}

return 0;

}



SUMĂ ARMONICĂ

Suma armonică a unui număr întreg pozitiv se obține prin însumarea produsului

dintre cifrele lui și poziția din cadrul numărului. Cifra unităților se consideră prima cifră,

iar numărarea cifrelor continuă spre dreapta cu cifra zecilor, a sutelor, …

Exemplu: pentru 1859, suma este 47 = 1*9 + 2*5 + 3*8 + 4*1

Problemă

Se citește de la consolă un număr natural n cu cel puțin două cifre. Să se

determine și să se afișeze suma armonică a cifrelor acestuia.

Pseudocod

citește n

cnt ← 0

cât timp n != 0 execută

| c ← n % 10

| cnt++

| s ← s + c * cnt

| n ← n /10

└■sf. cât timp

SCRIE s

Implementare C++

#include<iostream>


int n,s=0, cnt=0, c;

int main()

{

cout << "dati numarul ";

cin >> n;

while(n != 0)

{ c = n% 10;

cnt++;

s = s +c *cnt;

n/=10;

}

cout << s;

return 0;

}

TRANSFORMARE A UNUI NUMĂR DIN BAZA 10 IN BAZA B

Algoritmul de transformare a unui număr din baza 10 în baza b presupune

scrierea numărului din baza 10 cu cifrele bazei de la 0 la b-1.

Exemple: 10(10) =2(2) ;

24(10)=11000(2) ;

174(10)=10101110(2);



Problemă

Să se afișeze scrierea numărului n din baza 10 în baza b.

Pseudocod

citește n,b

nr ← 0

p←1

cât timp (n>=b) execută

| r←n%b

| nr←nr+r*p

| n←n/b

| p←p*10

└■sf. dacă

nr ← nr+n*p

SCRIE nr

Implementare C++

#include <iostream>


int n,b,r,nr=0,p=1;

int main()

{

cout<<"dati numarul in baza 10";

cin>>n;

cout<<"dati baza ";

cin>>b;

while (n>=b)

{

r=n%b;

nr=nr+r*p;

n=n/b;

p=p*10;

}

nr=nr+n*p;

cout<<"numarul din baza 10 in baza "<<b<<" este "<<nr;

return 0;

}

TRANSFORMARE A UNUI NUMĂR DIN BAZA B IN BAZA 10

Algoritmul de transformare a unui număr din baza b în baza 10 presupune

scrierea numărului din baza b cu cifrele bazei 10 (de la 0 până la 9).

Exemple: 21(3)=7(10)

65(7)=47(10)

14(2)=6(10)



Problemă

Să se afișeze scrierea numărului n din baza b în baza 10.

Pseudocod

citește n,b

nr (10) ←0

p←1


| r←n%10

| nr (10) ←nr (10) +r*p

| n←n/10

| p←p*b

└■sf. cât timp

SCRIE nr (10)

Implementare C++

#include <iostream>


int n,b,r,nr=0,p=1;

int main()

{ cout<<"dati numarul in baza b ";

cin>>n;

cout<<"dati baza ";

cin>>b;

while (n!=0)

{

r=n%10;

nr=nr+r*p;

n=n/10;

p=p*b;

}

cout<<"numarul din baza "<<b<<" in baza 10 este "<<nr;

return 0;

}

VERIFICARE laturi TRIUNGHI

Perechi de trei numere întregi pozitive pot forma laturile unui triunghi.

Exemple:

5, 5, 5 => pot forma un triunghi echilateral

8, 8, 14 => pot forma un triunghi isoscel

3, 4, 5 => pot forma un triunghi dreptunghic

3, 6, 10 => nu pot forma un triunghi

Problemă

Se citesc de la consolă trei numere întregi pozitive a,b și c. Să se verifice dacă pot

forma laturile unui triunghi. În cazul în care pot constitui un triunghi, să se afișeze ce fel

de triunghi pot forma.



Pseudocod

citește a,b,c

dacă a+b>c si a+c>b si b+c>a atunci

| dacă a=b si b=c atunci SCRIE triunghi echilateral

| | altfel

| | dacă a=b sau b=c sau a=c atunci SCRIE triunghi isoscel

| | | altfel

| | | dacă a*a+b*b=c*c sau b*b+c*c=a*a sau a*a+c*c=b*b atunci

| | | | SCRIE triunghi dreptunghic

| | | | altfel SCRIE triunghi oarecare

| | | └■ sf. dacă


| └■ sf. dacă

| altfel

| SCRIE nu pot forma laturile triunghiului

└■ sf. dacă

Implementare C++

#include <iostream>


int main()

{

unsigned a,b,c;

int ok=1;

cout<<"dati numerele ";

cin>>a>>b>>c;

if(a<b+c && b<a+c && c<a+b)

{

if(a==b && b==c)

cout<<"triunghi echilateral";

else

if(a==b || a==c || b==c)

cout<<"triunghi isoscel";

else

if (a*a+b*b==c*c || b*b+c*c==a*a ||

a*a+c*c==b*b)

cout<<"triunghi dreptunghic";

else

cout<<"triunghi oarecare";

}

else

cout<<"nu pot forma laturile triunghiul";

return 0;

}


INFORMATICA

implementare C++

ISBN 978-973-0-36613-6

Culegere de ALGORITMI elementari la INFORMATICA

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?