Structura alternativă

Uneori un algoritm trebuie să aleagă între două drumuri. Dacă plouă, iei umbrela; altfel, pleci fără ea. Verificarea „plouă?” este o condiție. Un algoritm poate executa o ramură când condiția este adevărată și altă ramură când este falsă. Aceasta se numește structură alternativă.

Imaginează-ți că un joc acordă un mesaj după scor. Regula este: dacă scorul este cel puțin 10, afișează „Ai trecut”; altfel, afișează „Mai încearcă”. Pentru scorul 12, compari $12\ge 10$, obții „adevărat” și alegi primul mesaj. Pentru scorul 8, comparația este falsă și alegi al doilea mesaj. Nu se afișează ambele mesaje într-o singură executare.

Uneori există o singură ramură: „dacă ai terminat exercițiul, primești o stea”. Când condiția este falsă, algoritmul doar continuă după decizie. Într-o alternativă dublă există și un „altfel”, deci una dintre cele două ramuri se execută. După oricare dintre ramuri, algoritmul continuă cu pasul de după decizie.

Ca să urmărești un desen cu săgeți sau un program, verifică întâi condiția folosind valorile din acel moment. Apoi urmează numai săgeata potrivită. Dacă un pas din ramură schimbă scorul, o verificare de mai târziu poate avea alt rezultat. Un exemplu cu valoarea exact la prag, scorul 10, este util: expresia „cel puțin 10” îl include, pe când „mai mare decât 10” nu.

Exemplu rezolvat — biletul la cinema. Regula casei de bilete: dacă vârsta este cel puțin 14 ani, biletul costă 20 de lei; altfel, costă 10 lei. Ce plătesc doi copii, unul de 12 ani și unul de 14 ani?

1. Pentru primul copil, vârsta este 12. Compari $12\ge 14$: răspunsul este „fals”.
2. Condiția fiind falsă, se alege ramura „altfel”: biletul costă 10 lei.
3. Pentru al doilea copil, vârsta este 14. Compari $14\ge 14$: răspunsul este „adevărat”, pentru că „cel puțin 14” include chiar 14.
4. Condiția fiind adevărată, se alege prima ramură: biletul costă 20 de lei.

Pentru fiecare copil se execută exact una dintre cele două ramuri, niciodată amândouă. Dacă regula ar fi fost „mai mult de 14 ani”, al doilea copil ar fi plătit 10 lei, deoarece 14 nu este mai mare decât 14.

Structura alternativă alege o ramură în funcție de o condiție. În C++ există trei forme: if (c) A; (alternativă simplă: A se execută numai dacă $c$ este adevărată), if (c) A; else B; (alternativă dublă: se execută exact una dintre A și B) și lanțul if ... else if ... else ..., în care condițiile se verifică pe rând, de sus în jos, iar prima adevărată hotărăște ramura. Dacă o ramură are mai multe instrucțiuni, ele se grupează între acolade. Condiția este o expresie logică: se pot combina comparații cu && (și), || (sau) și ! (nu). Caracterul = atribuie, iar == compară: if (x = 0) atribuie valoarea 0 și este mereu fals.

Exemplul 1 — semnul unui număr. Un număr este negativ, zero sau pozitiv; trei cazuri se tratează cu un lanț de decizii.

#include <iostream>
using namespace std;
int main() {
    int x;
    cin >> x;
    if (x < 0)
        cout << "negativ";
    else if (x == 0)
        cout << "zero";
    else
        cout << "pozitiv";
    return 0;
}

Pentru intrările $-5$, $0$ și $8$ programul afișează negativ, zero și pozitiv. Pentru $x=0$ prima condiție este falsă, a doua este adevărată și lanțul se oprește; ultima ramură nu se mai verifică.

Exemplul 2 — cel mai mare dintre trei numere. Se citesc $a$, $b$ și $c$. Se păstrează în m cel mai mare dintre primele două, apoi se compară cu al treilea.

#include <iostream>
using namespace std;
int main() {
    int a, b, c, m;
    cin >> a >> b >> c;
    if (a > b)
        m = a;
    else
        m = b;
    if (c > m)
        m = c;
    cout << m;
    return 0;
}

Pentru 4 9 6: $4>9$ este fals, deci $m=9$; $6>9$ este fals, deci $m$ rămâne 9, iar programul afișează 9. Pentru 4 9 12, a doua decizie este adevărată și $m$ devine 12.

Exemplul 3 — calificativ după notă. Calificativul este „Insuficient” sub 5, „Suficient” sub 7, „Bine” sub 9 și „Foarte bine” în rest. Condițiile se verifică de sus în jos, deci fiecare ramură poate presupune că cele de dinainte au fost false: dacă nota nu este sub 5, nu mai trebuie scris „și mai mare sau egală cu 5”.

double nota = 7;
if (nota < 5) cout << "Insuficient";
else if (nota < 7) cout << "Suficient";
else if (nota < 9) cout << "Bine";
else cout << "Foarte bine";

Pentru nota $7$: $7<5$ este fals, $7<7$ este fals, iar $7<9$ este adevărat, deci se afișează Bine. Pentru $4,5$ se afișează Insuficient, iar pentru $9,5$ ultima ramură, Foarte bine. Dacă s-ar inversa ordinea primelor două condiții, nota 4,5 ar primi „Suficient”, pentru că $4,5<7$ este adevărat: ordinea testelor în lanț contează.

Exemplul 4 — anul bisect. Un an este bisect dacă se împarte exact la 4 și nu se împarte la 100, sau dacă se împarte exact la 400. Regula are două părți legate prin „sau”, iar prima conține la rândul ei un „și”.

int an = 1900;
if ((an % 4 == 0 && an % 100 != 0) || an % 400 == 0)
    cout << "bisect";
else
    cout << "nebisect";

Pentru 1900: restul împărțirii la 4 este 0, dar și restul împărțirii la 100 este 0, deci prima paranteză este falsă; restul împărțirii la 400 este 300, deci și a doua parte este falsă și se afișează nebisect. Pentru 2000, prima paranteză este falsă, dar $2000$ se împarte exact la 400, deci rezultatul este bisect. Pentru 2024 prima paranteză este adevărată, iar pentru 2026 ambele părți sunt false.

Anul 1900 este cazul-limită pe care îl greșesc cel mai des cei care rețin doar „se împarte la 4”: fără partea cu 100 și 400, programul ar declara bisect un an care nu este.

Într-un șir de teste imbricate, urmărește precis ramura căreia îi aparține else: fără acolade, el se asociază cu cel mai apropiat if care nu are încă else, indiferent de indentare. Pentru a evita o interpretare greșită, marchează blocurile cu acolade înainte de calcul. La praguri verifică separat egalitatea: x >= 10 este adevărat și pentru $x=10$. În pseudocodul de Bac, alternativa se scrie „dacă scor≥10 atunci scrie «Ai trecut» altfel scrie «Mai încearcă»”, iar după ramura aleasă execuția continuă cu instrucțiunea următoare structurii. Când condiția combină comparații, calculează fiecare comparație separat și apoi aplică „și”, respectiv „sau”: pentru $x=10$, condiția x > 5 && x < 10 este falsă, deoarece a doua parte este falsă, iar x > 5 || x < 10 este adevărată.

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

int x = 5;
if (x > 3)
    if (x > 10)
        cout << "A";
    else
        cout << "B";
cout << "C";

• a) C
• b) B
• c) BC
• d) AC

Răspunsul corect este c). Condiția x > 3 este adevărată, deci se intră în if-ul interior. Acolo x > 10 este falsă, iar else aparține lui if (x > 10), nu primului if: se afișează B. Instrucțiunea cout << "C" nu face parte din nicio ramură, deci se execută după decizie și afișează C. Varianta a) ar fi corectă dacă else ar aparține primului if, iar varianta d) ar presupune că x > 10 este adevărată.

Dacă o decizie are două condiții independente, scrie-le separat și urmărește fiecare if în parte: pentru x = 6, secvența if (x > 3) x = x - 4; if (x > 3) x = x - 4; dă mai întâi $x=2$, iar a doua decizie nu mai modifică nimic, deoarece $2>3$ este fals.

Atenție la condițiile care par să excludă cazuri: x > 5 || x < 10 este adevărată pentru orice număr, deoarece orice $x$ este fie mai mare decât 5, fie mai mic decât 10.

Greșeli frecvente

• Greșit: la o alternativă dublă se execută ambele ramuri.
  Corect: se execută exact ramura aleasă de condiție.
• Greșit: „cel puțin 10” se scrie > 10.
  Corect: se scrie >= 10, incluzând egalitatea.
• Greșit: un else fără acolade se leagă după alinierea vizuală.
  Corect: C++ îl asociază cu cel mai apropiat if liber.

Înainte și după