SISergiu Ilincameditații informatică
Meniu

clasa a IX-a · Structuri de control · lecția 5

Structuri repetitive (1): while și do-while

60 mintoate profilurile

Înainte de lecția asta: IX.4 Structura alternativă: if, else, switch

Ce vei ști după lecție

  • Scrii bucle while (test înainte) și do-while (test după) și știi când folosești fiecare variantă.
  • Citești un șir de numere până la apariția lui 0 (sau a altei valori de oprire).
  • Calculezi sume și numărări „din mers”, fără să memorezi toate valorile.
  • Recunoști și eviți buclele infinite.
  • Transformi o structură cât timp într-una repetă…până când (și invers), ca la Bac.

Lecția are și o fișă de lucru, de rezolvat după ce o citești. Mergi la fișă ↓

Fișiere PDF și de lucru

1. De ce avem nevoie de repetiție?

„Citește numere până la 0 și afișează-le suma.” Nu știm câte numere vor fi, deci nu putem scrie de mână câte un cin pentru fiecare. Avem nevoie de o instrucțiune care repetă un bloc de câte ori e nevoie.

Imaginează-ți o casieră: ia produs după produs și adună prețul la total, până când nu mai sunt produse. Nu știe de la început câte sunt; știe doar ce face la fiecare pas și când se oprește.

2. while — testul înainte

while (conditie)
{
    // corpul buclei: se repetă cât timp condiția e adevărată
}

Pseudocod ↔ C++:

cât timp n ≠ 0 execută         while (n != 0)
   s ← s + n % 10              {   s = s + n % 10;
   n ← [n / 10]                    n = n / 10;
                              }

La fiecare iterație (repetare) calculatorul face: (1) testează condiția; (2) dacă e adevărată, execută corpul și se întoarce la (1); (3) dacă e falsă, sare după buclă.

  • Dacă de la început condiția e falsă, corpul nu se execută deloc.
  • În corp trebuie să se modifice ceva din condiție, altfel bucla nu se oprește.

Șablonul „citire până la 0”

Șablonul citire până la 0

#include <iostream>
using namespace std;

int main()
{
    int x, s = 0;
    cin >> x;                 // citim PRIMA valoare înainte de buclă
    while (x != 0)
    {
        s = s + x;            // prelucrăm valoarea curentă
        cin >> x;             // citim URMĂTOAREA valoare la sfârșitul corpului
    }
    cout << s;
    return 0;
}

Suma din mers

Urmărirea variabilelor pentru intrarea 5 3 8 0:

moment x x != 0? s
după prima citire 5 da 0
după iterația 1 3 da 5
după iterația 2 8 da 8
după iterația 3 0 nu → ies 16

Intrare / ieșire:

Intrare Ieșire Explicație
5 3 8 0 16 5 + 3 + 8
0 0 corpul nu se execută deloc
7 0 7 o singură iterație

De ce așa?

De ce citim de două ori? Trebuie să știm valoarea lui x înainte de a testa condiția, deci prima citire e în afara buclei. Apoi, la sfârșitul fiecărei iterații, citim următoarea valoare ca să fie testată la reluare. Dacă am citi la început de corp și apoi am testa, am prelucra și valoarea 0 (inofensiv la sumă, dar greșit la numărări și la produse).

3. do-while — testul după

do
{
    // corpul se execută cel puțin o dată
} while (conditie);       // atenție la ; de la final

Exemplu clasic: numărul de cifre. Funcționează și pentru n = 0, care are o cifră.

while versus do-while

#include <iostream>
using namespace std;

int main()
{
    int n, nr = 0;
    cin >> n;
    do
    {
        nr++;
        n = n / 10;
    } while (n != 0);
    cout << nr;
    return 0;
}
iterația n la început nr după n după
1 2048 1 204
2 204 2 20
3 20 3 2
4 2 4 0 → stop

De ce așa?

De ce do-while aici? Orice număr, inclusiv 0, are cel puțin o cifră. Cu while (n != 0) pentru n = 0 bucla nu rulează și am afișa 0 cifre. Folosim do-while exact când acțiunea trebuie făcută măcar o dată (alt exemplu: „citește până când utilizatorul introduce un număr valid”).

4. repetă … până când din pseudocod

La Bac, pseudocodul folosește repetă … până când, care se oprește când condiția devine adevărată. În C++ nu există until, deci negăm condiția:

repetă                          do
   s ← s + n % 10               {   s = s + n % 10;
   n ← [n / 10]                     n = n / 10;
până când n = 0                 } while (n != 0);   // NOT (n = 0)

Atenție — greșeli frecvente

repetă … până când C se oprește când C e adevărată; do … while (C) continuă cât C e adevărată. Condițiile sunt opuse: asta e cea mai frecventă greșeală la transcriere.

La BAC

Exercițiu foarte frecvent la Subiectul al II-lea: „Scrieți un algoritm pseudocod echivalent cu cel dat, înlocuind structura cât timp cu o structură repetitivă de alt tip.” Pași:

  1. cât timp C execută B devine dacă C atunci repetă B până când not C;
  2. Condiția se neagă (De Morgan dacă e compusă);
  3. dacă-ul din față e necesar pentru că repetă execută corpul cel puțin o dată.

5. Bucle infinite — cum le recunoști

int i = 1;
while (i <= 10)
    cout << i << ' ';     // lipsește i++ → afișează 1 la nesfârșit
int n = 5;
while (n != 0)
    n = n - 2;            // 5, 3, 1, -1, -3... nu ajunge niciodată la 0

Pe pbinfo, o buclă infinită apare ca „Depășire limită de timp”. Verifică:

  • se modifică variabila din condiție?
  • se apropie de valoarea de oprire? Poate „sări” peste ea?

De ce așa?

De ce n != 0 e riscant, iar n > 0 e mai sigur? n != 0 cere ca valoarea să aterizeze exact pe 0. Cu n > 0 e suficient să treacă dedesubt. Când nu ești sigur că pasul „nimerește” valoarea de oprire, folosește <, >.

6. Tipare de prelucrare „din mers”

Nu memorăm toate numerele, le prelucrăm pe rând, pe măsură ce le citim.

Ce calculăm Inițializare În buclă
sumă s = 0 s += x;
produs p = 1 p *= x;
câte au proprietatea P cnt = 0 if (P) cnt++;
ultimul cu proprietatea P ult = -1 if (P) ult = x;
primul cu proprietatea P prim = -1 if (P && prim == -1) prim = x;
există vreunul cu P? gasit = false if (P) gasit = true;
toate au P? toate = true if (!P) toate = false;

De ce așa?

De ce suma pornește de la 0 și produsul de la 1? Valoarea inițială trebuie să fie elementul neutru: 0 nu schimbă o sumă, 1 nu schimbă un produs. Un produs care pornește de la 0 ar rămâne 0.

Exemplu: oprire la două valori consecutive egale (#459 suma1)

Trebuie să ținem minte valoarea anterioară:

#include <iostream>
using namespace std;

int main()
{
    int ant, x, s;
    cin >> ant >> x;
    s = ant + x;
    while (x != ant)
    {
        ant = x;          // valoarea curentă devine „anterioară”
        cin >> x;         // citim una nouă
        s += x;
    }
    cout << s;
    return 0;
}
citit ant x x != ant? s
1 2 1 2 da 3
+3 2 3 da 6
+3 3 3 nu → stop 9

(Verifică pe enunț dacă trebuie adunate și cele două valori egale: fiecare problemă precizează.)

De ce așa?

De ce ant = x; înainte de cin >> x;? Dacă am citi mai întâi, am pierde vechea valoare. Mereu: salvezi vechea valoare, apoi citești noua.

7. Greșeli frecvente

Greșeala Efect Corect
while (x != 0); ; face corpul gol → buclă infinită fără ;
lipsește citirea de la final bucla repetă aceeași valoare cin >> x; la sfârșit
do { } while (c) fără ; eroare de compilare while (c);
acumulator neinițializat rezultat aleator s = 0
repetă…până când C copiat ca while (C) condiția e inversată while (!C)

8. La BAC

La BAC

Aproape sigur ai o grilă în care cauți câte iterații are o buclă sau ce valoare are o variabilă la ieșire. Fă un tabel cu coloanele variabilelor și completează rând cu rând (ca în lecție). Nu face în minte mai mult de două iterații.

Exemplu: n = 2048, numărăm zerourile.

n n % 10 zero? k
2048 8 nu 0
204 4 nu 0
20 0 da 1
2 2 nu 1
0 stop 1

9. Exerciții tip Bac (pe hârtie)

Răspunsurile sunt la finalul lecției, după probleme.

1. Ce afișează pentru n = 2048? Dar pentru n = 1000?

citește n
k ← 0
cât timp n > 0 execută
   dacă n % 10 = 0 atunci k ← k + 1
   
   n ← [n / 10]

scrie k

2. Dați un exemplu de valoare pentru n, cu exact 4 cifre, pentru care se afișează 3.

3. Scrieți un algoritm echivalent folosind repetă … până când.

4. Ce afișează?

int i = 1, s = 0;
while (i <= 5) { s += i; i += 2; }
cout << s << ' ' << i;

5. De câte ori se execută corpul buclei? Ce valoare are i după ea?

int i = 10;
while (i > 0) i -= 3;

6. Care dintre secvențe sunt bucle infinite?

a) i = 1; while (i <= 10) i--;
b) n = 7; while (n != 0) n -= 2;
c) i = 1; while (i <= 10) i *= 2;
d) x = 100; while (x > 0) x /= 2;

7. Ce afișează cout << i; după secvența următoare?

int s = 0, i = 1;
while (s < 20) { s += i; i++; }

8. Scrie bucla care citește numere până la 0 și afișează câte numere pare au fost citite.

9. Traduceți în C++: repetă citește x; s ← s + x până când s ≥ 100.

10. Mai departe (pentru cine vrea mai mult)

Conjectura lui Collatz. Pornește de la un număr n. Dacă e par, îl împarți la 2; dacă e impar, îl faci 3n + 1. Repetă. Se pare că ajungi mereu la 1, dar nimeni nu a demonstrat asta! Verifică pe calculator:

int n = 27, pasi = 0;
while (n != 1)
{
    if (n % 2 == 0) n = n / 2;
    else n = 3 * n + 1;
    pasi++;
}
cout << pasi;   // 111

Pentru n = 27 numărul crește până la 9232 înainte să coboare. Aici condiția n != 1 nu se poate înlocui ușor cu <: nu știi dacă bucla se termină, iar acest lucru e o problemă matematică deschisă.

Invariantul buclei. Cum demonstrezi că o buclă e corectă? Găsești o afirmație adevărată înainte de buclă, păstrată de fiecare iterație, și care la ieșire dă răspunsul. La suma de mai sus: „s = suma valorilor citite până acum”. Este ideea din spatele demonstrațiilor de corectitudine din informatica serioasă.

Mai puțin cod, mai puține bug-uri. while (cin >> x) citește până la sfârșitul datelor (fără valoare-santinelă 0). Este varianta folosită la probleme de concurs; încearcă-o: while (cin >> x) s += x;.

Rezumat

  • while testează înainte (poate executa de 0 ori); do-while testează după (cel puțin o dată).
  • Citire până la 0: citește înainte, prelucrează, citește la final.
  • repetă … până când C ≡ do { } while (!C);
  • Acumulatori: sumă începe de la 0, produs de la 1, contor de la 0.
  • Orice buclă trebuie să se apropie de condiția de oprire; urmărește variabilele într-un tabel.

Fișa de lucru

Ai citit lecția? Printează fișa sau deschide-o pe ecran și rezolvă exercițiile în ordine.

Fișă de lucru · 7 pagini · 100 min

Bucle: while, do-while, for

  • Numeri exact de câte ori se execută o buclă și ce valoare are contorul la ieșire.
  • Alegi între while, do-while și for și traduci corect repetă … până când.
  • Folosești break, continue și bucle imbricate (desene, tabele, numărări pe perechi).

Fișa acoperă și: IX.6

Te-ai blocat la un exercițiu?

Probleme de lucru

Începe cu acestea, în ordine. Problemele se deschid pe pbinfo.ro, unde trimiți soluția și primești punctajul.

  • suma#51

    Citire până la 0, suma tuturor valorilor.

    ușoară
  • sumapare1#52

    La fel, dar adunăm doar numerele pare.

    ușoară
  • suma1#459

    Oprire la două valori consecutive egale: trebuie să ții minte valoarea anterioară.

    ușoară

Temă

Rezolvă-le singur și bifează ce ai terminat. Bifele rămân salvate în acest browser.

  • cateimpare#53

    ușoară
  • catepare#1261

    ușoară
  • sumcnt1#4278

    ușoară
  • suma2cifre#4921

    ușoară
  • suma3cifre#4560

    ușoară

Grile din subiectele de BAC

Exerciții de tip grilă din variantele de Bacalaureat. Se rezolvă pe pbinfo.ro, care îți verifică imediat răspunsul.

Citește și exersează în plus

  • Structuri repetitive · pbinfo.ro
  • Instrucțiunea while · pbinfo.ro
  • Instrucțiunea do…while · pbinfo.ro
  • Python Tutor pentru C++ · pythontutor.com

    rulează un while pas cu pas și urmărește variabilele

  • cppreference — while / do-while · en.cppreference.com

    referința oficială, în engleză

  • VisuAlgo · visualgo.net

    animații pentru algoritmi (mai folositor din lecțiile următoare)

Te-ai blocat la lecția asta?

Scrie-mi ce nu iese și vedem împreună de unde se blochează.

Răspunsuri

Exercițiul de BAC (secțiunea 8)

Pentru 2048 se afișează 1: un singur zero, cifra zecilor.

Exersează pe hârtie

1. Pentru 2048: 1. Pentru 1000: 3 (trei zerouri; la ultima iterație n = 1 și 1 % 10 = 1).

2. De exemplu 1000, 2000, 9000 (trei zerouri la final). Numerele ca 1001 dau 2 și nu merg.

3.

citește n
k ← 0
dacă n > 0 atunci
  repetă
     dacă n % 10 = 0 atunci k ← k + 1
     
     n ← [n / 10]
  până când n ≤ 0

scrie k

dacă-ul de la început este necesar: repetă execută corpul măcar o dată, iar cât timp poate să nu-l execute.

4. 9 7. i ia valorile 1, 3, 5 (s = 1 + 3 + 5 = 9); după 5 devine 7 și condiția e falsă.

5. 4 execuții (i = 10, 7, 4, 1). După ele, i = -2.

6. a) și b). La a) i scade și rămâne mereu ≤ 10. La b) 7, 5, 3, 1, −1, … nu atinge niciodată 0. La c) i merge 1, 2, 4, 8, 16 → se oprește. La d) x ajunge 100, 50, 25, 12, 6, 3, 1, 0 → se oprește.

7. 7. s = 1, 3, 6, 10, 15, 21 (după i = 1, 2, 3, 4, 5, 6); al șaselea pas aduce s la 21 și i la 7.

8.

int x, cnt = 0;
cin >> x;
while (x != 0)
{
    if (x % 2 == 0) cnt++;
    cin >> x;
}
cout << cnt;

9.

int x, s = 0;
do
{
    cin >> x;
    s = s + x;
} while (s < 100);

s ≥ 100 neagat este s < 100.