Bac informatică 2025 Varianta 1, rezolvată

Răspuns corect: d) 2025%2021+8

2025%2019 este restul împărțirii lui 2025 la 2019, adică 6, deci expresia dată valorează 6 + 6 = 12.

Variantele: a) 2025/2020+5 = 1 + 5 = 6; b) 2025/2021+8 = 1 + 8 = 9; c) 2025%2020+5 = 5 + 5 = 10; d) 2025%2021+8 = 4 + 8 = 12. Doar d) are aceeași valoare.

Răspuns corect: a) 1211213

f(0) nu afișează nimic. Pentru fiecare i de la 1 la n: dacă i e par, se afișează i și apoi se apelează f(i-1); dacă e impar, întâi se apelează f(i-1) și abia apoi se afișează i.

f(1) afișează 1. f(2) afișează 1 (pentru i=1), apoi 2 și f(1), adică 121. f(3) afișează 1 (i=1), apoi 2 urmat de f(1), adică 21 (i=2), apoi f(2), adică 121, urmat de 3 (i=3). Totul: 1 21 1213, adică 1211213.

Răspuns corect: b) float m[4][25];

Un tablou bidimensional se declară cu câte o pereche de paranteze drepte pentru fiecare dimensiune, iar numerele reale se memorează în tipul float. float m[4][25]; are 4·25 = 100 de elemente.

a) scrie dimensiunile cu virgulă, ceea ce nu este valid în C/C++; c) nu este o declarare validă; d) declară un tablou unidimensional de numere întregi.

Răspuns corect: c) 975862

Codurile se generează în ordine crescătoare, deci ultimul este cel mai mare: primele trei cifre, impare, cât mai mari, 9, 7, 5, iar ultimele trei, pare, 8, 6, 4 — 975864.

Chiar înaintea lui, se schimbă doar ultima cifră, cu cea mai mare cifră pară mai mică decât 4 și nefolosită: 2. Penultimul cod este 975862.

Răspuns corect: b) 45

Într-un graf orientat fără circuite vârfurile se pot așeza în ordine, astfel încât fiecare arc să meargă de la un vârf la unul aflat după el. Între două vârfuri poate exista deci cel mult un arc, într-un singur sens, iar cu toate perechile folosite se obțin 10·9/2 = 45 de arce.

90 ar însemna arce în ambele sensuri între oricare două vârfuri, deci circuite.

Răspunsul din barem: 9

Pentru fiecare i, începând de la m, bucla cât timp găsește cel mai mic x cu x*x ≥ i. Dacă x*x este chiar i, i este pătrat perfect și se reține în nr; altfel se trece la i+1. Algoritmul afișează deci primul pătrat perfect din intervalul [m,n] sau 0, dacă nu există. Pentru 7 și 17, primul pătrat perfect de la 7 încolo este 9.

Exemplu: 17 și 25

Se afișează primul pătrat perfect de la m până la 25. Ca acesta să fie chiar 25, între m și 24 nu trebuie să existe niciun pătrat perfect; cel dinaintea lui 25 este 16, deci m poate fi orice număr din intervalul [17,25].

#include <iostream>
using namespace std;

int main()
{
    int m, n, nr = 0, i, x;
    cin >> m >> n;
    i = m;
    do
    {
        x = 1;
        while (x * x < i) x = x + 1;
        if (x * x == i) nr = i;
        else i = i + 1;
    } while (i <= n && nr == 0);
    cout << nr;
    return 0;
}

repetă…până când i>n sau nr≠0 devine do…while cu condiția de continuare, negația celei de oprire: i <= n && nr == 0 (negația lui „sau” este „și” între condițiile negate).

citește m,n (numere naturale nenule, m≤n)
nr←0; i←m
┌repetă
│ x←1
│┌dacă x*x<i atunci
││┌repetă
│││ x←x+1
││└până când x*x≥i
│└■
│┌dacă x*x=i atunci nr←i
││altfel i←i+1
│└■
└până când i>n sau nr≠0
scrie nr

repetă…până când execută corpul cel puțin o dată, iar cât timp poate să nu îl execute deloc: pentru i=1, x←1 are deja x*x ≥ i și x nu trebuie să crească. De aceea structura cu test final este pusă sub condiția x*x<i. Condiția de oprire este negația celei de continuare: x*x≥i.

Exemplu: nodurile {1, 2, 3} și muchiile {[1,2], [1,3], [2,3]}

Din listele de adiacență, muchiile grafului sunt [1,2], [1,3], [1,4], [1,6], [2,3], [2,5], [3,5], [4,5], [4,6] și [5,6]. Un subgraf păstrează un grup de noduri și toate muchiile dintre ele. Ca să fie eulerian, trebuie să fie conex și să aibă toate gradele pare. Nodurile 1, 2 și 3 sunt legate două câte două: subgraful lor este un ciclu cu trei muchii, fiecare nod are gradul 2 și niciun nod nu e izolat. Merge la fel, de exemplu, și subgraful cu nodurile 1, 4 și 6.

struct prajitura
{   int cod;
    float pret;
    int informatii[3];
} p;

Expresiile din enunț spun exact ce câmpuri trebuie să existe: p.cod este un întreg, p.pret un număr real, iar p.informatii[0] arată că informatii este un tablou, cu cele trei numere naturale (glazura, crema și numărul de blaturi).

int ascendent(int n, int x, int y)
{
    int u = n % 10, s = 0, k, t, ok;
    for (k = x; k <= y; k++)
    {
        t = k;
        ok = 1;
        do
        {
            if (t % 10 < u) ok = 0;
            t = t / 10;
        } while (t != 0);
        if (ok == 1) s = s + k;
    }
    return s;
}

u este cifra unităților lui n. Pentru fiecare k din intervalul [x,y] se verifică toate cifrele lui k: dacă una este mai mică decât u, k nu este ascendent. Ascendenții se adună în s, care rămâne 0 dacă nu există niciunul. Structura do…while verifică și numărul 0, care are o singură cifră, 0.

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

int main()
{
    char s[201], c;
    int i = 0, j, k, p, gasit = 0;
    cin.getline(s, 201);
    while (s[i] != '\0')
    {
        j = i;
        while (s[j] != ' ' && s[j] != '\0') j++;
        if ((j - i) % 2 == 0)
        {
            gasit = 1;
            k = (j - i) / 2;
            for (p = 0; p < k; p++)
            {
                c = s[i + p];
                s[i + p] = s[i + k + p];
                s[i + k + p] = c;
            }
        }
        i = j;
        if (s[i] == ' ') i++;
    }
    if (gasit == 1) cout << s;
    else cout << "nu exista";
    return 0;
}

Textul se parcurge cuvânt cu cuvânt: i este începutul cuvântului, j poziția de după el, deci cuvântul are j-i litere. Pentru un cuvânt cu număr par de litere, 2·k, se interschimbă litera de pe poziția i+p cu cea de pe poziția i+k+p, pentru p de la 0 la k-1: prima jumătate ajunge în locul celei de-a doua și invers, direct în șirul citit. Variabila gasit ține minte dacă s-a transformat vreun cuvânt; dacă toate au număr impar de litere, se afișează nu exista.

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

Datele se prelucrează pe măsura citirii, fără să fie memorate. Se citește întâi intervalul disponibil al tânărului, [h1,h2]. Apoi, pentru fiecare muzeu, se numără al câtelea este și se citește intervalul lui, [a,b].

Timpul în care muzeul poate fi vizitat este intersecția celor două intervale: de la v1 = max(h1,a) până la v2 = min(h2,b). Muzeul este convenabil dacă intersecția are cel puțin o oră, adică v1 < v2 (orele sunt fixe). Atunci se crește numărul de muzee convenabile și se reține numărul de ordine al muzeului curent ca ultimul convenabil. La final se afișează cele două valori.

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

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

int main()
{
    ifstream fin("bac.in");
    int h1, h2, a, b, v1, v2, nr = 0, crt = 0, ultim = 0;
    fin >> h1 >> h2;
    while (fin >> a >> b)
    {
        crt++;
        if (a > h1) v1 = a;
        else v1 = h1;
        if (b < h2) v2 = b;
        else v2 = h2;
        if (v1 < v2)
        {
            nr++;
            ultim = crt;
        }
    }
    fin.close();
    cout << nr << ' ' << ultim;
    return 0;
}

Programul face pașii de la 3.a. Intersecția se calculează fără funcții din biblioteci: v1 este cel mai mare dintre începuturi, v2 cel mai mic dintre sfârșituri. Enunțul garantează cel puțin un muzeu convenabil, deci ultim primește sigur o valoare.