Simulare Bac informatică 2026: subiectele, baremul și rezolvarea

Documentele oficiale

Subiectele și baremele oficiale sunt publicate de Ministerul Educației; mai jos sunt linkurile către ele, pe profiluri.

Datele probei

Pagina oficială de arhivă a subiectelor: subiecte.edu.ro/2027/arhiva.

Proba E.d) din simularea examenului național de bacalaureat 2026 a avut loc pe 25 martie 2026, a treia zi a simulării, după româna (23 martie) și proba E.c) (24 martie). Sursa: lista oficială a subiectelor și calendarul simulării din OMEC 6.059/2025, anexa 2. Lucrarea are trei ore de lucru efectiv, cum scrie în antetul subiectului.

Subiectele sunt publicate în arhiva oficială E_d_2026_Simulare.zip, sub forma unui subiect pentru fiecare profil, limbaj și limbă de predare. Pe această pagină sunt rezolvate subiectele în limbajul C/C++, în limba română. Variantele pentru Pascal sunt în aceeași arhivă, în fișierele E_d_Informatica_2026_sp_MI_Pascal_var_simulare_LRO.pdf (matematică-informatică) și E_d_Informatica_2026_sp_SN_Pascal_var_simulare_LRO.pdf (științele naturii), și nu sunt rezolvate aici. Baremul este comun pentru C/C++ și Pascal.

Informatică M_mate-info: simularea din martie 2026

Simulare. Filieră teoretică, profil real, specializare matematică-informatică / matematică-informatică intensiv informatică; filieră vocațională, profil militar, specializare matematică-informatică. Limbajul C/C++. Se acordă 90 de puncte pentru subiecte și 10 din oficiu; timpul de lucru efectiv este de trei ore.

Subiectul I (20 de puncte)

La fiecare item se alege litera răspunsului corect; fiecare răspuns corect valorează 4 puncte. Baremul oficial dă numai litera, iar justificările de mai jos sunt ale noastre.

1. (4 puncte)

Variabila x este de tip întreg. Indicați o expresie care are valoarea 1 dacă și numai dacă expresia C/C++ x<=20 || x>26 are valoarea 1.

a. !(x>20) || !(x<=26) b. !(x>=20) && !(x>=26) c. !(x<20 || x<=26) d. !(x<20 && x<26)

Rezolvare. Negăm expresia dată cu legile lui De Morgan. Expresia x<=20 || x>26 este adevărată exact când nu este adevărat că x>20 && x<=26, adică are aceeași valoare ca !(x>20 && x<=26). Aplicând De Morgan, aceasta este !(x>20) || !(x<=26), adică varianta a. Celelalte variante nu se potrivesc: b se reduce la x<20 && x<26, adică x<20; c este adevărată numai pentru x>=20 && x>26, adică x>26; d se reduce la x>=20 || x>=26, adică x>=20. Am comparat cele patru expresii cu cea dată pentru toate valorile întregi dintr-un interval mare, iar numai a coincide cu ea.

Răspuns: a.

Punctaj în barem: 4 puncte pentru litera corectă, a.

Lecțiile din spate: Expresii, Operatori în C/C++

2. (4 puncte)

Un mozaic este alcătuit din plăcuțe de formă pătrată, cu dimensiuni egale, de culoare albă sau roșie, așezate pe două rânduri și aliniate ca în exemplu. Mozaicul are un model în zig-zag dacă oricare două plăcuțe cu o latură comună au culoare diferită. Se știe că plăcuțele de pe latura din dreapta au culori diferite.

Variabilele j și ok sunt întregi, iar variabila a este un tablou bidimensional cu două linii și 12 coloane, cu elemente de tip char, în care fiecare linie, în ordine, memorează succesiunea de plăcuțe aflate pe un rând al mozaicului, notându-se cu litera R cele roșii și cu litera A cele albe. Liniile și coloanele sunt numerotate începând de la 0. Indicați expresia care poate înlocui punctele de suspensie astfel încât, în urma executării secvenței C/C++ obținute, variabila ok să aibă valoarea 1, dacă mozaicul are un model în zig-zag, sau valoarea 0 în caz contrar.

Exemplu: în urma executării secvenței pentru tabloul de mai jos, unde sunt evidențiate două zone în care nu se respectă modelul, ok=0.

Figura din enunț este tabloul cu cele două linii, așezate una sub alta și aliniate pe coloane, cu zonele în care modelul nu se respectă marcate:

R A A R A R A R A R A R
A R R A R A R A R R R A

Secvența de completat este:

ok=1;
for(j=0;j<11;j++)
   if(........) ok=0;

Variantele sunt:

a. a[0][j]==a[0][j-1] || a[0][j]==a[1][j-1] b. a[0][j]==a[0][j+1] || a[0][j]==a[1][j+1] c. a[0][j]==a[0][j-1] || a[0][j]==a[1][j+1] d. a[0][j]==a[0][j+1] || a[0][j]==a[1][j]

Rezolvare. Plăcuțele sunt aliniate, deci plăcuța a[0][j] are ca vecini, cu latură comună, pe a[0][j+1] (la dreapta) și pe a[1][j] (sub ea). Condiția de zig-zag cere ca aceste perechi să aibă culori diferite, iar ciclul for se oprește la j=10, deci j+1 rămâne în tablou. Variantele a și c folosesc j-1, care la j=0 iese din tablou, iar b și c compară a[0][j] cu plăcuța a[1][j+1], care este vecină pe diagonală și nu are latură comună cu ea. Rămâne d, care verifică exact cele două perechi vecine ale lui a[0][j].

Varianta d nu verifică separat perechile din rândul al doilea sau coloana 11, și nici nu este nevoie. Cu două culori, dacă a[1][j] diferă de a[0][j] și a[1][j+1] diferă de a[0][j+1], plăcuțele din rândul de jos sunt opusele celor de sus; cum cele de sus diferă între ele, diferă și cele de jos. Coloana 11 este acoperită de precizarea din enunț, că plăcuțele din dreapta au culori diferite. Pe exemplul din enunț secvența dă ok=0, deoarece a[0][1]==a[0][2] (ambele A). Am verificat varianta d, rulând secvența pe 20 000 de mozaice aleatoare, față de definiția modelului în zig-zag: rezultatul coincide de fiecare dată, iar variantele b și c dau cel puțin o dată rezultat greșit (a și c ies în plus din tablou la j=0).

Răspuns: d.

Punctaj în barem: 4 puncte pentru litera corectă, d.

Lecțiile din spate: Matrice, Prelucrări de matrice

3. (4 puncte)

Subprogramul f este definit alăturat, iar variabila x este de tip întreg. Indicați ce se afișează în urma executării secvenței C/C++ de mai jos: x=3; f(x);

void f(int &n)
{   if(n>0) {cout<<n; | printf("%d",n);
             n=n-1; f(n);
             cout<<n; | printf("%d",n);
         }
}

a. 321000 b. 321012 c. 321123 d. 3210123

Rezolvare. Parametrul n este transmis prin referință, deci toate apelurile lucrează cu aceeași variabilă x. Apelul f(3) afișează 3, scade la 2 și apelează f(2), care afișează 2, scade la 1 și apelează f(1); acesta afișează 1, scade la 0 și apelează f(0), care nu face nimic, pentru că n>0 nu mai e adevărat. La întoarcerea din fiecare apel se execută a doua afișare, iar variabila are acum valoarea 0 pentru toate cele trei apeluri aflate în așteptare. Ordinea afișărilor este deci 3, 2, 1 (la coborâre), apoi 0, 0, 0 (la urcare). Am rulat programul și se afișează 321000.

Răspuns: a.

Punctaj în barem: 4 puncte pentru litera corectă, a.

Lecțiile din spate: Recursivitate, Parametri

4. (4 puncte)

La balul absolvenților se acordă șase premii pe baza unei tombole cu 30 de bilete, numerotate de la 30 la 1, în această ordine. Utilizând metoda backtracking, se generează toate variantele de a alege biletele celor șase câștigători, care sunt anunțați în ordine descrescătoare a numerelor de pe bilete. Două soluții diferă prin cel puțin un bilet. Primele trei soluții generate sunt, în această ordine: (30,29,28,27,26,25), (30,29,28,27,26,24), (30,29,28,27,26,23). Indicați penultima soluție generată.

a. (7,6,5,4,3,2) b. (7,6,5,3,2,1) c. (7,6,4,3,2,1) d. (7,5,4,3,2,1)

Rezolvare. Soluțiile sunt generate în ordine lexicografică descrescătoare: se păstrează începutul cât mai mare și se scade ultima valoare cât se poate, apoi cea dinaintea ei. Ultima soluție este cea cu cele mai mici numere, (6,5,4,3,2,1). Soluția dinaintea ei are primul număr 7, cel mai mic cu care se mai pot completa șase premii. Printre soluțiile care încep cu 7 se aleg încă cinci numere din 6, 5, 4, 3, 2, 1, adică șase soluții, în ordinea generării: (7,6,5,4,3,2), (7,6,5,4,3,1), (7,6,5,4,2,1), (7,6,5,3,2,1), (7,6,4,3,2,1), (7,5,4,3,2,1). Ultima dintre ele urmează imediat înaintea lui (6,5,4,3,2,1), deci penultima soluție generată este (7,5,4,3,2,1). Un program care generează cele $\left(\genfrac{}{}{0ex}{}{30}{6}\right)=593775$ de soluții în această ordine confirmă lista de la sfârșit.

Răspuns: d.

Punctaj în barem: 4 puncte pentru litera corectă, d.

Lecțiile din spate: Backtracking, Combinări

5. (4 puncte)

Într-un arbore cu 7 noduri, numerotate de la 1 la 7, nodul 3 este rădăcină și pentru orice nod numerotat cu $i$ ($i\in [1,7]$), dacă se notează cu $F(i)$ numărul de descendenți direcți („fii”) ai lui, atunci $F(i)=0$, dacă $i$ este „frunză”, sau $F(i)=i-1$, în caz contrar. Indicați numărul maxim de „frați” ai nodului 1.

a. 1 b. 2 c. 3 d. 4

Rezolvare. Un arbore cu 7 noduri are 6 muchii, deci numărul total de fii este 6: suma valorilor $F(i)$ ale nodurilor care nu sunt frunze este 6. Nodul 1 nu poate avea $1-1=0$ fii decât ca frunză, deci este frunză. Rădăcina 3 are fii (arborele are mai mult de un nod), deci $F(3)=2$. Mai rămân 4 fii de repartizat nodurilor care nu sunt frunze dintre 2, 4, 5, 6, 7, cu $F=1,3,4,5,6$. Suma 4 se obține în două moduri: un singur nod, 5, cu 4 fii, sau nodurile 2 și 4, cu $1+3$ fii.

În primul caz, rădăcina 3 are doi fii, dintre care unul este 5, iar nodul 5 are patru fii. Nodul 1 poate fi unul dintre cei patru fii ai lui 5, deci are 3 frați. În al doilea caz, cel mai mare număr de fii al unui nod este 3 (nodul 4), deci nodul 1 are cel mult 2 frați. Maximul este 3. O parcurgere a tuturor arborilor cu rădăcina 3 care respectă regula, 25 la număr, confirmă că numărul maxim de frați ai nodului 1 este 3.

Răspuns: c.

Punctaj în barem: 4 puncte pentru litera corectă, c.

Lecțiile din spate: Arbori, Arbori cu rădăcină

Subiectul al II-lea (40 de puncte)

1. (6 + 6 + 10 + 6 puncte)

Algoritmul alăturat este reprezentat în pseudocod. S-a notat cu a%b restul împărțirii numărului natural a la numărul natural nenul b și cu [c] partea întreagă a numărului real c.

citește n (număr natural)
x←0; y←0; p←1
repetă
   c←n%10; n←[n/10]
   dacă c%2=0 atunci
      x←x*10+c
      y←c*p+y; p←p*10
   ■
până când n=0
dacă x<y atunci scrie x
altfel scrie y
■

Algoritmul extrage pe rând cifrele lui n, de la ultima la prima. Pentru fiecare cifră pară c, variabila x o adaugă la dreapta, deci x are cifrele pare în ordine inversă. Variabila y o adaugă la stânga, cu ponderea p, deci y are cifrele pare în ordinea lor din n. La final se scrie cea mai mică dintre valorile x și y.

a. (6 puncte)

Scrieți ce se afișează în urma executării algoritmului dacă se citește numărul 250326.

Rezolvare. Cifrele sunt luate în ordinea 6, 2, 3, 0, 5, 2. Cifra 6 este pară: $x=6$, $y=6$, $p=10$. Cifra 2: $x=62$, $y=2\cdot 10+6=26$, $p=100$. Cifra 3 este impară și nu schimbă nimic. Cifra 0: $x=620$, $y=0\cdot 100+26=26$, $p=1000$. Cifra 5 este impară. Ultima cifră, 2: $x=6202$, $y=2\cdot 1000+26=2026$, $p=10000$, iar acum $n=0$ și ciclul se oprește. Cum $x=6202$ nu este mai mic decât $y=2026$, se scrie $y$.

Răspuns: se afișează 2026.

Punctaj în barem: 6 puncte pentru răspunsul corect, 2026.

b. (6 puncte)

Scrieți două numere din intervalul $[1000,9999]$ care pot fi citite, astfel încât, pentru fiecare dintre acestea, în urma executării algoritmului, să se afișeze valoarea 64.

Rezolvare. Numărul $y$ are cifrele pare ale lui $n$ în ordinea lor, iar $x$ în ordine inversă; rezultatul este $\min (x,y)$. Pentru $64$ avem nevoie ca una dintre valori să fie 64 și cealaltă să nu fie mai mică. Cifrele pare 0, 6, 4, în această ordine, dau $y=064=64$ și $x=460$, deci se afișează 64; o cifră impară oarecare completează numărul la patru cifre. Un exemplu este $1064$: din cifrele pare 0, 6, 4 rezultă $y=64$ și $x=460$. Alt exemplu este $4600$: cifrele pare 4, 6, 0, 0 dau $y=4600$, iar $x$ se formează din 0, 0, 6, 4 și este 64, deci se afișează 64. Am rulat algoritmul pentru ambele numere și se afișează 64.

Răspuns: de exemplu 1064 și 4600.

Punctaj în barem: 3 puncte pentru fiecare număr corect; baremul acceptă orice număr de forma x064, x460, 4x60, 4600, 460x sau 46x0, cu x cifră impară.

c. (10 puncte)

Scrieți programul C/C++ corespunzător algoritmului dat.

Rezolvare. Se traduce algoritmul instrucțiune cu instrucțiune: structura repetă ... până când n=0 devine do { ... } while (n != 0);, iar condiția de oprire se neagă, pentru că do ... while continuă cât timp condiția e adevărată.

#include <iostream>
using namespace std;

int main()
{
    int n, c, x = 0, y = 0, p = 1;
    cin >> n;
    do
    {
        c = n % 10;
        n = n / 10;
        if (c % 2 == 0)
        {
            x = x * 10 + c;
            y = c * p + y;
            p = p * 10;
        }
    } while (n != 0);
    if (x < y)
        cout << x;
    else
        cout << y;
    return 0;
}

Am compilat și rulat programul pentru 250326, care afișează 2026, iar pentru 1064 și 4600 afișează 64.

Răspuns: programul de mai sus.

Punctaj în barem: 10 puncte: câte 1 punct pentru declararea variabilelor, citirea datelor, afișarea datelor, atribuiri și corectitudinea globală, 3 puncte pentru instrucțiunile de decizie (doar 2 dacă numai una dintre cele două este conform cerinței) și 2 puncte pentru instrucțiunea repetitivă.

d. (6 puncte)

Scrieți în pseudocod un algoritm, echivalent cu cel dat, înlocuind adecvat structura repetă...până când cu o structură repetitivă cu test inițial.

Rezolvare. Testul se mută la început: ciclul continuă cât timp $n\ne 0$. Pentru $n\ge 1$ cei doi algoritmi execută aceleași iterații. Pentru $n=0$ ciclul repetă face o singură iterație cu $c=0$, care adaugă un zero la $x$ și la $y$; ambele rămân 0 și se afișează 0, la fel ca în varianta cu test inițial, unde nu se intră în ciclu și $y=0$.

citește n (număr natural)
x←0; y←0; p←1
cât timp n≠0 execută
   c←n%10; n←[n/10]
   dacă c%2=0 atunci
      x←x*10+c
      y←c*p+y; p←p*10
   ■
■
dacă x<y atunci scrie x
altfel scrie y
■

Am verificat varianta cu while pe un program C++ și afișează aceleași valori ca varianta cu do ... while, pentru 250326, 1064, 4600 și 0.

Răspuns: algoritmul de mai sus, cu structura cât timp n≠0 execută.

Punctaj în barem: 2 puncte pentru utilizarea unei structuri repetitive cu test inițial, 3 puncte pentru expresia logică a testului inițial în secvența obținută prin înlocuire și 1 punct pentru algoritmul complet și corectitudinea globală; baremul punctează orice formă explicită de structură repetitivă cu test inițial și acordă punctajul chiar dacă algoritmul obținut nu este echivalent cu cel dat.

Lecțiile din spate: Cifrele unui număr, Structura repetitivă cu test final, Structura repetitivă cu test inițial, Pseudocod

2. (6 puncte)

Un graf neorientat, fără cicluri, are 26 de muchii și două componente conexe. Pentru fiecare dintre cele două componente, scrieți un exemplu de număr de noduri, respectiv de număr de muchii.

Rezolvare. Un graf fără cicluri are fiecare componentă conexă arbore, iar un arbore cu $n$ noduri are $n-1$ muchii. Dacă cele două componente au $n_1$ și $n_2$ noduri, numărul total de muchii este $(n_1-1)+(n_2-1)=n_1+n_2-2=26$, deci $n_1+n_2=28$. Alegem $n_1=10$ noduri și $m_1=9$ muchii pentru prima componentă, apoi $n_2=18$ noduri și $m_2=17$ muchii pentru a doua. Verificare: $9+17=26$.

Răspuns: de exemplu prima componentă cu 10 noduri și 9 muchii, a doua cu 18 noduri și 17 muchii.

Punctaj în barem: câte 2 puncte pentru numărul de noduri al primei componente, pentru numărul de muchii al ei, corespunzător numărului de noduri ales, și pentru datele celei de-a doua componente; se acceptă orice componente cu $n_1\in [1,27]$ noduri și $m_1=n_1-1$ muchii, respectiv $n_2=28-n_1$ și $m_2=n_2-1$.

Lecțiile din spate: Arbori, Conexitate, Grafuri neorientate

3. (6 puncte)

Pentru o sală de examen se memorează următoarele date specifice: numărul de locuri disponibile și durata examenului, exprimată în ore. Variabila s memorează datele specifice pentru fiecare dintre cele 10 săli ale unui centru de testare, iar expresiile de mai jos au valori întregi și reprezintă numărul de locuri ale primei săli, respectiv durata examenului din această sală. Definiți o structură C/C++ cu eticheta sala, care să permită memorarea datelor pentru o sală de examen, și declarați corespunzător variabila s.

s[0].nrLocuri s[0].durata

Rezolvare. Structura sala are două câmpuri întregi, numite după expresiile din enunț: nrLocuri și durata. Variabila s memorează datele a 10 săli, deci este un tablou cu 10 elemente de tip sala, iar s[0] este prima sală.

struct sala
{
    int nrLocuri;
    int durata;
};
sala s[10];

Am compilat declarațiile și am folosit s[0].nrLocuri și s[0].durata. În C se scrie struct sala s[10];; în C++ cuvântul struct poate lipsi la declarare.

Răspuns: structura sala cu câmpurile nrLocuri și durata și declarația sala s[10];.

Punctaj în barem: 6 puncte: 1 punct pentru definirea principial corectă a unei structuri, câte 1 punct pentru fiecare dintre etichetă, primul câmp și al doilea câmp (3 puncte), 1 punct pentru declararea variabilei cerute și 1 punct pentru corectitudinea globală a secvenței.

Lecțiile din spate: Înregistrări, Tipuri de date proprii

Subiectul al III-lea (30 de puncte)

1. (10 puncte)

Într-un depozit se montează un raft cu trei polițe de aceeași lungime și de lățimi $x$, $y$ respectiv $z$. Pe fiecare poliță se plasează, una lângă alta, cutii de forma unui cub cu latura egală cu lățimea poliței. În depozit există suficiente cutii de fiecare tip, iar raftul este echilibrat doar dacă fiecare poliță este ocupată complet de cutii.

Subprogramul depozit are trei parametri, x, y și z, prin care primește trei numere naturale din intervalul $[10,100]$, reprezentând lățimile celor trei polițe, exprimate în centimetri. Subprogramul returnează un număr natural, reprezentând lungimea minimă, exprimată în centimetri, a unei polițe a raftului echilibrat. Scrieți definiția completă a subprogramului C/C++.

Exemplu: pentru $x=40$, $y=20$ și $z=30$, subprogramul returnează valoarea 120 (raftul are trei polițe, fiecare cu lungime de 120 cm: prima poate conține 3 cutii cu latura de 40 cm, a doua 6 cutii cu latura de 20 cm, iar a treia 4 cutii cu latura de 30 cm).

Rezolvare. O poliță este ocupată complet de cutii cu latura $x$ când lungimea ei este multiplu de $x$; la fel pentru $y$ și $z$. Lungimea comună a celor trei polițe este deci un multiplu comun al lui $x$, $y$ și $z$, iar lungimea minimă este cel mai mic multiplu comun, $\mathrm{cmmmc}(x,y,z)$. Se calculează cu cel mai mare divizor comun: $\mathrm{cmmmc}(a,b)=\frac{a}{\mathrm{cmmdc}(a,b)}\cdot b$, mai întâi pentru $x$ și $y$, apoi cu $z$. Împărțirea se face înainte de înmulțire, ca să nu apară valori inutil de mari; rezultatul este cel mult $100\cdot 99\cdot 98=970200$, deci încape într-un int. Pentru $40,20,30$ se obține $\mathrm{cmmmc}(40,20)=40$, apoi $\mathrm{cmmmc}(40,30)=120$.

int cmmdc(int a, int b)
{
    while (b != 0)
    {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}

int depozit(int x, int y, int z)
{
    int l = x / cmmdc(x, y) * y;
    l = l / cmmdc(l, z) * z;
    return l;
}

Am compilat subprogramul și depozit(40, 20, 30) returnează 120.

Răspuns: subprogramul depozit de mai sus, care returnează $\mathrm{cmmmc}(x,y,z)$.

Punctaj în barem: 10 puncte: 2 puncte pentru antetul subprogramului (1 punct pentru structură, 1 punct pentru parametrii de intrare), 6 puncte pentru determinarea lungimii cerute, câte 2 puncte pentru identificarea unui multiplu sau divizor al unui număr, a unui multiplu comun a două numere și a celui mai mic multiplu comun, 1 punct pentru instrucțiunea de returnare și 1 punct pentru declararea variabilelor locale și corectitudinea globală.

Lecțiile din spate: Cel mai mic multiplu comun, Algoritmul lui Euclid, Subprograme

2. (10 puncte)

O metodă de criptare a unui text se bazează pe un cifru format din mai multe coduri, numere naturale. Prin criptare se elimină spațiile, apoi la fiecare pas se ia în considerare o pereche formată dintr-o literă a textului și un cod al cifrului, iar această literă se înlocuiește cu cea obținută prin deplasarea circulară, spre dreapta, în alfabetul limbii engleze, cu un număr de poziții egal cu codul din pereche. Prima pereche este formată din prima literă a textului și primul cod al cifrului, iar după fiecare pereche urmează cea formată din litera următoare a textului, parcurs de la stânga la dreapta, respectiv din codul următor din cifru, parcurs circular, spre dreapta, ca în exemplu.

Într-un text de cel mult 100 de caractere cuvintele sunt formate din litere mari ale alfabetului limbii engleze și sunt separate prin unul sau mai multe spații. Alfabetul limbii engleze are 26 de litere.

Scrieți un program C/C++ care citește de la tastatură trei numere naturale din intervalul $[0,25]$, reprezentând, în această ordine, codurile unui cifru, apoi un text de tipul precizat. Programul modifică textul în memorie, criptându-l cu cifrul dat, apoi afișează pe ecran textul obținut.

Exemplu: pentru cifrul cu codurile 3, 1, 6 și textul PIXEL BINE MAPAT se obține textul SJDHMHLOKPBVDU (primele patru perechi sunt P-3, I-1, X-6, E-3).

Rezolvare. Programul are trei etape. Mai întâi citește cele trei coduri, apoi textul cu cin.getline, după ce cin.get() consumă sfârșitul de rând rămas după ultimul cod, pentru că textul conține spații. Apoi elimină spațiile, copiind în același șir numai caracterele diferite de spațiu, astfel că textul este modificat în memorie. În sfârșit, parcurge literele de la stânga la dreapta și pentru fiecare calculează litera deplasată circular: $(\text{litera}-\text{‘A‘}+\text{cod})\mathrm{mod}26$ dă poziția în alfabet, iar adunată cu 'A' dă litera nouă. Indicele codului crește cu 1 după fiecare literă și revine la 0 după al treilea, prin k = (k + 1) % 3. Pentru exemplul din enunț, PIXEL devine SJDHM, BINE devine HLOK, iar MAPAT devine PBVDU.

#include <iostream>
using namespace std;

int main()
{
    int cod[3], i, j, k;
    char s[102];
    cin >> cod[0] >> cod[1] >> cod[2];
    cin.get();
    cin.getline(s, 102);
    j = 0;
    for (i = 0; s[i] != '\0'; i++)
        if (s[i] != ' ')
            s[j++] = s[i];
    s[j] = '\0';
    k = 0;
    for (i = 0; s[i] != '\0'; i++)
    {
        s[i] = 'A' + (s[i] - 'A' + cod[k]) % 26;
        k = (k + 1) % 3;
    }
    cout << s;
    return 0;
}

Am compilat și rulat programul pe exemplul din enunț (codurile 3, 1, 6 și textul PIXEL BINE MAPAT) și se afișează SJDHMHLOKPBVDU.

Răspuns: programul de mai sus.

Punctaj în barem: 10 puncte: 1 punct pentru declararea unei variabile care memorează un șir de caractere, 1 punct pentru citirea datelor, 6 puncte pentru codificarea șirului, câte 1 punct pentru fiecare aspect dintre identificarea unei litere sau a caracterului spațiu, tratarea a cel puțin unei perechi literă-cod cu deplasare la dreapta în alfabet, tratarea a cel puțin unei perechi literă-cod cu deplasare circulară în alfabet, deplasarea circulară în cadrul codurilor, caracterele-suport modificate sau eliminate și modificarea în memorie, apoi 1 punct pentru afișarea datelor și 1 punct pentru declararea variabilelor simple și corectitudinea globală.

Lecțiile din spate: Caractere și șiruri de caractere, Operații cu șiruri de caractere

3. (2 + 8 puncte)

Fișierul bac.txt conține numere naturale din intervalul $[1,10^9]$: pe prima linie două numere, $x$ și $y$ ($x<y$), iar pe a doua linie un șir de cel mult $10^6$ numere, ordonate crescător, separate prin câte un spațiu.

Se cere să se afișeze pe ecran numărul de valori pare distincte, din șirul aflat pe a doua linie a fișierului, care aparțin intervalului $[x,y]$. Proiectați un algoritm eficient din punctul de vedere al timpului de executare și al memoriei utilizate.

Exemplu: dacă fișierul are conținutul alăturat, pe ecran se afișează 3.

6 11
1 1 1 2 2 3 5 5 5 5 6 6 7 8 10 10 12 15 15 21 21

a. (2 puncte)

Descrieți în limbaj natural algoritmul proiectat, justificând eficiența acestuia.

Rezolvare. Șirul este ordonat crescător, deci valorile egale sunt alăturate și o valoare distinctă apare prima dată exact atunci când diferă de cea citită imediat înainte. Se citesc $x$ și $y$, apoi numerele din șir, pe rând, fără a le memora într-un tablou: se păstrează doar valoarea precedentă ant, inițial 0 (în fișier nu există valoarea 0), și valoarea curentă crt. Un număr se numără dacă $x\le crt\le y$, este par și diferă de ant; după fiecare citire ant devine crt. Cum șirul este crescător, citirea se oprește la prima valoare mai mare decât $y$, pentru că nicio valoare următoare nu mai poate fi în interval. Pentru exemplul din enunț se numără 6, 8 și 10, deci rezultatul este 3.

Algoritmul este eficient ca timp, pentru că parcurge fișierul o singură dată, deci are complexitatea $O(n)$, iar un șir de $10^6$ numere nu cere sortare sau căutare. Este eficient și ca memorie, pentru că folosește câteva variabile simple, deci $O(1)$, în loc de un tablou cu $10^6$ elemente.

Răspuns: parcurgere liniară, într-o singură trecere, cu valoarea precedentă și un contor, fără tablou.

Punctaj în barem: 2 puncte: 1 punct pentru descrierea coerentă a algoritmului și 1 punct pentru justificarea elementelor de eficiență; punctajul se acordă chiar dacă algoritmul ales nu este eficient.

b. (8 puncte)

Scrieți programul C/C++ corespunzător algoritmului proiectat.

Rezolvare. Programul citește $x$ și $y$ și apoi parcurge valorile cu fin >> crt, în ciclul care se oprește la sfârșitul fișierului sau la prima valoare mai mare decât $y$.

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

ifstream fin("bac.txt");

int main()
{
    int x, y, ant = 0, crt, nr = 0;
    fin >> x >> y;
    while (fin >> crt && crt <= y)
    {
        if (crt >= x && crt % 2 == 0 && crt != ant)
            nr++;
        ant = crt;
    }
    cout << nr;
    fin.close();
    return 0;
}

Am rulat programul pe fișierul din exemplu și afișează 3.

Răspuns: programul de mai sus.

Punctaj în barem: 8 puncte: 1 punct pentru operațiile cu fișiere (declarare, pregătire pentru citire, citire), 5 puncte pentru determinarea valorii cerute, 1 punct pentru utilizarea unui algoritm liniar care folosește eficient memoria și 1 punct pentru declararea variabilelor, afișarea datelor și corectitudinea globală. Baremul indică o soluție posibilă cu ultimele două valori citite, ant și crt, și numărul cerut, nr; se punctează însă orice modalitate de rezolvare corectă. Dacă algoritmul este principial corect, dar nu dă rezultatul cerut pentru toate seturile de date, se acordă numai 3 puncte la determinarea valorii cerute.

Lecțiile din spate: Fișiere text în C/C++, Numărarea elementelor unui șir

Informatică științe ale naturii: simularea din martie 2026

Simulare. Filieră teoretică, profil real, specializare științe ale naturii. Limbajul C/C++. Se acordă 90 de puncte pentru subiecte și 10 din oficiu; timpul de lucru efectiv este de trei ore.

Subiectul I (20 de puncte)

La fiecare item se alege litera răspunsului corect; fiecare răspuns corect valorează 4 puncte. Baremul oficial dă numai litera, iar justificările de mai jos sunt ale noastre.

1. (4 puncte)

Variabila x este de tip întreg. Indicați o expresie care are valoarea 1 dacă și numai dacă expresia C/C++ x<=20 || x>26 are valoarea 1.

a. !(x>20) || !(x<=26) b. !(x>=20) && !(x>=26) c. !(x<20 || x<=26) d. !(x<20 && x<26)

Rezolvare. Expresia x<=20 || x>26 este adevărată exact când nu este adevărat că x>20 && x<=26, adică are aceeași valoare ca !(x>20 && x<=26). Cu legile lui De Morgan aceasta este !(x>20) || !(x<=26), adică varianta a. Celelalte variante nu se potrivesc: b se reduce la x<20, c este adevărată numai pentru x>26, iar d se reduce la x>=20. Am comparat cele patru expresii cu cea dată pentru toate valorile întregi dintr-un interval mare, iar numai a coincide cu ea.

Răspuns: a.

Punctaj în barem: 4 puncte pentru litera corectă, a.

Lecțiile din spate: Expresii, Operatori în C/C++

2. (4 puncte)

Pentru a verifica dacă în tabloul unidimensional (5,10,14,16,19,21,26) există elementul cu valoarea $x$, număr natural, se aplică metoda căutării binare. Indicați mulțimea tuturor valorilor posibile ale lui $x$, astfel încât succesiunea de elemente ale tabloului a căror valoare se compară cu valoarea lui $x$ pe parcursul aplicării metodei indicate să fie 16, 21, 19.

a. $\{19\}$ b. $\{18,20\}$ c. $\{18,19,20\}$ d. $\{17,18,19,20\}$

Rezolvare. Tabloul are 7 elemente, pe pozițiile 0–6. Căutarea binară compară mai întâi $x$ cu elementul din mijloc, 16 (poziția 3). Cum a doua comparație este cu 21, aflat în jumătatea din dreapta (pozițiile 4–6, cu mijlocul pe poziția 5), rezultă $x>16$. A treia comparație este cu 19, în jumătatea din stânga a lui 21 (poziția 4), deci $x<21$. Valorile naturale $x$ cu $16<x<21$ sunt 17, 18, 19 și 20. Pentru oricare dintre ele se compară mai întâi 16, apoi 21, apoi 19; la $x=19$ căutarea se oprește cu succes, iar pentru 17, 18 și 20 se oprește după a treia comparație, pentru că intervalul rămas nu mai are elemente. Simulând căutarea binară pentru toate valorile naturale de la 0 la 39, succesiunea 16, 21, 19 apare exact pentru 17, 18, 19 și 20.

Răspuns: d.

Punctaj în barem: 4 puncte pentru litera corectă, d.

Lecțiile din spate: Căutarea binară

3. (4 puncte)

Indicați valoarea expresiei C/C++ alăturate: abs(25-3-2026)

a. $-2054$ b. $-2004$ c. $2004$ d. $2054$

Rezolvare. Se calculează mai întâi diferența, de la stânga la dreapta: $25-3-2026=22-2026=-2004$. Funcția abs returnează valoarea absolută, deci $|-2004|=2004$.

Răspuns: c.

Punctaj în barem: 4 puncte pentru litera corectă, c.

Lecțiile din spate: Funcții predefinite în C/C++, Expresii

4. (4 puncte)

O probă a unui examen începe la ora 9:00, iar variabila întreagă p memorează durata probei, în minute. Indicați secvența C/C++ care atribuie variabilelor întregi h și m, ora, respectiv minutul la care se încheie proba, în aceeași zi.

a. h=9+p%60; m=p/60; b. h=9+p/60; m=p%60; c. h=(9+p)%24; m=p/60; d. h=(9+p)/24; m=p%60;

Rezolvare. Începând de la 9:00, trec $p/60$ ore întregi și $p\%60$ minute rămase, deci ora de încheiere este 9+p/60, iar minutul este p%60; proba se termină în aceeași zi, așa că ora nu se reduce modulo 24. Pentru $p=200$ se obține ora 12 și minutul 20, adică 12:20, corect pentru 3 ore și 20 de minute după 9:00. Variantele a și c inversează rolurile lui p/60 și p%60, iar d împarte la 24 în loc să adune orele.

Răspuns: b.

Punctaj în barem: 4 puncte pentru litera corectă, b.

Lecțiile din spate: Operatori în C/C++, Tipuri simple de date

5. (4 puncte)

La balul absolvenților se acordă trei premii pe baza unei tombole cu 10 bilete, numerotate de la 1 la 10. Variabilele i, j și k sunt de tip întreg, iar secvența de instrucțiuni C/C++ de mai jos generează toate variantele de a alege biletele celor trei câștigători, care sunt anunțați în ordine descrescătoare a numerelor de pe bilete. Două soluții diferă prin cel puțin un bilet. Indicați penultima soluție generată.

for(i=10;i>=3;i--)
   for(j=i-1;j>=2;j--)
      for(k=j-1;k>=1;k--)
         cout<<i<<" "<<j<<" "<<k<<endl; | printf("%d %d %d\n",i,j,k);

a. (5,2,1) b. (4,3,2) c. (4,3,1) d. (4,2,1)

Rezolvare. Ciclurile generează tripletele în ordine lexicografică descrescătoare, iar ultimul triplet este (3,2,1), cu cele mai mici valori ($i=3$, $j=2$, $k=1$). Cu $i=4$ se generează, în ordine: pentru $j=3$, tripletele (4,3,2) și (4,3,1); pentru $j=2$, tripletul (4,2,1). Valoarea $i=3$ dă doar (3,2,1), deci penultimul triplet este ultimul cu $i=4$, adică (4,2,1). Rulând ciclurile se obțin 120 de triplete, iar ultimele trei sunt (4,3,1), (4,2,1), (3,2,1).

Răspuns: d.

Punctaj în barem: 4 puncte pentru litera corectă, d.

Lecțiile din spate: Combinări, Structura repetitivă cu număr cunoscut de pași

Subiectul al II-lea (40 de puncte)

1. (6 + 6 + 10 + 6 puncte)

Algoritmul alăturat este reprezentat în pseudocod. S-a notat cu a%b restul împărțirii numărului natural a la numărul natural nenul b și cu [c] partea întreagă a numărului real c.

citește n (număr natural)
x←0; y←0; p←1
repetă
   c←n%10; n←[n/10]
   dacă c%2=0 atunci
      x←x*10+c
      y←c*p+y; p←p*10
   ■
până când n=0
dacă x<y atunci scrie x
altfel scrie y
■

Cerințele a–d sunt aceleași ca la profilul M_mate-info, cu același barem. Algoritmul extrage cifrele lui n de la ultima la prima; variabila x păstrează cifrele pare în ordine inversă, iar y în ordinea lor din n, apoi se scrie cea mai mică dintre ele.

a. (6 puncte)

Scrieți ce se afișează în urma executării algoritmului dacă se citește numărul 250326.

Rezolvare. Cifrele sunt luate în ordinea 6, 2, 3, 0, 5, 2. Cifrele pare dau, pe rând, $x=6$, $y=6$; apoi $x=62$, $y=26$; apoi, pentru cifra 0, $x=620$, $y=26$; apoi, pentru ultima cifră 2, $x=6202$ și $y=2\cdot 1000+26=2026$. Cifrele 3 și 5 sunt impare și nu schimbă nimic. Cum $x=6202$ nu este mai mic decât $y=2026$, se scrie $y$.

Răspuns: se afișează 2026.

Punctaj în barem: 6 puncte pentru răspunsul corect, 2026.

b. (6 puncte)

Scrieți două numere din intervalul $[1000,9999]$ care pot fi citite, astfel încât, pentru fiecare dintre acestea, în urma executării algoritmului, să se afișeze valoarea 64.

Rezolvare. Rezultatul este $\min (x,y)$, unde $y$ are cifrele pare în ordinea lor, iar $x$ în ordine inversă. Cifrele pare 0, 6, 4, în această ordine, dau $y=064=64$ și $x=460$, deci se afișează 64; o cifră impară completează numărul la patru cifre. De exemplu, $1064$ dă $y=64$ și $x=460$. Un alt număr bun este $4600$: cifrele pare 4, 6, 0, 0 dau $y=4600$, iar $x$, format din 0, 0, 6, 4, este 64. Am rulat algoritmul pentru ambele numere și se afișează 64.

Răspuns: de exemplu 1064 și 4600.

Punctaj în barem: 3 puncte pentru fiecare număr corect; baremul acceptă orice număr de forma x064, x460, 4x60, 4600, 460x sau 46x0, cu x cifră impară.

c. (10 puncte)

Scrieți programul C/C++ corespunzător algoritmului dat.

Rezolvare. Structura repetă ... până când n=0 se scrie do { ... } while (n != 0);, iar restul instrucțiunilor se traduc direct.

#include <iostream>
using namespace std;

int main()
{
    int n, c, x = 0, y = 0, p = 1;
    cin >> n;
    do
    {
        c = n % 10;
        n = n / 10;
        if (c % 2 == 0)
        {
            x = x * 10 + c;
            y = c * p + y;
            p = p * 10;
        }
    } while (n != 0);
    if (x < y)
        cout << x;
    else
        cout << y;
    return 0;
}

Am compilat și rulat programul: pentru 250326 afișează 2026, iar pentru 1064 și 4600 afișează 64.

Răspuns: programul de mai sus.

Punctaj în barem: 10 puncte: câte 1 punct pentru declararea variabilelor, citirea datelor, afișarea datelor, atribuiri și corectitudinea globală, 3 puncte pentru instrucțiunile de decizie (doar 2 dacă numai una dintre cele două este conform cerinței) și 2 puncte pentru instrucțiunea repetitivă.

d. (6 puncte)

Scrieți în pseudocod un algoritm, echivalent cu cel dat, înlocuind adecvat structura repetă...până când cu o structură repetitivă cu test inițial.

Rezolvare. Testul se mută la început: ciclul continuă cât timp $n\ne 0$. Pentru $n\ge 1$ iterațiile sunt aceleași. Pentru $n=0$, repetă face o singură iterație cu $c=0$, care lasă $x=y=0$, deci se scrie 0, ca și în varianta cu test inițial, unde nu se intră în ciclu.

citește n (număr natural)
x←0; y←0; p←1
cât timp n≠0 execută
   c←n%10; n←[n/10]
   dacă c%2=0 atunci
      x←x*10+c
      y←c*p+y; p←p*10
   ■
■
dacă x<y atunci scrie x
altfel scrie y
■

Am verificat varianta cu while pe un program C++ și afișează aceleași valori ca varianta cu do ... while, pentru 250326, 1064, 4600 și 0.

Răspuns: algoritmul de mai sus, cu structura cât timp n≠0 execută.

Punctaj în barem: 2 puncte pentru utilizarea unei structuri repetitive cu test inițial, 3 puncte pentru expresia logică a testului inițial în secvența obținută prin înlocuire și 1 punct pentru algoritmul complet și corectitudinea globală; baremul punctează orice formă explicită de structură repetitivă cu test inițial și acordă punctajul chiar dacă algoritmul obținut nu este echivalent cu cel dat.

Lecțiile din spate: Cifrele unui număr, Structura repetitivă cu test final, Structura repetitivă cu test inițial, Pseudocod

2. (6 puncte)

Tablourile unidimensionale $A=(26,19,16,8,4)$ și $B=(50,15,12,3,1)$ sunt interclasate în ordine crescătoare, fiind parcurse de la dreapta la stânga. Scrieți toate valorile elementelor tabloului $B$ care se compară cu elementul cu valoarea 16 din tabloul $A$ pe parcursul aplicării metodei.

Rezolvare. Parcurse de la dreapta la stânga, tablourile sunt crescătoare: $A$ dă 4, 8, 16, 19, 26, iar $B$ dă 1, 3, 12, 15, 50. La fiecare pas se compară elementul curent din $A$ cu cel curent din $B$ și se trece mai departe în tabloul din care s-a luat elementul mai mic. Comparațiile sunt: $4$ cu $1$ (se ia 1), $4$ cu $3$ (se ia 3), $4$ cu $12$ (se ia 4), $8$ cu $12$ (se ia 8). Acum elementul curent din $A$ este 16 și se compară pe rând cu 12 (se ia 12), cu 15 (se ia 15) și cu 50 (se ia 16). În tabloul $B$, valorile comparate cu 16 sunt deci 12, 15 și 50. Am simulat interclasarea și am obținut aceeași listă.

Răspuns: 12, 15, 50.

Punctaj în barem: 6 puncte, câte 2 puncte pentru fiecare dintre cele trei valori.

Lecțiile din spate: Interclasarea

3. (6 puncte)

Un mozaic este alcătuit din mai multe plăcuțe de formă pătrată, cu dimensiuni egale, de culoare albă sau roșie, așezate pe un rând și aliniate ca în exemplu. Mozaicul are un model alternativ dacă oricare două plăcuțe cu o latură comună au culoare diferită.

Variabilele x1, x2 și x3 memorează câte o literă corespunzătoare primelor trei plăcuțe din mozaic, în această ordine, notându-se cu litera R cele roșii și cu litera A cele albe. Declarați variabilele x1, x2 și x3 și scrieți o secvență de instrucțiuni C/C++ în urma executării căreia să se afișeze mesajul alternativ, dacă cele trei plăcuțe respectă modelul alternativ al mozaicului, sau mesajul neconform, în caz contrar.

Exemplu: pentru mozaicul alăturat, unde sunt evidențiate două zone în care nu se respectă modelul, variabilele x1, x2 și x3 memorează literele A, R, respectiv A, și se afișează pe ecran mesajul alternativ.

Mozaicul din figură are 12 plăcuțe, așezate pe un rând:

A R A A R A R A R R R A

Rezolvare. Primele trei plăcuțe au model alternativ dacă plăcuțele vecine au culori diferite: prima diferă de a doua, iar a doua de a treia. Pentru exemplul A, R, A ambele condiții sunt adevărate, deci se afișează alternativ; zonele nerespectate din figură sunt mai departe, la plăcuțele 3–4 și 9–11 (AA, respectiv RRR). Se declară variabilele de tip char, apoi se compară cu !=; cu două culori, x1!=x2 și x2!=x3 înseamnă R A R sau A R A.

char x1, x2, x3;
if (x1 != x2 && x2 != x3)
    cout << "alternativ";
else
    cout << "neconform";

Am compilat secvența într-un program care citește x1, x2, x3 și am verificat-o pentru A R A și R A R (afișează alternativ) și pentru A A R și R R R (afișează neconform).

Răspuns: secvența de mai sus, cu variabilele declarate char.

Punctaj în barem: 6 puncte: 1 punct pentru declararea variabilelor conform cerinței, 4 puncte pentru afișarea mesajelor cerute, câte 1 punct pentru fiecare aspect dintre utilizarea unei constante de tip char, compararea a cel puțin două plăcuțe alăturate, tratarea tuturor cazurilor și mesajele corespunzătoare cazurilor tratate, și 1 punct pentru corectitudinea globală a secvenței.

Lecțiile din spate: Structuri de control în C/C++, Tipuri simple de date

Subiectul al III-lea (30 de puncte)

1. (10 puncte)

Într-un depozit se montează un raft cu trei polițe de aceeași lungime și de lățimi $x$, $y$ respectiv $z$. Pe fiecare poliță se plasează, una lângă alta, cutii de forma unui cub cu latura egală cu lățimea poliței. În depozit există suficiente cutii de fiecare tip, iar raftul este echilibrat doar dacă fiecare poliță este ocupată complet de cutii.

Se citesc trei numere naturale din intervalul $[10,100]$, $x$, $y$ și $z$, reprezentând lățimile celor trei polițe, exprimate în centimetri, și se cere să se scrie un număr natural, reprezentând lungimea minimă, exprimată în centimetri, a unei polițe a raftului echilibrat. Scrieți, în pseudocod, algoritmul de rezolvare pentru problema enunțată.

Exemplu: pentru $x=40$, $y=20$ și $z=30$, se scrie valoarea 120 (raftul are trei polițe, fiecare cu lungime de 120 cm: prima poate conține 3 cutii cu latura de 40 cm, a doua 6 cutii cu latura de 20 cm, iar a treia 4 cutii cu latura de 30 cm).

Rezolvare. Lungimea comună a polițelor trebuie să fie multiplu de $x$, de $y$ și de $z$, iar lungimea minimă este cel mai mic multiplu comun al celor trei numere. Un multiplu comun este în particular un multiplu al lui $x$, deci căutăm primul multiplu al lui $x$ care se împarte exact și la $y$, și la $z$. Pornim de la $l=x$ și, cât timp $l$ nu se împarte exact la $y$ sau la $z$, trecem la următorul multiplu al lui $x$, adică $l\leftarrow l+x$. Primul multiplu găsit este cmmmc, pentru că oricare multiplu comun al celor trei numere este multiplu al lui $x$. Pentru $40,20,30$ se testează 40 (nu se împarte la 30), 80 (nu se împarte la 30), apoi 120, care se împarte la 20 și la 30, deci se scrie 120. Am transcris algoritmul în C++ și l-am comparat cu formula cu cmmdc pentru toate tripletele din $[10,100{]}^3$: rezultatele coincid.

citește x, y, z
l←x
cât timp l%y≠0 sau l%z≠0 execută
   l←l+x
■
scrie l

Răspuns: algoritmul de mai sus, care scrie cel mai mic multiplu comun al numerelor $x$, $y$ și $z$.

Punctaj în barem: 10 puncte: 2 puncte pentru citirea datelor, 6 puncte pentru determinarea lungimii cerute, câte 2 puncte pentru identificarea unui multiplu sau divizor al unui număr, a unui multiplu comun a două numere și a celui mai mic multiplu comun, 1 punct pentru afișarea datelor și 1 punct pentru scrierea principial corectă a structurilor de control; baremul punctează orice formă explicită de structură repetitivă sau decizională.

Lecțiile din spate: Cel mai mic multiplu comun, Algoritmul lui Euclid, Pseudocod

2. (10 puncte)

O metodă de criptare a unui șir de numere se bazează pe un cifru format din mai multe coduri, numere naturale. Prin criptare, la fiecare pas se ia în considerare o pereche formată dintr-un termen nenul al șirului și un cod al cifrului, iar acest termen este înlocuit cu suma dintre el și codul din pereche. Prima pereche este formată din primul termen nenul al șirului și primul cod al cifrului, iar după fiecare pereche urmează cea formată din termenul următor nenul al șirului, parcurs de la stânga la dreapta, respectiv din codul următor din cifru, parcurs circular, spre dreapta, ca în exemplu.

Scrieți un program C/C++ care citește de la tastatură numere naturale: un număr $n$ ($n\in [1,100]$), apoi un șir de $n$ numere din intervalul $[0,10^4]$, elemente ale unui tablou unidimensional, iar la final trei numere din intervalul $[0,10]$, reprezentând, în această ordine, codurile unui cifru. Programul modifică tabloul în memorie, criptând șirul cu cifrul dat, apoi afișează pe ecran tabloul obținut.

Exemplu: pentru $n=11$, tabloul $(9,6,8,3,1,0,21,14,0,20,5)$ și cifrul cu codurile 3, 1, 6 se obține tabloul $(12,7,14,6,2,0,27,17,0,21,11)$; primele patru perechi sunt 9-3, 6-1, 8-6, 3-3.

Rezolvare. Programul citește $n$, tabloul și cele trei coduri. Apoi parcurge tabloul de la stânga la dreapta: termenii nuli rămân neschimbați și nu consumă niciun cod, iar fiecare termen nenul crește cu codul curent cod[k]. Indicele k crește cu 1 numai după un termen nenul și revine la 0 după al treilea cod, prin k = (k + 1) % 3. La final, se afișează tabloul. În exemplu, termenii nenuli 9, 6, 8, 3, 1, 21, 14, 20, 5 primesc, în ordine, codurile 3, 1, 6, 3, 1, 6, 3, 1, 6, iar cei doi zerouri rămân pe loc. Rezultă $(12,7,14,6,2,0,27,17,0,21,11)$. Valorile ating cel mult $10^4+10$, deci încap într-un int.

#include <iostream>
using namespace std;

int main()
{
    int n, i, k, a[100], cod[3];
    cin >> n;
    for (i = 0; i < n; i++)
        cin >> a[i];
    cin >> cod[0] >> cod[1] >> cod[2];
    k = 0;
    for (i = 0; i < n; i++)
        if (a[i] != 0)
        {
            a[i] = a[i] + cod[k];
            k = (k + 1) % 3;
        }
    for (i = 0; i < n; i++)
        cout << a[i] << " ";
    return 0;
}

Am compilat și rulat programul pe exemplul din enunț și se afișează 12 7 14 6 2 0 27 17 0 21 11.

Răspuns: programul de mai sus.

Punctaj în barem: 10 puncte: 1 punct pentru declararea unei variabile care memorează un tablou unidimensional, 1 punct pentru citirea datelor, 6 puncte pentru codificarea șirului, câte 1 punct pentru fiecare aspect dintre identificarea unei valori nule sau nenule, tratarea a cel puțin unei perechi valoare nenulă-cod prin adunare, deplasarea circulară în cadrul codurilor, perechile valoare nenulă-cod suport parcurse, valorile nule sau nenule suport nemodificate sau modificate și modificarea în memorie, apoi 1 punct pentru afișarea datelor și 1 punct pentru declararea variabilelor simple și corectitudinea globală.

Lecțiile din spate: Vectori, Citirea și parcurgerea unui șir

3. (2 + 8 puncte)

Fișierul bac.txt conține numere naturale din intervalul $[1,10^9]$: pe prima linie un număr, $x$, iar pe a doua linie un șir de cel mult $10^6$ numere, ordonate crescător, separate prin câte un spațiu.

Se cere să se afișeze pe ecran numărul de valori pare distincte din șirul aflat pe a doua linie a fișierului care sunt mai mari sau egale cu $x$. Proiectați un algoritm eficient din punctul de vedere al timpului de executare și al memoriei utilizate.

Exemplu: dacă fișierul are conținutul alăturat, pe ecran se afișează 4.

5
1 1 1 2 2 3 5 5 5 5 6 6 7 8 10 10 12 15 15 21 21

a. (2 puncte)

Descrieți în limbaj natural algoritmul proiectat, justificând eficiența acestuia.

Rezolvare. Șirul este ordonat crescător, deci valorile egale sunt alăturate și o valoare distinctă apare prima dată exact atunci când diferă de cea citită imediat înainte. Se citește $x$, apoi numerele din șir, pe rând, fără a le memora într-un tablou: se păstrează valoarea precedentă ant, inițial 0 (în fișier nu există valoarea 0), și valoarea curentă crt. Un număr se numără dacă este par, mai mare sau egal cu $x$ și diferă de ant; după fiecare citire ant devine crt. Pentru exemplul din enunț se numără 6, 8, 10 și 12, deci rezultatul este 4.

Algoritmul este eficient ca timp, pentru că parcurge fișierul o singură dată, deci are complexitatea $O(n)$, fără sortare sau căutări repetate. Este eficient și ca memorie, pentru că folosește câteva variabile simple, deci $O(1)$, în loc de un tablou cu $10^6$ elemente.

Răspuns: parcurgere liniară, într-o singură trecere, cu valoarea precedentă și un contor, fără tablou.

Punctaj în barem: 2 puncte: 1 punct pentru descrierea coerentă a algoritmului și 1 punct pentru justificarea elementelor de eficiență; punctajul se acordă chiar dacă algoritmul ales nu este eficient.

b. (8 puncte)

Scrieți programul C/C++ corespunzător algoritmului proiectat.

Rezolvare. Programul citește $x$ și apoi parcurge toate valorile din fișier cu fin >> crt, fără limită superioară, pentru că în acest profil nu există $y$.

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

ifstream fin("bac.txt");

int main()
{
    int x, ant = 0, crt, nr = 0;
    fin >> x;
    while (fin >> crt)
    {
        if (crt >= x && crt % 2 == 0 && crt != ant)
            nr++;
        ant = crt;
    }
    cout << nr;
    fin.close();
    return 0;
}

Am rulat programul pe fișierul din exemplu și afișează 4.

Răspuns: programul de mai sus.

Punctaj în barem: 8 puncte: 1 punct pentru operațiile cu fișiere (declarare, pregătire pentru citire, citire), 5 puncte pentru determinarea valorii cerute, 1 punct pentru utilizarea unui algoritm liniar care folosește eficient memoria și 1 punct pentru declararea variabilelor, afișarea datelor și corectitudinea globală. Baremul indică o soluție posibilă cu ultimele două valori citite, ant și crt, și numărul cerut, nr; se punctează însă orice modalitate de rezolvare corectă. Dacă algoritmul este principial corect, dar nu dă rezultatul cerut pentru toate seturile de date, se acordă numai 3 puncte la determinarea valorii cerute.

Lecțiile din spate: Fișiere text în C/C++, Numărarea elementelor unui șir

Întrebări frecvente