Pseudocodul

Pseudocodul descrie un algoritm fără să îl lege de sintaxa unui limbaj de programare. Folosește instrucțiuni pentru citire, atribuire, afișare, alegere și repetare. Un enunț în pseudocod trebuie citit după convențiile lui: „$x\leftarrow x+1$” schimbă valoarea lui $x$, pe când „$x=x+1$” ca egalitate matematică nu ar fi adevărată. Un tabel de urmărire arată valoarea fiecărei variabile după pasul executat.

Pentru intrările $a=3$ și $b=4$, descrierea „citește $a,b$; $s\leftarrow a+b$; scrie $s$” produce $s=7$ și afișează 7. Același algoritm poate fi implementat în C++ sau Python fără să schimbe ideea de calcul. La repetări verifici unde se află testul și dacă semnifică oprire ori continuare.

Convențiile din subiectele de Bacalaureat

Fiecare structură începe cu ┌ și se închide cu └■ pe aceeași verticală, iar liniile dintre ele, marcate cu │, sunt instrucțiunile din interiorul structurii. La repetă, linia de închidere este chiar └până când condiție. Atribuirea se scrie cu săgeata ←, partea întreagă cu paranteze drepte, iar restul împărțirii cu %. Lângă citește, între paranteze, se precizează ce fel de numere se citesc („număr natural nenul”); aceste precizări fac parte din enunț. Programa nouă de clasa a IX-a folosește aceleași convenții și admite și varianta în care structura se închide în cuvinte (sfârșit dacă, sfârșit cât timp, sfârșit pentru).

Schema logică

Același algoritm se poate desena ca schemă logică, din blocuri legate prin linii de flux. Programa nouă de clasa a IX-a folosește următoarele blocuri:

O structură repetitivă apare în schemă ca o decizie de la care o săgeată se întoarce înapoi, deasupra ei. Pseudocodul e mai ușor de scris și de tradus în cod, de aceea subiectele de examen îl folosesc pe el.

Urmărirea valorilor variabilelor

Ca să afli ce afișează un algoritm, faci un tabel cu o coloană pentru fiecare variabilă și scrii o linie nouă de fiecare dată când o variabilă se schimbă. Nu sări pași „pe intuiție”: majoritatea greșelilor apar la ultima trecere prin buclă sau la o condiție scrisă cu < în loc de ≤.

Algoritmi echivalenți

Doi algoritmi sunt echivalenți dacă, pentru aceleași date de intrare, afișează aceleași rezultate. Transformările cerute cel mai des:

• pentru → cât timp: i ← a înainte de buclă, condiția i ≤ b și i ← i + 1 la sfârșitul corpului.
• cât timp → repetă: repetă execută corpul cel puțin o dată, deci îl pui într-un dacă c atunci, ca să nu se execute când condiția e falsă de la început; condiția de oprire devine not c.
• repetă → cât timp: corpul se execută o dată înainte de buclă (sau te asiguri că prima testare e adevărată), iar condiția devine negația condiției de la până când.

Un exemplu cu cele două feluri de test

• alternativa: dacă condiție atunci instrucțiuni altfel instrucțiuni, cu ramura altfel opțională;
• repetarea cu test inițial: cât timp condiție execută instrucțiuni, care poate executa corpul de zero ori;
• repetarea cu număr cunoscut de pași: pentru i←a,b execută instrucțiuni, unde $i$ ia valorile $a,a+1,\dots ,b$;
• repetarea cu test final: repetă instrucțiuni până când condiție, care oprește ciclul când condiția devine adevărată, sau execută instrucțiuni cât timp condiție, care îl continuă cât timp condiția este adevărată. Ambele execută corpul cel puțin o dată.

Pentru a verifica un algoritm îl urmărești: scrii într-un tabel valorile variabilelor după fiecare instrucțiune sau după fiecare execuție a corpului. Același algoritm se poate transpune în C++ sau Python fără să schimbe ideea de calcul.

Exemplul 1 — suma cifrelor. Algoritmul:

citește n
s ← 0
cât timp n > 0 execută
    s ← s + n % 10
    n ← [n / 10]
scrie s

Pentru $n=583$ tabelul valorilor $(n;s)$ după fiecare execuție a corpului este: la început $(583;0)$, apoi $(58;3)$, $(5;11)$ și $(0;16)$. Testul $0>0$ este fals, ciclul se oprește și se scrie 16. Transpus în C++, algoritmul este:

#include <iostream>
using namespace std;
int main() {
    int n, s = 0;
    cin >> n;
    while (n > 0) {
        s += n % 10;
        n /= 10;
    }
    cout << s;
    return 0;
}

Exemplul 2 — repetare cu test final. Algoritmul a ← 1, repetă a ← a * 2 până când a > 50, scrie a calculează cea mai mică putere a lui 2 mai mare decât 50. Valorile lui $a$ sunt 2, 4, 8, 16, 32 și 64. După a cincea execuție testul $32>50$ este fals, deci ciclul continuă; după a șasea, $64>50$ este adevărat și se scrie 64. Condiția din pseudocod este de oprire; în C++ ciclul do { a *= 2; } while (a <= 50); folosește condiția de continuare, negația ei.

Tabelul de urmărire are o coloană pentru fiecare variabilă și un rând pentru fiecare execuție a corpului; pentru ciclurile cu test se adaugă o coloană cu rezultatul condiției. Dacă ultimul rând arată o condiție adevărată de continuare, algoritmul încă nu s-a oprit și trebuie urmărit mai departe.

Exemple suplimentare

Exemplul 3 — alternativa. Secvența citește x, dacă x % 2 = 0 atunci scrie "par" altfel scrie "impar" afișează „par” pentru $x=18$ și „impar” pentru $x=7$. Egalitatea din condiție se scrie =, iar atribuirea se scrie cu săgeată: expresia $x=18$ este o comparație, pe când $x\leftarrow 18$ este o atribuire.

Exemplul 4 — repetarea cu număr cunoscut de pași. Algoritmul

s ← 0
pentru i←1,4 execută
    s ← s + i * i
scrie s

execută corpul de 4 ori. Perechile $(i;s)$ după fiecare execuție sunt $(1;1)$, $(2;5)$, $(3;14)$ și $(4;30)$, deci se scrie 30, suma pătratelor $1^2+2^2+3^2+4^2$. Contorul $i$ nu se modifică în corpul ciclului, iar numărul de execuții este $b-a+1$, adică 4 pentru limitele 1 și 4. Dacă limitele sunt inversate, ca la pentru i←5,2, corpul nu se execută nicio dată, iar $s$ rămâne 0. Dacă limitele sunt egale, ca la pentru i←3,3, corpul se execută o singură dată.

Exemple rezolvate

Exemplul 1: un algoritm de tip Bac, cu toate cerințele

Se consideră algoritmul:

citește n (număr natural)
k ← 0; s ← 0
┌cât timp n > 0 execută
│  c ← n % 10
│ ┌dacă c % 2 = 0 atunci
│ │  s ← s * 10 + c
│ │altfel
│ │  k ← k + 1
│ └■
│  n ← [n / 10]
└■
scrie s, ' ', k

a) Ce se afișează pentru n = 52816? Cifrele se iau de la dreapta la stânga:

Se afișează 682 2: s este format din cifrele pare, în ordinea inversă, iar k numără cifrele impare.

b) Câte numere de trei cifre pot fi citite, astfel încât să se afișeze 0 3? Pentru k = 3 trebuie ca toate cele trei cifre să fie impare; atunci s rămâne 0. Fiecare cifră se alege din 1, 3, 5, 7, 9, deci sunt 5 · 5 · 5 = 125 de numere. Atenție: s = 0 se obține și când singurele cifre pare sunt zerouri (pentru 7300 se afișează 0 2), dar la trei cifre k = 3 nu lasă loc pentru niciun zero.

c) Programul C++ corespunzător:

#include <iostream>
using namespace std;

int main() {
    int n, k = 0, s = 0, c;
    cin >> n;
    while (n > 0) {
        c = n % 10;
        if (c % 2 == 0)
            s = s * 10 + c;
        else
            k = k + 1;
        n = n / 10;
    }
    cout << s << ' ' << k;
    return 0;
}

Pentru intrarea 52816, programul afișează:

682 2

d) Un algoritm echivalent, cu structura repetă … până când:

citește n (număr natural)
k ← 0; s ← 0
┌repetă
│  c ← n % 10
│ ┌dacă c % 2 = 0 atunci
│ │  s ← s * 10 + c
│ │altfel
│ │  k ← k + 1
│ └■
│  n ← [n / 10]
└până când n = 0
scrie s, ' ', k

Verifici singurul caz în care cele două structuri se pot purta diferit: n = 0. Algoritmul inițial nu intră în buclă și afișează 0 0. Cel nou intră o dată, cu c = 0, care e par, deci s = 0 · 10 + 0 = 0, apoi n rămâne 0 și bucla se oprește: afișează tot 0 0. De aceea aici nu e nevoie de dacă n > 0 atunci în jurul buclei; în general, trebuie verificat de fiecare dată.

În Python (clasa a IX-a, programa nouă), același algoritm se scrie:

n = int(input())
k = 0
s = 0
while n > 0:
    c = n % 10
    if c % 2 == 0:
        s = s * 10 + c
    else:
        k = k + 1
    n = n // 10
print(s, k)

682 2

Rezultatul de mai sus este pentru intrarea 52816. În Python, câtul împărțirii întregi se scrie //, iar / dă un număr real.

Numărul 125 de la punctul b) se poate verifica și în C++, rulând algoritmul pe toate numerele de trei cifre:

#include <iostream>
using namespace std;

int main() {
    int total = 0;
    for (int x = 100; x <= 999; x++) {
        int n = x, k = 0, s = 0;
        while (n > 0) {
            int c = n % 10;
            if (c % 2 == 0) s = s * 10 + c;
            else k++;
            n = n / 10;
        }
        if (s == 0 && k == 3)
            total++;
    }
    cout << total << "\n";
    return 0;
}

125

Exemplul 2: de la pentru la cât timp

citește a, b (numere naturale, a ≤ b)
s ← 0
┌pentru i ← a, b execută
│ ┌dacă i % 3 = 0 atunci
│ │  s ← s + i
│ └■
└■
scrie s

1. Algoritmul adună multiplii lui 3 dintre a și b, inclusiv capetele. Pentru a = 4 și b = 20: 6 + 9 + 12 + 15 + 18 = 60.
2. Varianta cu cât timp: i ← a înainte de buclă, condiția i ≤ b, iar i ← i + 1 ca ultimă instrucțiune din corp.

#include <iostream>
using namespace std;

int main() {
    int a, b, s1 = 0, s2 = 0;
    cin >> a >> b;
    for (int i = a; i <= b; i++)        // pentru i <- a, b
        if (i % 3 == 0)
            s1 = s1 + i;
    int i = a;                          // cat timp, echivalent
    while (i <= b) {
        if (i % 3 == 0)
            s2 = s2 + i;
        i = i + 1;
    }
    cout << s1 << " " << s2 << "\n";
    return 0;
}

Pentru intrarea 4 20, ambele variante dau același rezultat:

60 60

Exemplul 3: când repetă și cât timp nu sunt echivalente

Algoritmul de mai jos numără cifrele lui n:

citește n (număr natural)
nr ← 0
┌repetă
│  nr ← nr + 1
│  n ← [n / 10]
└până când n = 0
scrie nr

1. Pentru n = 2026 se fac patru treceri și se afișează 4.
2. Pentru n = 0 se face o trecere și se afișează 1, ceea ce e corect: 0 are o cifră.
3. Dacă înlocuiești structura cu cât timp n ≠ 0 execută, pentru n = 0 corpul nu se mai execută și se afișează 0. Varianta cu cât timp e echivalentă numai dacă adaugi tratarea separată a lui n = 0.

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int x = n, nr1 = 0;
    do {                       // repeta ... pana cand x = 0
        nr1++;
        x = x / 10;
    } while (!(x == 0));
    x = n;
    int nr2 = 0;
    while (x != 0) {           // cat timp x != 0
        nr2++;
        x = x / 10;
    }
    cout << nr1 << " " << nr2 << "\n";
    return 0;
}

Pentru intrarea 0, programul afișează rezultatele diferite ale celor două variante:

1 0

Pentru intrarea 2026, ambele variante dau 4.

La un algoritm dat în pseudocod, stabilește mai întâi ce fel de ciclu este și ce condiție folosește. Nu transpune mecanic „până când $x\ge n$” în while (x >= n): dacă sensul este oprirea, continuarea este x < n. Urmărește și ultima execuție a corpului: testul se evaluează cu valoarea rezultată după ea. În expresii, % și / au prioritate față de + și -, iar $[x]$ trunchiază: $[7/2]=3$ și $[10/10]=1$. Variabilele a căror valoare nu se schimbă în corp nu pot face condiția să devină falsă. Numărul de execuții se poate afla fără tabel: pentru $n>0$, ciclul cu $n\leftarrow [n/10]$ se execută de atâtea ori câte cifre are $n$, adică 3 ori pentru 583 și 4 ori pentru 2345.

Exemplu în formatul examenului. Se citește numărul $n=2345$. Ce se scrie în urma executării algoritmului de mai jos?

citește n
c ← 0
cât timp n ≠ 0 execută
    dacă (n % 10) % 2 = 1 atunci
        c ← c + 1
    n ← [n / 10]
scrie c

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

Răspunsul corect este b). Cifrele se extrag în ordinea 5, 4, 3, 2, iar valorile lui $n$ sunt 2345, 234, 23, 2, 0. Cifra 5 este impară ($5\%2=1$), deci $c=1$; 4 este pară; 3 este impară, deci $c=2$; 2 este pară. Când $n=0$ ciclul se oprește și se scrie 2. Algoritmul numără cifrele impare ale lui $n$. Varianta d) numără toate cifrele, iar varianta c) ar rezulta dacă s-ar număra și una dintre cifrele pare.

Unde apare la examen

• Bacalaureatul, informatică, matematică-informatică: programa de examen cuprinde „Descrierea algoritmilor (programe pseudocod)”, iar printre competențele evaluate sunt reprezentarea algoritmilor prin pseudocod și prin programe, urmărirea evoluției valorilor variabilelor și construirea algoritmilor echivalenți (programa de examen, anexa 2 la OMECTS 4800/2010). La sesiunea din iunie–iulie 2026, primul exercițiu al Subiectului al II-lea a pornit de la un algoritm în pseudocod și a cerut, ca în exemplul 1: valoarea afișată pentru date date (6 puncte), un set de date de intrare pentru un rezultat dat (6 puncte), programul C/C++ corespunzător (10 puncte) și un algoritm echivalent, cu altă structură repetitivă (6 puncte) (subiectele și baremele Bac 2026). Formatul descris este cel din 2026; potrivit proiectului de ordin pentru Bacalaureatul 2027, programa rămâne aceeași.
• Programa școlară: pseudocodul și structurile de bază sunt la clasa a IX-a, pe ambele programe; programa nouă precizează convențiile de scriere și simbolurile schemei logice (OMEC 6930/2025, anexa 42).

Greșeli frecvente

• Greșit: „până când” și „cât timp” au același sens al condiției.
  Corect: „până când” dă condiția de oprire, iar „cât timp” condiția de continuare; repetă … până când n = 0 devine do { … } while (n != 0);, nu while (n == 0).
• Greșit: $x\leftarrow x+1$ compară două expresii.
  Corect: atribuie lui $x$ valoarea veche plus 1.
• Greșit: la „repetă … până când” corpul poate fi omis.
  Corect: se execută cel puțin o dată; la transformarea lui cât timp în repetă, verifici datele pentru care condiția e falsă de la început (de obicei n = 0).
• Greșit: pentru i ← 1, n se scrie în C++ cu i < n.
  Corect: corpul se execută și pentru i = n, deci condiția este i <= n.
• Greșit: partea întreagă [n / 10] se copiază ca atare în C++.
  Corect: pentru variabile întregi este n / 10 în C++ și n // 10 în Python.
• Greșit: precizările de lângă citește se ignoră.
  Corect: „număr natural nenul” sau „a ≤ b” spun ce date sunt corecte, iar răspunsul trebuie să le respecte.
• Greșit: urmărirea sare pași.
  Corect: faci tabelul complet, cu o linie la fiecare modificare; la Bac se punctează numai rezultatul exact.

Înainte și după

Întrebări frecvente