Bucle cu test inițial și final la BAC: transformări

Diferența dintre o buclă cu test inițial și una cu test final este momentul în care se verifică condiția. O buclă cu test inițial poate să nu execute deloc corpul. O buclă cu test final îl execută cel puțin o dată. La BAC informatică, această diferență devine esențială când trebuie să transformi un algoritm într-unul echivalent.

Echivalent înseamnă același rezultat pentru toate datele admise, nu doar pentru exemplul din enunț. Dacă transformarea funcționează pentru zece și eșuează pentru zero, iar zero aparține domeniului, nu ai obținut un algoritm echivalent. În lecție lucrăm cu valori naturale și indicăm explicit ce înseamnă fiecare formă de pseudocod.

Cele trei forme pe care trebuie să le deosebești

Formă	Când se testează?	Când continuă?	Minimum de execuții
cât timp C execută	Înainte de corp	C este adevărată	Zero
execută ... cât timp C	După corp	C este adevărată	Una
repetă ... până când C	După corp	C este falsă	Una

Ultimele două forme au test final, dar condițiile lor au sens opus. În C++, instrucțiunea do ... while(C) repetă cât timp condiția este adevărată. În forma „până când”, condiția exprimă oprirea. Nu traduce mecanic aceleași cuvinte într-o expresie identică.

O schemă utilă de memorare este verifică → execută pentru testul inițial și execută → verifică pentru testul final. Ea nu îți spune însă singură dacă valoarea adevărată înseamnă continuare sau oprire. Pentru aceasta citești formularea exactă a structurii.

Exemplu: numărarea cifrelor unui număr natural

Începem cu o buclă cu test inițial:

citește n
k ← 0
cât timp n > 0 execută
    k ← k + 1
    n ← n div 10
scrie k

Pentru n=406, corpul se execută de trei ori. Valorile lui n după împărțire sunt patruzeci, patru și zero, iar contorul ajunge la trei. Pentru n=0, condiția este falsă de la început și se afișează zero. Algoritmul numără corect cifrele numerelor naturale nenule, dar nu tratează reprezentarea zecimală a lui zero ca o cifră.

Acum folosim un test final:

citește n
k ← 0
execută
    k ← k + 1
    n ← n div 10
cât timp n > 0
scrie k

Pentru 406, rezultatul rămâne trei. Pentru zero, corpul se execută o dată și rezultatul este unu. A doua variantă poate fi potrivită pentru cerința „numărul de cifre al unui număr natural, inclusiv zero”, dar nu este echivalentă cu prima pe întregul domeniu al numerelor naturale. O corectare a unei cerințe și o transformare echivalentă sunt două sarcini diferite.

Transformarea corectă a testului inițial în test final

Pentru a păstra posibilitatea de zero execuții, adaugi un test exterior:

dacă C atunci
    execută
        corpul buclei
    cât timp C

Aceasta corespunde structurii cât timp C execută corpul buclei, dacă evaluarea condiției și corpul păstrează același sens. Testul exterior verifică dacă prima execuție este permisă. Testul de la final decide dacă urmează încă una. Nu adaugi o actualizare suplimentară a variabilei de control între cele două teste.

În exemplul cu cifre, scrii dacă n>0 atunci înaintea buclei cu test final. Pentru zero, sari peste întregul bloc, iar contorul rămâne zero. Pentru un număr pozitiv, intri și prelucrezi aceleași cifre ca în algoritmul inițial. Astfel sunt acoperite ambele categorii de intrări.

Dacă enunțul garantează de la început n>0, testul exterior poate fi redundant pentru acel exemplu concret. Totuși, justificarea trebuie să se bazeze pe domeniul precizat, nu pe presupunerea că „de obicei se citesc valori pozitive”. La examen, condițiile intrării fac parte din demonstrația echivalenței.

Transformarea inversă: păstrează prima execuție

O buclă cu test final de forma „execută corpul cât timp C” poate fi transformată astfel:

corpul buclei
cât timp C execută
    corpul buclei

Prima copie a corpului garantează execuția inițială. Testul următor vede valorile deja modificate, exact ca în varianta originală. Dacă pui condiția înaintea primei copii, ai schimbat comportamentul pentru intrările care o fac falsă inițial.

Pentru forma „repetă până când C”, condiția buclei cu test inițial va fi nu C. De exemplu, „până când n=0” devine „cât timp n≠0”. Nu folosi n>0 fără să verifici domeniul: cele două condiții sunt echivalente pentru numere naturale, dar nu pentru orice întreg.

Exemplu comparativ cu acumulare

Pornim de la x=5 și s=0. Corpul execută mai întâi s←s+x, apoi x←x-2, iar continuarea este permisă cât timp x>0. În forma cu test inițial, se adună cinci, trei și unu, deci suma finală este nouă. După ultima scădere, x devine minus unu și bucla se oprește.

Pentru x=0, varianta cu test inițial nu execută nimic și lasă suma zero. Varianta cu test final adună zero o dată și apoi modifică x la minus doi. Suma afișată poate fi aceeași, însă starea finală a lui x diferă. Dacă algoritmul folosește ulterior această variabilă, diferența poate schimba și rezultatul final.

De aceea, la o transformare, urmărește toate variabilele care mai sunt utilizate. Faptul că un singur număr afișat coincide într-un exemplu nu dovedește echivalența întregului program. Compară traseele și momentul fiecărui test.

Transcriere în C++

Pentru numărarea cifrelor, cu zero inclus, o variantă completă este:

#include <iostream>
using namespace std;

int main() {
    unsigned long long n;
    cin >> n;
    int k = 0;
    do {
        ++k;
        n /= 10;
    } while (n > 0);
    cout << k;
    return 0;
}

Observă punctul și virgula după condiția finală. Corpul include ambele instrucțiuni între acolade. Dacă elimini acoladele și lași în buclă numai incrementarea, împărțirea nu mai are loc în fiecare iterație, ceea ce poate împiedica oprirea. Erorile de structură se depistează urmărind exact ce instrucțiuni aparțin corpului.

Exerciții cu răspunsuri explicate

1. O buclă „cât timp x<3” începe cu x=3. De câte ori se execută corpul? Răspuns: de zero ori. Egalitatea cu trei nu satisface inegalitatea strictă. Dacă testul ar fi final, corpul s-ar executa o dată înainte de verificare.

2. Transformă „repetă x←x-1 până când x≤0” într-o structură cu test inițial. Răspuns: execută o dată scăderea, apoi repet-o cât timp x>0. Prima scădere rămâne obligatorie chiar dacă valoarea inițială este zero.

3. Pentru numărarea cifrelor cu test final, ce rezultate obții pentru zero, șapte și o sută? Răspuns: unu, unu și trei. La o sută sunt prelucrate și cele două cifre zero din dreapta; împărțirea elimină câte o poziție zecimală.

4. Este suficient să schimbi cuvântul „cât timp” în „până când”, păstrând condiția? Răspuns: nu. Cele două forme folosesc adevărul condiției în sensuri opuse. Pentru a păstra comportamentul, negi condiția și verifici dacă prima execuție rămâne aceeași.

Întrebări frecvente

Care formă este mai bună pentru BAC?

Forma potrivită depinde de cerință. Dacă prima execuție este obligatorie, testul final poate fi natural. Dacă poate exista cazul fără execuții, testul inițial exprimă direct această posibilitate.

Trebuie să păstrez toate inițializările?

Da, cu excepția unei rescrieri echivalente justificate. Mutarea inițializării unui contor în corpul buclei îl poate reseta la fiecare pas și schimbă rezultatul.

Cum verific rapid o transformare?

Testează o intrare care execută zero pași în varianta inițială, una cu un singur pas și una cu mai mulți. Apoi explică de ce corespondența se păstrează, nu doar că cele trei exemple coincid.

Exersează pe subiecte BAC cu barem, notând condițiile de intrare pentru fiecare transformare. Abordarea se bazează pe înțelegerea pașilor, nu doar memorarea sintaxei. Un profesor de informatică poate verifica o transformare împreună cu tine folosind tocmai cazurile-limită. Reperul de conținut este programa oficială de informatică, în secțiunea structurilor repetitive, pentru specializarea ta.