Limbaj de programare și pseudocod

Ce este limbajul de programare?

Limbajul de programare este un set de instrucțiuni foarte precise, scrise cu o anumită
sintaxă astfel încât să implementeze un algoritm. Această modalitate de a scrie algoritmul
este „limbajul comun” pe care îl folosesc programatorii și resursele software ale unui
calculator pentru a trimite informații resurselor hardware ale acestuia. Instrucțiunile
scrise în limbajul de programare sunt transformate de compilator în instrucțiuni scrise în
limbaj mașină (limbajul pe care îl înțelege calculatorul) și apoi lansate în execuție.

Ce este pseudocodul?
Limbajul pseudocod este o reprezentare de tip text a algoritmului. Putem spune că
limbajul pseudocod este un fel de intermediar între algoritmul pe care l-am gândit pentru
rezolvarea unei probleme și transpunerea sa în limbaj de programare. Limbajul
pseudocod poate fi scris sub orice formă, de aceea noi vom folosi pentru limbajul
pseudocod cuvintele și expresiile din limba română.
Să rezolvăm problemele din pagina cu schema logică:
Problema 1:
Se citesc de la tastatură două numere întregi. Să se determine suma lor.
Analiza problemei: citim două numere întregi, a și b, de la tastatură, calculăm S, suma lor,
și afișăm pe ecran S.
Acum să transformăm aceste idei în limbaj pseudocod. Vom începe cu cuvântul START
pentru a marca începutul algoritmului. Vom marca sfârșitul algoritmului cu ajutorul
cuvântului STOP.

START
a, b, S – întregi;
citește a și b;
S = a + b;
afișează S;
STOP
Voi exemplifica acum și transpunerea limbajului pseudocod în limbajul de programare
C++. Nu trebuie să ne facem griji, vom înțelege puțin mai târziu ce înseamnă liniile de mai
jos.

#include
using namespace std;
int a, b, S;
int main()
{
cin >> a >> b;
S = a + b;
cout << S;
return 0;
}
Aceasta a fost doar o demonstrație, mai multe despre transpunerea algoritmilor în C++
vom discuta în lecțiile viitoare.
Problema 2:
Să se afișeze maximul a două numere întregi.
Analiza problemei: Se citesc două numere întregi, x și y, de la tastatură, dacă a >= b,
atunci maxim = a, altfel maxim = b, afișează maxim pe ecran.
Pseudocod:
START
x, y, maxim – întregi;
citește x și y;
Dacă a >= b atunci
maxim = a;
Altfel
maxim = b;
afișează maxim;
STOP
Problema 3:
Să se rezolve ecuația de gradul I (a*x+b=0).
Analiza problemei: Se citesc două numere întregi, a și b, de la tastatură. Dacă a <>
(diferit) 0, atunci x = -b/a, afișează x, altfel datele nu corespund problemei și afișează
„Eroare!”.
Pseudocod:
START
a, b – întregi;
x – real;
citește a și b;
Dacă a <> 0 atunci
x = -b / a;
afișează x;
Altfel
afișează „Eroare!”
STOP
Introducere în C++ >>
<< Probleme rezolvate

Introducere în C++
Ce este C++?
C++ este un limbaj de programare. C++ este limbajul de programare în care vom transcrie
algoritmii de rezolvare a problemelor pe care le vom studia în continuare. Trebuie să știm
că C++, la fel ca și alte limbaje de programare, are o sintaxă specifică prin care putem să
transmitem instrucțiunile pe are dorim să le execute calculatorul. Limbajul C++ are o serie
de cuvinte rezervate, cuvinte pe care nu le putem folosi în alt sens decât cel reglementat
de C++. Unul dintre aceste cuvinte este main. Cuvântul main este rezervat pentru funcția
principală a unui program C++, fără de care programul nu poate funcționa.
Să luăm un exemplu de program scris în limbajul C++:
#include
using namespace std;
int main()
{
cout << „Bună ziua!”;
return 0;
}
Pentru ca acest program să poată fi executat este necesar în primul rând să avem instalat
pe calculator un compilator. Vă recomand să instalați Code::Blocks (instrucțiuni pentru
instalare găsiți aici). După ce am reușit să creăm un proiect vom vedea în partea stângă
un panou. Căutăm tab-ul Projects unde vom găsi proiectul pe care tocmai l-am creat. În
proiectul nostru, în folder-ul Sources găsim un fișier care se numește main.cpp. Dăm
dublu-click pe acesta și vom vedea conținutul lui în fereastra din dreapta (spațiul de
lucru). Înlocuim codul cu cel pe care l-am scris mai sus și dăm click pe Build and Run (sau
apăsăm F9 de la tastatură). Rezultatul codului va apărea într-o fereastră neagră și… da, ați
ghicit! Scrie pe ecran textul „Bună ziua!”.
Acum, hai să înțelegem câteva dintre liniile de cod ale programului:

 #include este o directivă care îi spune compilatorului să introducă în programul nostru

toate liniile de cod din fișierul specificat (iostream). Vom scrie câte o directivă #include
pentru fiecare fișier pe care vrem să îl includem în proiectul nostru.

 este numele fișierului pe care vrem să îl includem în proiectul nostru. Acest fișier este,
de fapt, o bibliotecă unde putem să găsim scrierea explicită a unor funcții de care avem
nevoie în cadrul proiectului. include, printre altele, definiția lui cout și cin.

 using namespace std; indică programului unde să caute domeniul de valabilitate

pentru anumite „funcții” cum ar fi cout, cin, endl, și altele. Observație: trebuie
obligatoriu să includem și să folosim using namespace std; pentru ca operațiile cin și
cout să funcționeze.
Notă: Nu vă faceți griji dacă nu înțelegeți prea bine ce fac acestea, trebuie să știți doar că
sunt obligatorii atunci când folosiți cout sau cin.
 int (de la int main) specifică prototipul funcției main (este obligatoriu să îl scriem, de
înțeles veți înțelege mai târziu)

 după main punem obligatoriu ()

 funcția main va conține un set mai mult sau mai puțin amplu de instrucțiuni, iar orice
set de instrucțiuni trebuie inclus între acolade. Așadar, după () vom deschide o acoladă
(„{„), iar la sfârșit, după ce am scris ultima instrucțiune din funcția main vom închide
acolada („}”)

 cout este operația pe care o vom folosi pentru afișarea datelor pe ecran. cout se
folosește întotdeauna împreună cu semnul <<.

 cin este operația pe care o vom folosi pentru citirea datelor de la tastatură. cin se
folosește întotdeauna împreună cu semnul >>.

 return 0 este obligatoriu să fie scrisă ca ultimă instrucțiune din funcția main, vom
învăța mai târziu ce face acesta.

 Observați că unele dintre rânduri se termină cu semnul punct și virgulă ( ; ). Vom folosi
acest semn la sfârșitul oricărui rând. Totuși, sunt câteva excepții, astfel că nu vom folosi
semnul ; în următoarele cazuri:

o după directiva #include

o înainte și după acoladă deschisă ( { )

o după acoladă închisă ( { ).

Cuvintele using, namespace, int, main, cout, return sunt cuvinte rezervate în limbajul
C++ și nu pot fi folosite în alte scopuri decât cele specificate în cadrul limbajului.

Tipuri de date și Variabile

Tipuri de date
Orice program preia, prelucrează și furnizează date. Pentru a putea crea programe care
să prelucreze eficient date trebuie să știm care sunt, de fapt, tipurile de date cu care putem
să lucrăm. Voi încerca să prezint mai jos câteva din tipurile de date folosite frecvent în
C++:
 Char – cuvântul char este o prescurtare de la character, care înseamnă caracter. Astfel,
datele de tip char pot să conțină un caracter (literă, cifră, altfel de caracter)

 String – reprezintă o înșiruire de caractere, grupate într-o singură entitate.

 Int – int este o prescurtare de la integer și reprezintă un număr întreg cuprins între –
2,147,483,648 și 2,147,483,647. Putem să spune că tipul int cuprinde valori din
intervalul aproximativ -2*109 și aproximativ 2*109. Tipul int poate fi modificat cu
ajutorul următorilor termeni:

o short (sau short int) – reprezintă un număr întreg cuprins între –32,768 și 32,767

o long (sau long int) – odată cu crearea arhitecturilor de procesoare pe 32 biți int a
ajuns la aceleași valori cu long int

o long long – reprezintă un număr întreg cuprins între –

9,223,372,036,854,775,808 și –9,223,372,036,854,775,807

o unsigned – elimină valorile negative și dublează valorile pozitive (ex: unsinged

short: 0 – 65,535, unsigned int: 0 – 4,294,967,295, long long: 0
– 18,446,744,073,709,551,615)

 Boolean – este un tip de date care conține doar două valori: true (adevărat) sau false
(fals).
Vom folosi pentru început tipurile de date de tip întreg (în special int și long long). De
asemenea, trebuie să amintesc aici și tipurile de date de tip real: float și double, dar despre
acestea vom vorbi după ce vom ajunge și la matematică la nivelul acesta de cunoștințe.

Variabile
Ca să putem să înțelegem ce este o variabilă, să luăm următorul exemplu de la matematică:
x + 3 = 0.
Vom face calculul și vom ajunge la concluzia că x = -3. Așadar necunoscuta x va avea
valoarea -3. În cazul de față, necunoscuta x este o variabilă. Să mergem mai departe și să
scriem forma generală a unei ecuații de gradul 1: a * x + b = 0.
În acest caz, atât x, cât și a și b sunt variabile, deoarece fiecare dintre ele pot lua alte valori
la un exercițiu diferit.
O variabilă poate să aibă orice nume dacă respectă următoarele reguli:
 numele va conține doar litere, cifre și semnul _

 numele unei variabile începe cu o literă

 variabila nu poate să aibă ca nume un cuvânt rezervat

O variabilă poate primi o valoare prin citire de la tastatură, citire din fișier sau atribuire.

Să luăm ca exemplu următoarea problemă: Se citesc de la tastatură numerele întregi a și

b. Să se calculeze S, suma lor, și să se afișeze pe ecran.

Identificăm în cadrul problemei 3 variabile de tip întreg: a, b și S. Variabilele a și b vor

primi o valoare prin citire de la tastatură, iar variabilei S i se va atribui valoarea rezultată
din adunarea a + b. Rezolvarea completă a acestei probleme o găsiți aici.

Operatori în C++
Cu cât înaintăm în elaborarea algoritmilor pentru rezolvarea unor probleme observăm că
avem nevoie să folosim anumiți operatori pentru evaluarea unor expresii. De exemplu, în
rezolvarea Problemei 1 de aici am folosit expresia S = a + b; Putem observa că în această
expresie găsim doi operatori:
= este operatorul de atribuire.
+ este operatorul aritmetic de adunare.
Prin urmare, expresia S = a + b se traduce astfel: Variabilei S i se atribuie rezultatul
adunării a + b.
Pe lângă operatorul de atribuire ( = ) avem și următorii operatori în C++:

 Operatori aritmetici

o + (adunare)

o – (scădere)

o * (înmulțire)

o / (împărțire)

o / (câtul împărțirii a două numere întregi)

o % (restul împărțirii a două numere întregi)

 Operatori relaționali

o < (mai mic)

o > (mai mare)

o <= (mai mic sau egal)

o >= (mai mare sau egal)

o == (egal)

o != (diferit)

 Operatori logici

o ! (negație sau NOT)

o && (ȘI logic sau AND)

o || (SAU logic sau OR)

Pentru a înțelege cum se evaluează expresiile cu operatori logici trebuie să înțelegem
următoarele tabele:

ȘI true false

true true false

false false false

Explicație: Două propoziții legate prin ȘI logic ( && ) vor da o valoare adevărat dacă și
numai dacă ambele propoziții sunt adevărate.
SAU true false

true true true

false true false

Explicație: Două propoziții legate prin SAU logic ( || )vor da o valoare adevărat dacă cel
puțin una din cele două propoziții este adevărată.
Valoare true false
 NOT false true

Explicație: Operatorul de negare ( ! ) inversează valoarea de adevăr a propoziției negate.

Exemple:
Fie a = 4, b = 5, c = 6.
(a < b) && (b < c) = TRUE (a < b = TRUE, b < c = TRUE, TRUE && TRUE = TRUE)
(b < a) || (b < c) = TRUE (b < a = FALSE, b < c = TRUE, FALSE || TRUE = TRUE)
!(b < c) = FALSE (b < c = TRUE, !TRUE = FALSE)
La fel ca și la matematică, și în programare trebuie să ținem cont de ordinea efectuării
operațiilor. Pentru aceasta voi scrie mai jos operațiile în ordinea descrescătoare a
priorității:

1. Negația logică ( ! )

2. Operatori aritmetici multiplicativi ( * , / , % )

3. Operatori aritmetici aditivi ( + , – )

4. Operatori relaționali

5. ȘI logic ( && )

6. SAU logic ( || )
IMPORTANT: În programare parantezele pătrate și acoladele au un rol specific, astfel că
acestea nu pot fi folosite în expresii matematice. Voi scrie o expresie matematică în două
moduri:

 matematic: {5x[4×3+2x(7+9)]}

 informatic: (5*(4*3+2*(7+9)))
Așadar, atenție la închiderea parantezelor!

Structura alternativă
În programare există trei tipuri de structuri de control cu ajutorul cărora putem construi
orice algoritm:

 structura secvențială (liniară)

 structura alternativă (decizională)

 structura repetitivă
Structura secvențială este compusă dintr-un set de instrucțiuni care se execută în
ordinea scrierii lor.
Exemplu:
Se citesc două numere întregi de la tastatură. Să se scrie un program care afișează pe ecran
suma lor.

D.I.: a, b – întregi
D.O.: S – întreg
Algoritm:
START
citește a, b;
S <- a + b;
scrie S;
STOP
Program:
1
2 #include <iostream>
using namespace std;
3 int a, b, S;
4 int main()
5 {
6 cin >> a >> b;
7 S = a + b;
cout << S;
8 return 0;
9 }
10

Structura alternativă (decizională) execută un anumit set de instrucțiuni dacă o

condiție este îndeplinită, altfel execută alt set de instrucțiuni. Forma generală a unei
structuri alternative este:
Dacă (condiție) atunci
execută …
Altfel
execută …
Condiția va returna întotdeauna un rezultat de tip boolean (TRUE sau FALSE). Să
rezolvăm câteva probleme cu ajutorul structurii decizionale.

În C++ structura decizională (alternativă) este if.

If (condiție)
{
…
}
else
{
…
}
Acoladele marchează începutul și sfârșitul unui bloc de instrucțiuni. Acestea pot fi omise
dac blocul de instrucțiuni conține o singură instrucțiune.

Problema 1. Să se scrie un program care citeşte de la tastatură un număr natural şi

verifică dacă numărul este par sau impar.
D.I.: a – întreg;

Algoritm:
START
citește a;
Dacă (a mod 2 = 0) atunci
scrie „par”;
Altfel
scrie „impar”;
STOP
Explicație: Dacă restul împărțirii numărului la 2 este 0, atunci numărul este par, altfel este
impar.
Program:
1 #include <iostream>
using namespace std;
2 int a;
3 int main()
4 {
5 cin >> a;
6 if (a % 2 == 0)
cout << "par";
7 else
8 cout << "impar";
9 return 0;
10 }
11
12

Problema 2. Să se scrie un program care determină maximul a două numere întregi citite
de la tastatură.
D.I.: a, b – întregi
D.O.: maxim – întreg
Algoritm:
START
citește a, b;
Dacă (a > b) atunci
maxim = a;
Altfel
maxim = b;
scrie maxim;
STOP
Program:
1
2 #include <iostream>
3 using namespace std;
4 int a, b, maxim;
int main()
5 {
6 cin >> a >> b;
7 if (a > b)
8 maxim = a;
else
9 maxim = b;
10 cout << maxim;
11 return 0;
12 }
13

Problema 3. Determinați câte sticle de x litri cu apă trebuie deschise pentru a umple un
vas de y litri.
Raționament: Dacă y se împarte exact la x, atunci avem nevoie de y/x sticle, altfel avem
nevoie de y/x+1 sticle.
D.I.: x, y – întregi
D.O.: nrsticle – întreg
Algoritm:
START
citește x, y;
Dacă (x mod y = 0) atunci
nrsticle = y / x;
Altfel
nrsticle = y / x + 1;
scrie nrsticle;
STOP
Program:
1
2 #include <iostream>
3 using namespace std;
int x, y, nrsticle;
4 int main()
5 {
6 cin >> x >> y;
7 if(y % x == 0)
8 nrsticle = y / x;
else
9 nrsticle = y / x + 1;
10 return 0;
11 }
12

Structura alternativă – continuare

Structura alternativă – condiții compuse. Condiția unei structuri alternative poate fi
compusă din două sau mai multe condiții alăturate prin operatorii ȘI logic și SAU logic.
Rezultatele condițiilor compuse cu ȘI logic și SAU logic se pot revedea în tabelele de aici.
Să vedem cum se rezolvă probleme cu condiții compuse:
Problema 1. Se dau trei numere naturale a, b și x. Să se verifice dacă numărul x aparține
intervalului [a, b].
Raționament: Dacă a <= x și x <= b atunci afișează DA, altfel afișează NU.
D.I.: a, b, x – întregi

Algoritm:
START
citește a, b, x;
Dacă (a <= x ȘI x <= b) atunci
scrie „DA”;
Altfel
scrie „NU”;
STOP
Program:
1
#include <iostream>
2 using namespace std;
3 int a, b, x;
4 int main()
5 {
6 cin >> a >> b >> x;
7 if(a <= x && x <= b)
8 cout << "DA";
9 else
cout << "NU";
10
return 0;
11 }
12

Este foarte important să ținem cont de ordinea efectuării operațiilor (detalii aici), iar dacă
anumite operații nu se efectuează în ordinea în care dorim să folosim parantezele (doar
paranteze rotunde).
Problema 2. Se citesc de la tastatură două numere întregi, a și b. Să se afișeze pe ecran
semnul produsului celor două numere.
Raționament: Dacă a < 0 sau b < 0 atunci afișează -, altfel afișează +.
D.I.: a, b – întregi

Algoritm:
START
citește a, b;
Dacă (a < 0 SAU b < 0) atunci
scrie „-„;
Altfel
scrie „+”;
STOP
Program:
1
#include <iostream>
2 using namespace std;
3 int a, b;
4 int main()
5 {
6 cin >> a >> b;
7 if(a < 0 || b < 0)
8 cout << "-";
9 else
cout << "+";
10
return 0;
11 }
12

Structura alternativă compusă. O structură alternativă compusă este o structură

alternativă care are măcar pe una din cele două ramuri o altă structură alternativă.
O formă de structură alternativă compusă poate fi:

Dacă (condiție) atunci

Dacă (condiție) atunci
execută …
Altfel
execută …
Altfel
Dacă (condiție) atunci
execută …
Altfel
execută …

Problemă. Se citesc de la tastatură 3 numere naturale (x, y, z). Să se afișeze pe ecran cel
mai mare dintre acestea.
Raționament: Comparăm pe x cu y. Apoi pe cel mai mare dintre x și y îl comparăm cu z.
D.I. : x, y, z – întregi

D.O. : maxim – întreg

Algoritm:
START
citește x, y, z;
Dacă (x > y) atunci
Dacă (x > z) atunci
maxim = x;
Altfel
maxim = z;
Altfel
Dacă (y > z) atunci
maxim = y;
Altfel
maxim = z;
scrie maxim;
STOP
1
2
#include <iostream>
3 using namespace std;
4 int x, y, z, maxim;
5 int main()
6 {
7 cin >> x >> y >> z;
8 if(x > y) // dacă x este mai mare decât y
9 {
10 if(x > z) // dacă x este mai mare și decât z
{
11
maxim = x;
12 }
13 else // dacă z este mai mare decât x
14 // (care este mai mare decât y)
15 {
16 maxim = z;
17 }
18 }
else if(y > z) // dacă y este mai mare decât x și
19
// dacă y este mai mare și decât z
20
{
21 maxim = y;
22 }
23 else // dacă z este mai mare decât y
24 // (care este mai mare decât x)
25 {
26 maxim = z;
27 }
cout << maxim;
28
return 0;
29 }
30
31
Structura repetitivă >>
<< Structura alternativă

Structura repetitivă
Structura repetitivă este un set de instrucțiuni care se repetă până când o condiție nu
mai este îndeplinită. Structura repetitivă poate fi:

1. Structură repetitivă cu test inițial

2. Structură repetitivă cu test final

3. Structură repetitivă cu un număr cunoscut de pași (sau structura repetitivă cu contor)

Structura repetitivă cu test inițial are specificul de a verifica o condiție înainte de a
executa primul ciclu de instrucțiuni. Forma generală a structurii repetitive cu test inițial
este:
Cât timp (condiție)
execută …
În C++ structura repetitivă cu test inițial este structura while:
while (condiție)
{
…
}
Problema 1. Se dă un număr natural n. Să se determine numărul de cifre ale acestuia.
Raționament: Cât timp n este mai mare decât 0 creștem numărul de cifre și îl împărțim pe n
la 10.
D.I. : n – întreg;
D.O. : nrcifre – întreg;
Algoritm:
START
citește n;
nrcifre = 0;
câttimp (n > 0)
nrcifre = nrcifre + 1;
n = n / 10;
sfârșit câttimp;
scrie nrcifre;
STOP
Program:
1
2 #include
3 using namespace std;
4 int n, nrcifre;
int main()
5
{
6 cin >> n;
7 nrcifre = 0;
8 while(n>0)
9 {
nrcifre = nrcifre + 1;
10 n = n / 10;
11 }
12 cout << nrcifre;
13 return 0;
14 }
15

Problema 2. Se dau două numere naturale a și b. Să se afișeze pe ecran ab. Restricții:

0<a<10, 0<b<10.
Raționament: ab = a * a * …* a (de b ori). Pentru fiecare i <= b avem P = P * a.
D.I. : a, b – întregi;

D.O. : P – întreg;

Algoritm:
START
citește a, b;
i = 1;
P = 1;
câttimp (i <= b)
P = P * a;
i = i + 1;
scrie P;
STOP
Program:
1
2 #include
3 using namespace std;
4 int a, b, P;
5 int main()
{
6 cin >> a >> b;
7 int i = 1;
8 P = 1;
9 while(i <= b)
10 {
P = P * a;
11 i = i + 1;
12 }
13 cout << P;
14 return 0;
}
15
16

Structura repetitivă cu test final execută o dată setul de instrucțiuni din cadrul
structurii, apoi verifică validitatea condiției. Putem să spunem că structura repetitivă cu
test final este invers decât structura repetitivă cu test inițial.
Forma generală a structurii cu test final:

execută …
câttimp (condiție)
În C++ structura repetitivă cu test final este structura do… while:
do
{
…
} while (condiție)
Să rezolvăm problema anterioară și cu această structură.

Algoritm:

START
citește a, b;
i = 1;
P = 1;
execută
P = P * a;
i = i + 1;
câttimp (i <= b)
scrie P;
STOP
Program:
1
2 #include
3 using namespace std;
4 int a, b, P;
5 int main()
{
6 cin >> a >> b;
7 int i = 1;
8 P = 1;
9 do
10 {
P = P * a;
11 i = i + 1;
12 } while(i <= b);
13 cout << P;
14 return 0;
}
15
16

Structură repetitivă cu un număr cunoscut de pași (sau structura repetitivă cu contor)

execută un set de instrucțiuni de un număr fix de ori. De exemplu, pentru aflarea
numărului de cifre ale unui număr nu cunoaștem numărul de pași, însă pentru suma
primelor n numere naturale se cunosc numărul de pași: n. O structură repetitivă cu număr
cunoscut de pași are nevoie de 3 parametri: variabila contor (de obicei se folosește i, iar
la nevoie se folosesc și j, k și l), condiția de încheiere a buclei și pasul de incrementare sau
decrementare a variabilei contor.
Forma generală a unei structuri cu număr cunoscut de pași:

pentru i <- a, n, x
execută …
a – valoarea inițială a variabilei contor i
n – valoarea finală a variabilei contor i
x – pasul de incrementare al variabilei i
În C++ structura cu număr cunoscut de pași este structura for:
for(int i = a; i <= n; i++)
{
…
}
Problemă. Se citește de la tastatură un număr natural n. Să se afișeze pe ecran suma
primelor n numere naturale.
Raționament: Pentru fiecare i <= n se adaugă la sumă al i-lea număr natural.
D.I. : n – întreg;
D.O. : S – întreg;
Algoritm:
START
citește n;
S = 0;
pentru i<-1, n, 1
S = S + i;
scrie S;
STOP
Program:
1
2 #include
3 using namespace std;
4 int n, S;
int main()
5 {
6 cin >> n;
7 S = 0;
8 for(int i = 1; i <= n; i++)
9 {
S = S + i;
10 }
11 cout << S;
12 return 0;
13 }
14

Temă: Se citește n de la tastatură. Să se determine produsul primelor n numere naturale.

Restricție: n <= 15. Să se rezolve problema în trei moduri (câte un mod pentru fiecare
structură repetitivă învățată).
Observație: pentru n = 15, P > int… Așadar P trebuie să fie de tipul long long int.
>>
<< Structura alternativă – continuare
Structura repetitivă
Structura repetitivă este un set de instrucțiuni care se repetă până când o condiție nu
mai este îndeplinită. Structura repetitivă poate fi:

1. Structură repetitivă cu test inițial

2. Structură repetitivă cu test final

3. Structură repetitivă cu un număr cunoscut de pași (sau structura repetitivă cu contor)

Structura repetitivă cu test inițial are specificul de a verifica o condiție înainte de a
executa primul ciclu de instrucțiuni. Forma generală a structurii repetitive cu test inițial
este:
Cât timp (condiție)
execută …
În C++ structura repetitivă cu test inițial este structura while:
while (condiție)
{
…
}
Problema 1. Se dă un număr natural n. Să se determine numărul de cifre ale acestuia.
Raționament: Cât timp n este mai mare decât 0 creștem numărul de cifre și îl împărțim pe n
la 10.
D.I. : n – întreg;
D.O. : nrcifre – întreg;
Algoritm:
START
citește n;
nrcifre = 0;
câttimp (n > 0)
nrcifre = nrcifre + 1;
n = n / 10;
sfârșit câttimp;
scrie nrcifre;
STOP
Program:
1
2 #include
3 using namespace std;
4 int n, nrcifre;
5 int main()
{
6 cin >> n;
7 nrcifre = 0;
8 while(n>0)
9 {
nrcifre = nrcifre + 1;
10 n = n / 10;
11 }
12 cout << nrcifre;
13 return 0;
14 }
15

Problema 2. Se dau două numere naturale a și b. Să se afișeze pe ecran ab. Restricții:

0<a<10, 0<b<10.
Raționament: ab = a * a * …* a (de b ori). Pentru fiecare i <= b avem P = P * a.
D.I. : a, b – întregi;

D.O. : P – întreg;

Algoritm:
START
citește a, b;
i = 1;
P = 1;
câttimp (i <= b)
P = P * a;
i = i + 1;
scrie P;
STOP
Program:
1 #include
using namespace std;
2 int a, b, P;
3 int main()
4 {
5 cin >> a >> b;
6 int i = 1;
P = 1;
7 while(i <= b)
8 {
9 P = P * a;
10 i = i + 1;
}
11 cout << P;
12 return 0;
13 }
14
15
16

Structura repetitivă cu test final execută o dată setul de instrucțiuni din cadrul
structurii, apoi verifică validitatea condiției. Putem să spunem că structura repetitivă cu
test final este invers decât structura repetitivă cu test inițial.
Forma generală a structurii cu test final:

execută …
câttimp (condiție)
În C++ structura repetitivă cu test final este structura do… while:
do
{
…
} while (condiție)
Să rezolvăm problema anterioară și cu această structură.

Algoritm:

START
citește a, b;
i = 1;
P = 1;
execută
P = P * a;
i = i + 1;
câttimp (i <= b)
scrie P;
STOP
Program:
1
2 #include
3 using namespace std;
4 int a, b, P;
5 int main()
{
6 cin >> a >> b;
7 int i = 1;
8 P = 1;
9 do
10 {
P = P * a;
11 i = i + 1;
12 } while(i <= b);
13 cout << P;
14 return 0;
}
15
16

Structură repetitivă cu un număr cunoscut de pași (sau structura repetitivă cu contor)

execută un set de instrucțiuni de un număr fix de ori. De exemplu, pentru aflarea
numărului de cifre ale unui număr nu cunoaștem numărul de pași, însă pentru suma
primelor n numere naturale se cunosc numărul de pași: n. O structură repetitivă cu număr
cunoscut de pași are nevoie de 3 parametri: variabila contor (de obicei se folosește i, iar
la nevoie se folosesc și j, k și l), condiția de încheiere a buclei și pasul de incrementare sau
decrementare a variabilei contor.
Forma generală a unei structuri cu număr cunoscut de pași:

pentru i <- a, n, x
execută …
a – valoarea inițială a variabilei contor i
n – valoarea finală a variabilei contor i
x – pasul de incrementare al variabilei i
În C++ structura cu număr cunoscut de pași este structura for:
for(int i = a; i <= n; i++)
{
…
}
Problemă. Se citește de la tastatură un număr natural n. Să se afișeze pe ecran suma
primelor n numere naturale.
Raționament: Pentru fiecare i <= n se adaugă la sumă al i-lea număr natural.
D.I. : n – întreg;
D.O. : S – întreg;
Algoritm:
START
citește n;
S = 0;
pentru i<-1, n, 1
S = S + i;
scrie S;
STOP
Program:
1
2 #include
3 using namespace std;
4 int n, S;
int main()
5 {
6 cin >> n;
7 S = 0;
8 for(int i = 1; i <= n; i++)
9 {
S = S + i;
10 }
11 cout << S;
12 return 0;
13 }
14

Temă: Se citește n de la tastatură. Să se determine produsul primelor n numere naturale.

Restricție: n <= 15. Să se rezolve problema în trei moduri (câte un mod pentru fiecare
structură repetitivă învățată).
Observație: pentru n = 15, P > int… Așadar P trebuie să fie de tipul long long int.
>>
<< Structura alternativă – continuare
 • Vom folosi doua tipuri de propozitii pseudocod:
1.Propozitii standard, fiecare avand sintaxa si semantica sa;
2.Propozitii nestandard (texte care descriu parti ale algoritmului inca
incomplet elaborate). Aceste propozitii convenim sa inceapa cu semnul ’@’.

• Comentariile vor fi cuprinse intre acolade.

• Citirea datelor se face folosind propozitia standard: citeste lista

• Tiparirea rezultatelor se face folosind propozitia standard: tipareste lista

• Atribuirea se va simboliza prin ←

• Instructiunea alternativa va avea forma:

Daca expresie logica atunci
instructiuni
altfel
instructiuni
SfDaca
unde sectiunea altfel poate lipsi.

• Structura repetitiva cu numar cunoscut de pasi:

Pentru contor = li, lf, pas executa
instructiuni
SfPentru
unde contorul ia valori de la valoarea initiala li, la valoarea finala lf,
la fiecare pas adaugandu-se valoarea pas. Pasul poate lipsi fiind implicit egal cu 1.

• Structura repetitiva cu numar necunoscut de pasi conditionata anterior (test

initial):
CatTimp expresie logica executa
instructiuni
SfCatTimp

• Structura repetitiva cu numar necunoscut de pasi conditionata posterior (test

final):
Repeta
instructiuni
PanaCand expresie logica

• Definirea unui subalgoritm se va face folosind propozitia standard:

Subalgoritm nume(...)
instructiuni
SfSubalgoritm

• Definirea unei functii se va face folosind propozitia standard:

Functia nume(...)
instructiuni
 SfFunctia

• Pentru a specifica rezultatul intors de o functie vom folosi numele functiei.

Exemplu:
Functia minim(a, b)
min ← a;
Daca a < b atunci
min ← b;
SfDaca
minim ← min;
SfFunctia

• Apelul unei proceduri se face folosind:

nume(< lista parametri actuali >)

• Apelul unei functii se face scriind intr-o expresie numele functiei urmat de
lista parametrilor actuali.
(ex: m ← minim(2, 3))

Limbajul Pseudocod a fost conceput pentru descrierea algoritmilor.

Limbajul Pseudocod are două tipuri de propoziţii:

 standard (care au o structură fixă şi este formată cu ajutorul unor cuvinte

cheie),
 propoziţii nestandard (care descriu părţi ale algoritmului încă incomplet
elaborate, nefinisate, asupra cărora urmează să se revină)
 comentarii (texte scrise între acolade utilizate pentru documentarea
algoritmului).

Propoziţiile limbajului Pseudocod se vor executa în ordinea întâlnirii lor în text,

asemenea oricărui text al limbii române.

În descrierea algoritmilor se recomandă o scriere structurată prin utilizarea

următoarelor structuri :

 secvenţială (formată dintr-o succesiune de propoziţii simple),

 alternativă (permite executarea anumitor ramuri în funcţie de anumite
condiţii)
 repetitivă (prin care putem execută aceleaşi propoziţii de mai multe ori).
  1) Factorialul unui numar n n!=1*2*3*...*n folosind structura repetitiva
conditionata anterior.
 Rezolvare
 2) Factorialul unui numar n (n!=1*2*3*...*n) folosind structura repetitiva
conditionata posterior.
 Rezolvare
 3) Media aritmetica a n numere ma=(n1+n2+...nn)/n.
 Rezolvare
 4) Sa se verifice daca un numar n diferit de 0 sau 1 este prim sau nu.
 Rezolvare
 5) Sa se calculeze CMMDC pentru doua numere
prin impartiri repetate (algoritmul lui Euclid).
 Rezolvare
 6) Sa se afle daca un numar este perfect.
Un numar este perfect daca este egal cu suma divizorilor sai, inclusiv 1, dar fara el
insusi.
Exemplu: 6=1+2+3 este numar perfect.
 Rezolvare
 7) Sa se afle cifra maxima a unui numar (cea mai mare cifra a unui numar).
 Rezolvare