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
3using namespace std;
4int n, nrcifre;
5int main()
6{
7    cin >> n;
    nrcifre = 0;
8
    while(n>0)
9    {
10        nrcifre = nrcifre + 1;
11        n = n / 10;
12    }
13    cout << nrcifre;
14    return 0;
15}

Problema 2. Se dau două numere naturale a și b. Să se afișeze pe ecran a b.

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
3using namespace std;
4int a, b, P;
5int main()
6{
7    cin >> a >> b;
8    int i = 1;
    P = 1;
9
    while(i <= b)
10    {
11        P = P * a;
12        i = i + 1;
13    }
14    cout << P;
15    return 0;
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
3using namespace std;
4int a, b, P;
5int main()
6{
7    cin >> a >> b;
8    int i = 1;
    P = 1;
9
    do
10    {
11        P = P * a;
12        i = i + 1;
13    } while(i <= b);
14    cout << P;
15    return 0;
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#include
2using namespace std;
3int n, S;
4int main()
5{
6    cin >> n;
7    S = 0;
    for(int i = 1; i <= n; i++)
8
 9    {
10        S = S + i;
11    }
12    cout << S;
13    return 0;
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