Bac informatică 2024 Varianta 8, rezolvată

Răspuns corect: b) !(x<=99 && y>=10)

Intervalul [x,y] conține un număr de două cifre exact când se suprapune cu [10,99], adică x<=99 && y>=10. Negația acestei condiții este varianta b).

a) este adevărată, de exemplu, pentru [5,50], care conține numere de două cifre; c) este adevărată tot pentru [5,50]; d) nu poate fi adevărată niciodată, pentru că x≤y.

Răspuns corect: d) f(6,1,1);

Fiecare apel cu z<x afișează y și continuă cu y mai mare cu 2 și z mai mare cu 1. Se afișează deci y, y+2, y+4, … de x−z ori.

Pentru 13579 trebuie să se înceapă de la 1 și să se afișeze 5 valori: y=1 și x−z=5, adică f(6,1,1). a) începe de la 0, b) afișează doar patru valori, iar c) nu afișează nimic.

Răspuns corect: a) oare

strcmp(x,y) compară șirurile alfabetic, literă cu literă: „soare” începe cu s, care vine după p, deci este mai mare decât „ploaie” și rezultatul este pozitiv.

Se execută strcpy(s,x+1), care copiază șirul x începând cu a doua literă: oare.

Răspuns corect: b) 3

În vectorul de tați, rădăcina este singurul nod care nu are tată, adică cel pentru care valoarea din vector este 0. Valoarea 0 se află pe poziția 3, deci rădăcina este nodul 3.

Răspuns corect: c) 18

Ca să rămână cât mai multe vârfuri izolate, arcele se pun între cât mai puține vârfuri. Între k vârfuri pot exista cel mult k·(k−1) arce, câte unul în fiecare sens pentru fiecare pereche.

5 vârfuri permit doar 20 de arce, prea puține, dar 6 vârfuri permit 30, suficient pentru 24. Rămân izolate 24 − 6 = 18 vârfuri.

Răspunsul din barem: 43141

43141

La prima trecere prin buclă, x primește ultimele două cifre ale numărului; la fiecare trecere următoare, y primește ultimele două cifre ale valorii curente, deci la final y conține primele două cifre. Bucla se oprește când rămâne prima cifră. Rezultatul alipește prima cifră și cele două perechi, cea mai mică dintre ele înaintea celeilalte.
Pentru 412531: x = 31, y = 41, iar n rămâne 4. Cum 31 < 41, n devine (4·100+31)·100+41 = 43141.

Exemplu: 111 1111

Rezultatul este prima cifră, urmată de cea mai mică și apoi de cea mai mare dintre perechile x (ultimele două cifre) și y (primele două cifre). Ca să iasă 11111, prima cifră trebuie să fie 1, iar ambele perechi 11. Din intervalul [1,11110], asta se întâmplă pentru 111, 1111 și 11011.

#include <iostream>
using namespace std;

int main()
{
    int n, x = -1, y = -1;
    cin >> n;
    while (n > 9)
    {
        if (x == -1) x = n % 100;
        else y = n % 100;
        n = n / 10;
    }
    if (x < y) n = (n * 100 + x) * 100 + y;
    else n = (n * 100 + y) * 100 + x;
    cout << n;
    return 0;
}

cât timp devine while, iar [n/10] este împărțirea întreagă din C/C++.

citește n (număr natural nenul)
x←-1; y←-1
┌dacă n>9 atunci
│┌repetă
││┌dacă x=-1 atunci x←n%100
│││altfel y←n%100
││└■
││ n←[n/10]
│└până când n≤9
└■
┌dacă x<y atunci n←(n*100+x)*100+y
│altfel n←(n*100+y)*100+x
└■
scrie n

repetă…până când execută corpul cel puțin o dată, iar cât timp poate să nu îl execute deloc: pentru un n de o cifră, bucla dată nu se execută. De aceea structura cu test final este pusă sub condiția n>9. Condiția de oprire este negata celei de continuare: n≤9.

Răspunsul din barem: (crin, gerbera, iris) (crin, iris, orhidee)

(crin, gerbera, iris) (crin, iris, orhidee)

Buchetele se generează ca submulțimi de trei flori, în ordinea din mulțime, iar crinul nu apare împreună cu eustoma sau zambila.
Înainte de (crin, gerbera, orhidee): cu (crin, gerbera) pe primele poziții, floarea de dinaintea orhideei care se poate folosi este irisul, pentru că eustoma nu poate sta cu crinul. După el: după orhidee ar urma zambila, interzisă cu crinul, deci se schimbă a doua floare, gerbera, cu următoarea, irisul, iar a treia devine cea mai mică floare de după el care se poate folosi, orhideea.

if ((m.nota1 <= 'E' && m.nota2 == m.nota1 + 2) || (m.nota1 >= 'F' && m.nota2 == m.nota1 - 5))
    cout << "TERTA";
else cout << "NU";

În gamă notele sunt, în ordine, C, D, E, F, G, A, B. O terță sare peste o singură notă. Pentru C, D și E, nota aflată la două poziții după ea este tot în ordinea alfabetului: nota1 + 2 (C→E, D→F, E→G). Pentru F și G, ordinea gamei continuă cu A și B, aflate în alfabet cu 5 poziții înainte: F→A și G→B, adică nota1 − 5.

int moderat(int n)
{
    int p, q, k, d, prim;
    if (n < 6) return 0;
    p = 2;
    while (n % p != 0) p++;
    q = n / p;
    if (q <= p) return 0;
    for (k = p + 1; k <= q; k++)
    {
        prim = 1;
        for (d = 2; d * d <= k; d++)
            if (k % d == 0) prim = 0;
        if (k == q) return prim;
        if (prim == 1) return 0;
    }
    return 0;
}

Cel mai mic divizor p ≥ 2 al lui n este sigur prim. Dacă n este produsul a două numere prime consecutive, p este cel mai mic dintre ele, iar celălalt este q = n/p, mai mare decât p.
Se parcurg numerele de la p+1 la q: dacă vreunul dintre ele, înainte de q, este prim, atunci p și q nu sunt consecutive și se returnează 0; când se ajunge la q, rezultatul este 1 exact dacă q este prim. Numerele sub 6 nu pot fi moderate (cel mai mic este 2·3).

#include <iostream>
using namespace std;

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

Primul rând (linia 0) are gazon, deci rândurile cu flori sunt liniile 1, 3, 5, … Pentru fiecare astfel de linie i se află înălțimea minimă a florilor. Orice parcelă cu gazon de pe rândul anterior, linia i−1, trebuie să fie cu cel puțin un decimetru mai joasă decât toate florile, deci cel mult minim−1; cele mai înalte se tund exact la această valoare. Dacă ultimul rând are gazon, după el nu mai urmează flori și rămâne neschimbat.

Formula termenului general se poate întoarce: dacă a, b, c, d sunt patru termeni consecutivi, d = 4c − 3b − 2a, deci termenul dinaintea lor este a = (4c − 3b − d)/2. Din ultimii trei termeni scriși se obține, așadar, termenul de dinaintea lor.

Se scriu în fișier z, y și x, în această ordine (descrescătoare). Apoi, repetat, se calculează termenul anterior, (4·y − 3·x − z)/2, se scrie și se mută fereastra: z primește y, y primește x, iar x noul termen. Primii doi termeni ai șirului sunt singurele valori 0, deci algoritmul se oprește după ce au fost scrise două valori 0 (numărând și eventualele zerouri dintre valorile citite).

Eficiență: fiecare termen se obține în timp constant din cei trei scriși înaintea lui, deci timpul este liniar în numărul de termeni scriși; se păstrează doar trei valori, fără tablou, deci memoria folosită este constantă.

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

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

Programul face pașii de la 3.a. Numărul de zerouri pornește de la cele aflate deja printre valorile citite (de exemplu pentru 0 0 1 nu mai trebuie calculat nimic). Termenii ajung la 10^9, iar 4·y trece de limita tipului int, de aceea se folosește long long.