Invatare Atomica

Probleme tip Bacalaureat: urmarirea executiei

Progres lectie:
0%
🎯

Obiectivul lectiei

Vei invata metoda de tabel de trasare (urmarirea variabilelor pas cu pas) pentru a determina EXACT ce afiseaza un program cu structuri de control — tipul de exercitiu cel mai frecvent la Subiectul II al examenului de Bacalaureat.

Dupa aceasta lectie vei putea:

  • Sa construiesti un tabel de trasare a variabilelor pentru un program cu bucle
  • Sa determini ce afiseaza un program cu structura FOR fara sa-l rulezi
  • Sa urmaresti executia unei bucle WHILE cu conditie de oprire
  • Sa trasezi cod cu IF imbricat intr-o bucla (decizii pe fiecare iteratie)
  • Sa rezolvi probleme tip Bac de citire si trasare in Python si C++ (intensiv)

Incearca singur!

🎯 PREDICTIE
Provocare:

Fara sa rulezi nimic, ce crezi ca afiseaza acest fragment? Scrie raspunsul tau, apoi verifica in prima sectiune.

s = 0
for i in range(1, 6):
    s = s + i
print(s)
💡 Ai nevoie de un indiciu?

range(1, 6) genereaza valorile 1, 2, 3, 4, 5 (limita din dreapta NU este inclusa). La fiecare pas adunam valoarea lui i in s.

Aduna in minte: 1 + 2 + 3 + 4 + 5. Cat iti da?

1

1. Metoda tabelului de trasare

A trasa (a urmari executia) inseamna sa notezi intr-un tabel valoarea fiecarei variabile dupa fiecare pas al programului. Asa afli exact ce se afiseaza, fara sa rulezi codul — metoda standard ceruta la Bacalaureat.

Sa luam fragmentul din provocare:

s = 0
for i in range(1, 6):
    s = s + i
print(s)

Trasam fiecare iteratie: coloana i = valoarea curenta a contorului, coloana s = valoarea dupa atribuire.

Iteratieis = s + is dupa pas
start——0
110 + 11
221 + 23
333 + 36
446 + 410
5510 + 515

Iesire reala (rulat cu python):

15

💡
Capcana clasica

In Python, range(1, 6) NU include 6. Multi elevi aduna gresit pana la 6 si obtin 21. Citeste mereu cu atentie limitele lui range.

2

2. Trasarea unei bucle WHILE: suma cifrelor

La buclele WHILE, atentia merge la conditia de oprire. Sa trasam un algoritm clasic de Bac — suma cifrelor unui numar:

n = 2451
s = 0
while n != 0:
    s = s + n % 10   # adauga ultima cifra
    n = n // 10       # elimina ultima cifra
print(s)
Pasn (inainte)n % 10sn (dupa // 10)
1245111245
22455624
3244102
422120
stop0conditia n != 0 este FALSA → bucla se opreste

Iesire reala (rulat cu python):

12

⚡
Regula de aur la WHILE

Verifica intotdeauna ca exista un pas care apropie variabila de conditia de oprire (aici n = n // 10). Daca lipseste, bucla devine infinita.

3

3. IF imbricat intr-o bucla FOR

Cele mai grele probleme combina o bucla cu o decizie. Aici, la fiecare pas decidem dupa paritatea lui i:

x = 0
for i in range(1, 8):
    if i % 2 == 0:
        x = x + i      # i par: aduna i
    else:
        x = x - 1      # i impar: scade 1
print(x)

range(1, 8) parcurge 1, 2, 3, 4, 5, 6, 7. Notam si ramura aleasa:

ii par?ramuraoperatiex
1nuelsex - 1-1
2daifx + 21
3nuelsex - 10
4daifx + 44
5nuelsex - 13
6daifx + 69
7nuelsex - 18

Iesire reala (rulat cu python):

8

4

4. Trasare cu doua variabile care se schimba

Acesta este nucleul descompunerii in factori primi (tema 2.2 din programa). Doua variabile evolueaza: n (numarul ramas) si d (divizorul incercat). Numaram in nr cati factori primi are 60:

n = 60
d = 2
nr = 0
while n > 1:
    if n % d == 0:
        nr = nr + 1
        n = n // d
    else:
        d = d + 1
print(nr)
Pasndn % d == 0?actiunenr
1602dan=301
2302dan=152
3152nud=32
4153dan=53
553nud=43
654nud=53
755dan=14
stop15n > 1 este FALS → stop

Iesire reala (rulat cu python):

4

Intr-adevar 60 = 2 · 2 · 3 · 5, deci 4 factori primi (numarati cu multiplicitate). Acest algoritm face un numar de pasi proportional cu numarul incercarilor de divizor; pentru cazul cel mai rau (n prim) complexitatea este O(n).

5

5. Acelasi tipar in C++ intensiv

⚡
Sectiune EXCLUSIV intensiv informatica

La specializarea intensiv informatica, al doilea limbaj este C++. Subiectele de tip Bac in C++ folosesc EXACT aceeasi metoda de trasare; doar sintaxa difera. Daca esti la profil standard, poti sari peste acest atom.

Problema clasica: oglinda (rasturnatul) unui numar. Trasam constructia in r:

#include <iostream>
using namespace std;
int main() {
    int n = 1234, r = 0;
    while (n != 0) {
        r = r * 10 + n % 10;  // adauga ultima cifra la dreapta lui r
        n = n / 10;            // elimina ultima cifra din n
    }
    cout << r << endl;
    return 0;
}
Pasnn % 10r = r*10 + n%10n / 10
1123444123
212334312
31224321
41143210
stop0n != 0 este FALS → stop

Iesire reala (compilat cu g++ -std=c++17):

4321

⚠
Atentie la C++

In C++, n / 10 pe variabile int face impartire INTREAGA (echivalentul lui // din Python). Daca n ar fi double, / 10 ar pastra zecimalele si algoritmul nu ar mai functiona.

6

6. Bucle imbricate: numara executiile intensiv

⚡
Sectiune EXCLUSIV intensiv informatica

Buclele imbricate cu limita dependenta (interiorul porneste de la i) sunt frecvente la profilul intensiv. Aici contorul depinde de iteratia exterioara.

Cand bucla interioara incepe de la i (nu de la 1), numarul de pasi scade la fiecare runda. Trasam contorul c:

#include <iostream>
using namespace std;
int main() {
    int c = 0;
    for (int i = 1; i <= 3; i++)
        for (int j = i; j <= 3; j++)
            c++;
    cout << c << endl;
    return 0;
}
ivalori jcati pasic cumulat
11, 2, 333
22, 325
3316

Iesire reala (compilat cu g++ -std=c++17):

6

Pentru limita generala n in loc de 3, corpul se executa de 1 + 2 + ... + n = n(n+1)/2 ori, deci complexitatea este O(n²) — tipic pentru doua bucle imbricate.

Exercitii practice

Exercitiul 1 (Nivel minim) - Determina iesirea

Construieste tabelul de trasare si scrie ce afiseaza programul:

n = 5
while n >= 1:
    print(n, end=" ")
    n = n - 2

Indiciu: porneste de la 5 si scade 2 la fiecare pas, cat timp valoarea ramane ≥ 1. Raspunsul corect este: 5 3 1

Exercitiul 2 (Nivel standard) - Trasare cu IF in bucla

Fara sa rulezi, completeaza tabelul de trasare (coloanele i, ramura, p) si determina ce se afiseaza:

p = 1
for i in range(1, 5):
    if i % 2 == 1:
        p = p * i
print(p)

Indiciu: range(1,5) da 1,2,3,4. Inmultim p doar pentru valorile impare ale lui i (1 si 3). Verifica-ti raspunsul rezolvand tabelul pana la capat.

Exercitiul 3 (Nivel performanta) - Algoritm clasic Bac

Trasaza acest algoritm pentru n = 13 si spune ce afiseaza. Apoi explica in cuvinte ce verifica programul despre n:

n = 13
d = 2
ok = 1
while d < n:
    if n % d == 0:
        ok = 0
    d = d + 1
print(ok)

Indiciu: ok ramane 1 doar daca niciun d intre 2 si n-1 nu divide pe n. Ce proprietate a numarului n inseamna asta? (Provocare: rescrie acelasi algoritm in C++ — sectiune intensiv.)

Ce ai invatat astazi

  • Metoda tabelului de trasare: o coloana pentru fiecare variabila, un rand pentru fiecare pas
  • La FOR: citeste cu atentie limitele lui range (dreapta NU se include)
  • La WHILE: urmareste conditia de oprire si pasul care apropie variabila de ea
  • La IF in bucla: noteaza pe fiecare rand ce ramura s-a executat
  • Tiparul "ultima cifra": n % 10 ia cifra, n // 10 o elimina
  • Bucle imbricate cu limita dependenta → complexitate O(n²) (intensiv)

Ai terminat modulul!

Aceasta a fost ultima lectie din modulul Structuri de Control. Intoarce-te la pagina modulului pentru a-ti vedea progresul.

Inapoi la modul →