Bac informatică 2022 Varianta 5, rezolvată

Răspuns corect: b) !(x<3 || x>=10)

x>=3 && x<10 este adevărată exact când nu e adevărată niciuna dintre x<3 și x>=10, adică !(x<3 || x>=10). În a) negarea unei expresii mereu false dă mereu 1; în c) rămâne x<3, adică exact numerele excluse; în d) rămâne x>=3, care e 1 și pentru x=10.

Răspuns corect: a) y+2

Subprogramul verifică dacă x e prim: elimină întâi numerele pare, apoi caută un divizor y, pornind de la 3. Cum numerele pare sunt deja tratate, are rost să încerce doar divizorii impari, deci pasul este y+2. Cu y-2 apelul ar merge înapoi la infinit, cu y*2 s-ar sări peste divizori impari, iar y/2 ar ajunge la 1, care împarte orice număr.

Răspuns corect: d) (prună, caisă, piersică)

Platourile se generează în ordinea fructelor din mulțime, iar gutuia și piersica nu pot fi împreună. După (gutuie, prună, caisă) ar urma (gutuie, prună, piersică) și (gutuie, caisă, piersică), dar amândouă au și gutuie, și piersică, deci se sar; rămâne (prună, caisă, piersică).

Răspuns corect: c) 79

Pe diagonala secundară a unui tablou cu 100 de linii și 100 de coloane, numerotate de la 0 la 99, suma indicilor unui element este 99. Din 20+j=99 rezultă j=79.

Răspuns corect: b) [1,4] și [5,7]

Lanțul dat folosește muchiile [1,2], [2,7], [7,5], [5,4] și [4,6]; dintre ele, [5,7] nu e în lista celor șase, deci e una dintre muchiile care lipsesc. Cealaltă trebuie să nu creeze un lanț mai lung: cu [1,4], nodurile 3 și 6 rămân legate doar de 4, deci niciun lanț nu le poate cuprinde pe amândouă împreună cu restul, iar lanțul dat, cu șase noduri, rămâne maxim. Cu [3,6] în schimb ar exista lanțul 1, 2, 7, 5, 4, 3, 6, cu toate cele șapte noduri, mai lung decât cel din enunț.

Răspunsul din barem: 45

Bucla interioară calculează, prin scăderi repetate, cel mai mare divizor comun dintre m și valoarea curentă a lui n, iar bucla exterioară merge mai departe cât timp acesta este 1. Pentru m=21 se încearcă pe rând 47 și 46, care nu au divizori comuni cu 21, apoi 45: cum 21 și 45 se împart amândouă la 3, bucla se oprește. Se afișează n+1, adică ultima valoare încercată, 45.

10 și 12

Se afișează ultima valoare încercată, adică primul număr, coborând de la n, care are un divizor comun cu 5 — altfel spus, primul multiplu de 5. Ca acesta să fie 10, valoarea citită trebuie să fie cel puțin 10 (ca 10 să fie încercat) și cel mult 14 (ca 15 să nu fie întâlnit înaintea lui). Merge deci orice număr din intervalul [10,14].

#include <iostream>
using namespace std;

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

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

cât timp x=1 verifică la început și merge înainte cât timp condiția e adevărată, iar repetă…până când verifică la sfârșit și se oprește când condiția devine adevărată: condiția se neagă, deci x≠1. Aici înlocuirea nu schimbă nimic, pentru că x←1 de dinainte făcea oricum ca prima verificare să treacă — de altfel, după înlocuire, acea inițializare nu mai e necesară.

Răspunsul din barem: 2, 8

Ca nodul 5 să aibă doi frați, părintele lui trebuie să aibă trei fii. Vecinii lui 5 sunt 2, 4, 6 și 8. Dacă rădăcina este chiar 2, fiii lui 2 sunt 3, 5 și 7, deci 5 are doi frați; la fel, dacă rădăcina este 8, fiii lui sunt 1, 5 și 9. Pentru orice altă rădăcină, părintele lui 5 pierde un fiu în favoarea propriului părinte, deci 5 ar rămâne cu un singur frate.

if (x.temperatura > 11) cout << "CALDUROS";
else if (x.temperatura < 10) cout << "RACOROS";
     else cout << "NORMAL";

Se citește câmpul temperatura al înregistrării și se compară, în ordine, cu cele două praguri. Cazurile se leagă cu else, ca fiecare temperatură să intre într-unul singur: peste 11 grade e cald, sub 10 e răcoros, iar ce rămâne — exact valorile 10 și 11 — e normal.

void schimb(int &n, int x, int p)
{
    int put = 1;
    for (int i = 0; i < p; i++) put = put * 10;
    int cifra = (n / put) % 10;   // cifra care se schimbă
    n = n + (x - cifra) * put;
}

Poziția p înseamnă puterea lui 10 corespunzătoare: put ajunge 10^p. Cifra aflată acolo este (n/put)%10. În loc să fie reconstruit tot numărul, se adaugă diferența dintre cifra nouă și cea veche, înmulțită cu put: restul cifrelor rămân neatinse. Parametrul n e transmis prin referință, fiindcă rezultatul se întoarce tot prin el.

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

int main()
{
    char s[51];
    cin >> s;
    char vocale[] = "aeiou";
    for (int i = 0; i < strlen(s); i++)
    {
        char prietena = s[i];
        if (strchr(vocale, s[i]) == NULL)
        {
            // Cea mai apropiată vocală dinaintea consoanei.
            prietena = 'a';
            for (int j = 0; j < 5; j++)
                if (vocale[j] < s[i]) prietena = vocale[j];
        }
        s[i] = prietena;
    }
    cout << s;
    return 0;
}

O vocală rămâne neschimbată. Pentru o consoană se caută vocala prietenă: dintre cele cinci vocale, cea mai mare care este încă înaintea ei în alfabet — parcurgându-le în ordine, ultima care îndeplinește condiția. Consoanele dinaintea lui e (b, c, d) primesc a, iar cele de după u primesc u. Cuvântul se modifică pe loc și se afișează la final.

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

Șirul se citește din fișier o singură dată, fără a fi memorat. Se ține minte doar termenul anterior și lungimea secvenței paritare care se termină în termenul curent: dacă termenul citit are aceeași paritate cu cel dinainte, lungimea crește cu 1, altfel secvența s-a încheiat și începe una nouă, de lungime 1.

La fiecare încheiere de secvență, lungimea ei se compară cu maximul de până atunci: dacă e mai mare, maximul se actualizează și numărătorul se readuce la 1; dacă e egală, numărătorul crește. După ultimul termen se închide și ultima secvență, care altfel nu ar fi luată în seamă.

Se face o singură parcurgere, cu un număr de operații proporțional cu numărul de termeni, și se rețin doar câteva variabile — paritatea anterioară, lungimea curentă, maximul și numărătorul — deci memoria folosită nu crește cu lungimea șirului.

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

int main()
{
    ifstream f("bac.txt");
    int v, ant, lung = 1, maxim = 0, cate = 0;
    f >> ant;
    while (f >> v)
    {
        if (v % 2 == ant % 2) lung = lung + 1;
        else
        {
            if (lung > maxim) { maxim = lung; cate = 1; }
            else if (lung == maxim) cate = cate + 1;
            lung = 1;
        }
        ant = v;
    }
    // Ultima secvență nu are după ea un termen de altă paritate care să o închidă.
    if (lung > maxim) { maxim = lung; cate = 1; }
    else if (lung == maxim) cate = cate + 1;
    f.close();
    cout << cate << ' ' << maxim;
    return 0;
}