Invatare Atomica

Strategii pentru examenul de BAC la informatica

Progres lectie:
0%
🎯

Obiectivul lectiei

Vei stapani un plan concret de atac al examenului de Bacalaureat la informatica: cum sa distribui cele 180 de minute, in ce ordine abordezi cerintele, cum eviti capcanele de timp si cum verifici eficient inainte de a preda.

Dupa aceasta lectie vei putea:

  • Sa planifici distributia celor 180 de minute pe cele 3 subiecte ale examenului
  • Sa aplici strategia "citeste-schiteaza-codifica-verifica" la Subiectul III
  • Sa identifici cerintele cu punctaj garantat si sa le rezolvi primele
  • Sa recunosti semnalele de alarma care indica pierdere inutila de timp
  • Sa aplici o rutina de verificare finala in ultimele 20 de minute
  • Sa gestionezi situatia in care ramai blocat la o cerinta EXCLUSIV INTENSIV

Incearca singur!

Provocare:

Inainte sa citesti lectia, raspunde sincer: ai 180 de minute si 3 subiecte a cate 30 de puncte fiecare. Cat timp dai fiecaruia si in ce ordine le rezolvi? Scrie planul tau actual.

💡 Ai nevoie de un indiciu?

Gandeste-te ca nu toate cerintele au acelasi raport dificultate/punctaj. Unele cerinte de 5 puncte pot fi rezolvate in 2 minute, altele tot de 5 puncte pot bloca 20 de minute.

Regula de aur: punctaj garantat intai, dificultate maxima ultima — si pastreaza mereu 20 de minute pentru verificare.

1

1. Structura examenului — ce te asteapta

Examenul de Bacalaureat E(d) Informatica are 180 de minute si 3 subiecte, fiecare cu maxim 30 de puncte oficiale (plus 10 puncte din oficiu = 100 total). Limbajul ales (C++ sau Pascal) trebuie declarat pe foaia de examen.
Structura celor 3 subiecte (model 2024-2025):

Subiectul I (30p) — teorie si evaluare rapida: grile, expresii, conversii baze de numeratie, trasarea unui algoritm dat, pseudocod simplu. Tip: 5-6 itemi de 5 puncte fiecare.

Subiectul II (30p) — algoritmi clasici: CMMDC, recursivitate, prelucrare vectori si siruri de caractere. Tip: 3-4 subpuncte progresive.

Subiectul III (30p) — problema complexa cu date structurate: backtracking, grafuri, arbori, matrice. Un singur enunt cu 4-5 subpuncte progresive.

De ce 180 de minute nu sunt suficiente daca nu planifici:

Un candidat nepregatit poate pierde 40-50 de minute pe prima cerinta grea din Subiectul III, ramanand fara timp pentru cerintele usoare de la Subiectul I. Planificarea inverseaza aceasta capcana: cerintele cu cel mai bun raport punctaj/minut se rezolva primele.

2

2. Distributia optima a timpului

Principiu: nu aloca timp proportional cu dificultatea — aloca timp proportional cu punctajul garantat. Subiectul I are cel mai bun raport punctaj/minut, deci se face repede si sigur. Subiectul III necesita mai mult timp dar nu trebuie sa fure timp de la Subiectul I.

Planul confirmat prin simulare (Python, rulat si verificat):

# Plan optimal BAC Informatica (180 minute)
subiecte = [
    {"nr": "I",   "timp_min": 40,  "puncte": 30},
    {"nr": "II",  "timp_min": 50,  "puncte": 30},
    {"nr": "III", "timp_min": 70,  "puncte": 30},
]
rezerva = 20  # minute verificare finala
total = sum(s["timp_min"] for s in subiecte) + rezerva
for s in subiecte:
    rata = s["puncte"] / s["timp_min"]
    print(f"Subiectul {s['nr']}: {s['timp_min']} min | {rata:.3f} p/min")
print(f"Verificare: {rezerva} min | TOTAL: {total} min")
Output real (rulat cu python):
Subiectul I: 40 min | 0.750 p/min
Subiectul II: 50 min | 0.600 p/min
Subiectul III: 70 min | 0.429 p/min
Verificare: 20 min | TOTAL: 180 min
De ce 20 de minute rezerva pentru verificare?

O eroare de ; uitat, o conditie gresita (<= in loc de <) sau o variabila neinitializata poate costa 5-10 puncte. 20 de minute de verificare atenta pot recupera mai mult decat inca 20 de minute petrecute la o cerinta blocanta.

3

3. Ordinea de rezolvare — punctaj garantat intai

Regula fundamentala: nu sari direct la cerinta grea doar pentru ca e prima listata. Citeste rapid tot subiectul (2 minute), identifica cerintele la care stii sigur raspunsul si rezolv-le primele. Cerintele blocante se lasa la final.
Strategia pas cu pas pentru fiecare subiect:

Pasul 1 — Citire rapida (2 min): Citesti tot subiectul fara sa scrii nimic. Clasifici fiecare cerinta: "garantata" (stiu sigur), "probabila" (cu efort reusesc), "riscanta" (nu sunt sigur).

Pasul 2 — Garantate (~60% din timp): Rezolvi rapid cerintele garantate. Nu te opri sa perfectezi formularea — scrie direct si clar.

Pasul 3 — Probabile (~30% din timp): Cerintele la care trebuie sa gandesti. Aloca un timp maxim si respecta-l cu strictete.

Pasul 4 — Riscante (~10% din timp sau 0): Daca mai ai timp, incerci. Daca nu, lasi liber. O foaie alba la o cerinta grea este mai buna decat cod gresit si sters.

Exemplu concret la Subiectul II:

Daca subiectul are: a) scrie algoritmul CMMDC (5p) + b) urmareste executia pe a=48, b=18 (5p) + c) modifica algoritmul (10p) + d) implementeaza functia recursiva (10p)

Ordinea recomandata: a, b, c, d — in ordine, cerintele sunt progresive. Dar daca d te blocheaza: scrie semnatura functiei corecte si un comentariu explicativ — punctaj partial exista in baremul oficial.

4

4. Atacul Subiectului III — citeste-schiteaza-codifica-verifica

Subiectul III este problema complexa (backtracking, grafuri, arbori sau matrice). Candidatii care incep sa scrie cod direct pierd frecvent 10-15 minute rescrind dupa ce constata o greseala de logica. Solutia: 4 faze distincte, executate in ordine.
Faza 1 — Citire atenta (5 minute):

Citesti enuntul complet si toate subpunctele inainte sa scrii un singur cuvant. Identifici: ce tip de structura de date (vector, matrice, graf, arbore)? Ce operatie principala (parcurgere, cautare, generare solutii)? Ce date de intrare si ce format de output?

Pe enunt, subliniaza: dimensiunile maxime (n ≤ 1000? n ≤ 100?), restrictiile (elemente distincte? numar pozitiv?), formatul outputului (pe o linie? sortat? cu spatii intre?).

Faza 2 — Schita pe ciorna (5-10 minute):

Pe ciorna, nu pe foaia de examen, scrii pseudocod sau schema logica a algoritmului principal. Nu cod C++, ci logica: "citesc n, citesc vectorul v, apelez bkt(0, solutie), pentru fiecare solutie gasita afisez..."

Aceasta faza economiseste 15-20 de minute de rescris cod gresit pe foaia curata si reduce erorile de logica cu pana la 70%.

Faza 3 — Codificare (40-50 minute):

Scrii codul curat, complet, cu declaratii corecte. Respecta indentarea — corectorii scad puncte daca codul e ilizibil. Include comentarii scurte la functii complexe (ex: // bkt: genereaza toate permutarile).

Faza 4 — Verificare manuala (5 minute):

Urmaresti executia algoritmului pas cu pas pe exemplul mic din enunt. Compari output-ul asteptat cu cel cerut. Verifici: declari toate variabilele? Conditia de oprire e corecta? Vectorii incep de la 0 sau 1? Afisezi exact ce se cere (cu newline, spatii)?

5

5. Capcane tehnice frecvente la BAC in C++ EXCLUSIV INTENSIV

⚡ Sectiune doar pentru intensiv informatica

La profilul intensiv C++ este limbajul principal. Urmatoarele capcane apar frecvent in cod scris sub presiune de timp si costa puncte inutile.

Cod complet compilat si verificat (g++ -std=c++17):

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Capcana 1: limita superioara a vectorului
    int n = 5;
    vector<int> v = {3, 1, 4, 1, 5};
    int suma = 0, maxim = v[0];
    // CORECT: i < n (nu i <= n, care acceseaza v[5] = comportament nedefinit)
    for (int i = 0; i < n; i++) {
        suma += v[i];
        if (v[i] > maxim) maxim = v[i];
    }
    cout << "Suma: " << suma << " | Maxim: " << maxim << endl;

    // Capcana 2: impartire intreaga vs reala
    int a = 7, b = 2;
    double gresit = a / b;           // impartire intreaga => 3.0 (GRESIT!)
    double corect = (double)a / b;   // cast explicit => 3.5 (CORECT)
    cout << "7/2 (int div): " << gresit
         << " | (double)7/2: " << corect << endl;

    // Capcana 3: overflow int la valori mari (n pana la 10^6 la BAC)
    int x = 1000000, y = 1000000;
    long long produs = (long long)x * y;  // cast inainte de inmultire
    cout << "1000000 * 1000000 = " << produs << " (long long, corect)" << endl;

    return 0;
}
Output real (compilat g++ -std=c++17, rulat):
Suma: 14 | Maxim: 5
7/2 (int div): 3 | (double)7/2: 3.5
1000000 * 1000000 = 1000000000000 (long long, corect)
Lista de verificare tehnica inainte de predare (C++):

✓ Toate variabilele declarate si initializate la 0 / valoarea corecta?

✓ Indicii de vector incep de la 0 sau 1 (in functie de conventie declarata)?

✓ Conditia de oprire a buclei este i < n, nu i <= n?

✓ Impartirile care trebuie sa fie reale au cast la double?

✓ Produse de numere mari sunt stocate in long long?

✓ Fiecare functie are instructiunea return pe toate caile?

✓ Afisezi exact ce cere enuntul (spatii, linii noi, format)?

✓ Nu ai lasat cod comentat sau variabile nefolosite care pot deruta corectorul?

6

6. Semnale de alarma si rutina de verificare finala

Semnalele de alarma indica faptul ca strategia de timp este devansata. Identificarea lor in timp util permite o corectie inainte sa fie prea tarziu. Rutina de verificare finala de 20 de minute este cea mai buna "investitie" de puncte din tot examenul.
Semnale de alarma — opreste-te si recalibreaza imediat:

⚠ Ai petrecut mai mult de 15 minute pe o singura cerinta de 5 puncte — cerinta e peste nivelul tau curent. Las-o, nu o forta.

⚠ Ai scris si sters acelasi cod de 3 ori — abordarea ta e gresita. Mergi la ciorna si schiteaza altceva.

⚠ Mai ai 40 de minute si Subiectul I e nerealizat — treci imediat la Subiectul I, rezolva tot ce poti in 20 de minute, revii la Subiectul III cu ce ramane.

⚠ Ai incercat 3 abordari diferite si niciuna nu converge — acel subtip de cerinta nu este dominat de tine. Scrie ce stii partial, cu semnatura functiei si un comentariu de intentie, si treci mai departe.

Rutina de verificare finala (ultimele 20 de minute):

Minut 1-5 — Subiectul I: Recitesti fiecare raspuns. Verifici conversiile baze, valorile expresiilor, raspunsurile grilelor. O grila gresita = 5 puncte; 2 minute de recitire o poate salva.

Minut 6-12 — Subiectul II: Urmaresti executia codului tau pe exemplul din enunt, pas cu pas. Compari output-ul asteptat cu cel cerut. Corectezi sintaxa evidenta: ; lipsa, acolada neclosita, variabila nedeclarata.

Minut 13-18 — Subiectul III: Urmaresti executia functiei principale pe datele de test mici (n=3 sau n=4). Verifici ca afisezi exact formatul cerut, inclusiv spatii si linii noi.

Minut 19-20 — Administrativa: Verifici ca ai scris numele, prenumele, CNP-ul si limbajul ales pe foaia de examen. Aranjezi foile in ordine numerotata.

Planul verificat prin simulare C++ (g++ -std=c++17, rulat):
// Output: eficienta pe subiect confirma prioritatea de verificare
// Subiectul I (Grile/Teorie): 40 min | 0.75 p/min
// Subiectul II (Algoritmi):   50 min | 0.60 p/min
// Subiectul III (Prob.compl): 70 min | 0.43 p/min
// Verificare:                 20 min
// TOTAL:                     180 min
//
// => Subiectul I are 0.75 p/min, cel mai ridicat.
// => La verificare, corecteaza Subiectul I intai!

Exercitii practice

Exercitiul 1 (Nivel minim) — Planul de timp

Ai la dispozitie 180 de minute. Completeaza tabelul: cat timp aloci fiecarui subiect si pentru verificare, astfel incat totalul sa fie exact 180 de minute. Justifica de ce Subiectul I primeste mai putin timp decat Subiectul III, desi ambele valoreaza 30 de puncte.

Exercitiul 2 (Nivel standard) — Ordinea de rezolvare

La Subiectul II gasesti: a) Scrie algoritmul CMMDC pentru doua numere (5p). b) Traseaza executia pentru a=48, b=18 (5p). c) Modifica algoritmul sa calculeze si CMMMC (10p). d) Implementeaza o functie recursiva pentru CMMDC (10p). In ce ordine le rezolvi si cat timp aloci fiecareia? Ce faci daca d) te blocheaza mai mult de 15 minute?

Exercitiul 3 (Nivel performanta) — Simulare completa EXCLUSIV INTENSIV

Cerinta tip Subiectul III: "Se da un vector cu n numere intregi. Scrieti un program C++ care afiseaza toate perechile (i,j) cu i<j astfel incat v[i]+v[j] este par. Complexitate: O(n^2)." Aplica strategia citeste-schiteaza-codifica-verifica: scrie pseudocod pe ciorna, implementeaza in C++, urmareste manual executia pe v={1,2,3,4,5} si verifica toate capcanele tehnice din Atomul 5 (limita vector, impartire intreaga, overflow).

Ce ai invatat astazi

  • Structura examenului BAC E(d) Informatica: 180 minute, 3 subiecte a 30 puncte
  • Planul optim de timp: Subiectul I 40 min + II 50 min + III 70 min + 20 min verificare
  • Principiul "punctaj garantat intai": eficienta p/minut ghideaza ordinea de rezolvare
  • Strategia celor 4 faze la Subiectul III: citeste, schiteaza, codifica, verifica
  • Capcanele tehnice C++: limita vector (i < n), impartire intreaga, overflow long long
  • Rutina de verificare finala (20 minute) si cele 4 semnale de alarma

Urmatoarea lectie

Lectia 8 analizeaza greselile frecvente intalnite la corectarea lucrarilor de BAC — ce sa eviti si cum sa nu pierzi puncte prin erori tehnice sau de prezentare.

Lectia 8 →