Bac informatică 2026 Model, rezolvată

Răspuns corect: a) 0

/ și * au aceeași prioritate și se aplică de la stânga la dreapta. 20/25 este o împărțire între numere întregi, deci dă câtul, 0. Apoi 0*20 este 0, iar 0/2 este tot 0.

b) și c) ar presupune o împărțire cu zecimale, iar d) o altă ordine a operațiilor.

Răspuns corect: b) 2

Funcția împarte intervalul de poziții în două jumătăți până ajunge la câte o singură poziție d și numără pozițiile pentru care v[d]==2*d.

Pentru (2,0,2,6,8): v[0]=2≠0, v[1]=0≠2, v[2]=2≠4, v[3]=6=6, v[4]=8=8. Două poziții îndeplinesc condiția, deci f(0,4,x) = 2.

Răspuns corect: a) șah, lego, scrabble

Seturile se generează în ordinea din mulțime: jenga, kendama, lego, șah, scrabble, deci ultimele sunt cele care încep cu cel mai târziu joc permis pe prima poziție. scrabble nu poate fi primul, așa că ultimele seturi încep cu șah.

Dacă șah este primul, jenga și kendama nu mai pot apărea după el, deci celelalte două jocuri sunt lego și scrabble: întâi (șah, lego, scrabble), apoi (șah, scrabble, lego), ultimul set. Penultimul este (șah, lego, scrabble).

Răspuns corect: a) z[0].densitate*z[0].suprafata

z este un tablou de structuri, deci prima zonă este z[0], iar câmpurile ei se accesează cu punct: z[0].densitate și z[0].suprafata. Densitatea este numărul de locuitori împărțit la suprafață, deci numărul de locuitori este produsul lor.

b), c) și d) pun indicele sau numele variabilei în locuri greșite și nu sunt expresii C/C++ valide.

Răspuns corect: c) [2,3] și [4,5]

Lanțul 3, 7, 4, 5, 2, 1 folosește muchiile [3,7], [7,4], [4,5], [5,2] și [2,1]. Dintre ele, doar [4,5] nu se află printre cele șase date, deci este una dintre muchiile lipsă. Rămân variantele a) și c).

În a), muchia [1,6] ar prelungi lanțul: 3, 7, 4, 5, 2, 1, 6 are lungimea 6, deci lanțul dat n-ar mai avea lungime maximă. În c), nodurile 1 și 6 au un singur vecin, pe 2, deci nu pot fi amândouă capete ale unui lanț prin toate cele 7 noduri: lungimea maximă rămâne 5.

Răspunsul din barem: 36

36

Al doilea repetă calculează, prin scăderi repetate, cel mai mare divizor comun al lui m și al valorii curente a lui n, iar primul repetă se oprește când acesta nu mai este 1. Se afișează n+1, adică exact valoarea verificată ultima, fiindcă n fusese deja micșorat.
Pentru m=27: cmmdc(27,38)=1, cmmdc(27,37)=1, cmmdc(27,36)=9, deci se afișează 36.

Exemplu: 10 și 14

Pentru m=5, se afișează primul număr care se împarte la 5, coborând de la n. Acesta este 10 pentru orice n de la 10 la 14; pentru n=15 s-ar afișa chiar 15.

#include <iostream>
using namespace std;

int main()
{
    int m, n, x, y;
    cin >> m >> n;
    do
    {
        x = m; y = n; n = n - 1;
        do
        {
            if (x > y) x = x - y;
            else y = y - x;
        } while (y != 0);
    } while (x == 1);
    cout << n + 1;
    return 0;
}

repetă…până când y=0 devine do…while (y != 0), iar repetă…până când x≠1 devine do…while (x == 1): în C/C++ se scrie condiția de continuare, adică negata celei de oprire.

citește m,n (numere naturale, 1<m<n)
┌repetă
│ x←m; y←n; n←n-1
│┌cât timp y≠0 execută
││┌dacă x>y atunci x←x-y
│││altfel y←y-x
││└■
│└■
└până când x≠1
scrie n+1

repetă…până când execută corpul cel puțin o dată, iar cât timp poate să nu îl execute deloc. Aici nu contează: n nu scade niciodată sub m (pentru n=m cel mai mare divizor comun este m, deci bucla exterioară se oprește), așa că y←n primește mereu o valoare nenulă și corpul s-ar executa oricum. Condiția de continuare este negata celei de oprire: y≠0.

2 6

Nodul 8 are vecinii 2, 5, 6 și 7. Ca 8 să aibă doi frați, tatăl lui trebuie să aibă trei fii, iar tatăl lui 8 este unul dintre vecinii lui.
Nodul 2 are vecinii 1, 8 și 9, iar nodul 6 are vecinii 3, 4 și 8. Un nod cu trei vecini are trei fii doar când este chiar rădăcina; altfel unul dintre vecini îi este tată. Cu rădăcina 2, fiii lui 2 sunt 1, 8 și 9; cu rădăcina 6, fiii lui 6 sunt 3, 4 și 8. Nodurile 5 și 7 au un singur vecin, deci nu pot fi tatăl lui 8 cu trei fii.

strcpy(tL, pN);
strcat(tL, strchr(tI, ')') + 1);

Numărul local este prefixul național urmat de cifrele de după paranteza închisă. strchr(tI, ')') indică paranteza, deci de la poziția următoare începe numărul propriu-zis. În tL se copiază întâi prefixul (chiar dacă e șirul vid), apoi i se adaugă restul numărului.

void Plus(int &n)
{
    int m = n, r = 0, p = 1, c;
    while (m > 0)
    {
        c = m % 10;
        if (c == 5 && m / 10 % 10 == 2) c = 6;
        r = r + c * p;
        p = p * 10;
        m = m / 10;
    }
    n = r;
}

Cifrele lui n se iau de la dreapta, cu m%10, și se pun într-un număr nou r, fiecare pe poziția ei (p este puterea lui 10 a poziției). O cifră 5 care are în stânga cifra 2 este finalul unei secvențe 25, deci în locul ei se pune 6.
Pentru că p crește la fiecare cifră, și zerourile de la finalul lui n rămân la locul lor. Rezultatul se furnizează prin parametrul transmis prin referință, int &n.

#include <iostream>
using namespace std;

int main()
{
    int n, a[100][100], i, j;
    cin >> n;
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            cin >> a[i][j];
    for (i = 0; i < n; i++)
        for (j = n - 1 - i; j < n - 1; j++)
            a[i][j] = a[i][j + 1];
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n - 1; j++)
            cout << a[i][j] << ' ';
        cout << '\n';
    }
    return 0;
}

Pe linia i (numerotând de la 0), elementul de pe diagonala secundară este în coloana n-1-i. Elementele de după el se mută cu o poziție spre stânga, peste el, deci fiecare linie rămâne cu n-1 jucării, fără spații libere între ele. Se afișează primele n-1 elemente de pe fiecare linie.

26 = 2·13, iar p este cea mai mare putere pentru care 26^p divide produsul 1·2·…·n. În acest produs factorul 2 apare de mai multe ori decât factorul 13 (fiecare al doilea număr este par, dar doar fiecare al treisprezecelea se împarte la 13), deci p este numărul de apariții ale lui 13 în descompunerea produsului.

Dintre numerele de la 1 la n, [n/13] se împart la 13 și aduc câte un 13; dintre ele, [n/13^2] se împart la 13^2 și mai aduc unul, [n/13^3] încă unul și așa mai departe. Deci p = [n/13] + [n/13^2] + [n/13^3] + …, adunând cât timp puterea lui 13 nu depășește n.

Eficiență: se calculează câte un termen pentru fiecare putere a lui 13 până la n (cel mult 8 pentru n ≤ 10^9), deci numărul de pași este logaritmic, sub cel liniar cerut. Se folosesc doar câteva variabile simple, deci memoria este constantă.

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

int main()
{
    long long n, p = 0, q = 13;
    cin >> n;
    while (q <= n)
    {
        p = p + n / q;
        q = q * 13;
    }
    ofstream fout("bac.txt");
    fout << p;
    fout.close();
    return 0;
}

Programul adună termenii de la 3.a. q este long long: la ultimul pas, după ce trece de n, q*13 poate depăși limita tipului int.