Bac informatică 2026 Varianta 4, rezolvată

Răspuns corect: d) 2026%100

% dă restul împărțirii, iar 2026 = 20·100 + 26, deci 2026%100 este 26. Celelalte trei nu pot: (2026-26)/100 și 2026/100 dau amândouă 20 (împărțirea a două numere întregi trunchiază), iar (2026-26)%100 este 0, fiindcă 2000 se împarte exact la 100.

Răspuns corect: b) 3

Fiecare apel adaugă 1 și se autoapelează cu n mai mare cu 1 și m mai mic cu 2, deci distanța m-n scade cu 3 de fiecare dată: 9 → 6 → 3 → 0. Recursivitatea se oprește când n>=m. Desfășurat: f(1,10) = 1+f(2,8) = 1+1+f(3,6) = 1+1+1+f(4,4) = 3+0 = 3.

Răspuns corect: b) (Eșelnița, Predeal, Olimp)

(Șvinița, Bușteni, Venus) este primul pachet care începe cu Șvinița, deci înaintea lui vine ultimul pachet care începe cu Eșelnița — adică cel cu ultima destinație din fiecare dintre celelalte două mulțimi: (Eșelnița, Predeal, Olimp). Varianta a) este dimpotrivă primul pachet cu Eșelnița, iar c) și d) încep cu Șvinița, deci vin după, nu înainte.

Răspuns corect: c) 1, 3, 4, 2, 1

Un circuit elementar pornește și se închide în același vârf, fără să treacă de două ori prin altul. 1, 3, 4, 2, 1 folosește arcele 1→3, 3→4, 4→2 și 2→1, toate cu 1 în matrice. În a) vârful 1 apare și la mijloc, deci nu e elementar; b) nu se închide; d) ar avea nevoie de arcul 1→4, iar în matrice pe linia 1, coloana 4 este 0.

Răspuns corect: c) 5

Rețeaua e un lanț de patru triunghiuri: {1,2,3} — {4,5,6} — {7,8,9} — {10,11,12}, legate prin muchiile 2-4 și 3-5, apoi 6-7, apoi 9-10. Centrele 10, 11 și 12 ajung la restul rețelei doar prin 9, deci una dintre componente trebuie să fie {9,10,11,12} — asta cere eliminarea muchiilor 7-9 și 8-9. Rămân opt centre de împărțit în două grupe de patru: muți un centru din {4,5,6} lângă triunghiul {1,2,3}, de exemplu {1,2,3,4} și {5,6,7,8}, ceea ce taie 3-5, 4-5 și 4-6. În total 2 + 3 = 5 muchii.

Răspunsul din barem: 3

Algoritmul numără câți factori primi DISTINCȚI are n, fiindcă p devine 1 o singură dată pentru fiecare divizor, oricâte împărțiri s-ar face. 2600 = 2^{^3} · 5^{^2} · 13, deci trei: 2, 5 și 13.

Pas cu pas: d=2 împarte de trei ori (n ajunge 325) și adaugă 1 la nr; d=3 și d=4 nu divid 325; d=5 împarte de două ori (n ajunge 13) și mai adaugă 1. Bucla se oprește fiindcă 6·6 > 13. Cum n a rămas 13 ≠ 1, ultima decizie mai adaugă 1. Se afișează 3.

Exemplu: 16 și 97

Se afișează 1 exact pentru numerele cu un singur factor prim distinct, adică pentru puterile unui număr prim. Din intervalul [10,99]: 16=2^{^4}, 32, 64, 27=3^{^3}, 81, 25=5^{^2}, 49=7^{^2}, precum și orice număr prim de două cifre (11, 13, 17, …, 97).

Pentru 16: d=2 împarte de patru ori, nr devine 1, iar n ajunge 1, deci ultima decizie nu mai adaugă nimic. Pentru 97: niciun d cu d·d ≤ 97 nu îl divide, nr rămâne 0, dar n = 97 ≠ 1, deci ultima decizie îl face 1.

#include <iostream>
using namespace std;

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

cât timp se scrie while, iar [n/d] nu cere nimic special: împărțirea a două numere întregi în C/C++ dă deja câtul. Condiția d*d<=n folosește n așa cum e în acel moment — n se micșorează în buclă, exact ca în pseudocod, așa că se transcrie ca atare.

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

repetă…până când execută corpul cel puțin o dată, pe când cât timp poate să nu îl execute deloc. De aceea înlocuirea cere în plus o gardă: se intră în repetă numai dacă n%d=0. Condiția de oprire este negația celei de continuare: se repetă cât timp n%d=0, deci se oprește când n%d≠0.

Răspunsul din barem: 10 DA DA

strlen(s) numără caracterele din "anatoliana": 10. strstr(s,t) caută "ana" în "anatoliana" și o găsește chiar de la început, deci pointerul întors este egal cu s → DA. strstr(s+1,t) caută în "natoliana" și găsește "ana" la sfârșit; strcmp compară acel subșir cu "ana" și dă 0 → DA.

struct astru
{   float magnitudine;
    int distanta;
};

struct observator
{   int numar;
    astru stea[200];
};

observator s;

Expresiile din enunț spun exact ce câmpuri sunt necesare: s.numar e un întreg, iar s.stea[0] e la rândul lui o structură, cu magnitudine (real) și distanta (întreg). Tabloul stea are 200 de elemente, fiindcă se observă cel mult 200 de stele, iar distanța de cel mult 10^{^6} ani-lumină încape într-un int.

void moda(int n, int &pc)
{
    int k = 0, ultimaPara = 0;
    do
    {
        k++;
        if (n % 10 % 2 == 0) ultimaPara = k;
        n = n / 10;
    } while (n != 0);
    pc = k - ultimaPara + 1;
}

Cifrele se parcurg de la dreapta la stânga și se numără (k). La fiecare cifră pară se reține poziția ei, numărată de la dreapta; ultima reținută este cifra pară cea mai din stânga, adică primul costum. Numărată de la stânga, poziția ei este k - ultimaPara + 1. Structura do…while tratează și n = 0 (o singură cifră, 0, pară) și zerourile de la final: pentru 5700 cifrele citite sunt 0, 0, 7, 5, deci ultimaPara = 2, k = 4 și pc = 3.

#include <iostream>
using namespace std;

int main()
{
    int m, n, a[50][50], i, j, p, aux;
    cin >> m >> n;
    for (i = 0; i < m; i++)
        for (j = 0; j < n; j++)
            cin >> a[i][j];
    for (j = 0; j < n; j++)
    {
        p = 0;
        for (i = 1; i < m; i++)
            if (a[i][j] < a[p][j]) p = i;
        if (a[p][j] % 2 == 0)
        {
            aux = a[p][j]; a[p][j] = a[0][j]; a[0][j] = aux;
        }
        else
        {
            aux = a[p][j]; a[p][j] = a[m - 1][j]; a[m - 1][j] = aux;
        }
    }
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
            cout << a[i][j] << ' ';
        cout << '\n';
    }
    return 0;
}

Pentru fiecare coloană se află poziția p a minimului (prima apariție). Dacă minimul e par, se interschimbă cu primul element al coloanei, altfel cu ultimul. Când pe o coloană sunt mai multe minime, enunțul acceptă oricare dintre ele, deci pot fi mai multe tablouri corecte — de aceea testele de aici au pe fiecare coloană un singur minim.

Timp de executare: O(n) · Memorie: O(1)

Șirul crește, deci termenul următor este a(k) = a(k-1) + 2·(a(k-1) - a(k-2)) = 3·a(k-1) - 2·a(k-2). De aici, termenul dinaintea a două valori consecutive x (ultima) și y (penultima) este z = (3·y - x) / 2.

Se scriu în fișier x și y, apoi, cât timp ultima valoare scrisă (y) nu este 0, se calculează z = (3·y - x) / 2, se scrie z și se mută fereastra: x devine y, y devine z. Primul termen al șirului este 0, deci procesul se oprește exact după ce 0 a fost scris.

Eficiență: fiecare lună se calculează o singură dată, în timp constant, deci timpul este liniar în numărul de luni; se păstrează doar ultimele două valori, deci memoria folosită este constantă, fără niciun tablou.

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

int main()
{
    long long x, y, z;
    cin >> x >> y;
    ofstream fout("bac.txt");
    fout << x << ' ' << y;
    while (y != 0)
    {
        z = (3 * y - x) / 2;
        fout << ' ' << z;
        x = y;
        y = z;
    }
    fout.close();
    return 0;
}

Valorile ajung până la 10^{^9}, iar 3·y depășește limita tipului int, de aceea se folosește long long. Fișierul se scrie în ordinea cerută, descrescător, fără să fie nevoie de memorarea șirului.