Structura repetitivă „Pentru”

1. Introducere detaliată cu exemple din viața reală

Structura „Pentru” se folosește atunci când știm exact de câte ori trebuie repetată o acțiune. Este diferită de „Cât timp”, unde repetarea depinde de o condiție care poate fi adevărată sau falsă în funcție de date externe.

Citirea paginilor unei cărți:
- Numărul de repetări: total pagini (ex: 100)
- Acțiunea repetată: citești pagina
- La sfârșitul ultimei pagini → bucla se oprește automat

Participarea la ore într-o săptămână (luni–vineri):
- Numărul de repetări: 5 (luni, marți, miercuri, joi, vineri)
- Acțiunea repetată: participi la ore
- Explicație pas cu pas:
  - Luni → participi la ore
  - Întrebare: s-a terminat săptămâna? Nu → treci la marți
  - Marți → participi la ore
  - Întrebare: s-a terminat săptămâna? Nu → treci la miercuri
  - Miercuri → participi la ore
  - Joi → participi la ore
  - Vineri → participi la ore
  - Întrebare finală: s-a terminat săptămâna? Da → bucla se oprește

Spălarea fructelor dintr-un coș:
- Numărul de repetări: total fructe (ex: 5 mere)
- Acțiunea repetată: speli fructul
- La sfârșitul coșului → nu mai speli nimic

Urcatul pe trepte:
- Numărul de repetări: numărul de trepte (ex: 20)
- Acțiunea repetată: urci o treaptă
- După ultima treaptă → bucla se oprește automat

2. Analogie vizuală

Structura „Pentru” poate fi vizualizată ca un contor automat sau un cronometru programat:

Contorul pornește de la o valoare inițială și se modifică pas cu pas până la o valoare finală.
La fiecare „clic” al contorului, se execută instrucțiunile buclei.
Când contorul ajunge la valoarea finală → bucla se oprește automat.

Exemplu: un robot trebuie să ridice 10 cutii. Robotul știe exact câte cutii să ridice și se oprește automat după ultima cutie.

3. Avantajele structurii „Pentru”

Predictibilitate completă – numărul de repetări este cunoscut dinainte.
Control precis asupra fiecărei iterări – putem manipula indexul sau contorul pentru a accesa elemente specifice.
Reducerea riscului de buclă infinită – deoarece contorul ajunge întotdeauna la valoarea finală.
Ideală pentru secvențe numerice și liste – putem calcula sume, produse sau parcurge vectori fără verificări suplimentare.
Flexibilitate limitată, dar sigură – programul este mai predictibil decât cu „Cât timp”, dar mai puțin adaptativ la date externe neprevăzute.
Permite ușor indexarea elementelor – putem face operații pe elementele de la poziția 1 până la poziția n fără calcul suplimentar.

4. Structura formală a buclei „Pentru”

Inițializarea contorului – valoarea de start a variabilei de control (ex: i = 1)
Valoarea finală – până când contorul ajunge la această valoare, bucla continuă
Incrementarea/decrementarea contorului – modificarea contorului la fiecare iterație
Instrucțiunile repetate – ce se execută la fiecare pas
Sfârșitul buclei – marchează punctul unde repetarea încetează

5. Diferențe față de „Cât timp”

Caracteristică	Cât timp	Pentru
Număr de repetări	Necunoscut, depinde de o condiție	Fix, determinat numeric
Condiție de oprire	Expresie logică verificată la fiecare iterație	Contor ajunge la valoarea finală
Riscul buclei infinite	Ridicat dacă condiția nu se schimbă corect	Foarte scăzut, dar poate apărea dacă contorul nu se modifică corect
Flexibilitate	Mare, adaptivă la date externe	Limitată la numărul de repetări prestabilit
Cazuri ideale	Când nu știm câte repetări sunt necesare	Când știm exact câte repetări sunt necesare

6. Observații esențiale

Inițializarea contorului este obligatorie.
Incrementarea/decrementarea contorului trebuie să fie corectă pentru a evita bucle infinite.
Instrucțiunile din buclă trebuie să fie corecte și relevante pentru scopul repetării.
Sfârșitul buclei se marchează clar pentru a delimita zona de repetare.
Se poate combina „Pentru” cu „Dacă/Altfel” pentru logică suplimentară sau operații condiționate.

Exemple

Exemplul 1: Se citește un număr n. Să se afișeze numerele de la 1 la n.

Pseudocod:
Pentru i ← 1,n executa
    Scrie i
Sfârșit pentru

C++:
for(int i = 1; i <= n; i++) {
    cout << i << " ";
}

Exemplul 2: Se citește un număr n. Determinați suma pătratelor numerelor de la 1 la n.

Pseudocod:
s ← 0
Pentru i ← 1,n executa
    s ← s + i*i
Sfârșit pentru
Scrie s

C++:
int s = 0;
for(int i = 1; i <= n; i++) {
    s += i*i;
}
cout << s;

Exemplul 3: Se citește un număr n. Determinați factorialul lui n.

Pseudocod:
p ← 1
Pentru i ← 1,n executa
    p ← p * i
Sfârșit pentru
Scrie p

C++:
int p = 1;
for(int i = 1; i <= n; i++) {
    p *= i;
}
cout << p;

Exemplul 4: Se citește un număr n. Afișați suma numerelor pare de la 1 la n.

Pseudocod:
s ← 0
Pentru i ← 2,n,2 executa
    s ← s + i
Sfârșit pentru
Scrie s

C++:
int s = 0;
for(int i = 2; i <= n; i += 2) {
    s += i;
}
cout << s;

Exerciții propuse 1-40

Se citește un număr natural n. Afișați pătratele numerelor de la 1 la n.
Exemplu: Input: 5 → Output: 1 4 9 16 25
Se citește un număr natural n. Determinați suma numerelor pare de la 1 la n.
Exemplu: Input: 6 → Output: 12
Se citește un număr natural n, apoi n numere întregi. Să se determine suma numerelor pare din cele citite.
Exemplu: Input: 5 2 7 8 3 4 → Output: 14
Se citește un număr natural n, apoi n numere întregi. Să se afișeze câte dintre ele sunt strict pozitive.
Exemplu: Input: n=6 si numerele -3 0 5 9 -2 7 → Output: 3
Se citește un număr natural n. Să se afișeze pătratele numerelor de la 1 la n, în ordine inversă.
Exemplu: Input: 4 → Output: 16 9 4 1
Se citește un număr natural n, apoi n numere naturale. Să se determine câte dintre aceste numere se termină cu cifra 5.
Exemplu: Input: n=4 si numerele 15 25 30 41 → Output: 2
Se citește un număr natural n. Afișați toți divizorii lui n în ordine crescătoare.
Exemplu: Input: 12 → Output: 1 2 3 4 6 12
Se citesc n numere întregi. Determinați suma numerelor negative și a celor pozitive separat.
Exemplu: Input: n=5 si numerele -3 5 -2 4 0 → Output: Suma pozitive: 9, Suma negative: -5
Se citește un număr natural n. Să se afișeze primele n numere impare.
Exemplu: Input: 5 → Output: 1 3 5 7 9
Se citește un număr natural n, apoi n numere întregi. Să se afișeze câte dintre ele sunt pare și câte sunt impare.
Exemplu: Input: n=5 si numerele 2 3 4 5 6 → Output: Numere pare: 3, Numere impare: 2
Se citește un număr natural n. Afișați numerele de la 1 la n care nu conțin cifra 5.
Exemplu: Input: 10 → Output: 1 2 3 4 6 7 8 9 10
Se citește un număr natural n. Afișați suma pătratelor numerelor impare de la 1 la n.
Exemplu: Input: 5 → Output: 35 (1² + 3² + 5²)
Se citesc n numere întregi. Afișați doar numerele care sunt mai mari decât numărul anterior.
Exemplu: Input: n=5 si numerele 3 7 2 5 0 → Output: 7 5
Se citește un număr natural n. Să se afișeze suma primelor n numere naturale.
Exemplu: Input: 5 → Output: 15
Se citește un număr natural n. Să se afișeze toate numerele pare de la 1 la n.
Exemplu: Input: 8 → Output: 2 4 6 8
Se citește un număr natural n. Să se afișeze toate pătratele numerelor de la 1 la n.
Exemplu: Input: 4 → Output: 1 4 9 16
Se citește un număr natural n. Să se afișeze toate cuburile numerelor de la 1 la n.
Exemplu: Input: 3 → Output: 1 8 27
Se citește un număr natural n. Să se afișeze numerele de la n la 1 în ordine descrescătoare.
Exemplu: Input: 5 → Output: 5 4 3 2 1
Se citește un număr natural n. Să se afișeze toate numerele impare de la 1 la n.
Exemplu: Input: 7 → Output: 1 3 5 7
Se citește un număr natural n. Să se afișeze numerele de la 1 la n și suma lor.
Exemplu: Input: 4 → Output: 1 2 3 4, suma: 10
Se citesc n numere naturale. Afișați doar numerele care respectă regula **Fazan**: ultima cifră a unui număr trebuie să fie egală cu prima cifră a numărului următor.
Exemplu: Input: n=9 si numerele 12 23 34 72 216 61953 213 51356 651 → Output: 12 23 72 216 51356
Se citesc n numere naturale. Să se afișeze toate grupurile de 3 numere consecutive care au același număr de cifre distincte diferite de 0.
Exemplu: Input: n=6 si numerele 23 34 122 45 56 789 → Output: 23 34 122, 34 122 45, 122 45 56
Se citește un număr natural n și n numere întregi. Să se determine cel mai lung șir crescător consecutiv din secvența dată.
Exemplu: Input: n=7 si numerele 2 3 5 1 2 3 4 → Output: 4 (secvența 1 2 3 4)
Se citește un număr natural n și apoi n numere întregi. Să se determine suma maximă a oricăror 3 numere consecutive din secvența dată.
Exemplu:
Input: n=6 si numerele 2 5 1 4 3 6 → Output: 13 (grupul 4, 3, 6)
Se citește un număr natural n. Afișați o piramidă dublă (triunghi echilateral cu baza dublă) folosind stele (*).
Exemplu:
Input: 4 → Output:
```
   *
  ***
 *****
*******
  
```
Se citește un număr natural n. Afișați un trapez inversat folosind stele (*), cu baza mare de n stele și fiecare rând deasupra cu 2 stele mai puțin.
Exemplu:
Input: 5 → Output:
```
*****
 ***
  *
  
```
Se citește un număr natural n. Afișați un diamant complet folosind stele (*), format dintr-un romb complet cu 2n-1 rânduri.
Exemplu:
Input: 3 → Output:
```
  *
 ***
*****
 ***
  *
  
```
Se citește un număr natural n. Afișați o stea cu X de dimensiune n × n folosind stele (*).
Exemplu:
Input: 5 → Output:
```
*   *
 * *
  *
 * *
*   *
  
```
Se citește un număr natural n. Afișați o piramidă inversată cu goluri, unde fiecare rând are o stea la început și la sfârșit, restul spații.
Exemplu:
Input: 5 → Output:
```
* * * * *
 *     *
  *   *
   * *
    *
  
```
Se citește un număr natural n. Afișați o piramidă cu linii diagonale, unde stelele formează două diagonale care se întâlnesc în centru.
Exemplu:
Input: 5 → Output:
```
*       *
 *     *
  *   *
   * *
    *
  
```

Se citesc trei numere naturale n1, n2 și n3, care reprezintă înălțimea fiecărui triunghi al bradului. Afișați un brad de Crăciun cu triunghiuri suprapuse de dimensiuni diferite, astfel încât:

Primul triunghi are înălțimea n1
Al doilea triunghi are înălțimea n2 și este mai lat decât primul
Al treilea triunghi are înălțimea n3 și este cel mai lat
Trunchiul este centrat sub ultimul triunghi și are înălțimea 2 rânduri

Fiecare rând trebuie centrat față de baza celui mai mare triunghi. Exemplu: Input: n1=3, n2=4, n3=5 → Output:

       *          <- triunghi 1, rând 1
      ***         <- triunghi 1, rând 2
     *****        <- triunghi 1, rând 3
       *          <- triunghi 2, rând 1
      ***         <- triunghi 2, rând 2
     *****        <- triunghi 2, rând 3
    *******       <- triunghi 2, rând 4
       *          <- triunghi 3, rând 1
      ***         <- triunghi 3, rând 2
     *****        <- triunghi 3, rând 3
    *******       <- triunghi 3, rând 4
   *********      <- triunghi 3, rând 5
       *          <- trunchi rând 1
       *          <- trunchi rând 2

Se citesc două numere naturale: k (numărul de romburi din coloana lui Brâncuși) și n (dimensiunea fiecărui romb, adică înălțimea jumătății superioare a rombului). Afișați coloana infinitului astfel încât fiecare romb să fie centrat față de cel mai mare rând din romb. Exemplu: Input: k=2, n=3 → Output:
```
   *
  ***
 *****
  ***
   *
   *
  ***
 *****
  ***
   *
  
```