Pagina Principală
Ora 6

Structuri Repetitive: Noțiuni Fundamentale

Introducere în bucle - elemente comune, tipuri și aplicații de bază

40min teorie + 15min probleme PBInfo
Competența 3.2
Sigla liceului
TEORIE - 40 minute

Ce vei învăța astăzi?

După această lecție, vei înțelege conceptul de structură repetitivă, vei ști să recunoști toate tipurile de bucle și vei putea identifica elementele comune ale oricărei structuri repetitive.

Ce este o structură repetitivă și de ce este necesară
Cele 3 tipuri fundamentale de bucle
Elementele comune ale oricărei bucle
Probleme simple ce necesită repetiții

Ce este o Structură Repetitivă?

Definiție: O structură repetitivă (buclă sau ciclu) este o structură de control care permite executarea repetată a unui set de instrucțiuni, fie pentru un număr cunoscut de ori, fie atâta timp cât o anumită condiție este îndeplinită.

Analogie: Exercițiile fizice zilnice

Gândește-te la o buclă ca la exercițiile fizice zilnice:

CONDIȚIA

Mai sunt repetări de făcut?

Verificare la fiecare exercițiu
ACȚIUNEA

Execută o repetare

Instrucțiunea care se repetă
CONTORUL

Numără repetările făcute

Urmărește progresul

De ce avem nevoie de bucle?

Problema: Afișează numerele de la 1 la 10

Cerință: Scrieți un algoritm care afișează pe ecran numerele de la 1 la 10, fiecare pe linie separată.

Fără buclă ar fi: 10 linii de cod scrise manual!

citește n (n = 10) scrie 1 scrie 2 scrie 3 scrie 4 scrie 5 scrie 6 scrie 7 scrie 8 scrie 9 scrie 10

Probleme majore:

  • 10 linii de cod identice!
  • Dacă vrem 1-100, ar fi 100 de linii
  • Ușor de greșit (uiti vreun număr)
  • Cod greu de modificat
citește n (n = 10) i ← 1 ┌ cât timp i ≤ n execută │ scrie i │ i ← i + 1 └■

Avantaje enorme:

  • Doar 6 linii de cod!
  • Funcționează pentru orice n (1-10, 1-100, 1-1000)
  • Ușor de modificat (schimbi doar valoarea lui n)
  • Mult mai puține erori
Cod mai scurt

Reduci sute de linii la câteva linii

Flexibilitate

Funcționează pentru orice valoare de intrare

Fiabilitate

Mai puține locuri unde poți face greșeli

Întreținere ușoară

Modifici într-un singur loc, funcționează peste tot

Tipurile Fundamentale de Structuri Repetitive

1. Cu Număr CUNOSCUT de Pași

Caracteristică: Știm exact de câte ori trebuie să se repete bucla.

Exemple practice:
  • Afișează numerele de la 1 la 10
  • Calculează suma primelor 20 de numere
  • Generează 5 numere aleatoare

Cum implementăm: instrucțiunea pentru (for)

2. Cu Număr NECUNOSCUT de Pași
(test la început)

Caracteristică: Mai întâi verifică dacă se poate executa, apoi execută.

Exemple practice:
  • Citește numere până la 0
  • Calculează până la o precizie dorită
  • Verifică până găsește răspunsul corect

Cum implementăm: instrucțiunea cât timp (while)

3. Cu Număr NECUNOSCUT de Pași
(test la sfârșit)

Caracteristică: Execută cel puțin o dată, apoi verifică dacă mai continuă.

Exemple practice:
  • Meniu interactiv (afișează, apoi întreabă)
  • Jocuri (joacă o rundă, apoi întreabă)
  • Validări (cere input, apoi verifică)

Cum implementăm: instrucțiunea repetă...până când (do...while)

Exercițiu simplu: Care tip de buclă?

Pentru fiecare situație, gândește-te ce tip de buclă ai folosi:

"Calculează suma primelor 20 de numere naturale"
Știm exact 20 de iterații → NUMĂR CUNOSCUT
"Citește numere până când utilizatorul introduce 0"
Nu știm câte numere va introduce → NUMĂR NECUNOSCUT (test la început)
"Afișează un meniu, apoi întreabă dacă vrei să continui"
Trebuie să afișezi meniul cel puțin o dată → NUMĂR NECUNOSCUT (test la sfârșit)

Elementele Esențiale ale Orice Bucle

1. INIȚIALIZARE

Pregătim variabilele înainte de buclă

i ← 1 ← începem de la 1
suma ← 0 ← pregătim suma
↓

2. CONDIȚIE

Verifică dacă mai continuăm

i ≤ 10 ← mai sunt numere?
suma < 100 ← am atins limita?
↓

3. CORP BUCLĂ

Instrucțiunile care se execută DE FIECARE DATĂ

scrie "Salut" ← se repetă
suma ← suma + i ← se repetă
↓

4. ACTUALIZARE

Pregătim următoarea iterație

i ← i + 1 ← următorul număr
n ← n - 1 ← scădem contorul
↻

5. REVENIRE

Salt înapoi pentru verificarea condiției

Se face automat de către calculator!

Exercițiu simplu: Identifică elementele

Urmărește acest algoritm simplu și identifică fiecare element:

suma ← 0 ______ # Pregătim variabila suma (începe de la 0)
i ← 1 ______ # Pregătim contorul (începe de la 1)
┌ cât timp i ≤ 5 execută ______ # Verifică: mai sunt numere? (i ≤ 5?)
│ suma ← suma + i ______ # SE EXECUTĂ DE FIECARE DATĂ: adaugă i la sumă
│ i ← i + 1 ______ # Pregătim următoarea iterație: următorul număr
└■ # Sfârșitul buclei (revenirea se face automat)
Elemente buclei:
inițializare condiție corp actualizare
💡 Corpul buclei = instrucțiunile care se repetă de fiecare dată când intrăm în buclă.

Primul Tău Program cu Buclă

citește n (n = 5 pentru exemplu) s ← 0 i ← 1 ┌ cât timp i ≤ n execută │ s ← s + i │ i ← i + 1 └■ scrie "Suma numerelor de la 1 la ", n, " este: ", s

Ce face acest algoritm? Calculează suma numerelor de la 1 la n.

Pentru n=5: 1 + 2 + 3 + 4 + 5 = 15

Program C++ echivalent
#include <iostream>

using namespace std;

int main() {
    int n;
    cout << "Introdu n: ";
    cin >> n;
    
    int s = 0;      // inițializare sumă
    int i = 1;      // inițializare contor
    
    while (i <= n) {    // condiție
        s = s + i;      // corp - se execută de fiecare dată
        i = i + 1;      // actualizare - pentru următoarea iterație
    }
    
    cout << "Suma numerelor de la 1 la " << n 
         << " este: " << s;
    
    return 0;
}
Urmărește pas cu pas pentru n=3:
➡️ Inițializare: n=3, s=0, i=1
➡️ Verificare 1: i ≤ 3? (1 ≤ 3) → DA
➡️ Execuție 1: s = 0 + 1 = 1
➡️ Actualizare 1: i = 1 + 1 = 2
↻ Revenim la verificare...
➡️ Verificare 2: i ≤ 3? (2 ≤ 3) → DA
➡️ Execuție 2: s = 1 + 2 = 3
➡️ Actualizare 2: i = 2 + 1 = 3
↻ Revenim la verificare...
➡️ Verificare 3: i ≤ 3? (3 ≤ 3) → DA
➡️ Execuție 3: s = 3 + 3 = 6
➡️ Actualizare 3: i = 3 + 1 = 4
➡️ Verificare 4: i ≤ 3? (4 ≤ 3) → NU
➡️ Ieșire din buclă: s = 6

Atenție la Buclele Infinite!

Ce este o buclă infinită?

O buclă care nu se oprește niciodată pentru că condiția rămâne întotdeauna adevărată.

❌ EXEMPLU DE BUC LĂ INFINITĂ:
i ← 1 ┌ cât timp i ≤ 5 execută │ scrie "Salut!" │ # AICI E PROBLEMA: nu mărim i! └■

Problemă: i rămâne întotdeauna 1, condiția i ≤ 5 este întotdeauna adevărată!

Găsește bucla infinită:

Care dintre aceste bucle NU se va opri niciodată?

Opțiunea A:
i ← 1 ┌ cât timp i ≤ 10 execută │ scrie i │ i ← i + 1 └■
i crește: 1→2→3...→10→11 (apoi STOP)
Opțiunea B:
x ← 5 ┌ cât timp x > 0 execută │ scrie x │ x ← x - 1 └■
x scade: 5→4→3→2→1→0 (apoi STOP)
Opțiunea C:
n ← 1 ┌ cât timp n ≠ 0 execută │ scrie n │ n ← n + 1 └■
n crește: 1→2→3→4... (NICIOADATĂ nu devine 0!)

Cum evităm buclele infinite?

✅ Uită-te la ACTUALIZARE - asigură-te că variabila din condiție se modifică
✅ Urmărește VALORILE - scrie pe hârtie cum se modifică variabilele
✅ TESTEAZĂ cu valori mici - verifică mai întâi pentru n=2, n=3
✅ ÎNTREABĂ-TE - "condiția va deveni vreodată falsă?"
EXERCIȚII PBINFO - 15 minute

PBInfo #1007 - Suma primelor N numere

Problemă perfectă pentru prima buclă

Enunț:

Cerință: Să se scrie un program care citește un număr natural n și afișează suma primelor n numere naturale.

Date de intrare:

Programul citește de la tastatură un număr natural n.

Date de ieșire:

Programul va afișa pe ecran suma numerelor de la 1 la n.

Exemplu:

Intrare:

5

Ieșire:

15

Explicație: 1 + 2 + 3 + 4 + 5 = 15

Restricții și precizări:
  • 1 ≤ n ≤ 1000
  • Se va folosi o buclă (while sau for)
  • Timp de execuție: 0.1 secunde
  • Memorie: 2 MB
Cum gândim soluția:
  1. Citim n de la tastatură
  2. Pregătim o variabilă suma care începe de la 0
  3. Pregătim un contor i care începe de la 1
  4. Cât timp i ≤ n:
    • Adaugă i la suma
    • Mărește i cu 1
  5. Afișează suma
Scrie soluția ta în C++:
Soluție corectă:
#include <iostream>

using namespace std;

int main() {
    int n;
    cin >> n;
    
    int suma = 0;   // inițializare sumă
    int i = 1;      // inițializare contor
    
    while (i <= n) {    // condiție
        suma = suma + i;  // corp - adaugă i la sumă
        i = i + 1;        // actualizare - următorul număr
    }
    
    cout << suma;
    
    return 0;
}

Ce am învățat din această problemă:

  • Inițializare corectă: suma = 0 (începem de la 0), i = 1 (începem de la 1)
  • Condiție logică: i <= n (inclusiv n)
  • Actualizare obligatorie: i = i + 1 (altfel bucla infinită!)
  • Acumulare rezultat: adunăm la suma pe rând fiecare număr

PBInfo #1010 - Numere consecutive

Altă problemă simplă cu buclă

Enunț:

Cerință: Să se scrie un program care citește un număr natural n și afișează toate numerele naturale de la 1 la n, separate prin spațiu.

Date de intrare:

Programul citește de la tastatură un număr natural n.

Date de ieșire:

Programul va afișa pe ecran toate numerele de la 1 la n, separate prin câte un spațiu.

Exemplu:

Intrare:

5

Ieșire:

1 2 3 4 5
Restricții și precizări:
  • 1 ≤ n ≤ 1000
  • Numerele se afișează în ordine crescătoare
  • Ultimul număr este urmat de un spațiu (sau nu, depinde de platformă)
  • Se va folosi o buclă
Cum gândim soluția:
  1. Citim n de la tastatură
  2. Pregătim un contor i care începe de la 1
  3. Cât timp i ≤ n:
    • Afișează i și un spațiu
    • Mărește i cu 1
Scrie soluția ta în C++:
Soluție corectă:
#include <iostream>

using namespace std;

int main() {
    int n;
    cin >> n;
    
    int i = 1;      // inițializare contor
    
    while (i <= n) {    // condiție
        cout << i << " ";  // corp - afișează i și spațiu
        i = i + 1;        // actualizare - următorul număr
    }
    
    return 0;
}

Puncte cheie importante:

  • Aceeași structură: inițializare → condiție → corp → actualizare
  • Corp diferit: în loc de suma = suma + i, avem cout << i << " "
  • Spațiul important: " " separă numerele (altfel ar fi 12345)
  • Actualizare identică: tot i = i + 1 pentru următorul număr

Transformare Pseudocod → C++

Exercițiu de traducere pentru fixare

Pseudocod dat (afișează numerele pare de la 1 la n):

citește n i ← 1 ┌ cât timp i ≤ n execută │ ┌ dacă i % 2 = 0 atunci │ │ scrie i, " " │ └■ │ i ← i + 1 └■

Ce face acest algoritm? Afișează numerele pare (divizibile cu 2) de la 1 la n.

Exemplu pentru n=7: 2 4 6

Scrie programul C++ echivalent:
Soluție corectă:
#include <iostream>

using namespace std;

int main() {
    int n, i;
    
    cin >> n;
    
    i = 1;
    while (i <= n) {
        if (i % 2 == 0) {
            cout << i << " ";
        }
        i = i + 1;
    }
    
    return 0;
}

Reguli de transformare Pseudocod → C++ pentru bucle:

Pseudocod C++
┌ cât timp ... execută while (...) {
└■ }
scrie cout <<
← =
% (rest) % (rămâne la fel)
Fără ; Cu ; la sfârșit
PROBLEME - 10 minute

Exercițiul Practic: Primul Algoritm cu Buclă

Sarcini de lucru

Completează următoarele sarcini pentru a-ți consolida cunoștințele despre structurile repetitive

Sarcina 1: Analiză algoritm cu buclă

Pseudocod dat:

n ← 4 produs ← 1 i ← 1 ┌ cât timp i ≤ n execută │ produs ← produs * i │ i ← i + 1 └■ scrie "Produsul este: ", produs
Soluție pentru Sarcina 1:

Analiza algoritmului:

  • Ce calculează: Produsul numerelor de la 1 la n (factorialul lui n)
  • Calcul pentru n=4: 1 × 2 × 3 × 4 = 24
  • Elementele buclei:
    • Inițializare: produs ← 1, i ← 1
    • Condiție: i ≤ n (i ≤ 4)
    • Corp: produs ← produs × i (înmulțește)
    • Actualizare: i ← i + 1 (următorul număr)
  • Tip de buclă: Cu număr cunoscut de pași (4 iterații)
Sarcina 2: Scriere pseudocod pentru problemă nouă

Enunț: "Scrieți un algoritm care calculează media aritmetică a primelor n numere naturale."

Exemplu pentru n=5: (1+2+3+4+5)/5 = 15/5 = 3

Soluție pentru Sarcina 2:
ALGORITMUL MediaPrimelorN
VARIABILE
    n, i, suma, media: întreg
ÎNCEPUT
    CITESTE n
    suma ← 0
    i ← 1
    CÂT TIMP i ≤ n EXECUTĂ
        suma ← suma + i
        i ← i + 1
    SFÂRȘIT CÂT TIMP
    media ← suma / n
    SCRIE "Media primelor ", n, " numere este: ", media
SFÂRȘIT

Explicație pas cu pas:

  1. Citim n (până la cât calculăm)
  2. Pregătim suma (începe de la 0)
  3. Pregătim contorul i (începe de la 1)
  4. Bucla: adaugă i la sumă și mărește i
  5. După buclă: calculează media = suma / n
  6. Afișează rezultatul

Descarcă exercițiile