Repetarea cu test final

Într-o repetare cu test final, faci mai întâi pașii și verifici abia la sfârșit dacă trebuie să continui. Gândește-te la un joc în care arunci un zar, apoi decizi dacă îl mai arunci. Prima aruncare are loc sigur; hotărârea vine după ea. De aceea corpul unei asemenea repetări se execută cel puțin o dată.

Să presupunem că pornești cu 0 puncte și câștigi câte 2 puncte la fiecare tură până ai cel puțin 5. Prima tură te duce la 2; verifici și continui. A doua te duce la 4; continui. A treia te duce la 6; acum te oprești. Ai făcut trei ture. Nu oprești la 5, fiindcă punctele cresc din doi în doi.

Poți descrie pașii în două feluri. „Repetă până când ai cel puțin 5” spune când te oprești. „Fă pașii cât timp ai mai puțin de 5” spune când continui. Condițiile au sensuri opuse, deși descriu același joc. Citirea atentă a cuvintelor „până când” și „cât timp” te ferește de un test inversat.

Dacă începi cu 6 puncte, tot faci prima tură și ajungi la 8 înainte de verificare. Aceasta deosebește repetarea cu test final de cea cu test inițial. Ca să o urmărești, scrie pe rând valoarea după fiecare tură și rezultatul testului de la sfârșitul acelei ture.

Exemplu rezolvat — un număr pozitiv de la tastatură. Un joc cere un număr pozitiv. Întâi citești numărul, apoi verifici; dacă nu este pozitiv, ceri din nou. Ai citit pe rând numerele $-3$, $0$ și $5$.

1. Citești $-3$. Verifici dacă este pozitiv: nu, deci continui.
2. Citești $0$. Zero nu este pozitiv, deci continui.
3. Citești $5$. Este pozitiv, deci te oprești.

Ai citit de trei ori; prima citire s-a făcut înainte de orice verificare, pentru că nu ai avut ce verifica fără număr. Dacă primul număr ar fi fost 5, ai fi citit o singură dată și ai fi verificat o singură dată. Condiția de oprire este „numărul este pozitiv”, iar condiția de continuare este „numărul nu este pozitiv”.

În C++, do corp while (conditie); este repetarea cu test final: corpul se execută, apoi se evaluează condiția, iar dacă ea este adevărată ciclul continuă. Corpul se execută deci cel puțin o dată, iar numărul de teste este egal cu numărul de execuții. Condiția din do-while este condiția de continuare. În pseudocod, formularea „repetă corp până când C” folosește condiția de oprire C, deci condiția de continuare din C++ este negația ei: „până când $x\ge 5$” se scrie while (x < 5).

Exemplul 1 — puncte până la cel puțin 5. Se pornește de la un număr de puncte citit și se adaugă 2 la fiecare tură cât timp totalul este mai mic decât 5.

#include <iostream>
using namespace std;
int main() {
    int puncte;
    cin >> puncte;
    do {
        puncte += 2;
    } while (puncte < 5);
    cout << puncte;
    return 0;
}

Pentru intrarea 4, corpul rulează o dată: puncte devine 6, condiția 6 < 5 este falsă, iar ieșirea este 6. Pentru intrarea 5 corpul tot rulează o dată și se afișează 7, pe când o buclă while (puncte < 5) ar afișa 5. Pentru intrarea 0 valorile sunt 2, 4, 6 și ieșirea este 6.

Exemplul 2 — citire cu validare. Se cere un număr între 1 și 10, iar citirea se repetă până când valoarea este bună. Condiția de oprire este $1\le n\le 10$, deci cea de continuare este n < 1 || n > 10.

#include <iostream>
using namespace std;
int main() {
    int n, citiri = 0;
    do {
        cin >> n;
        citiri++;
    } while (n < 1 || n > 10);
    cout << n << ' ' << citiri;
    return 0;
}

Pentru valorile 15 0 7: prima citire dă 15, care nu este bun; a doua dă 0, care nu este bun; a treia dă 7, bun. Programul afișează 7 3. Nu s-ar fi putut testa $n$ înainte de prima citire, pentru că variabila nu avea încă o valoare.

Exemplul 3 — numărul de cifre al lui 0. Pentru a număra cifrele lui $n$ prin împărțiri la 10, un ciclu while (n > 0) ar da 0 pentru $n=0$. Cu test final, do { n /= 10; nr++; } while (n > 0); execută corpul o dată și dă corect 1 cifră pentru 0; pentru $n=583$ dă 3. Aceasta este situația tipică în care testul final este potrivit: pasul trebuie făcut oricum, iar verificarea vine după el.

Exemplul 4 — suma numerelor citite până la 0. Marcajul de sfârșit este tot un număr citit, de aceea citirea se face în corp, înaintea testului.

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

Pentru intrarea 4 -1 7 0 perechile $(x;s)$ după fiecare tură sunt $(4;4)$, $(-1;3)$, $(7;10)$ și $(0;10)$, deci se afișează 10. Marcajul 0 se adună și el, dar nu schimbă suma. Dacă prima valoare citită este 0, corpul rulează o singură dată și se afișează 0.

Exemplul 5 — dublări până la un prag. Pornind de la $p=1$, se dublează $p$ cât timp $p<100$. Valorile după fiecare tură sunt 2, 4, 8, 16, 32, 64 și 128, deci ciclul face 7 ture și se oprește cu $p=128$. Numărul de pași. Dacă valoarea inițială este $p$ și se adaugă 2 la fiecare tură, numărul de ture este cel mai mic întreg pozitiv $t$ pentru care $p+2t\ge 5$. Pentru $p=4$ rezultă $t=1$, pentru $p=0$ rezultă $t=3$, iar pentru $p=5$ rezultă tot $t=1$, pentru că prima tură se face oricum.

La Bac, „repetă … până când $C$” se oprește când $C$ devine adevărată, iar „execută … cât timp $C$” continuă cât timp $C$ este adevărată. Ambele execută corpul cel puțin o dată. Schimbarea accidentală a sensului condiției produce o iterație în plus sau o buclă fără sfârșit: dacă $x$ pornește de la 1 și corpul face $x\leftarrow x+1$, forma „până când $x\ge 3$” se oprește la 3. Corpul se execută și când condiția de continuare este falsă de la început. De aceea, într-o secvență cu do-while, numărul de execuții este cel puțin 1, iar variabilele modificate în corp au deja noua valoare când se face testul. La traducerea din pseudocod în C++ scrie întâi condiția de oprire din enunț, apoi neagă-o: „până când $x\le 0$” devine while (x > 0).

Exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

int x = 10, k = 0;
do {
    x -= 3;
    k++;
} while (x > 0);
cout << x << ' ' << k;

• a) 1 3
• b) -2 4
• c) 0 3
• d) -2 3

Răspunsul corect este b). Valorile lui $x$ după fiecare execuție sunt 7, 4, 1 și $-2$, iar $k$ ajunge la 4. După a treia execuție $x=1>0$, deci ciclul continuă; după a patra $x=-2$ și condiția este falsă. Varianta a) se oprește prea devreme, la 1, iar varianta d) numără o execuție mai puțin. Varianta c) cere ca $x$ să ajungă exact la 0, dar valorile sunt 7, 4, 1 și $-2$, iar 0 nu apare, pentru că 10 nu se împarte exact la 3.

Greșeli frecvente

• Greșit: testul final se face înaintea primei execuții.
  Corect: corpul se execută cel puțin o dată.
• Greșit: „până când $x\ge 5$” este aceeași condiție de continuare cu while (x >= 5).
  Corect: pentru această oprire, continuarea este x < 5.
• Greșit: valoarea finală trebuie să fie exact pragul.
  Corect: pașii pot sări peste prag; în exemplu valoarea finală este 6.

Înainte și după