Bac informatică 2023 Model, rezolvată

Răspuns corect: b) {20,41}

Pentru 20: 20%20 este 0, iar 20/23 este 0, deci egalitatea este adevărată. Pentru 41: 41%20 este 1, iar 41/23 este tot 1, deci și ea este adevărată.

În a) și c), pentru 40 se obțin 0 și 1, iar în d), pentru 60 se obțin 0 și 2.

Răspuns corect: d) f(21,27);

Fiecare apel afișează (m+n)/2 și continuă cu m mai mare cu 1 și n mai mic cu 2, cât timp m≤n.

f(21,27) afișează 24, apoi f(22,25) afișează 23, f(23,23) afișează tot 23, iar f(24,21) afișează 22 și se oprește: două valori egale cu 23. Celelalte apeluri afișează valoarea 23 cel mult o dată.

Răspuns corect: a) (mousse, castane, ganache)

Pe primele două straturi pot fi doar castane, mousse sau șerbet, iar ultimul strat este frișcă sau ganache; tipurile se încearcă în ordinea din mulțime.

Primele patru torturi încep cu castane. După (castane, șerbet, ganache) nu mai există alt al doilea strat pentru castane, deci primul strat devine mousse, iar al doilea, cel mai mic posibil, castane: al cincilea tort este (mousse, castane, frișcă), iar al șaselea (mousse, castane, ganache).

Răspuns corect: c) 4

Vârfurile 1, 2, 3 și 6 sunt în aceeași componentă tare conexă: 1→3→2→6→1 este un circuit care le cuprinde pe toate.

Din 3 se ajunge și în 4, 5 și 7, dar din acestea nu se mai poate reveni în 3: 4 și 7 formează o componentă separată, iar din 5 nu pleacă niciun arc. Componenta lui 3 are 4 vârfuri.

Răspuns corect: d) 5

Ciclul eulerian trece o singură dată prin fiecare muchie, deci graful are 11 muchii. Ciclul hamiltonian trece o singură dată prin fiecare nod, deci graful are 7 noduri.

Un arbore cu 7 noduri are 6 muchii, iar un ciclu hamiltonian arată că graful e conex, deci se poate păstra un astfel de arbore. Se elimină 11 − 6 = 5 muchii.

Răspunsul din barem: 90

90

Numerele care se împart la m sau la n se adună, iar cele care se împart la amândouă se scad imediat înapoi: se adună, de fapt, numerele dintre p și q care se împart la exact unul dintre m și n.
Pentru m=4, n=3, între 11 și 25: multiplii lui 3 sunt 12, 15, 18, 21, 24, ai lui 4 sunt 12, 16, 20, 24, iar 12 și 24 se împart la amândouă. Rămân 15 + 18 + 21 + 16 + 20 = 90.

Exemplu: 70 74

Pentru m=10, n=15 și p=2 se adună numerele care se împart la exact unul dintre 10 și 15, de la 2 la q. Numerele adunate sunt 10, 15, 20, 40, 45, 50, 70, 75, … (30 și 60 se împart la amândouă și nu se adună), iar sumele parțiale sunt 10, 25, 45, 85, 130, 180 și 250 după 70. Următorul număr adunat este 75, deci suma este 250 pentru orice q de la 70 la 74.

#include <iostream>
using namespace std;

int main()
{
    int m, n, p, q, s = 0, x;
    cin >> m >> n >> p >> q;
    for (x = p; x <= q; x++)
    {
        if (x % m == 0 || x % n == 0) s = s + x;
        if (x % m == 0 && x % n == 0) s = s - x;
    }
    cout << s;
    return 0;
}

pentru x←p,q execută devine for (x = p; x <= q; x++), sau devine ||, iar și devine &&.

citește m,n,p,q (numere naturale nenule, p≤q)
s←0
x←p
┌cât timp x≤q execută
│┌dacă x%m=0 sau x%n=0 atunci
││ s←s+x
│└■
│┌dacă x%m=0 și x%n=0 atunci
││ s←s-x
│└■
│ x←x+1
└■
scrie s

Cu cât timp, contorul se gestionează explicit: x primește valoarea inițială p înainte de buclă, se continuă cât timp x≤q, iar x←x+1 se face la sfârșitul corpului.

int i, j, ord[3] = {0, 1, 2}, aux;
for (i = 0; i < 2; i++)
    for (j = i + 1; j < 3; j++)
        if (c[ord[i]].rezultat < c[ord[j]].rezultat)
        {
            aux = ord[i];
            ord[i] = ord[j];
            ord[j] = aux;
        }
cout << c[ord[0]].nume << ' ' << c[ord[1]].nume << ' ' << c[ord[2]].nume;

Tabloul ord ține pozițiile echipelor și se ordonează după rezultate, descrescător, fără să se mute înregistrările propriu-zise. La final se afișează numele echipelor în această ordine. Se poate la fel de bine interschimba direct elementele tabloului c.

Răspunsul din barem: 7fantastic

7fantastic

strchr(s1,' ') indică spațiul, aflat pe poziția 7, deci p = 7, iar s2 devine "fistic", tot ce urmează după spațiu.
strcpy(s1+p-1, s2+2) scrie de la poziția 6 a lui s1 șirul "stic": s1 devine "plantastic". strcpy(s2+1, s1+2) scrie de la poziția 1 a lui s2 șirul "antastic": s2 devine "fantastic". Se afișează 7 urmat imediat de fantastic.

int DoiTrei(int n)
{
    do
    {
        if (n % 10 != 2 && n % 10 != 3) return 0;
        n = n / 10;
    } while (n != 0);
    return 1;
}

Cifrele se iau pe rând, de la dreapta. La prima cifră diferită de 2 și de 3 se returnează 0; dacă toate trec verificarea, se returnează 1. Structura do…while verifică și cifra lui n=0, care nu este din mulțime.

#include <iostream>
using namespace std;

int main()
{
    int n, a[102][102], i, j, gasit = 0;
    cin >> n;
    for (i = 0; i <= n + 1; i++)
        for (j = 0; j <= n + 1; j++)
            a[i][j] = 1;
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
            cin >> a[i][j];
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
            if (a[i][j] == 3 && a[i - 1][j] != 0 && a[i + 1][j] != 0 && a[i][j - 1] != 0 && a[i][j + 1] != 0)
            {
                cout << i << ' ';
                gasit = 1;
            }
    if (gasit == 0) cout << "nu exista";
    return 0;
}

Tabloul are o bordură de zone fictive, cu codul 1 (nu tobogan), în jurul suprafeței: așa, și zonele de pe margini sau din colțuri au patru vecini de verificat, fără cazuri separate. Un carusel se afișează dacă niciunul dintre cei patru vecini nu este tobogan. Rândurile se parcurg de sus în jos, deci numerele ies în ordine crescătoare, iar enunțul acceptă orice ordine.

O pereche (x, y) nu este p-ordonată doar dacă x și y au parități diferite și x < y. Șirul este p-ordonat exact când nu există o astfel de pereche între un x din prima jumătate și un y din a doua.

Pentru un x par, cel mai „periculos” y este cel mai mare impar din a doua jumătate; pentru un x impar, cel mai mare par. Deci șirul este p-ordonat exact când cel mai mic par din prima jumătate este mai mare decât cel mai mare impar din a doua și cel mai mic impar din prima jumătate este mai mare decât cel mai mare par din a doua.

Se citesc primii n termeni, reținând minimul par și minimul impar (pornite de la 1000001), apoi ultimii n termeni, reținând maximul par și maximul impar (pornite de la -1). La final se fac cele două comparații și se afișează DA sau NU.

Eficiență: fiecare număr se prelucrează o singură dată, în timp constant, fără să fie memorat, deci timpul este liniar, iar memoria constantă.

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

int main()
{
    ifstream fin("bac.txt");
    int n, i, x, p1 = 1000001, i1 = 1000001, p2 = -1, i2 = -1;
    fin >> n;
    for (i = 0; i < n; i++)
    {
        fin >> x;
        if (x % 2 == 0)
        {
            if (x < p1) p1 = x;
        }
        else if (x < i1) i1 = x;
    }
    for (i = 0; i < n; i++)
    {
        fin >> x;
        if (x % 2 == 0)
        {
            if (x > p2) p2 = x;
        }
        else if (x > i2) i2 = x;
    }
    fin.close();
    if (p1 > i2 && i1 > p2) cout << "DA";
    else cout << "NU";
    return 0;
}

Programul face pașii de la 3.a. Dacă o jumătate nu are numere pare (sau impare), minimul rămâne 1000001 și maximul -1, iar comparațiile corespunzătoare sunt adevărate de la sine, cum trebuie: nu există perechi de acel tip.