Bac informatică 2026 Varianta 1, rezolvată

Răspuns corect: b) !(x%26!=0) && !(x%2026==0)

x%26!=0 înseamnă „x nu se divide cu 26”, deci !(x%26!=0) înseamnă „x se divide cu 26”. La fel, !(x%2026==0) înseamnă „x nu se divide cu 2026”. Cele două condiții trebuie îndeplinite simultan, deci se leagă cu &&: varianta b).

a) folosește || și e adevărată și pentru numere care nu se divid cu 26 (de exemplu 1); c) cere ca x să nu se dividă nici cu 26, nici cu 2026; d) e adevărată dacă x se divide cu 26 sau cu 2026, deci și pentru 2026.

Răspuns corect: d) x>=1

f(x) îl apelează întâi pe f(x-1) și abia după aceea afișează x, deci numerele ies de la cel mai mic la cel mai mare. Ca f(10) să afișeze 1 2 … 10, autoapelurile trebuie să meargă până la f(1) și să se oprească la f(0): condiția x>=1.

Cu x>=2 s-ar opri la f(1), iar 1 n-ar mai fi afișat. Cu x<=10 sau x<=11 condiția rămâne adevărată și pentru 0, -1, …, deci autoapelurile nu se mai opresc.

Răspuns corect: c) m.valoare[0]*m.exemplare[0]

m este o singură structură, nu un tablou; tablourile sunt câmpurile ei, valoare și exemplare. Primul tip de bancnotă are indicele 0, deci valoarea unei bancnote este m.valoare[0], numărul de exemplare m.exemplare[0], iar suma de bani e produsul lor.

a) îl tratează pe m ca tablou (m[0]), iar b) și d) nu sunt expresii C/C++ valide.

Răspuns corect: a) {Arghezi, Blaga, Eminescu}

După o soluție, backtracking-ul încearcă întâi să adauge următorul autor din mulțime; când nu mai are ce adăuga, renunță la ultimul autor și îl înlocuiește cu unul aflat după el.

După {Arghezi, Blaga, Coșbuc, Eminescu} nu mai există autor de adăugat, deci se renunță la Eminescu, iar Coșbuc se înlocuiește cu următorul, Eminescu: {Arghezi, Blaga, Eminescu}. b) nu respectă ordinea din mulțime (Blaga după Eminescu), iar c) și d) nu îl mai conțin pe Arghezi, deci vin mult mai târziu.

Răspuns corect: b) 3

Un nod are cel mult un „frate”, deci fiecare nod are cel mult doi fii. Unde doi „tați” sunt la fel de apropiați, alegerea contează.

2 se leagă de 4. Pentru 3, atât 4, cât și 2 sunt la diferența 1. Dacă 3 ar merge sub 4, rădăcina s-ar umple, 5 ar ajunge sub 3 și 7 sub 5: patru niveluri. Punându-l pe 3 sub 2: 1 merge tot sub 2 (diferența 1), 5 sub 4 (diferența 1, 4 mai are loc), 7 sub 5 (diferența 2), iar 6 sub 5 (diferența 1).

Nivelurile sunt 0: 4; 1: 2 și 5; 2: 3, 1, 7 și 6 — trei niveluri. Mai puțin nu se poate: cu cel mult doi fii pe nod, pe două niveluri încap doar 3 noduri, iar arborele are 7.

Răspunsul din barem: 15

15

Algoritmul adună numerele i care au exact o cifră 1 în scrierea în baza 2, adică puterile lui 2: nr adună resturile împărțirilor repetate ale lui i la 2.
Pentru n=10, s devine 1, apoi 3 (după i=2), 7 (după i=4) și 15 (după i=8). Cum 15 ≥ 10, bucla se oprește și se afișează 15.

Exemplu: 16 și 31

Suma crește prin puteri ale lui 2: 1, 3, 7, 15, 31, 63, …, iar bucla se oprește la prima sumă care ajunge cel puțin la n.
Se afișează 31 exact când 15 < n ≤ 31, adică pentru orice n din intervalul [16,31].

#include <iostream>
using namespace std;

int main()
{
    int n, s = 0, i = 1, j, nr;
    cin >> n;
    while (s < n)
    {
        j = i; nr = 0;
        while (j != 0)
        {
            nr = nr + j % 2;
            j = j / 2;
        }
        if (nr == 1) s = s + i;
        i = i + 1;
    }
    cout << s;
    return 0;
}

Primul cât timp devine while (s < n), al doilea while (j != 0). Operația [j/2] este chiar împărțirea a două numere întregi în C/C++, iar j%2 este restul.

citește n (număr natural nenul)
s←0; i←1
┌cât timp s<n execută
│ j←i; nr←0
│┌repetă
││ nr←nr+j%2; j←[j/2]
│└până când j=0
│┌dacă nr=1 atunci
││ s←s+i
│└■
│ i←i+1
└■
scrie s

repetă…până când execută corpul cel puțin o dată, pe când cât timp poate să nu îl execute deloc. Aici nu e nevoie de o condiție în plus: i pornește de la 1 și doar crește, deci j←i este mereu nenul la intrare, iar corpul s-ar fi executat oricum măcar o dată. Condiția de oprire este negata celei de continuare: se continua cât timp j≠0, deci se oprește când j=0.

Răspunsul din barem: 20 44

20 44

Matricea de adiacență a unui graf cu 8 noduri are 8·8 = 64 de elemente. Fiecare muchie [x,y] pune 1 în două locuri, pe linia x, coloana y și pe linia y, coloana x, deci cele 10 muchii dau 20 de valori nenule. Restul, 64 − 20 = 44, sunt nule.

for(i=1;i<=5;i++)
  for(j=1;j<=5;j++)
   if(i%2==1 && j%2==1) a[i][j]=2;
   else if(i%2==0 && j%2==0) a[i][j]=0;
        else a[i][j]=3;

Pe pozițiile cu linia și coloana impare este 2, pe cele cu linia și coloana pare este 0, iar unde una este pară și cealaltă impară este 3. Sunt trei atribuiri, exact cât permite enunțul.

int baza(int n, int b)
{
    do
    {
        if (n % 10 >= b) return -1;
        n = n / 10;
    } while (n != 0);
    return 1;
}

Cifrele se iau pe rând de la dreapta, cu n%10. Dacă una este cel puțin b, nu poate fi cifră în baza b și se returnează imediat -1; dacă toate trec, se returnează 1.
Structura do…while tratează și n=0: are o singură cifră, 0, deci este reprezentat în orice bază.

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

int main()
{
    char s[201], *p, floare[21], minim[21];
    int ore, oreMin = 10;
    cin.getline(s, 201);
    p = strtok(s, " ");
    while (p != NULL)
    {
        strcpy(floare, p);
        p = strtok(NULL, " ");
        ore = p[0] - '0';
        if (ore < oreMin || (ore == oreMin && strcmp(floare, minim) < 0))
        {
            oreMin = ore;
            strcpy(minim, floare);
        }
        p = strtok(NULL, " ");
    }
    cout << minim;
    return 0;
}

Textul se citește întreg, apoi se împarte în cuvinte cu strtok: cuvintele vin în perechi, întâi denumirea, apoi numărul de ore, care e o singură cifră (de la 1 la 9), deci valoarea lui este p[0]-'0'.
Se reține cea mai mică valoare întâlnită și denumirea ei. O floare nouă o înlocuiește pe cea reținută dacă are mai puține ore sau, la același număr de ore, dacă e înaintea ei în ordine alfabetică (strcmp dă un rezultat negativ). Pornind de la oreMin=10, prima floare este reținută sigur.

Biții se citesc unul câte unul din fișier, fără să fie memorați, numărând poziția curentă.

Cel mai lung mesaj care conține un anumit 0 se întinde de la zeroul dinaintea lui până la zeroul de după el, fără aceste două capete. Dacă p1, p2, p3 sunt pozițiile a trei zerouri consecutive din șir, mesajul cu zeroul de la p2 cuprinde biții de pe pozițiile p1+1, …, p3-1, deci are lungimea p3-p1-1.

Se păstrează pozițiile ultimelor trei zerouri (pornite de la 0) și pozițiile corespunzătoare celui mai lung mesaj găsit până atunci. La fiecare 0 citit, pozițiile se mută (p1←p2, p2←p3, p3←poziția curentă), iar dacă p3-p1 depășește lungimea celui mai lung mesaj, se rețin ca noul maxim. La final se afișează p2m-p1m-1 biți 1, un 0, apoi p3m-p2m-1 biți 1.

Eficiență: fiecare bit se prelucrează o singură dată, în timp constant, deci algoritmul este liniar în numărul de biți din fișier. Se folosesc doar câteva variabile simple, fără niciun tablou, deci memoria folosită este constantă.

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

int main()
{
    ifstream fin("bac.txt");
    int x, i, pcrt = 0, p1 = 0, p2 = 0, p3 = 0, p1m = 0, p2m = 0, p3m = 0;
    while (fin >> x)
    {
        pcrt++;
        if (x == 0)
        {
            p1 = p2; p2 = p3; p3 = pcrt;
            if (p3 - p1 > p3m - p1m)
            {
                p1m = p1; p2m = p2; p3m = p3;
            }
        }
    }
    fin.close();
    for (i = p1m + 1; i < p3m; i++)
        if (i == p2m) cout << 0 << ' ';
        else cout << 1 << ' ';
    return 0;
}

Programul face pașii de la 3.a. Mesajul se afișează din pozițiile reținute: pe poziția p2m este 0, iar pe toate celelalte poziții dintre p1m și p3m sunt biți 1.
Când există mai multe mesaje de lungime maximă, programul îl păstrează pe primul (comparația e strictă), iar enunțul acceptă oricare dintre ele.