SUBIECTUL I

1. Răspuns corect: a

Justificare:
Dacă vrem să verificăm că trei numere au valori identice (sunt egale) este suficient ca unul dintre ele să fie egal
cu celelalte două asta conform relației de tranzitivitate pe care voi o cunoașteți și anume: daca x=y și y=z atunci
și x=z
Așa că relația de pa punctual a (x==y && x==z) este cea corectă
Relațiile de la punctele b și d par corecte matematic vorbind dar în C++ este greșit să scriem x==y==z, corect este
x==y&&y==z).

2. Răspuns corect: b

Justificare:
Marcăm cu roșu apelurile
f (20 , 2020) = 1 + f (20 , f (20 , 101))
f (20 , 101) = 1 + f (20 , f (20 , 5) )
f (20 , 5) = 1 + f ( f (4 , 5) , 5)
f(4 , 5) = 1+f (4 , f (4 , 1))
f(4 , 1)=0
Numărăm f-urile colorate, sunt 9.

3. Răspuns corect: d

Justificare:
Avem la dispoziție 3 mulțimi din care luăm elemente pentru a forma soluțiile. Din prima mulțime punem toate
elementele, din mulțimile 2 și 3 luăm câte un element având în vedere restricțiile.

Mulțimea 1 (ingredient de bază, se pun toate) (făină, lapte, ouă)

1 2 3
Mulțimea 2 (umplutura pentru clătite) (ciocolată, dulceață, urdă)
4 5 6
Mulțimea 3 (ingrediente pentru ornat) (cașcaval, mărar, frișcă)
7 8 9
Mai avem de generat două soluții. Le scriem cu atenție, încercând de fiecare dată să modificăm cât mai de la
coadă și, când nu mai e posibil revenim la cea anterioară celei pe care am încercat s-o modificăm și nu s-a putut.

Plecăm de la ultima soluție dată de ei,

(faina, ouă, lapte, ciocolată, frișcă) (1,3,2,4,9)
Pentru că pe ultima poziție nu mai putem pune altceva, ne concentrăm pe penultima poziție. Putem alege a
doua valoare și anume “dulceață”. Până aici este bine. Mergem mai departe și alegem un element din mulțimea
3. Primul este “cașcaval”, am avea:
- (faina, ouă, lapte, dulceață, cașcaval) - dar nu se potrivește datorită restricțiilor,
urmează “mărar” pe ultima poziție:
- (faina, ouă, lapte, dulceață, mărar) - nici el nu se potrivește așa că urmează “friscă” și este bine.
Așa că soluția 6 este (faina, ouă, lapte, dulceață, frișcă) (1, 3, 2, 5, 9)
Pentru că pe ultima poziție nu mai putem pune altceva, ne concentrăm pe penultima poziție. Putem alege a
treia valoare și anume “urdă”. Până aici este bine. Mergem mai departe și alegem un element din mulțimea 3.
Primul este “cașcaval”, am avea: (faina, ouă, lapte, urdă, cașcaval) (1, 3, 2, 6, 7) Este in regulă, deci acesta este
soluția 7, adică cea căutată de noi.
 4. Răspuns corect: c

Justificare:
După desenarea arborelui pe baza vectorului de tați dat, se conturează 3 lanțuri diferite care pleacă din nodul
rădăcină și se opresc în noduri de tip frunză.

Pentru că nodul 5 este tatăl nodului 3, nodul 3 este tatăl nodului 4, nodul 4 este
tatăl nodului 8 și nodul 8 este tatăl nodului 7 rezultă lantul (5, 3, 4, 8, 7), lanț de
lungime 4.
Pentru că nodul 5 este tatăl nodului 6 și nodul 6 este tatăl nodului 1, rezultă lanțul
(5, 6, 1), lanț de lungime 2.
Pentru că nodul 5 este tatăl nodului 6 și nodul 6 este tatăl nodului 2, rezultă lanțul
(5, 6, 2), lanț de lungime 2.

Conform definiției înălțimii unui arbore dată în enunțul problemei rezultă ca

înălțimea arborelui este 4.

5. Răspuns corect: b

Putem să ne imaginăm că un lanţ eulerian este de fapt un ciclu eulerian de la care lipseşte o muchie. Prin
urmare, analogie făcând cu proprietatea de caracterizare a unui graf eulerian, deducem că graful nostru trebuie
să fie conex, exact două noduri pot să aibă grad impar, restul având fiecare grad par.
Dacă desenăm graful, observăm că ar două componente conexe şi avem destul de multe noduri de grad impar:
1, 2, 4, 5, 6, 8. Cel mai probabil, soluţia care ne avantajează este să lăsăm exact două noduri cu grad impar.

O soluție posibilă (sigur nu este singura):

Adăugăm muchiile [2,6] și [5,8] (cele cu roşu, pe desenul de mai jos)
Un lanț eulerian posibil este: 1, 10, 3, 1, 2, 6, 4, 8, 6, 9, 8, 5, 7, 9, 5, 4

Am evidenţiat cu albastru nodurile care NU aveau grad par, pe graful iniţial:

SUBIECTUL al II-lea
1. a) La o analiză a algoritmului observăm o repetitivă exterioară în care se iau în variabilele c1 și c2 rând pe
rând toate perechile de câte două cifre consecutive din numărul natural citit n.
Dacă cifra c1 este mai mare decât c2 structura if la o analiza atentă, interschimbă între ele valorile celor
două variabile. În acest fel c1 va fi mai mic sau egal cu c2.
Urmează o structură repetitivă care afișează valoarea c1 atâta timp cât c1 este mai mic strict decât c2,
valoarea lui c2 modificându-se la fiecare pas prin împărțire la 2.
Repetitiva exterioară se execută până când numărul citit, din care la fiecare pas se taie câte o cifră, ajunge
să rămână cu o singură cifră.
Pe baza celor descrise mai sus pentru valoarea lui n egală cu 49335 se vor afișa valorile 3334 atenție, fără
spațiu intre ele.
Să verificăm că, și urmărind evoluțiile valorilor variabilelor cu tabel, obținem același lucru:
n c1 c2
49335 5
4933 3
5
3
scrie: 3
2
3
493 3
3
49 9
scrie: 3
4
scrie: 3
2
9
4 4
9
4
scrie 4
4
Deci, răspuns corect : 3334
b) Pentru următoarele valori ale lui n, respectiv pentru fiecare dintre acestea algoritmul va afișa valoarea 1100:
1014, 1015, 1016, 1017. Este corect să scriem oricare trei dintre numerele de mai sus.

c)
#include <iostream>
using namespace std;

int main()
{
int n,c1,c2;
cin>>n;
do
{
c1=n%10;
n=n/10;
c2=n%10;
if(c1>c2)
{
c2=c1;
c1=n%10;
}
while(c1<c2)
{
cout<<c1;
c2=c2/2;
}
}
while (n>9);
return 0;
}
 d)
Avem de transformat structura cât timp....execută intr-o structură de tipul repetă...până când.
Vă reamintesc modul general de transformare dintr-o repetitivă cu test inițial într-o repetitivă cu test final.

Se dă:
┌cât timp condiţie execută
│ instrucţiuni
└■

Transformarea sa:
┌dacă condiţie atunci
│ ┌repetă
│ │ instrucţiuni
│ └până când not condiţie
└■

Deci, iată rezolvarea, !!!!atenție, trebuie rescrisă toată secvența):

citește n (număr natural)
┌repetă
│ c1<-n%10; n<-[n/10]; c2<-n%10
| ┌dacă c1>c2 atunci
| | c2<-c1; c1<-n%10
| └■
| ┌dacă c1<c2 atunci
| | ┌repetă
| | | scrie c1
| | | c2<-[c2/2]
| | └până când c1≥c2
| └■
└până când n≤9

2. Iată o variantă de declarație pentru structura cerută:

struct poliedru
{
int NrVarfuri;
double Muchie;
struct
{
double FataMuchie, FataFata;
} Unghi;
} p;

3. Răspuns corect: opusqrdzdce

Justificare:
Explicația algoritmului este următoarea:
- se copiază în șirul de caractere s cuvântul “optsprezece”
- variabila i primește valoarea 0 (poziția primului caracter din șir) și variabila j primește valoarea 10
(poziția ultimului caracter din șir)
- cât timp i<j, dacă caracterul de pe poziția i nu este vocală și dacă caracterul de pe poziția j este
vocală, caracterul de pe poziția i primeste următorul caracter din alfabet iar caracterul de pe poziția j
primeste caracterul precedent din alfabet
- apoi indiferent de rezultatul condiției i crește cu 1 și j scade cu 1 (practic se pune condiția asupra
caracterelor egal departate de mijlocul șirului)
 SUBIECTUL al III-lea

1. Pentru că subprogramul afișează valori va fi de tip void.

Iată o variantă de rezolvare:

void generatoare (int n)

{
int nr=0,a,b; ///var. nr numără câte perechi am afișat, acesta ne va ajuta să
/// afișam mesajul "nu exista" dacă nu vom avea nicio pereche

///am luat cu cele două for-uri toate valorile posibile pe care le pot lua variabilele
a și b

for(a=2;a<=n/2;a+=2) ///enuntul ne cere ca variabila a să aibă valoare pară

for(b=1;b<=n/2;b++)
if(a*b+a/b==n) {
cout<<a<<"-"<<b<<" ";
nr++;
}
if(nr==0) cout<<"nu exista";
}

2. Iată o variantă de rezolvare:

#include <iostream>

using namespace std;

int main()
{
int n,m,a[22][22],i,j,nr,ok;
cin>>m;
cin>>n;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
cin>>a[i][j];
nr=0;///var nr numără câte coloane complementare cu prima col. avem
for(j=2;j<=n;j++)
{
ok=1; ///pp. coloanele a fi complementare
for(i=1;i<=m;i++)
if(a[i][1]==a[i][j]) ok=0;
if(ok) nr++;
}
cout<<nr;

return 0;
}

3. O soluție eficientă parcurge șirul din fișier, memorând variabila curentă (crt), valoarea anterioară celei curente
(ant) , precum și numărul de apariții ale valorii curente (nr). La întâlnirea unei valori crt diferite de ant, se
afișează ant, după caz, și se actualizează corespunzător variabilele. Ultima secvență este tratată individual.

Algoritmul este eficient d.p.d.v. al timpului de executare deoarece se fac puțini pași, pentru că datele de intrare
sunt parcurse o singură dată, algoritmul fiind liniar.
Algoritmul este eficient d.p.d.v. al memoriei deoarece utilizează doar câteva variabile simple.
Iată varianta de rezolvare eficientă:

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

ifstream fin("bac.txt");

int main()
{
int x,crt,ant,nr,ok;
ok=0;
fin>>x;
ant=x;
nr=1;
while(fin>>x)
{
crt=x;
if(ant==crt) nr++;
else
{
if(nr==2) {
cout<<ant<<" ";
ok=1;
}
ant=crt;
nr=1;
}
}
if(nr==2)
{
cout<<crt;
ok=1;
}
if(ok==0) cout<<"nu exista";

return 0;
}