programare

111
1ALGORITMI ELEMENTARI

Cuprins:
Reprezentarea algoritmilor:.........................................................................................................................4
I.Principiile programarii structurate.............................................................................................................4
PSEUDOCODUL:...........................................................................................................................................5
SCHEMA LOGICA..........................................................................................................................................6
MECANISM DE FUNCTIONARE.....................................................................................................................7
SELECTIA MULTIPLA.....................................................................................................................................7
cu cifreleunui numar:...................................................................................................................................9
a) Extragerea cifrelor unui numar................................................................................................................9
b) Inversul unui numar:.............................................................................................................................10
Aflarea cifrei maxime dintr-un număr n:...................................................................................................11
Aflarea cifrei minime dintr-un număr n:....................................................................................................12
număr cu cifre distincte:............................................................................................................................12
numere de tip palindrome:........................................................................................................................13
Determinarea divizorilor unui numar........................................................................................................15
Determinarea unui numar prim.................................................................................................................15
descompunerea in factori primi:...............................................................................................................16
Descompunerea în factori primi................................................................................................................18
Algoritmul lui Euclid (cel mai mare divizor comun a doua numere)..........................................................18

În matematică și informatică un algoritm (cuvântul are ca origine

numele matematicianului persan Al-Khwarizmi) este o metodă
(procedură de calcul) în care se prezintă pașii
sau operațiile elementare necesare pentru rezolvarea unei probleme
sau categorii de probleme.

3
1ALGORITMI ELEMENTARI

De obicei algoritmii se implementează în mod concret prin

programarea adecvată a unui calculator, sau a mai multora. Din
diverse motive există și algoritmi încă neimplementați, teoretici.

Algoritmul este noțiunea centrală a informaticii. Totul este construit în

jurul algoritmilor (și a structurilor de date, cum ar
fi listele sau grafurile).

Este și un concept central al matematicii moderne alături de cel

de sistem axiomatic.

Câteva exemple de algoritmi:

 algoritmul lui Euclid;


 algoritmul de rezolvare a unei ecuații algebrice de gradul doi;

 algoritmul de explorare a unui labirint în vederea găsirii unei ieșiri
(una din soluții: se ține o mână pe perete și se merge fără a o
dezlipi de acesta);

 algoritmul de fabricare a unui automobil (urmărind procedeele și
schițele de fabricație);

 algoritmul de folosire a unei mașini-unelte (citind manualul de
folosire);

 algoritmul (ordinea operațiilor, sau „check list”) la decolarea unui

avion. Ultimele trei exemple de algoritm desigur nu țin în mod
direct de domeniul matematicii sau informaticii.

Exemplu :
Presupunand ca dispunem de un aragaz ,o tigaie ,2 oua ,sare si 200
ml ulei ,sa pregatim ochiuri .
4
1ALGORITMI ELEMENTARI

“Date,, de intrare :oua ,ulei ,sare .

“Date ,,de iesire :ochiuri .

Pas 1: Se pune tigaia pe foc .

Pas 2: Se toarna uleiul in tigaie .

Pas 3: Asteptam pana cand se incinge uleiul.

Pas 4: Spargem cu indemanare ouale se rumenesc.

Pas 5: Asteptam pana cand ouale se rumenesc .

Pas 6: Daca nu tinem regim ,adaugam sare .

Reprezentarea algoritmilor:

I.Principiile programarii structurate

Programarea structurata a aparut in anii 70 datorita cresterii

complexitatii aplicatiilor , aducand o serie de principii si tehnici
inovative . Modularizarea este una dintre ele , permitand impartirea
problemei in subprobleme de dimensiuni mai mici si complexitate mai
redusa

.Problemele erau rezolvate de echipe de programatori si rezultatele

erau combinate in scopul rezolvarii problemei initiale.
5
1ALGORITMI ELEMENTARI

O alta tehnica importanta a fost cea a structurarii datelor si

prelucrarilor.

Structurarea datelor permitea gruparea datelor in anumite zone de

program , dar si descrierea si utilizarea unor structuri de date
proprii.Structurarea prelucrarilor se poate realiza prin utilizarea
modulelor si a subprogramelor .Un principiu important presupunea ca
orice program se poate scrie prin secvente liniare , alternative si
repetitive

.
II. Descrierea algoritmilor:

Un algoritm de rezolvare presupune stabilirea pasilor necesari. Pasii

necesari pot fi descrisi intr-un limbaj de programare , insa nu toata
lumea cunoaste acel program si niciun program nu s-a impus ca fiind
singurul utilizat de programatori .

Din acest motiv s-au impus niste metode generale de descriere a

algoritmilor independente de limbajul de programare . Programele se
scriu pe baza acestor descrieri . Metodele cele mai importante sunt :
∙ pseudocodul
∙ schema logica

PSEUDOCODUL:
reprezinta un set restrans de cuvinte in romana sau engleza asociate
unor operanti.Astfel , cuvintele utilizate sunt : intreg , real , citeste ,
scrie , daca , atunci , altfel , sfarsit daca , pentru , cat timp ,

6
1ALGORITMI ELEMENTARI

sfarsit cat timp , executa cat timp .

Exemplu:

Cititi doua variabile intregi . Calculati suma lor si afisati rezultatul.

Intreg

, b , c

citeste a , b
c= a + b

scrie c

SCHEMA LOGICA este reprezentarea grafica a unor prelucrari. Aceasta

reprezinta un set de simboluri grafice.

STRUCTURA SECVENTIALA(LINIARĂ)

Presupune executarea unei prelucrari in ordinea precizata . ( ele nu se

executa conditional sau repetitiv ). Exista cateva tipuri , printre care :

1.) Declararea variabilelor se face cu sintaxa ,, tip data variabila ’’.

Definirea variabilei pune in legatura numele variabilei cu tipul sau .

7
1ALGORITMI ELEMENTARI

2.)Citirea variabilei reprezinta operatia prin care continutul unei

variabile e incarcat de la tastatura.

3.)Atribuirea este operatia prin care o valoare e asociata unei variabile.

4.)Afisarea se realizeaza cu sintaxa scrie exp 1 , … , exp n

5.)Instructiunea compusa reprezinta un set de prelucrari cuprinse intre

acolade .

{ p1
.
.
} pn
STRUCTURA ALTERNATIVA

SCOP : permite efectuarea unei unui set de operații in functie de

valoarea unei conditii.
Are două forme:
1.daca_conditie / expresie
instr.
sfarsit_daca

MECANISM DE FUNCTIONARE:

se evalueaza conditia sau expresia la o valoare logica. Daca e adevarata

se realizeaza instr. , daca nu , nu se executa nimic.
2. daca_cond atunci
instr1

8
1ALGORITMI ELEMENTARI

altfel
instr2
sfarsit_daca
Mecanism de functionare : se evalueaza conditia la o valoare logica.Daca
este adevarat se executa instr1 , daca nu , se executa instr2.

SELECTIA MULTIPLA

Este o structura derivata. Ea poate fi inlocuita prin struturi decizionale

, deoarece este implementata de instructiuni in limbaje de programare.
Ea poate fi prezentata in schema logica si pseudocod :
case_exp
v1 , p1
………..
vn , pn
end_case

9
1ALGORITMI ELEMENTARI

cu cifreleunui numar:

a) Extragerea cifrelor unui numar

Ex: Se citeste de la tastatura un numar intreg a. Sa se determine suma
cifrelor numarului a.

Algoritmul presupune extragerea pe rand a cifrelor numarului a incepand

de la ultima cifra si adaugarea cifrei la suma prin operatia s <- s + a mod
10 unde a mod 10 este ultima cifra a numarului, apoi eliminarea cifrei prin
operatia a <- a div 10. Algoritmul se incheie atunci cand s-au adunat toate
cifrele numarului deci valoarea variabilei a este 0.

intreg a, s;

inceput

citeste a;

s <- 0;

cat_timp a 0 executa

s <- s + a mod 10;

a <- a div 10;

sfarsit_cat_timp;

scrie s;

sfarsit.

10
1ALGORITMI ELEMENTARI

b) Inversul unui numar:

Pentru determinarea inversului (oglinditului) unui numar se vor utiliza

variabilele: a ( numarul citit de la tastatura) si inv (inversul). Initial valoarea
variabilei inv este 0. Inversul se va construi pas cu pas prin formula inv <-
inv *10 + a mod 10;

intreg a, inv;

inceput

citeste a;

inv <- 0;

cat_timp a 0 executa

inv <- inv * 10 + a mod 10;

a <- a div 10;

sfarsit_cat_timp;

scrie inv;

sfarsit.

Descompunerea unui număr în cifre începând cu cifra cea mai semnificativă:

#include

using namespace std;

int main() { int n, pc, p;

p = 1; while (p * 10 <= n) { p = p * 10; }

11
1ALGORITMI ELEMENTARI

while(n > 0) { pc = n / p;

n = n % p;

p = p /10;

cout<<pc<

Se citește un număr natural n. Să se spună câte cifre pare are el.

Exemple:

dacă n=5428 el are 3 cifre pare (4, 2 și 8), dacă n=49285640 el are 6 cifre pare (4,
2, 8, 6, 4, 0).
#include

using namespace std;

int main() { int n, nrp;

cin>>n;

nrp = 0;

while ( n > 0 ) { c = n % 10;

if ( c % 2 == 0 ) { nrp = nrp + 1; }

n = n / 10; }

cout<<"Nr. cifre pare: "<

Aflarea cifrei maxime dintr-un număr n:

#include

using namespace std;

int main() { int n, cmax=0, u;

//cifra maxima se inițializează cu 0 sau cu -1 cin>>n;

12
1ALGORITMI ELEMENTARI

while (n>0) { u=n%10;

//ultima cifra if (u>cmax) {cmax=u;}

n = n /10;

// tăierea ultimei cifre până când n ajunge

0 } cout<

Aflarea cifrei minime dintr-un număr n:

#include

using namespace std;

int main() { int n, cmin=0, u;

//cifra minima se inițializează cu 10 sau cu 9 cin>>n;

while (n>0) { u=n%10;

// ultima cifra if (u< cmin) { cmin =u;}

n = n /10;

// tăierea ultimei cifre până când n ajunge 0 }

cout<< cmin;

// afișarea cifrei minime

return 0;}

număr cu cifre distincte:

Să se spună dacă un număr are toate cifrele distincte.

Exemplu:
13
1ALGORITMI ELEMENTARI

545453967 nu are cifre distincte, cifrele 5 și 4 apar de două ori în număr;

Numărul 5438 are cifre distincte, nici o cifră a sa nu se repetă.

#include

using namespace std;

int main() { int n, cn, c;

cin>>n;

c n= 0;

while ( n > 9 && cn == 0 )

{ c = n % 10;

cn = n / 10;

while ( cn > 0 && cn % 10 != c )

cn = cn/ 10;

n = n / 10; }

if (cn==0)

cout<<

numere de tip palindrome:

Cum aflăm dacă un număr este de tip palindrom (simetric)?

Exemplu:
22, 32123, 454, etc.
Algoritmul clasic răstoarnă numărul şi testează dacă numărul este egal cu
răsturnatul său:
14
1ALGORITMI ELEMENTARI

#include

using namespace std;

int main() { int p, c, r;

// declararea variabilelor cin>>p;

// citirea numărului p – presupus

a fi de tip palindrom c = p;
// salvarea numărului p într-o altă variabilă c (copie) r = 0;
// initializarea lui r cu 0
while ( p > 0 ) { r = r * 10 + p % 10;
// se construiește răsturnatul p = p / 10;
// se goleşte numărul de cifre } if ( c == r )
// dacă răsturnatul este egal cu copia cout<<"DA" ;
else cout<<"NU" ;
return 0;}

Acest algoritm poate depăși valoarea maximă reprezentabilă pe tipul long

long (pentru numere mari). O soluţie ar fi să răsturnăm numărul numai
până la jumătate:

#include
using namespace std;
int main() { long long p, r;
cin>>p;
r = 0;
while ( p > r ) { r = r * 10 + p % 10;
p = p / 10; }
// când numărul are un număr par de cifre testăm dacă
p == r //
când numărul are un număr impar de cifre testăm dacă
p == r / 10 if ( p == r || p == (r / 10) )
cout<<"DA" ;
else cout<<"NU" ;
return 0; }

15
1ALGORITMI ELEMENTARI

divizori si numar prim:

Determinarea divizorilor unui numar

Pentru determinarea divizorilor unui numar se vor utiliza variabilele: a

(numarul citit de la tastatura), i (contor). Se vor cauta posibilii divizori in
intervalul [2, a/2]. Daca a mod i = 0 (a se divide la i) atunci se afiseaza
divizorul (i).

intreg a, i;

inceput

citeste a;

pentru i <- 2,a/2 executa

daca a mod i=0

atunci scrie i;

sfarsit_daca;

sfarsit_pentru;

sfarsit.

Determinarea unui numar prim

Un numar este prim daca se divide doar la 1 si la el insusi.

Pentru verificarea unui numar prim se vor utiliza variabilele: a (numarul citit
de la tastatura), i (contor) si sw.

16
1ALGORITMI ELEMENTARI

Vom considera ca numarul este prim deci variabila sw se va initializa cu

valoarea 1. Se vor cauta posibilii divizori in intervalul [2, a/2]. Daca a mod i
= 0 (a se divide la i) atunci rezulta ca numarul nu este prim deci schimbam
valoarea variabilei sw=0.

intreg a, i,sw;

inceput

citeste a;

sw <- 1;

pentru i <- 2,a/2 executa

daca a mod i=0

atunci sw <- 0;

sfarsit_daca;

sfarsit_pentru;

daca sw = 1

atunci scrie "Numarul este prim";

altfel scrie "Numarul nu este prim."

sfarsit.

descompunerea in factori primi:

Număr prim

17
1ALGORITMI ELEMENTARI

Se citește un număr n. Să se spună dacă n este prim. Un număr este prim dacă nu
se împarte decât la 1 și la el însuși. Vom proceda similar cu afişarea divizorilor:
vom căuta primul divizor al lui n, începând cu 2.

Dacă găsim un divizor, numărul nu este prim. Dacă, în schimb, primul divizor găsit
este chiar n, numărul este prim. Putem face mai puține iterații dacă observăm că
dacă un număr nu are nici un divizor strict mai mare ca 1 dar mai mic sau egal cu
radical din n atunci el nu va avea nici alți divizori mai mari decât radical din n dar
mai mici decât n. Putem, deci, înlocui condiția d <= n/2 cu d * d <= n. În acest caz
va trebui să modificăm condiția finală de test de primalitate în d * d > n.
#include

using namespace std;

int main() { int n, d;

cin>>n ;

d = 2;

while ( d * d <= n && 3 n % d > 0 ) /*

condiția de oprire este d * d > n or n % d == 0

adică ori nu am găsit { d = d + 1;}

niciun divizor, ori am găsit primul divizor */

if ( d * d > n

) cout<

Descompunerea unui număr în cifre începând cu cifra cea mai semnificativă:

#include

using namespace std;

18
1ALGORITMI ELEMENTARI

int main()

{ int n, pc, p;

p = 1;

while (p * 10 <= n) { p = p * 10; }

while(n > 0)

{ pc = n / p; n = n % p; p = p /10;

cout<<pc<” “;}

return 0;}

Descompunerea în factori primi

Se citește un număr n. Să se descompună în factori primi. Exemple : dacă n = 45 vom
afișa 45 = * 3^2 * 5^1; dacă n = 1008 vom afișa 1008 = * 2^4 * 3^2 * 7^1.

Observație: nu este nevoie să testăm dacă un divizor este prim, putem testa toți
divizorii.
#include

using namespace std;

int main() { int n, p, d; cin>>n;

cout<< "n= "; d = 2;

while ( n > 1 ) { p = 0;

while ( n % d == 0 ) { dacă am găsit un divizor … p = p + 1;

// puterea unui divizor prim d – de cate ori se cuprinde d în n n = n / d;

// … împărţim numărul la d cât timp se mai poate }

if ( p > 0 ) // dacă puterea este >0 cout

<<" *"<<d<<" ^"<

19
1ALGORITMI ELEMENTARI

Algoritmul lui Euclid (cel mai mare divizor comun a doua numere)

Cel mai mare divizor comun al două numere naturale n și m poate fi determinat
folosind descompunerea în factori primi a celor două numere.

Această metodă este mai dificil de implementat.

Există o metodă mai simplu de, numită algoritmul lui Euclid.

Algoritmul lui Euclid cu împărțiri se bazează pe ideea că cel mai mare divizor a
două numere a, b divide și restul împărțirii acestora, r, conform teoremei
împărțirii cu rest.

Algoritmul este:

· Cât timp b != 0: o

Determinăm restul împărțirii lui a la b. o

În continuare a devine b, iar b devine restul calculat.

· Valoarea actuală a lui a este cel mai mare divizor comun a valorilor inițiale.

#include

using namespace std;

int main() { int a, b, r, p;

cin>>a>>b; p=a*b;

while ( b > 0 ) { r = a % b; a = b; b = r; }

cout<<a<<

Observație:

20
1ALGORITMI ELEMENTARI

Pentru a determina cel mai mic multiplu comun a două numere naturale folosim
următoarea teoremă: Produsul a două numere naturale este egal cu produsul
dintre cel mai mare divizor comun al lor și cel mai mic multiplu comun al lor:

n * m = cmmdc * cmmmc

Exemplu

Doi prieteni, un iepure și o broscuță joacă un joc: pornesc de la o linie de start și

încep să sară. Broasca sare n centimetri, iar iepurele m centimetri. Cine este mai
în spate vine la rând să sară. Jocul se termină atunci când iepurele și broasca sunt
iarăși la egalitate. Câți centimetri au parcurs cei doi prieteni?

Săriturile broscuței și iepurelui;

Răspuns:

după cum se vede și din figură, broscuța și iepurele vor sări o lungime egală cu
CMMMC(m, n).

21