cls12BAC 2023 9

Informatică
Bacalaureat
specializarea matematică-informatică
2023-9
PROBLEME DE INFORMATICĂ
date la bacalaureat
la specializarea matematică-informatică
ı̂n
**** 2023 2022 2021 2020

2019 2018 2017 2016 2015
2014 2013 2012 2011 2010
Dacă ştii să rezolvi problemele date ı̂n ultimii 10-20 de ani
atunci vei şti să rezolvi problemele care se vor da ı̂n acest an!
... draft (ciornă) ...

*** Nobody is perfect ***
Adrian Răbâea, Ph.D.
https://www.scribd.com/user/552245048/Adi-Rabaea (sprijin financiar![ 19 ])
2023-9-9
Figura 1: Descompunerea canonică a lui f
”O imagine valorează
cât 1000 de cuvinte!” 1
x1 x1
x3 x3
x2 x2
elevii f = aleg ”şeful” elevi
ı̂n clasă ı̂n clasă
fac echipe echipei
y1 y1
y3 y3
y2 y2
p : proiecţia canonică (se fac listele) i : injecţia canonică

(şefii revin)
(ı̂n clasă)
xr x1
liste cu elevi f¯ = predau lista şefi de echipe

”şefului” echipei Im f
yr y1
Figura 2: Un desen ... i ` f¯ ` p f
1
I.d.k.: ”I don’t know who the author is.”
Dedication
I would like to dedicate this book ...
a ”to myself” ...

2
3
in a time when ...
4
I will not be able ... ”to be”
That is because ...
5
”When I Die Nobody Will Remember Me”
a to people impacted by the book

a to my nephew Adam.
( in ascending order! )
2
https://www.femalefirst.co.uk/books/carol-lynne-fighter-1034048.html
3
https://otiliaromea.bandcamp.com/track/dor-de-el
4
https://en.wikipedia.org/wiki/To_be,_or_not_to_be
5
https://www.youtube.com/watch?v=eMtcDkSh7fU
ii
Prefaţă
Stilul acestor cărţi este ... ca şi cum aş vorbi cu nepoţii mei (şi chiar cu mine ı̂nsumi!) ... ı̂ncercând
ı̂mpreună să găsim o rezolvare cât mai bună pentru o problemă dată la olimpiadă.
Ideea, de a scrie aceste culegeri de probleme date la olimpiadele de informatică, a apărut acum
câţiva ani când am ı̂ntrebat un student (care nu reuşea să rezolve nişte probleme foarte simple):
”Ce te faci dacă un elev, care ştie că eşti student şi că studiezi şi informatică, te roagă, din când ı̂n
când, să-l ajuţi să rezolve câte o problemă de informatică dată la gimnaziu la olimpiadă, sau pur
şi simplu ca temă de casă, şi tu, aproape de fiecare dată, nu ı̂l poţi ajuta? Eu cred că nu este prea
bine şi poate că ... te faci ... de râs!” Pe vremea mea (!), când eram elev de gimnaziu, un student
era ca un fel de ... zeu! Cu trecerea anilor am ı̂nţeles că nu este chiar aşa! Şi ı̂ncă ceva: nu am
reuşit să ı̂nţeleg de ce, atunci când cineva nu poate să rezolve corect o problemă de informatică
de clasa a 6-a, dată la olimpiada de informatică sau ca temă de casă, foloseşte această scuză: ”eu
nu am făcut informatică ı̂n liceu!” şi acest cineva este ”zeul” sau ”zeiţa” despre care vorbeam!.
6
Sunt convins că este important să studiem cu atenţie cât mai multe probleme rezolvate! . Cred
că sunt utile şi primele versiuni ale acestor cărţi ... ı̂n care sunt prezentate numai enunţurile şi
indicaţiile ”oficiale” de rezolvare. Acestea se găsesc ı̂n multe locuri; aici ı̂ncerc să le pun pe ”toate
la un loc”! Fiecare urcă spre vârf ... cât poate! Sunt multe poteci care duc spre vârf iar această
carte este ... una dintre ele!
Limbajul de programare se alege ı̂n funcţie de problema pe care o avem de rezolvat. Cu nişte
ani ı̂n urmă alegerea era mai simplă: dacă era o problemă de calcul se alegea Fortran iar dacă era
o problemă de prelucrarea masivă a datelor atunci se alegea Cobol. Acum alegerea este ceva mai
7 8
dificilă! :-) Vezi, de exemplu, IOI2020 şi IOI2019 , IOI2015 . (Numai GCC a fost mereu!)
Cred că, de cele mai multe ori, este foarte greu să gândim ”simplu” şi să nu ”ne complicăm”
atunci când cautăm o rezolvare pentru o problemă dată la olimpiadă. Acesta este motivul pentru
care vom analiza cu foarte mare atenţie atât exemplele date ı̂n enunţurile problemelor cât şi
”restricţiile” care apar acolo (ele sigur ”ascund” ceva interesant din punct de vedere al algoritmului
9
de rezolvare!) .
Am ı̂nceput câteva cărţi (pentru clasele de liceu) cu mai mulţi ani ı̂n urmă, pentru
perioada 2000-2007 ([29] - [33]), cu anii ı̂n ordine crescătoare!). A urmat o pauză de
câţiva ani (destul de mulţi!). Am observat că acele cursuri s-au ”ı̂mprăştiat” un pic
”pe net” ([48] - [56])! Încerc acum să ajung acolo unde am rămas ... plecând mereu
din prezent ... până când nu va mai fi posibil ... aşa că, de această dată, anii sunt
ı̂n ordine ... descrescătoare! :-)
”Codurile sursă” sunt cele ”oficiale” (publicate pe site-urile olimpiadelor) sau publicate pe alte
site-uri (dacă mi s-a părut că sunt utile şi se poate ı̂nvăţa câte ceva din ele).
Pentru liceu perioada acoperită este de ”azi” (până când va exista acest ”azi” pentru mine!)
până ı̂n anul 2000 (aveam deja perioada 2000-2007!).
Pentru gimnaziu perioada acoperită este de ”azi” până ı̂n anul 2010 (nu am prea mult timp
10
disponibil şi, oricum, calculatoarele folosite la olimpiade ı̂nainte de 2010 erau ceva mai ’slabe’ şi
... restricţiile de memorie, din enunţurile problemelor, par ’ciudate’ acum!).

6
Se poate observa din ”Coduri sursă” că orice problemă are numeroase soluţii, atât ca algoritmi de rezolvare
cât şi ca stil de programare! Studiind aceste coduri ... avem ce ı̂nvăţa ... deşi uneori pare că ’se trage cu tunul’ ...
7
IOI2019 şi IOI2020 au a permis utilizarea limbajelor de programare C++ şi Java
8
IOI2015 a permis utilizarea limbajelor de programare C++, Java, Pascal, Python şi Ruby
9
Vezi cele 5 secunde pentru Timp maxim de executare/test din problema ”avârcolaci” - ONI2014 clasa a 11-a
10
https://en.wikipedia.org/wiki/Computer
iii
În perioada 2017-2020 cele mai puternice calculatoare din lume au fost: ı̂n noiembrie 2017
11
ı̂n China, ı̂n noiembrie 2019 ı̂n SUA şi ı̂n iunie 2020 ı̂n Japonia. În iunie 2022 ”Frontier”
12
depăşeşte pragul ”exascale”! (1.102 Exaflop/s). ”Peta” a fost depăşit ı̂n 2008, ”tera” ı̂n 1997,
13
”giga” ı̂n 1972. . Pentru ce a fost mai ı̂nainte, vezi https://en.wikipedia.org/wiki/Li
st_of_fastest_computers.
14
O mică observaţie: ı̂n 2017 a fost prima ediţie a olimpiadei EJOI ı̂n Bulgaria şi ... tot
15
ı̂n Bulgaria a fost şi prima ediţie a olimpiadei IOI ı̂n 1989. Dar ... prima ediţie a olimpiadei
16
IMO (International Mathematical Olympiad) a fost ı̂n România ı̂n 1959. Tot ı̂n România s-au
ţinut ediţiile din anii 1960, 1969, 1978, 1999 şi 2018. Prima ediţie a olimpiadei BOI (Balkan
Olympiad in Informatics) a fost ı̂n România ı̂n 1993 la Constanţa. Prima ediţie a olimpiadei
CEOI (Central-European Olympiad in Informatics) a fost ı̂n România ı̂n 1994 la Cluj-Napoca.
Revenind la ... “culegerile noastre” ... mai departe, probabil, va urma completarea unor
informaţii ı̂n ”Rezolvări detaliate” ... pentru unele probleme numai (tot din cauza lipsei timpului
necesar pentru toate!). Prioritate vor avea problemele de gimnaziu (nu pentru că sunt mai ’uşoare’
ci pentru că ... elevii de liceu se descurcă şi singuri!). Acum, ı̂n martie 2022, am ı̂nceput şi
redactarea unei culegeri de probleme date la bacalaureat ı̂n ultimii câţiva ani (câţi voi putea!).
Îmi aduc aminte că exista o interesantă vorbă de duh printre programatorii din generaţia mea:
”nu se trage cu tunul ı̂ntr-o muscă” . Sensul este: nu se scrie un cod complicat dacă se
poate scrie un cod simplu şi clar! Asta ı̂ncerc eu ı̂n ”Rezolvări detaliate”.
Vom ı̂ncerca, ı̂mpreună, şi câteva probleme de ... IOI ... dar asta este o treabă ... nu prea
uşoară! Cred totuşi că este mai bine să prezint numai enunţuri ale problemelor date la IOI ı̂n
ultimii câţiva ani! (asta aşa, ca să vedem cum sunt problemele la acest nivel!). Cei care ajung
acolo sau vor să ajungă acolo (la IOI) sigur nu au nevoie de ajutorul meu! Se descurcă singuri!
”ALGORITMI utili la olimpiadele de informatică”, separat pentru gimnaziu şi liceu, sper să
fie de folos, aşa cum cred că sunt [1] - [28], [34] - [47], [57] - [83], ... şi multe alte cărţi şi site-uri!.
Ar fi interesant să descoperim noi ı̂nşine cât mai mulţi algoritmi ... ı̂n loc să-i ı̂nvăţăm pur şi
simplu!
O altă mică observaţie: ce am strâns şi am scris ı̂n aceste cărţi
se adresează celor interesaţi de aceste teme! Nu cârcotaşilor! Sunt
evidente sursele ”de pe net” (şi locurile ı̂n care au fost folosite) aşa
că nu sunt necesare ”ghilimele anti-plagiat”, referinţe şi precizări
suplimentare la fiecare pas!
Şi un ultim gând: criticile şi sfaturile sunt utile dacă au valoare!
Dacă sunt numai aşa ... cum critică lumea la un meci de fotbal ...
sau cum, pe bancă ı̂n parc, ”ı̂şi dă cu părerea” despre rezolvarea
problemelor economice ale ţării ... atunci ... !!!
17
”I’m only responsible for what I say, not for what you understand.”
Adrese interesante (rezultatele elevilor români):
https://stats.ioinformatics.org/halloffame/
https://stats.ioinformatics.org/tasks/
http://stats.ioinformatics.org/results/ROU
Adresele acestor cursuri:

https://www.scribd.com/user/550183580/Adrian-Rabaea
https://www.scribd.com/user/552245048/Adi-Rabaea
https://drive.google.com/drive/folders/1hC5PZuslCdS95sl37SW46H-qy59GRDGZ
Bistriţa, 9th September 2023 Adrian Răbâea
11
https://www.top500.org/lists/top500/2022/06/
12
https://en.wikipedia.org/wiki/Metric_prefix/
13
https://en.wikipedia.org/wiki/Computer_performance_by_orders_of_magnitude
14
https://ejoi.org/about/
15
https://stats.ioinformatics.org/olympiads/
16
https://en.wikipedia.org/wiki/International_Mathematical_Olympiad
17
https://www.facebook.com/johnwayne/photos/a.156450431041410/2645523435467418/?type=3
”Acknowledgements”
”I want to thank God most of all because

without God
I wouldn’t be able to do any of this.” 18
and
I thank everyone for their support 19
and/or
suggestions!
18
I.d.k.: ”I don’t know who the author is.”
19
donation/donaţie:
. name: RABAEA AUREL ADRIAN, IBAN: RO22BRDE060SV11538970600, SWIFT: BRDEROBUXXX
v
Despre autor
20
nume: Răbâea Aurel-Adrian, 18.03.1953 - ...
telefon: +40 728 zz ll aa +40 363 xx 25 xx

email: adrian1803@gmail.com skype: adrian.r53
Lector universitar - Universitatea Tehnică din Cluj Napoca - Centrul Universitar Nord din Baia
Mare, Facultatea de Ştiinţe, Str. Victoriei, nr. 76, Baia Mare, România, (pensionat: 01.10.2018)
https://dmi.cunbm.utcluj.ro/
Discipline predate (1992-2018):
Algoritmi şi structuri de date, Algoritmi ı̂n teoria opţiunilor financiare, Bazele matematice
ale calculatoarelor, Bazele tehnologiei informaţiei, Birotică, Capitole speciale de inteligenţă
artificială, Capitole speciale de teoria algoritmilor, Calcul paralel, Informatică economică,
Instruire asistată de calculator, Limbaje de programare; Programare orientată pe obiecte,
Programare procedurală, Structuri de date.
Studii doctorale ı̂n informatică economică - Diplomă de doctor (1997-2002):

Instituţia: Academia de Studii Economice, Bucureşti;
21
Titlul tezei: Algoritmi paraleli şi aplicaţii pe maşini virtual paralele
22
Conducător ştiinţific: Prof. dr. ing. Gheorghe Dodescu
Teme studiate: utilizarea algoritmilor paraleli ı̂n teoria opţiunilor financiare
Studii de specializare ı̂n informatică - Certificat anul V - ’master’ (1978-1979):
Instituţia: Facultatea de matematică şi informatică, Bucureşti;
Titlul tezei: Probleme la limită pentru procese cu creşteri independente şi aplicaţii ı̂n teoria
aşteptării
23
Conducător ştiinţific: Prof. dr. Constantin Tudor
Studii universitare de licenţă ı̂n informatică - Diplomă de licenţă (1974-1978):
Instituţia: Facultatea de matematică şi informatică, Bucureşti;
Titlul tezei: Metode de comparaţie multiplă ı̂n analiza dispersională
24
Conducător ştiinţific: Prof. dr. Ion Văduva
Locuri de muncă: (1979-2018):
- (2018-2009) Universitatea Tehnică din Cluj-Napoca, Centrul Universitar Nord din Baia-
Mare, Facultatea de Ştiinţe, Departamentul de Matematică-Informatică
- (2009-1992) Universitatea ”Ovidius” din Constanţa, Facultatea de Matematică şi Infor-
25
matică, Departamentul de Informatică
26
- (1992-1979) Centrul de Informatică şi organizare CINOR, Bucureşti
27
Olimpiade: (fiind elev la Liceul Militar ”Dimitrie Cantemir” - Breaza, PH)
- 1971: Olimpiada Naţională de matematică: participare (fără rezultat notabil)
- 1970: Olimpiada Naţională de matematică: participare (fără rezultat notabil)
20
https://dmi.cunbm.utcluj.ro/?page_id=2
21
http://opac.biblioteca.ase.ro/opac/bibliographic_view/149021
22
http://www.ionivan.ro/2015-PERSONALITATI/Dodescu.htm
23
http://old.fmi.unibuc.ro/ro/prezentare/promotii/promotia1978informatica_10ani/
24
https://ro.wikipedia.org/wiki/Ion_V%C4%83duva
25
https://fmi.univ-ovidius.ro/
26
https://www.cinor.ro/index.htm
27
https://www.cantemircml.ro/
vi
Dhawan Sanjeev, Kulvinder Singh, Eduard-Marius Craciun, Adrian Răbâea, Amit Batra;
Next-Cart Recommendation by Utilizing Personalized Item Frequency Information in Online Web
Portals, Neural Processing Letters, 2023; https://doi.org/10.1007/s11063-023-11207-2
Sanjeev Dhawan, Kulvinder Singh, Adrian Răbâea, Amit Batra;

ImprovedGCN: An efficient and accurate recommendation system employing lightweight graph con-
volutional networks in social media; Electronic Commerce Research and Applications, 2022, Vol-
ume 55, Pages 101191-101207; DOI: https://doi.org/10.1016/j.elerap.2022.101191
Sanjeev Dhawan, Kulvinder Singh, Adrian Răbâea, Amit Batra;

Session centered Recommendation Utilizing Future Contexts in Social Media; Analele Ştiinţifice
ale Universităţii Ovidius Constanţa - Seria Matematică, Vol. 29 (3), 2021, 91-104; DOI:
https://doi.org/10.2478/auom-2021-0036
E.M. Craciun, A. Răbâea, S. Das;

Cracks Interaction in a Pre-Stressed and Pre-Polarized Piezoelectric Material;
Journal of Mechanics, 36(2), 2020, 177-182; DOI: https://doi.org/10.1017/jmech.2019.57
https://www.cambridge.org/core/journals/journal-of-mechanics/article/abs/cracks-interaction-
in-a-prestressed-and-prepolarized-piezoelectric-material/3938BF0AD79D5BE6B81BC4FB6BE80208
EM Craciun, A Răbâea, MF Popa, CI Mihailov;

Crack propagation in the human bone. Mode I of fracture; Analele Ştiinţifice ale Univ. Ovidius
Constanţa - Seria Matematică, Vol. 26(2), 2018, 59-70; DOI: https://doi.org/10.2478/auom-2018-
0018
EM Craciun, M Marin, A Răbâea;

Anti-plane crack in human bone. I. Mathematical modelling; Analele Ştiinţifice ale Univer-
sităţii Ovidius Constanţa - Seria Matematică, Volume 26, Issue 1, 2018, Pages 81-90; DOI:
https://doi.org/10.2478/auom-2018-0004
T. Sadowski, E. M. Craciun, A. Răbâea, L. Marsavina;

Mathematical modeling of three equal collinear cracks in an orthotropic solid; Meccanica 51, 329-
339 (2016); https://doi.org/10.1007/s11012-015-0254-5
E.M. Craciun, T. Sadowski, A. Răbâea;

Stress concentration in an anisotropic body with three equal collinear cracks in Mode II of frac-
ture. I. Analytical study; ZAMM Journal of Applied Mathematics and Mechanics / Zeitschrift
fr Angewandte Mathematik und Mechanik, Vol. 94 (9); September 2014, Pages 721-729;
https://doi.org/10.1002/zamm.201200293
E-M Craciun, T. Sadowski, L. Marsavina, A. Răbâea;

Mathematical Aspects Regarding Cracks Behaviour in Wood Composites; Key Engineering Mate-
rials 601:108-111, March 2014; DOI: 10.4028/www.scientific.net/KEM.601.108
Probleme de informatică date la bacalaureat

Probleme de informatică date la olimpiade - I.O.I.
Probleme de informatică date la olimpiade - liceu
Probleme de informatică date la olimpiade - gimnaziu
https://scholar.google.com/citations?user=-sSE_1wAAAAJ&hl=en
https://www.scopus.com/authid/detail.uri?origin=resultslist&authorId=56122389200&zone=
http://www.facebook.com/adrian.rabaea
Cuprins
Prefaţă iii
Cuprins viii
Lista figurilor xx
Lista tabelelor xxvi
Lista programelor xxvii
I Enunţuri 1
1 BAC 2023 2
1.1 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Subiectul al III-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Sesiunea - Simulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Sesiunea specială . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Sesiunea iunie - iulie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 Sesiunea de toamnă . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 BAC 2022 17
2.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
viii
2.4.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3 BAC 2021 28
3.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4 BAC 2020 36
4.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5 BAC 2019 44
5.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6 BAC 2018 51
6.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7 BAC 2017 60
7.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
8 BAC 2016 69
8.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
8.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
8.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
8.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
9 BAC 2015 77
9.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
9.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
9.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
10 BAC 2014 86
10.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
10.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
10.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
10.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
11 BAC 2013 94
11.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
11.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
11.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
11.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
11.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
11.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
12 BAC 2012 102

12.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
12.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
12.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
12.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
12.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
12.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
13 BAC 2011 111

13.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
13.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
13.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
13.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
13.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
13.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
14 BAC 2010 119

14.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
14.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
14.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
14.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
14.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
14.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
II Indicaţii de rezolvare 127
15 BAC 2023 128
15.1 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
15.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
15.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
15.2 Sesiunea - Simulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
15.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
15.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
15.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
15.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
15.4.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
15.4.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
15.5.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
15.5.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
16 BAC 2022 139

16.1 Sesiunea - Simulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
16.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
16.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
16.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
16.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
16.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
16.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
16.4.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
16.4.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
17 BAC 2021 147

17.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
17.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
17.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
17.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
17.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
17.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
18 BAC 2020 153
18.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
18.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
18.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
18.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
18.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
18.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
19 BAC 2019 159

19.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
19.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
19.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
19.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
19.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
19.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
20 BAC 2018 164

20.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
20.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
20.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
20.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
20.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
20.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
21 BAC 2017 170

21.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
21.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
21.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
21.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
21.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
21.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
22 BAC 2016 176
22.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
22.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
22.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
22.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
22.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
22.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
23 BAC 2015 182

23.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
23.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
23.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
23.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
23.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
23.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
24 BAC 2014 188

24.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
24.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
24.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
24.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
24.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
24.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
25 BAC 2013 194

25.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
25.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
25.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
25.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
25.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
25.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
26 BAC 2012 200
26.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
26.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
26.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
26.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
26.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
26.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
27 BAC 2011 207

27.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
27.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
27.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
27.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
27.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
27.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
28 BAC 2010 214

28.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
28.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
28.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
28.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
28.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
28.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
III Rezolvări detaliate 221

29 BAC 2023 222
29.1 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
29.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
29.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
29.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
29.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
29.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
29.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
29.4 Sesiunea iunie-iulie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
29.4.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
29.4.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
29.5.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
29.5.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
30 BAC 2022 261

30.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
30.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
30.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
30.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
30.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
30.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
30.4.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
30.4.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
31 BAC 2021 302

31.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
31.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
31.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
31.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
31.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
31.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
32 BAC 2020 334

32.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
32.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
32.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
32.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
32.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
32.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
33 BAC 2019 366

33.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
33.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
33.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
33.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
33.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
33.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
34 BAC 2018 396

34.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
34.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
34.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
34.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
34.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
34.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
35 BAC 2017 427

35.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
35.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
35.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
35.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
35.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
35.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
36 BAC 2016 461

36.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
36.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
36.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
36.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
36.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
36.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
37 BAC 2015 489

37.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
37.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
37.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
37.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
37.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
37.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
38 BAC 2014 515
38.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
38.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
38.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
38.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
38.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
38.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
39 BAC 2013 539

39.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
39.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
39.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
39.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
39.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
39.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
40 BAC 2012 563

40.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
40.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
40.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
40.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
40.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
40.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
41 BAC 2011 589

41.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
41.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
41.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
41.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
41.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
41.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
42 BAC 2010 617
42.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
42.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
42.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
42.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
42.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
42.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
Appendix A ”Instalare” C++ 641

A.1 Kit OJI 2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
A.1.1 Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
A.1.2 Folder de lucru . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
A.1.3 Utilizare Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
A.1.4 Setări Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
A.1.5 Multe surse ı̂n Code Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
A.2 winlibs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
A.2.1 GCC şi MinGW-w64 pentru Windows . . . . . . . . . . . . . . . . . . . . . 651
A.2.2 PATH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
A.2.3 CodeBlocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654
Appendix B Exemple pentru rezolvarea subiectelor de BAC 664

B.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
B.1.1 Subiectul I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
Appendix C Diagonale ı̂n matrice 667

C.1 Diagonale ı̂n matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
C.2 Simetric faţă de diagonale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
C.2.1 Simetric faţă de diagonala principală . . . . . . . . . . . . . . . . . . . . . . 668
C.2.2 Simetric faţă de diagonala secundară . . . . . . . . . . . . . . . . . . . . . . 668
Appendix D Interclasare 669

D.1 Interclasarea vectorilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Appendix E Recursivitate 670

E.1 Recursivitate numai ”dus” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
E.2 Recursivitate numai ”ı̂ntors” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
E.3 Recursivitate ”dus şi ı̂ntors” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672
E.4 Recursivitate cu mesaj la oprire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672
Index 674
Bibliografie 676
Lista autorilor 679

Lista figurilor
1 Descompunerea canonică a lui f . . . . . . . . . . . . . . . . . . . . . . . . . . . . i

2 Un desen ... i ` f¯ ` p f . . . . . . . . . . . . . . . . . . . . . . . . . . . i
30.1 2022bac-s0-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

30.2 2022bac-s0-I-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
30.3 2022bac-s0-I-4-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
30.4 2022bac-s0-I-5-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
30.5 2022bac-s0-II-1a-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
30.6 2022bac-s0-II-1c-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
30.7 2022bac-s0-II-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
30.8 2022bac-s0-II-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
30.9 2022bac-s0-III-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
30.102022bac-s1-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
30.112022bac-s1-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
30.122022bac-s1-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
30.132022bac-s1-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
30.142022bac-s1-II-1b . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
30.152022bac-s1-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
30.162022bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
30.172022bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
30.182022bac-s2-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
30.192022bac-s2-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
30.202022bac-s2-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
30.212022bac-s2-I-5a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
30.222022bac-s2-I-5b . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
30.232022bac-s2-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
30.242022bac-s2-II-1b . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
30.252022bac-s2-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
30.262022bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
30.272022bac-s3-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
30.282022bac-s3-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
30.292022bac-s3-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
30.302022bac-s3-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
30.312022bac-s3-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
30.322022bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
31.1 2021bac-s1-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

31.2 2021bac-s1-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
31.3 2021bac-s1-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
31.4 2021-mai-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
31.5 2021bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
31.6 2021bac-s1-III-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
31.7 2021bac-s2-I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
31.8 2021bac-s2-I-2-rd-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
31.9 2021bac-s2-I-2-rd-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
31.102021bac-s2-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
31.112021bac-s2-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
31.122021bac-s2-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
31.132021bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
xx
31.142021bac-s2-II-1b x este mare! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
31.152021bac-s2-II-1b x este mic! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
31.162021-iunie-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
31.172021bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
31.182021bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
31.192021bac-s3-I-1a-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
31.202021bac-s3-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
31.212021bac-s3-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
31.222021bac-s3-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
31.232021bac-s3-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
31.242021bac-s3-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
31.252021-aug-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
31.262021bac-s3-II-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
31.272021aug-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
31.282021bac-s3-III-3r . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
32.1 2020bac-s1-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

32.2 2020bac-s1-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
32.3 2020bac-s1-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
32.4 2020bac-s1-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
32.5 2020bac-s1-II-1a-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
32.6 2020-mai-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
32.7 2020bac-s1-II-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
32.8 2020bac-s1-II-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
32.9 2020bac-s2-I-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
32.102020bac-s2-I-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
32.112020bac-s2-I-4-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
32.122020bac-s2-I-5-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
32.132020bac-s2-II-1-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
32.142020-iunie-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
32.152020bac-s2-II-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
32.162020bac-s2-II-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
32.172020bac-s3-I-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
32.182020bac-s3-I-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
32.192020bac-s3-I-4-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
32.202020bac-s3-I-5-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
32.212020bac-s3-II-1-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
32.222020-aug-II-1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
32.232020bac-s3-II-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
32.242020bac-s3-III-2-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
33.1 2019bac-s1-I-3-rd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

33.2 2019bac-s1-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
33.3 2019bac-s1-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
33.4 2019-s2-I-2-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
33.5 2019bac-s2-I-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
33.6 bac2019-s2-I-4-backtracking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
33.7 2019bac-s2-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
33.8 2019bac-s2-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
33.9 2019bac-s2-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
33.102019bac-s2-II-1a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
33.112019bac-s3-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
33.12*** . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
33.132019bac-s3-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
33.142019bac-s3-I-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
33.152019bac-s3-II-1a1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
33.162019bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
34.1 2018bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

34.2 2018bac-s1-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
34.3 2018bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
34.4 2018bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
34.5 2018bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
34.6 2018bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
34.7 2018bac-s2-I-2a1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
34.8 2018bac-s2-I-2a2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
34.9 2018bac-s2-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
34.102018bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
34.112018bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
34.122018bac-s2-II-4-v1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
34.132018bac-s2-II-4-v2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
34.142018bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
34.152018bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
34.162018bac-s3-I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
34.172018bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
34.182018bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
34.192018bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
34.202018bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
34.212018bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
34.222018bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
34.232018bac-s3-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
35.1 2017bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429

35.2 2017bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
35.3 2017bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
35.4 2017bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
35.5 2017bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
35.6 2017bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
35.7 2017bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
35.8 2017bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
35.9 2017bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
35.102017bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
35.112017bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
35.122017bac-s2-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
35.132017bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
35.142017bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
35.152017bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
35.162017bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
35.172017bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
35.182017bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
36.1 2016bac-s1-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464

36.2 2016bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
36.3 2016bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
36.4 2016bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
36.5 2016bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
36.6 2016bac-s1-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
36.7 2016bac-s2-I-2a1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
36.8 2016bac-s2-I-2a2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
36.9 2016bac-s2-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
36.102016bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
36.112016bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
36.122016bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
36.132016bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
36.142016bac-s2-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479
36.152016bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
36.162016bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
36.172016bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
36.182016bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
36.192016bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
36.202016bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
36.212016bac-s3-III-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
37.1 2015bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
37.2 2015bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
37.3 2015bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
37.4 2015bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
37.5 2015bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
37.6 2015bac-s1-III-2-fig1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
37.7 2015bac-s1-III-2-fig2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
37.8 2015bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
37.9 2015bac-s2-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
37.102015bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
37.112015bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
37.122015bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
37.132015bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
37.142015bac-s3-I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
37.152015bac-s3-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
37.162015bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
37.172015bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
37.182015bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
37.192015bac-s3-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
38.1 2014bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515

38.2 2014bac-s1-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
38.3 2014bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
38.4 2014bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
38.5 2014bac-s1-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
38.6 2014bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
38.7 2014bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
38.8 2014bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
38.9 2014bac-s2-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
38.102014bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
38.112014bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
38.122014bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
38.132014bac-s2-III-1-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
38.142014bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
38.152014bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
38.162014bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
38.172014bac-s3-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
38.182014bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
38.192014bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
38.202014bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
38.212014bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
38.222014bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
39.1 2013bac-s1-I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540

39.2 2013bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
39.3 2013bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
39.4 2013bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
39.5 2013bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
39.6 2013bac-s1-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
39.7 2013bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
39.8 2013bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
39.9 2013bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
39.102013bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
39.112013bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
39.122013bac-s2-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
39.132013bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
39.142013bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
39.152013bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
39.162013bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
39.172013bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
39.182013bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
39.192013bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
40.1 2012bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564

40.2 2012bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
40.3 2012bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
40.4 2012bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
40.5 2012bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
40.6 2012bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
40.7 2012bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
40.8 2012bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
40.9 2012bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
40.102012bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
40.112012bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
40.122012bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
40.132012bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
40.142012bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
40.152012bac-s3-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
40.162012bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
40.172012bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
40.182012bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
40.192012bac-s3-III-3-v1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
41.1 2011bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590

41.2 2011bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
41.3 2011bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
41.4 2011bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
41.5 2011bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
41.6 2011bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
41.7 2011bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
41.8 2011bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
41.9 2011bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
41.102011bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
41.112011bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
41.122011bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
41.132011bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
41.142011bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
41.152011bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
41.162011bac-s3-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
41.172011bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
41.182011bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
41.192011bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
41.202011bac-s3-III-2-v1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
41.212011bac-s3-III-2-v2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
42.1 2010bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618

42.2 2010bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
42.3 2010bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
42.4 2010bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
42.5 2010bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
42.6 2010bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
42.7 2010bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
42.8 2010bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
42.9 2010bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628
42.102010bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
42.112010bac-s2-III-2-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
42.122010bac-s2-III-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
42.132010bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
42.142010bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
42.152010bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
42.162010bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
42.172010bac-s3-III-1-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
42.182010bac-s3-III-2 backtracking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
A.1 Fişierele din Kit OJI 2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641

A.2 CodeBlocks & C++ Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
A.3 Ce conţine C:¯ OJI ¯ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
A.4 Folder de lucru . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
A.5 New % Text document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644
A.6 Schimbare nume fişier şi nume extensie fişier . . . . . . . . . . . . . . . . . . . . . . 644
A.7 Confirmare schimbare extensie ı̂n .cpp . . . . . . . . . . . . . . . . . . . . . . . . . 645
A.8 Pregătit pentru Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
A.9 Pregătit pentru a scrie cod de program C++ ı̂n Code::Blocks . . . . . . . . . . . . 645
A.10 Primul cod de program C++ ı̂n Code::Blocks . . . . . . . . . . . . . . . . . . . . . 646
A.11 Build - compilare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
A.12 0 error(s), 0 warning(s) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
A.13 Run - execuţie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
A.14 Executat corect: a făcut “nimic” . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
A.15 Settings % Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
A.16 Toolchain executables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649
A.17 Unde sunt acele programe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649
A.18 Multe surse ı̂n Code Blocks - setări . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
A.19 Multe surse in Code Blocks - exemple . . . . . . . . . . . . . . . . . . . . . . . . . 650
A.20 mingw64 pe D: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
A.21 search path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
A.22 System properties –¿ Advanced . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
A.23 Environment Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
A.24 Edit Environment Variables –¿ New . . . . . . . . . . . . . . . . . . . . . . . . . . 653
A.25 Calea şi versiunea pentru gcc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654
A.26 Settings –¿ Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
A.27 Toolchain executables –¿ Auto-detect . . . . . . . . . . . . . . . . . . . . . . . . . . 655
A.28 New –¿ Text Document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656
A.29 New text Document.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656
A.30 Schimbare nume şi extensie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656
A.31 Moore apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
A.32 Look for another app . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
A.33 Cale pentru codeblocks.exe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
A.34 Selectare codeblocks.exe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
A.35 Editare test01.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
A.36 Compilare test01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
A.37 Mesaje după compilare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 660
A.38 Execuţie test01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 660
A.39 Rezultat execuţie test01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
A.40 Fişiere apărute după compilare! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
A.41 Creare test02.cpp gol! + ¡dublu click¿ sau ¡Enter¿ . . . . . . . . . . . . . . . . . . 661
A.42 Lista programelor de utilizat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
A.43 Selectare Code::Blocks IDE pentru fişierele .cpp . . . . . . . . . . . . . . . . . . 662
A.44 Editare+Compilare+Execuţie pentru test02 . . . . . . . . . . . . . . . . . . . . . 662
A.45 Selectare tab ce conţine test01.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . 663
C.1 diagonale ı̂n matrice - start = 0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

C.2 diagonale ı̂n matrice - start = 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
C.3 simetric faţă de diagonala principală . . . . . . . . . . . . . . . . . . . . . . . . . . 668
C.4 simetric faţă de diagonala secundară . . . . . . . . . . . . . . . . . . . . . . . . . . 668
D.1 Interclasarea vectorilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
E.1 Recursivitate numai ”dus” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670

E.2 Recursivitate dus-intors cu mesaj de oprire . . . . . . . . . . . . . . . . . . . . . . 673
Lista tabelelor
31.1 2021bac-s1-I-3-t1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

31.2 2021bac-s1-I-3-t2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
31.3 2021bac-s1-I-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
xxvi
Lista programelor
29.1.12023bac-model-II-1c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
29.1.22023bac-model-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
29.1.32023bac-model-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
29.1.42023bac-model-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
29.1.52023bac-model-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
29.1.62023bac-model-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
29.2.12023bac-s0-II-1bc.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
29.2.22023bac-s0-II-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
29.2.32023bac-s0-II-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
29.2.42023bac-s0-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
29.2.52023bac-s0-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
29.2.62023bac-s0-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
29.3.12023bac-s1-I-2rd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
29.3.22023bac-s1-II-1crd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
29.3.32023bac-s1-II-1drd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
29.3.42023bac-s1-II-3rd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
29.3.52023bac-s1-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
29.3.62023bac-s1-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
29.3.72023bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
29.4.12023bac-s2-I-2rd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
29.4.22023bac-s2-II-1crd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
29.4.32023bac-s2-II-3rd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
29.4.42023bac-s2-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
29.4.52023bac-s2-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
29.4.62023bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
29.5.12023bac-s3-I-2rd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
29.5.22023bac-s3-II-1crd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
29.5.32023bac-s3-II-3rd.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
29.5.42023bac-s3-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
29.5.52023bac-s3-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
29.5.62023bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
30.1.1 2021bac-s1-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
30.1.2 2022bac-s0-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
30.1.3 2022bac-s0-II-1-b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
30.1.4 2022bac-s0-II-1-d.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
30.1.5 2022bac-s0-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
30.1.6 2022bac-s0-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
30.1.7 2022bac-s0-III-3-v0.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
30.1.8 2022bac-s0-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
30.1.9 2022bac-s0-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
30.1.10 2022bac-s0-III-3-v3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
30.2.1 2022bac-s1-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
30.2.2 2022bac-s1-I-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
30.2.3 2022bac-s1-II-1c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
30.2.4 2022bac-s1-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
30.2.5 2022bac-s1-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
30.2.6 2022bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
30.3.1 2022bac-s2-II-1c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
30.3.2 2022bac-s2-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
xxvii
30.3.3 2022bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
30.3.4 2022bac-s2-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
30.3.5 2022bac-s2-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
30.3.6 2022bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
30.4.1 2022bac-s3-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
30.4.2 2022bac-s3-II-1c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
30.4.3 2022bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
30.4.4 2022bac-s3-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
30.4.5 2022bac-s3-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
30.4.6 2022bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
31.1.1 2021bac-s1-I-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
31.1.2 2021bac-s1-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
31.1.3 2021bac-s1-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
31.1.4 2021bac-s1-II-1d.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
31.1.5 2021bac-s1-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
31.1.6 2021bac-s1-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
31.1.7 2021bac-s1-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
31.1.8 2021bac-s1-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
31.1.9 2021bac-s1-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
31.2.1 2021bac-s2-I-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
31.2.2 2021bac-s2-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
31.2.3 2021bac-s2-II-1ab.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
31.2.4 2021bac-s2-II-1c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
31.2.5 2021bac-s2-II-1d-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
31.2.6 2021bac-s2-II-1d-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
31.2.7 2021bac-s2-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
31.2.8 2021bac-s2-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
31.2.9 2021bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
31.3.1 2021bac-s3-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
31.3.2 2021bac-s3-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
31.3.3 2021bac-s3-II-1d.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
31.3.4 2021bac-s3-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
31.3.5 2021bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
31.3.6 2021bac-s3-III-1-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
31.3.7 2021bac-s3-III-1-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
31.3.8 2021bac-s3-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
31.3.9 2021bac-s3-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
31.3.10 2021bac-s3-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
31.3.11 2021bac-s3-III-3-v3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
32.1.1 2020bac-s1-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
32.1.2 2020bac-s1-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
32.1.3 2020bac-s1-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
32.1.4 2020bac-s1-II-2-v1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
32.1.5 2020bac-s1-II-2-v2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
32.1.6 2020bac-s1-II-2-v3a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
32.1.7 2020bac-s1-II-2-v1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
32.1.8 2020bac-s1-II-2-v2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
32.1.9 2020bac-s1-II-2-v3b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
32.1.10 2020bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
32.1.11 2020-mai-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
32.1.12 2020-mai-III-2-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
32.1.13 2020-mai-III-2-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
32.1.14 2020-mai-III-2-v3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
32.1.15 2020-mai-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
32.2.1 2020-iunie-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
32.2.2 2020-iunie-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
32.2.3 2020-iunie-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
32.2.4 2020-iunie-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
32.2.5 2020-iunie-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
32.2.6 2020-iunie-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
32.2.7 2020-iun-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
32.2.8 2020-iun-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
32.3.1 2020-august-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
32.3.2 2020-august-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
32.3.3 2020-august-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
32.3.4 2020-august-II-1d.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
32.3.5 2020-august-II-2-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
32.3.6 2020-august-II-2-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
32.3.7 2020-august-II-2-v3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
32.3.8 2020-august-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
32.3.9 2020-august-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
32.3.10 2020-august-III-2 v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
32.3.11 2020-august-III-2 v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
32.3.12 2020-august-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
33.1.1 2019-s1-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
33.1.22019-mai-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
33.1.32019-mai-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
33.1.42019-mai-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
33.1.52019-mai-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
33.1.62019-mai-III-2-vector-de-cuvinte.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . 370
33.1.72019-mai-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
33.1.82019-mai-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
33.1.92019-mai-III-3-v3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
33.1.10
2019-mai-III-3-v4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
33.2.12019-iunie-I-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
33.2.22019-iunie-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
33.2.32019-iunie-I-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
33.2.42019bac-s2-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
33.2.52019bac-s2-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
33.2.62019bac-s2-II-1d.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
33.2.72019bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
33.2.82019bac-s2-III-1-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
33.2.92019bac-s2-III-1-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
33.2.10
2019bac-s2-III-2 .cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
33.2.11
2019bac-s2-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
33.2.12
2019bac-s2-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
33.2.13
2019bac-s2-III-3-v3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
33.3.12019bac-s3-I-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
33.3.22019bac-s3-I-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
33.3.32019bac-s3-II-1a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
33.3.42019bac-s3-II-1b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
33.3.52019bac-s3-II-1d.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
33.3.62019bac-s3-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
33.3.72019bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
33.3.82019bac-s3-III-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
33.3.92019bac-s3-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
33.3.10
2019bac-s3-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
33.3.11
2019bac-s3-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
34.1.12018bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
34.1.22018bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
34.1.32018bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
34.1.42018bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
34.1.52018bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
34.1.62018bac-s1-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
34.1.72018bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
34.1.82018bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
34.2.12018bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
34.2.22018bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
34.2.32018bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
34.2.42018bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
34.2.52018bac-s2-II-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
34.2.62018bac-s2-II-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
34.2.72018bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
34.2.82018bac-s2-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
34.2.92018bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
34.2.10
2018bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
34.3.12018bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
34.3.22018bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
34.3.32018bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
34.3.42018bac-s3-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
34.3.52018bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
34.3.6***.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
34.3.72018bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
34.3.8***.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
34.3.92018bac-s3-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
34.3.10
2018bac-s3-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
35.1.1***.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
35.1.22017bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
35.1.32017bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
35.1.42017bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
35.1.52017bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
35.1.62017bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
35.1.72017bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
35.1.82017bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
35.1.92017bac-s1-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
35.1.10
2017bac-s1-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
35.1.11
2017bac-s1-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
35.1.12
2017bac-s1-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
35.2.12017bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
35.2.22017bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
35.2.32017bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
35.2.42017bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
35.2.52017bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
35.2.62017bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
35.2.72017bac-s2-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
35.2.82017bac-s2-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
35.2.92017bac-s2-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
35.2.10
2017bac-s2-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
35.3.12017bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
35.3.22017bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
35.3.32017bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
35.3.42017bac-s3-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
35.3.52017bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
35.3.62017bac-s3-II-5-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
35.3.72017bac-s3-II-5-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
35.3.82017bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
35.3.92017bac-s3-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
35.3.10
2017bac-s3-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
35.3.11
***.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
36.1.12016bac-s1-I-2a-cu-functie.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
36.1.22016bac-s1-I-2b-cu-functie.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
36.1.32016bac-s1-I-2c-do-cu-functie.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
36.1.42016bac-s1-I-2c-for-cu-functie.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
36.1.52016bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
36.1.62016bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
36.1.72016bac-s1-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
36.1.82016bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
36.1.92016bac-s1-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
36.1.10
2016bac-s1-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
36.2.12016bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
36.2.22016bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
36.2.32016bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
36.2.42016bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
36.2.52016bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
36.2.62016bac-s2-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
36.2.72016bac-s2-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
36.2.82016bac-s2-III-3-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
36.2.92016bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479
36.3.12016bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
36.3.22016bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
36.3.32016bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
36.3.42016bac-s3-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
36.3.52016bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
36.3.62016bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
36.3.72016bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
36.3.82016bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
36.3.92016bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
37.1.12015bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
37.1.22015bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
37.1.32015bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
37.1.42015bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
37.1.52015bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
37.1.62015bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
37.1.72015bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
37.1.82015bac-s1-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
37.1.92015bac-s1-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
37.2.12015bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
37.2.22015bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
37.2.32015bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
37.2.42015bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
37.2.52015bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
37.2.62015bac-s2-II-5-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
37.2.72015bac-s2-II-5-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
37.2.82015bac-s2-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
37.2.92015bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
37.2.10
2015bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
37.3.12015bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
37.3.22015bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
37.3.32015bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
37.3.42015bac-s3-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
37.3.52015bac-s3-II-4v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
37.3.62015bac-s3-II-4v2-setw(2).cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
37.3.72015bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
37.3.82015bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
37.3.92015bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
37.3.10
2015bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
38.1.12014bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
38.1.22014bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
38.1.32014bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
38.1.42014bac-s1-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
38.1.52014bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
38.1.62014bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
38.1.72014bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
38.1.82014bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
38.2.12014bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
38.2.22014bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
38.2.32014bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
38.2.42014bac-s2-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
38.2.52014bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
38.2.62014bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
38.2.72014bac-s2-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
38.2.82014bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529
38.2.92014bac-s2-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529
38.2.10
2014bac-s2-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
38.3.12014bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
38.3.22014bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
38.3.32014bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
38.3.42014bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
38.3.52014bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
38.3.62014bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
38.3.72014bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
39.1.12013bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
39.1.22013bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
39.1.32013bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
39.1.42013bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
39.1.52013bac-s1-II-5 strtok.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
39.1.6***.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
39.1.72013bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
39.1.82013bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
39.2.12013bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
39.2.22013bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
39.2.32013bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
39.2.42013bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
39.2.52013bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
39.2.62013bac-s2-II-5-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
39.2.72013bac-s2-II-5-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
39.2.82013bac-s2-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
39.2.92013bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
39.2.10
2013bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
39.3.12013bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
39.3.22013bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
39.3.32013bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
39.3.42013bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
39.3.52013bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
39.3.62013bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
39.3.72013bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
40.1.12012bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
40.1.22012bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
40.1.32012bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
40.1.42012bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
40.1.52012bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
40.1.62012bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568
40.1.72012bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
40.1.82012bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
40.1.92012bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
40.2.12012bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
40.2.22012bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
40.2.32012bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574
40.2.42012bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
40.2.52012bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
40.2.62012bac-s2-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
40.2.72012bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
40.2.82012bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
40.3.12012bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
40.3.22012bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
40.3.32012bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
40.3.42012bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
40.3.52012bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
40.3.62012bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
40.3.72012bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
40.3.82012bac-s3-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
40.3.92012bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
41.1.12011bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
41.1.22011bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
41.1.32011bac-s1-I-2c-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
41.1.42011bac-s1-I-2c-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
41.1.52011bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
41.1.62011bac-s1-II-5-v1 pozitie substring.cpp . . . . . . . . . . . . . . . . . . . . . . . . 593
41.1.72011bac-s1-II-5-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
41.1.82011bac-s1-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
41.1.92011bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
41.1.10
2011bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
41.2.12011bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
41.2.22011bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
41.2.32011bac-s2-I-2c-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
41.2.42011bac-s2-I-2c-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
41.2.52011bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
41.2.62011bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
41.2.72011bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
41.2.82011bac-s2-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
41.2.92011bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
41.2.10
2011bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
41.3.12011bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
41.3.22011bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
41.3.32011bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
41.3.42011bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
41.3.52011bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
41.3.62011bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
41.3.72011bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
41.3.82011bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
41.3.92011bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
42.1.12010bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
42.1.22010bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
42.1.32010bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
42.1.42010bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
42.1.52010bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
42.1.62010bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
42.1.72010bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
42.1.82010bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
42.1.92010bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
42.2.12010bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
42.2.22010bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
42.2.32010bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
42.2.42010bac-s2-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
42.2.52010bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628
42.2.62010bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
42.2.72010bac-s2-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
42.2.82010bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
42.3.12010bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
42.3.22010bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
42.3.32010bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
42.3.42010bac-s3-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
42.3.52010bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
42.3.62010bac-s3-II-5 strcpy.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
42.3.72010bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
42.3.82010bac-s3-III-3 v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
42.3.92010bac-s3-III-3 v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
42.3.10
2010bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
B.1.1 2017bac-s1-I-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
E.1.1recursivitate1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
Part I
Enunţuri
1
Capitolul 1
BAC 2023
1.1 Model
Varianta Model
Modelul este publicat la adresa:
http://subiecte.edu.ro/2023/bacalaureat/modeledesubiecte/probescrise/Bac 2023 E d Informatica modele.zip
Filieră teoretică, profil real, specializare matematică-informatică / matematică-informatică

intensiv informatică
Filieră vocaţională, profil militar, specializare matematică-informatică
a Toate subiectele sunt obligatorii. Se acordă zece puncte din oficiu.
a Timpul de lucru efectiv este de trei ore.
a Identificatorii utilizaţi ı̂n rezolvări trebuie să respecte precizările din enunţ (bold), iar ı̂n lipsa
unor precizări explicite, notaţiile trebuie să corespundă cu semnificaţiile asociate acestora (eventual
ı̂n formă prescurtată). Datele de intrare se consideră corecte, validarea lor nefiind necesară.
a În grafurile din cerinţe oricare muchie are extremităţi distincte şi oricare două muchii diferă
prin cel puţin una dintre extremităţi.
1.1.1 Subiectul I
Pentru fiecare dintre itemii de la 1 la 5, scrieţi pe foaia de examen litera core-
spunzătoare răspunsului corect. Fiecare răspuns corect se notează cu 4 puncte.
Problema 1
Indicaţi două valori pe care le poate avea variabila ı̂ntreagă x, astfel ı̂ncât,
pentru fiecare dintre acestea, expresia C/C++ alăturată să aibă valoarea 1.
a. {20, 40} b. {20, 41} c. {40, 62} d. {60, 83}
Problema 2
Subprogramul f este definit alăturat.
Indicaţi un apel ı̂n urma căruia ı̂n şirul
afişat există două valori egale cu 23
a. (20, 23) b. (20, 26) c. (21, 25) d. )(21, 27)
Problema 3
Utilizând metoda backtracking, se generează toate torturile formate din trei straturi de tipuri
distincte de cremă din mulţimea castane, mousse, frişcă, şerbet, ganache. Ultimul
strat este de frişcă sau de ganache, iar aceste tipuri de cremă nu pot apărea pe primele două
straturi. Două torturi cu straturi din aceleaşi tipuri de cremă sunt diferite dacă acestea sunt dis-
puse ı̂n altă ordine. Primele patru soluţii generate sunt, ı̂n această ordine: (castane, mousse,
frişcă), (castane, mousse, ganache), (castane, şerbet, frişcă), (castane,
şerbet, ganache). Indicaţi a şasea soluţie generată.
a. (mousse, castane, ganache) b. (mousse, şerbet, frişcă)
c. (şerbet, castane, frişcă) d. (şerbet, mousse, ganache)
2
CAPITOLUL 1. BAC 2023 1.1. MODEL 3
Problema 4
Un graf orientat cu 8 vârfuri, numerotate de la 1 la 8, are arcele (1,2), (1,3), (2,3), (2,6), (3,2),
(3,4), (3,6), (4,5), (4,7), (6,1), (7,4). Indicaţi numărul total de vârfuri ale componentei tare conexe
din care face parte vârful 3.
a. 2 b. 3 c. 4 d. 5
Problema 5
Un graf neorientat admite un ciclu eulerian, de lungime 11, precum şi un ciclu hamiltonian, de
lungime 7. Indicaţi numărul de muchii care pot fi eliminate din graf, astfel ı̂ncât graful parţial
obţinut să fie arbore.
a. 2 b. 3 c. 4 d. 5
1.1.2 Subiectul al II-a

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseudocod.
S-a notat cu a%b restul ı̂mpărţirii numărului natural
a la numărul natural nenul b.
a) Scrieţi valoarea afişată dacă se citesc, ı̂n această
ordine, numerele 4, 3, 11 şi 25. (6p.)
b. Dacă pentru m, n şi p se citesc numerele 10, 15,
respectiv 2, scrieţi două numere care pot fi citite pentru
q astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
fiecare dintre acestea, valoarea afişată să fie 250. (6p.)
c. Scrieţi programul C/C++ corespunzător algoritmului dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind adecvat prima structură
pentru...execută cu o structură repetitivă cu test iniţial. (6p.)
Problema 2
Variabila c, declarată alăturat, permite accesul la datele fiecăreia dintre
cele trei echipe participante la ultima etapă a unui concurs: numele şi
rezultatul (număr natural din intervalul [0,100]); cele trei echipe au
rezultate distincte.
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia să se afişeze pe ecran, separate prin
câte un spaţiu, numele celor trei echipe, ı̂n ordinea descrescătoare a rezultatelor obţinute.
Problema 3
Variabila p este de tip ı̂ntreg, iar variabilele s1
şi s2 permit memorarea câte unui şir de cel mult
30 de caractere. Scrieţi ce se afişează ı̂n urma
executării secvenţei alăturate. (6p.)
1.1.3 Subiectul al III-a

Problema 1
Subprogramul DoiTrei are un parametru, n, prin care primeşte un număr natural (n " 0, 10 ).
9
Subprogramul returnează valoarea 1 dacă toate cifrele lui n sunt din mulţimea {2,3} sau valoarea
0 ı̂n caz contrar. Scrieţi definiţia completă a subprogramului.
Exemplu: dacă n=22323 sau n=3, atunci subprogramul returnează 1, iar dacă n=2023 atunci
subprogramul returnează 0. (10p.)
Problema 2
Suprafaţa unui loc de joacă pentru copii este ı̂mpărţită ı̂n n n zone de formă pătrată dispuse pe
n rânduri şi n coloane, numerotate de la 1 la n, ı̂n fiecare zonă fiind plasat un tobogan, un leagăn,
un balansoar sau un carusel.
Zonelor li se atribuie câte un cod, ı̂n funcţie de destinaţie: codul 0 pentru tobogan, codul 1
pentru leagăn, codul 2 pentru balansoar şi codul 3 pentru carusel.
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural, n (n " 1, 10 ), şi
2
cele n n elemente ale unui tablou bidimensional, reprezentând codurile corespunzătoare zonelor
din locul de joacă, ı̂n ordinea parcurgerii lor rând după rând, şi a fiecărui rând de la stânga la
dreapta.
Programul determină zonele destinate plasării câte unui carusel, care NU
au nicio latură comună cu o zonă cu tobogan şi, pentru fiecare dintre acestea,
afişează pe ecran numărul de ordine al rândului pe care se află. Numerele
afişate sunt separate prin câte un spaţiu, iar dacă nu există nicio astfel de
zonă, se afişează pe ecran mesajul nu exista.
Exemplu: pentru n=6 şi tabloul alăturat se afişează pe ecran, nu neapărat ı̂n această ordine,
numerele: 2 3 3 6 (10p.)
Problema 3
O pereche de numere naturale x, y se numeşte p-ordonată dacă x şi y au paritate diferită, cu
x % y, sau dacă x şi y au aceeaşi paritate.
Exemplu: (7,4), (8,7), (7,9) sunt perechi p-ordonate, dar (7,8), (8,9) nu sunt perechi p-
ordonate.
Un şir, format din 2 n numere naturale, se numeşte p-ordonat dacă perechile de forma x, y
sunt p-ordonate, pentru orice x, dintre primii n termeni ai şirului, şi orice y, dintre ultimii n
termeni ai şirului.
6
Fişierul bac.txt conţine numere naturale din intervalul 0, 10 : pe prima linie un număr
nenul, n, iar pe a doua linie un şir de 2 n numere, separate prin câte un spaţiu.
Se cere să se afişeze pe ecran mesajul DA, ı̂n cazul ı̂n care şirul aflat ı̂n fişier este p-ordonat,
sau mesajul NU, ı̂n caz contrar.
Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare şi al memoriei
utilizate.
Exemplu: dacă fişierul are unul dintre conţinuturile de mai jos, se afişează pe ecran mesajul DA.
a. Descrieţi ı̂n limbaj natural algoritmul proiectat, justificând eficienţa acestuia. (2p.)
b. Scrieţi programul C/C++ corespunzător algoritmului proiectat. (8p.)
CAPITOLUL 1. BAC 2023 1.2. SESIUNEA - SIMULARE 5
1.2 Sesiunea - Simulare

Varianta Simulare
1.2.1 Subiectul I
Pentru fiecare dintre itemii de la 1 la 5, scrieţi pe foaia de examen litera corespunzătoare
răspunsului corect. Fiecare răspuns corect se notează cu 4 puncte.
Problema 1
Indicaţi numerele pe care le pot memora variabilele ı̂ntregi x şi y, astfel ı̂ncât
valoarea expresiei C/C++ alăturate să fie 23.
a. x=8 şi y=23 b. x=20 şi y=39 c. x=23 şi y=66 d. x=43 şi y=20
Problema 2
Subprogramul f este definit
alăturat. Indicaţi valoarea
lui f(2023).
a. 2303 b. 3232 c. 43332 d. 5355
Problema 3
Expresiile alăturate au ca valori trei numere naturale reprezentând, ı̂n această
ordine, următoarele informaţii memorate pentru o motocicletă: anul fabricaţiei
şi dimensiuni specifice (garda la sol şi lungimea).
Indicaţi o declarare corespunzătoare a variabilei m.
Problema 4
Utilizând metoda backtracking, se generează toate pachetele formate din câte 3 tipuri distincte
de ceai din mulţimea matcha, mate, moringa, oolong, tulsi. Două amestecuri sunt distincte dacă
diferă prin cel puţin un tip de ceai.
Primele patru soluţii obţinute sunt, ı̂n această ordine: (matcha, mate, moringa), (matcha,
mate, oolong), (matcha, mate, tulsi) şi (matcha, moringa, oolong).
Indicaţi succesiunea care NU se obţine, prin această metodă, ı̂n ordinea dată.
a. (matcha, moringa, tulsi) b. (moringa, oolong, tulsi)

c. (mate, moringa, oolong) d. (oolong, tulsi, mate)
Problema 5
Într-un magazin sunt 8 raioane, distribuite ı̂n trei zone importante, ı̂n fiecare zonă fiind un număr
par, nenul, de raioane.
În scopul fluidificării deplasării clienţilor se marchează unele culoare, astfel ı̂ncât fiecare culoar
să conecteze două raioane, iar deplasarea pe el să se facă ı̂ntr-un singur sens.
Se realizează o hartă, sub forma unui graf orientat, ı̂n care vârfurile reprezintă raioanele din
magazin, iar arcele reprezintă culoarele marcate.
Indicaţi numărul maxim de culoare care se pot marca, astfel ı̂ncât graful să aibă trei compo-
nente tare conexe, fiecare componentă fiind reprezentarea pe hartă a câte uneia dintre cele trei
zone importante din magazin.
a. 20 b. 28 c. 36 d. 56

Problema 1
a la numărul natural nenul b şi cu [c] partea ı̂ntreagă a
numărului real c.
a. Scrieţi valoarea afişată dacă se citeşte numărul 5174.
(6p.)
b. Scrieţi trei numere impare, cu cifre distincte, din
2 4
intervalul [10 ,10 ) care pot fi citite astfel ı̂ncât, ı̂n urma
executării algoritmului, pentru fiecare dintre acestea, să se
afişeze valoarea 34. (6p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind prima structură
repetă...până când cu o structură de tip pentru...execută. (6p.)
Problema 2
Un arbore cu 7 noduri, numerotate de la 1 la 7, este reprezentat prin vectorul de taţi (4,1,1,0,7,4,4).
Scrieţi trei muchii care i se pot adăuga, astfel ı̂ncât graful obţinut să fie eulerian. (6p.)
Problema 3
Variabilele i şi j sunt de tip ı̂ntreg, iar variabila a memorează un tablou bidimensional cu 5 linii şi
5 coloane, numerotate de la 1 la 5, având iniţial toate elementele nule.
Fără a utiliza alte variabile decât cele menţionate, scrieţi secvenţa de
instrucţiuni de mai jos, ı̂nlocuind punctele de suspensie astfel ı̂ncât, ı̂n urma
executării secvenţei obţinute, variabila a să memoreze tabloul alăturat.
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
.................. (6p)

Problema 1
Subprogramul NrImp are trei parametri:
x şi y, prin care primeşte câte un număr natural (2 & x $ y & 10 )
9
nr, prin care furnizează numărul valorilor naturale din intervalul x, y cu trei divizori
pozitivi impari.
Scrieţi definiţia completă a subprogramului.

Exemplu: dacă x 4 şi y 50, după apel nr=6 (pentru valorile 9, 18, 25, 36, 49, 50). (10p.)
Problema 2
Într-un text de cel mult 100 de caractere cuvintele sunt separate prin câte un spaţiu şi sunt formate
din litere mari ale alfabetului englez, iar dacă sunt scrise prescurtat sunt urmate de caracterul .
(punct).
Textul reprezintă denumirea ştiinţifică a unei păsări şi doar cuvintele din mulţimea {FAMILIA,
GENUL, SPECIA}, specifice sistemului de clasificare a organismelor, sunt mereu prescurtate, prin
eliminarea ultimelor lor litere.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul precizat şi construieşte
ı̂n memorie, apoi afişează pe ecran denumirea ştiinţifică, ı̂n care pentru cuvintele specifice sis-
temului de clasificare a organismelor se păstrează doar primele trei litere, scrise cu litere mici, şi
urmate de punct, ca ı̂n exemplu.
Exemplu: pentru textul FAMIL. PHASIANIDAE GEN. MELEAGRIS SP. GALLOPAVO
sau pentru textul FAM. PHASIANIDAE G. MELEAGRIS SPECI. GALLOPAVO se obţine
fam. PHASIANIDAE gen. MELEAGRIS spe. GALLOPAVO (10p.)
Problema 3
Pentru a studia un metal, s-a urmărit comportamentul său ı̂ntr-o succesiune de paşi, la fiecare pas
metalul fiind supus unei anumite temperaturi. Paşii sunt numerotaţi cu valori naturale consecu-
tive, ı̂ncepând de la 1. Un pas se numeşte reprezentativ dacă la niciunul dintre paşii anteriori
nu este utilizată o temperatură strict mai mare decât la acest pas.
Dacă există o secvenţă de paşi consecutivi la care se utilizează aceeaşi temperatură, se consideră
reprezentativ doar primul pas din secvenţă.
6 4
Fişierul bac.txt conţine cel mult 10 numere naturale din intervalul 0, 10 , separate prin câte
un spaţiu, reprezentând temperaturile la care este supus metalul, ı̂n ordinea paşilor corespunzători.
Se cere să se afişeze pe ecran, separaţi prin câte un spaţiu, paşii reprezentativi pentru datele
din fişier.
Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare şi al spaţiului
de memorie utilizat.
Exemplu: dacă fişierul conţine numerele 7 4 9 10 10 10 3 9 2 10 10 8 2 30 se afişează pe ecran
1 3 4 10 14
CAPITOLUL 1. BAC 2023 1.3. SESIUNEA SPECIALĂ 8
1.3 Sesiunea specială

Varianta 6
intensiv informatică Filieră vocaţională, profil militar, specializare matematică-informatică
Toate subiectele sunt obligatorii. Se acordă zece puncte din oficiu.
Timpul de lucru efectiv este de trei ore.
Identificatorii utilizaţi ı̂n rezolvări trebuie să respecte precizările din enunţ (bold), iar ı̂n lipsa
unor precizări explicite, notaţiile trebuie să corespundă cu semnificaţiile asociate acestora
(eventual ı̂n formă prescurtată). Datele de intrare se consideră corecte, validarea lor nefiind
necesară.
În grafurile din cerinţe oricare arc/muchie are extremităţi distincte şi oricare două arce/-
muchii diferă prin cel puţin una dintre extremităţi.
1.3.1 Subiectul I
Problema 1
Variabilele ı̂ntregi m şi n memorează câte un număr natural. Indicaţi expresia C/C++ care are
valoarea 1 dacă şi numai dacă fiecare dintre numerele memorate ı̂n variabilele m şi n este par.
a. (m+n)%2==0 b. (m-n)%2==0 c. m%2+n%2==0 d. m%2-n%2==0
Problema 2
int f(int n,int k)
Subprogramul f este definit alăturat. Indicaţi valoarea f(35,3). { if(n==0 || k==0) return 0;
return n%k+10*f(n/k,k);
a. 1022 b. 355 c. 102 d. 33 }
Problema 3
struct paralelipiped
Variabila p, declarată alăturat, memorează dimensiunile unui paralelip-
{ float lg,lt,h;
iped dreptunghic: lungimea, lăţimea, respectiv ı̂nălţimea. }p;
a. v=lg*lt*h; b. v=lg.p*lt.p*h.p; c. v=p(lg*lt*h); d. v=p.lg*p.lt*p.h;
Problema 4
Utilizând metoda bactracking se generează toate şirurile de 5 litere distincte din mulţimea A, M,
U, R, G, astfel ı̂ncât ı̂n fiecare şir litera R precede literele A şi M.
Primele cinci soluţii generate sunt, ı̂n această ordine: URAMG, URAGM, URMAG, URMGA,
URGAM.
Indicaţi soluţia generată imediat după GURMA.
a. GARUM b. GRAMU c. GRAUM d. GRUAM
Problema 5
Într-o zonă sunt 23 de obiective turistice, numerotate de la 1 la 23; zona este reprezentată ca un
graf orientat ı̂n care vârfurile corespund acestor obiective, iar arcele sunt stabilite ı̂n funcţie de
modalitatea de deplasare ı̂ntre două obiective, astfel:
de la fiecare obiectiv numerotat cu i (i"[1,23]) se poate merge direct doar la obiectivul numero-
tat cu 2*i, dacă acesta există, sau doar la obiectivul numerotat cu i-1, ı̂n caz contrar.
Indicaţi numărul maxim de vârfuri ale unui drum elementar ı̂n acest graf, cu extremitatea
iniţială 1.
a. 5 b. 11 c. 16 d. 21

(40 puncte)
Problema 1
a. Scrieţi ce se afişează ı̂n urma executării algoritmului,
dacă se citeşte numărul 3. (6p.)
b. Scrieţi două numere care pot fi citite, astfel ı̂ncât, pen-
tru fiecare dintre acestea, ı̂n total, numărul de cifre 2 afişate
să fie ı̂n intervalul [2,50]. (6p.)
c. Scrieţi programul C/C++ corespunzător algoritmului
dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat,
ı̂nlocuind una din structurile pentru ... execută cu o structură de tip cât timp ... execută
(6p.)
Problema 2
Un arbore cu 8 noduri, numerotate de la 1 la 8, este reprezentat prin vectorul de taţi”
(0,1,1,2,2,4,5,1). Enumeraţi toţi descendenţii nodului numerotat cu 2. (6p.)
Problema 3
Un şir de caractere a este numit prefix al unui şir de caractere b dacă este identic cu b sau dacă
b se obţine din a prin adăugarea la dreapta a unor alte caractere.
Variabila k este de tip ı̂ntreg, iar variabila s permite accesul la un şir de cel mult 20 de caractere.
Scrieţi secvenţa de instrucţiuni de mai jos, ı̂nlocuind punctele de suspensie astfel ı̂ncât, ı̂n urma
executării secvenţei obţinute, să se afişeze pe ecran, ı̂n ordinea descrescătoare a lungimii, separate
prin câte un spaţiu, toate prefixele şirului accesat prin variabila s, fiecare ı̂ncheindu-se cu prima
literă a şirului s, ca ı̂n exemplu. Declaraţi eventualele alte variabile utilizate.
Exemplu: pentru şirul elemente se afişează: elemente eleme ele e
for(k=strlen(s)-1;k>=0;k--)
{..................} (6p.)

Problema 1
Subprogramul Putere are trei parametri:
n, prin care primeşte un număr natural (nı̂[2,109]);
x şi p, prin care furnizează două numere naturale cu proprietatea că n=xp, iar x este cel
mai mic număr cu această proprietate.

Exemplu: dacă n=16 atunci, după apel, x=2 şi p=4, dacă n=216 atunci, după apel, x=6 şi
p=3, iar dacă n=12 atunci, după apel, x=12 şi p=1. (10p.)
Problema 2
La o expoziţie sunt prezentate mai multe tipuri de flori, fiecare având un anumit cod. Zona de
expunere este organizată pe n rânduri, fiecare având câte n parcele de dimensiune egală. Pe
primul rând sunt expuse n tipuri de flori distincte, fiecare parcelă conţinând flori de un anumit
tip. Celelalte parcele sunt ocupate astfel:
toate parcelele aflate ı̂n dreapta diagonalei secundare a zonei de expunere sunt ocupate de
gazon;
fiecare parcelă, aflată pe diagonala secundară a zonei de expunere sau ı̂n stânga acestei
diagonale, conţine flori cu un cod de cel mult două cifre, obţinut din ultimele două cifre
ale sumei codurilor florilor aflate ı̂n două parcele de pe rândul anterior, şi anume cea de pe
aceeaşi coloană, respectiv cea de pe coloana din dreapta sa; dacă prima dintre cifrele codului
obţinut este 0, ea este ignorată, ca ı̂n exemplu.
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural, n (n"[2,20]), apoi n
2
numere naturale distincte din intervalul 0, 10 , reprezentând, ı̂n această ordine, de la stânga la
dreapta, codurile florilor din parcelele aflate pe primul rând al zonei de expunere; gazonul are
codul -1.
Programul construieşte ı̂n memorie un tablou bidimensional cu n
linii şi n coloane, ı̂n care fiecare linie corespunde unui rând de parcele
şi fiecare element al liniei corespunde unei parcele, ı̂n ordinea acestora,
şi memorează codul plantelor (flori sau gazon) plasate ı̂n acea parcelă.
Programul afişează pe ecran tabloul obţinut, fiecare linie a tabloului pe
câte o linie a ecranului, elementele de pe aceeaşi linie fiind separate prin câte un spaţiu.
Exemplu: dacă se citesc numerele n=5, apoi 90, 10, 4, 27, 30 se obţine tabloul alăturat.
(10p.)
Problema 3
Intervalul [x,y] se numeşte p-interval pentru un şir de valori ı̂ntregi, dacă oricare dintre primii
p termeni ai şirului aparţine intervalului, iar numărul de valori ı̂ntregi distincte din interval este
minim.
Exemplu: pentru şirul 2, 7, -1, 8, 3, 10 există [2,2] ca 1-interval, [-1,8] ca 4-interval şi 5-interval
6 9 9
etc. Fişierul bac.in conţine un şir de cel mult 10 numere ı̂ntregi din intervalul 10 , 10 , separate
prin câte un spaţiu.
Se cere să se afişeze pe ecran cea mai mică şi cea mai mare valoare a lui p p ' 2 cu proprietatea
că p 1-interval este identic cu p-interval pentru şirul aflat ı̂n fişier. Valorile afişate pot fi egale,
iar dacă nu există nicio astfel de valoare, pe ecran se afişează mesajul nu exista. Proiectaţi un
algoritm eficient din punctul de vedere al timpului de executare şi al memoriei utilizate.
Exemplu: dacă fişierul conţine numerele 2 7 1 8 3 10 6 -3 -2 13, se afişează pe ecran 5 9
(intervale conform cerinţei se obţin pentru valorile 5, 7 şi 9 ale lui p), iar dacă fişierul conţine
numerele 2 7 1 0 8 10 -3 13, se afişează pe ecran nu exista
CAPITOLUL 1. BAC 2023 1.4. SESIUNEA IUNIE - IULIE 11
1.4 Sesiunea iunie - iulie

Varianta 5
necesară.
1.4.1 Subiectul I
Pentru fiecare dintre itemii de la 1 la 5, scriei pe foaia de examen litera corespunzătoare răspunsului
corect. Fiecare răspuns corect se notează cu 4 puncte.
Problema 1
Indicaţi expresia C/C++ care are cea mai mare valoare, comparativ cu celelalte trei expresii.
a. 20*23/(2*2) b. 20/2*23/2 c. (20*23)/2 d. (20*23)/2*2
Problema 2 void f (int n)

Subprogramul f este definit alăturat. Indicaţi ce se { if(n!=0) f(n/2);
cout<<n%2; | printf("%d",n%2);
afişează ı̂n urma apelului de mai jos.
}
f(23);
a. 100111 b. 111010 c. 010111 d. 01251123
Problema 2
strcpy(s,"bac2023");
Variabila k este de tip ı̂ntreg, iar variabila s permite memorarea unui
s[s[2]-’a’]=’\0’;
şir de maximum 50 de caractere. Indicaţi valoarea variabilei k ı̂n urma k=strlen(s);
executării secvenţei alăturate
a. 7 b. 6 c. 2 d. 1
Problema 4
Indicaţi un vector de taţi corespunzător unui arbore cu 7 noduri, ı̂n care cel puţin unul dintre
noduri are trei ascendenţi.
a. 0,1,2,1,1,1,2 b. 3,0,2,1,3,2,1 c. 4,3,0,3,4,4,3 d. 5,4,3,0,2,3,4
Problema 5
O companie de colectare a fructelor are 6 depozite, numerotate de la 1 la 6: depozitele 1, 3
şi 5 conţin mere, depozitele 2 şi 4 conţin pere, iar depozitul 6 conţine piersici. Compania a
construit 4 benzi de transport unidirecţional: de la depozitul 1 la depozitul 5, de la depozitul 5 la
depozitul 2, de la depozitul 5 la depozitul 4 şi de la depozitul 6 la depozitul 1. Dacă depozitele
reprezintă vârfurile unui graf orientat, iar benzile de transport reprezintă arcele acestuia, indicaţi
numărul minim de benzi de transport care pot fi adăugate, astfel ı̂ncât graful obţinut să aibă trei
componente tare conexe, fiecare dintre acestea având vârfuri care corespund depozitelor cu acelaşi
tip de fructe.
a. 4 b. 3 c. 2 d. 1

Problema 1
S-a notat cu a%b restul ı̂mpărţirii numărului natural a la
numărul natural nenul b şi cu [c] partea ı̂ntreagă a numărului
real c.
a. Scriei valoarea afişată dacă se citeşte numărul 6907512.
(6p.)
b. Scriei două valori distincte din intervalul [100,999] care
pot fi citite astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
fiecare dintre acestea, să se afişeze o valoare identică cu cea
citită. (6p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind structura cât
timp...execută cu o structură repetitivă cu test final. (6p.)
Problema 2
Utilizând metoda backtracking, se generează toate amestecurile de apă provenită din surse dis-
tincte din mulţimea {lac, mare, ocean, ploaie, râu}, astfel ı̂ncât o sursă să fie de apă sărată şi una
sau două surse să fie de apă dulce. Marea şi oceanul sunt surse de apă sărată, iar lacul, ploaia şi
râul sunt surse de apă dulce. Două amestecuri sunt distincte dacă diferă prin cel puţin o sursă a
apei. Primele patru soluii obinute sunt, ı̂n această ordine: (lac, mare), (lac, mare, ploaie), (lac,
mare, râu) şi (lac, ocean). Scrieţi soluţia generată imediat ı̂nainte şi soluţia generată imediat după
(ocean, ploaie). (6p)
Problema 3
Variabila f memorează, pentru fiecare dintre cele 10 soiuri de lalele care se vând ı̂ntr-o florărie,
caracteristicile acestora: denumirea (şir de maximum 20 de caractere) şi stocul, exprimat prin
numărul de fire şi preţul unui fir, ı̂n lei (numere naturale). Ştiind că expresiile de mai jos au ca
valori denumirea primului soi de lalele, respectiv suma, ı̂n lei, necesară pentru a cumpăra toate
lalelele din acest soi, scrieţi ı̂n limbajul C/C++ definiţia unei structuri cu eticheta lalea, care să
permită memorarea informaţiilor menţionate pentru un soi de lalea, şi declaraţi corespunzător
variabila f.
f[0].denumire f[0].stoc.nrFire*f[0].stoc.pretFir (6p.)

Problema 1
Un număr natural nenul, n, se numeşte număr abundent dacă S(n)/n % S(k)/k, pentru orice număr
natural nenul k (k & n 1), unde s-a notat cu S(i) suma divizorilor pozitivi ai numărului natural
nenul i. Subprogramul abundent are un singur parametru, n, prin care primeşte un număr
natural (n " 2, 10 ). Subprogramul returnează valoarea 1, dacă n este un număr abundent, sau
6
valoarea 0, ı̂n caz contrar.

Exemplu: pentru n=6, subprogramul returnează valoarea 1 (S(6)/6=2, iar cel mai mare
raport obţinut pentru valori strict mai mici decât 6 este S(4)/4=1.75), iar pentru n=7 sau n=8,
subprogramul returnează valoarea 0 (S(7)/7=1.14, S(8)/8=1.87). (10p.)
Problema 2
Pentru a identifica punctele ı̂n care se concentrează apa ı̂n albia unui râu ı̂n cazul secetei, se
determină talvegul acesteia linia care uneşte punctele cele mai adânci ale albiei. n̂ acest scop s-au
stabilit ns secţiuni transversale pe cursul apei, numerotate ı̂ncepând de la 1, şi ı̂n cadrul fiecărei
secţiuni s-a măsurat adâncimea apei ı̂n np puncte, numerotate ı̂ncepând de la 1. Din fiecare
secţiune, ı̂n ordine, se include ı̂n talveg cel mai adânc punct al acesteia, iar dacă ı̂n secţiune sunt
mai multe puncte aflate la aceeaşi adâncime, maximă, se va lua ı̂n considerare doar primul dintre
ele, ca ı̂n exemplu.
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale, ns şi np (ns"
1, 10 , np" 1, 50), şi cele ns np elemente ale unui tablou bidimensional, valori naturale din
3
2
intervalul 0, 10 .
Fiecare linie a tabloului corespunde câte unei secţiuni, ı̂n ordinea numerotării
acestora, iar valorile memorate pe linie reprezintă adâncimile celor np puncte stabilite
pentru acea secţiune, ı̂n ordinea numerotării lor. Programul afişează pe ecran, pentru
fiecare secţiune, o pereche formată din numărul de ordine al secţiunii şi numărul de
ordine al punctului său care s-a inclus ı̂n talveg. Numerele din fiecare pereche sunt
afişate separate prin câte un caracter : (două puncte), iar fiecare pereche este urmată
de un spaţiu.
Exemplu: pentru ns=6, np=4 şi tabloul alăturat, se afişează pe ecran valorile:
1:3 2:2 3:2 4:2 5:4 6:3 (10p.)
Problema 3
Un număr natural x este numit prefix al unui număr natural y dacă se obţine din acesta prin
eliminarea a cel puţin unei cifre de la dreapta sa, şi este numit sufix al lui y dacă se obţine din
acesta prin eliminarea a cel puţin unei cifre de la stânga sa.
Exemplu: 15 este prefix pentru 154 sau 1521, este sufix pentru 3415 sau 5115, dar nu este
nici prefix, nici sufix pentru 15.
4
Fişierul bac.txt conţine maximum 106 numere naturale din intervalul 10, 10 , separate prin
câte un spaţiu. Se cere să se afişeze pe ecran numărul valorilor de două cifre care apar de acelaşi
număr de ori ca sufix, respectiv ca prefix al numerelor din şirul aflat ı̂n fişier. Proiectaţi un
algoritm eficient din punctul de vedere al timpului de executare.
Exemplu: dacă fişierul are conţinutul 342 1684 2134 5434 111 98 98 3405 3412 7016 8634
10 10 102 310 se afişează pe ecran: 4 (pentru valorile 10, 11, 16, 34).
CAPITOLUL 1. BAC 2023 1.5. SESIUNEA DE TOAMNĂ 14
1.5 Sesiunea de toamnă

Varianta 7
necesară.
1.5.1 Subiectul I
Problema 1
Indicaţi numerele pe care le pot memora variabilele ı̂ntregi x şi y,
astfel ı̂ncât valoarea expresiei C/C++ alăturate să fie 1. y%x(x/y)*3!=0
a. x=25 \c si y=75 b. x=25 \c si y=15 c. x=15 \c si y=0 d. x=10 \c si y=30
Problema 2
Subprogramul f este definit alăturat. Indicaţi valoarea f(3,2).
a. 1 b. 2 c. 9 d. 18
Problema 3
Variabila s poate accesa un şir cu cel mult 20 de caractere. strcpy(s,"2019");
strcpy(s+3,"23");
Indicaţi şirul accesat prin s ı̂n urma executării secvenţei alăturate.
a. 20123 b. 201923 c. 202223 d. 2023
Problema 4
Utilizând metoda backtracking, se generează toate parfumurile formate prin amestecarea a câte 3
esenţe distincte din mulţimea {bergamotă, cireş, iris, lămâie, salcâm}.
Două parfumuri sunt distincte dacă diferă prin cel puţin o esenţă.
Primele patru soluţii obţinute sunt, ı̂n această ordine: (bergamotă, cireş, iris), (bergamotă,
cireş, lămâie), (bergamotă, cireş, salcâm) şi (bergamotă, iris, lămâie). Indicaţi penultima soluţie
generată.
a. (cireş, iris, salcâm) b. (cireş, lămâie, salcâm)
c. (lămâie, iris, salcâm) d. (iris, lămâie, salcâm)
Problema 5
Un graf neorientat are 5 noduri, numerotate de la 1 la 5, cu gradele
figurate ı̂n tabelul alăturat. Indicaţi o pereche de valori posibile
pentru x şi y.
a. 0 si 4 b. 1 si 5 c. 2 si 3 d. 3 si 3

Problema 1
a. Scrieţi valoarea afişată dacă se citesc, ı̂n această or-
dine, numerele 3, 746, 82, 3067, 67, 78, 178. (6p.)
b. Dacă pentru n se citeşte numărul 2, scrieţi un şir
de numere naturale din intervalul [0,9] care pot fi citite ı̂n
continuare, ı̂n acea ordine, astfel ı̂ncât, ı̂n urma executării
algoritmului, să se afişeze valoarea 0. (6p.)
dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel
dat, ı̂nlocuind prima structură cât timp ... execută cu o
structură pentru ... execută (6p.)
Problema 2
Într-un arbore cu rădăcină un nod se află pe nivelul x dacă lanţul elementar care are o extremitate
ı̂n nodul respectiv şi cealaltă extremitate ı̂n rădăcina arborelui are lungimea x. Pe nivelul 0 se
află un singur nod (rădăcina).
Un arbore cu 6 noduri, numerotate de la 1 la 6, are muchiile [1,2], [2,3], [2,6], [3,4], [3,5].
Scrieţi nodurile care pot fi desemnate ca rădăcină, astfel ı̂ncât fiecare dintre arborii obţinuţi
să aibă un număr minim de niveluri. (6p.)
Problema 3
struct produs
Variabila p, declarată alăturat, memorează caracteristicile unui produs: de- { char denumire[20];
numire şi preţ. Scrieţi o secvenţă de instrucţiuni C/C++ prin care variabila int pret;
a memorează valoarea primei litere a denumirii produsului respectiv, dacă }p;
acesta are preţul strict mai mic decât 100, sau caracterul * ı̂n caz contrar. char a;
(6p.)

Problema 1
Subprogramul DNPI are un singur parametru, n, prin care primeşte un număr natural (n "
9
1, 10 ), şi afişează pe ecran, separaţi prin câte un spaţiu, toţi divizorii pozitivi impari ai lui n
care NU sunt primi.
Exemplu: dacă n=90, se afişează pe ecran, nu neapărat ı̂n această ordine, numerele
1 9 15 45 (10p.)
Problema 2
Un joc foloseşte o tablă dreptunghiulară, pe care sunt reprezentate celule de dimensiune egală,
dispuse pe m linii şi pe n coloane. ı̂n fiecare celulă este ı̂nscris un număr natural.
Numim pătrat de valoare p patru celule ale tablei, situate pe două linii consecutive şi pe două
coloane consecutive, cu proprietatea că suma valorilor ı̂nscrise ı̂n aceste celule este egală cu p.
Scopul jocului este determinarea unui pătrat de valoare maximă.
Scrieţi un program C/C++ care citeşte de la tastatură două numere natu-
rale din intervalul [2,20], m şi n, apoi elementele unui tablou bidimensional cu
4
m linii şi n coloane, numere naturale din intervalul 0, 10 , reprezentând nu-
merele ı̂nscrise pe tabla de joc, ı̂n ordinea dispunerii celulelor corespunzătoare.
Programul determină un pătrat de valoare maximă al tablei şi afişează pe ecran această valoare.
Exemplu: pentru m=5, n=4 şi tabloul alăturat, se afişează pe ecran valoarea 36, core-
spunzătoare pătratului evidenţiat ı̂n figură.
Problema 3
6
Fişierul date.in conţine pe prima linie două numere naturale din intervalul 1, 10 , m şi n, iar
2
pe următoarele două linii numere naturale din intervalul 0, 10 : pe a doua linie un şir A, de m
numere, iar pe a treia linie un şir B, de n numere. Numerele aflate pe aceeaşi linie sunt separate
Se cere să se afişeze pe ecran numărul maxim de perechi de forma (pa,pb) (pa"[1,m], pb"[1,n]),
cu proprietatea că termenul de pe poziţia pa din şirul A are aceeaşi valoare cu termenul de pe
poziţia pb din şirul B şi că fiecare poziţie, corespunzătoare şirului A, respectiv şirului B, apare
ı̂n cel mult o pereche, ca ı̂n exemplu. Proiectaţi un algoritm eficient din punctul de vedere al
timpului de executare.
Exemplu: dacă fişierul conţine numerele alăturate, se afişează pe
ecran 6 (de exemplu, pentru perechile (1,1), (2,9), (4,2), (5,5), (6,6),
(7,7) sau pentru perechile (1,2), (2,9), (4,1), (5,7), (6,8), (8,5)).
Capitolul 2
BAC 2022

Varianta Simulare
2.1.1 Subiectul I
Pentru fiecare dintre itemii de la 1 la 5, scrieţi pe foaia de examen litera core-
spunzătoare răspunsului corect. Fiecare răspuns corect se notează cu 4 puncte.
Problema 1
Variabila x este de tip ı̂ntreg. Indicaţi o expresie care are valoarea 1 dacă şi numai dacă expresia
C/C++ alăturată are valoarea 1. (4p.) x<=3 || x>30
a. !(x<3) && x<30 b. !(x>=3 && x<=30)

c. !(x<3 || x<=30) d. !(x>3) || !(x<=30)
Problema 2
Subprogramul f
este definit alăturat.
Ştiind că variabila x

memorează un tablou unidimensional cu elementele (7,1,2,5,4), ı̂n această ordine, numerotate
de la 0 la 4, indicaţi valoarea f(0,4,x).
a. 2 b. 3 c. 4 d. 5
Problema 3
Un sport se desfăşoară pe o pistă ı̂ngheţată, cu o echipă alcătuită din 4 jucători, care sunt,
ı̂n această ordine, lider, secund, vice-skip şi skip. Lotul este format din jucătorii din mulţimea
{Alin, Bogdan, Cristian, Răzvan, Ştefan, Valentin}; Cristian poate fi doar lider, Alin
şi Valentin pot fi doar lider sau secund, Bogdan poate fi doar secund, iar ceilalţi doi jucători pot
fi doar vice-skip sau skip.
Două echipe sunt distincte dacă există cel puţin un rol care, ı̂n cele două echipe, este
atribuit unor jucători diferiţi. Pentru antrenamente, s-au format echipe ı̂n toate formulele
17
posibile, primele şase soluţii generate fiind, ı̂n această ordine: {Alin, Bogdan, Răzvan,
Ştefan}, {Alin, Bogdan, Ştefan, Răzvan}, {Alin, Valentin, Răzvan, Ştefan}, {Alin,
Valentin, Ştefan, Răzvan}, {Cristian, Alin, Răzvan, Ştefan}, {Cristian, Alin,
Ştefan, Răzvan}.
Indicaţi soluţia generată imediat după {Cristian, Valentin, Ştefan, Răzvan}.
a. {Cristian, Bogdan, Răzvan, Ştefan} b. {Cristian, Bogdan, Ştefan, Răzvan}
c. {Valentin, Alin, Răzvan, Ştefan} d. {Valentin, Bogdan, Ştefan, Răzvan}
Problema 4
struct recensamant
Variabila oras, declarată alăturat, memorează unele date obţinute ı̂n
{ char nume[21];
urma recensământului populaţiei ı̂n 100 dintre oraşele ţării. Ştiind că
int nrLocuitori;
densitatea unui oraş este egală cu raportul dintre numărul de locuitori
float suprafata;
şi suprafaţa acestuia (exprimată ı̂n km2), indicaţi o expresie a cărei
} oras[100];
valoare este egală cu densitatea primului oraş.
a. oras[0].nrLocuitori/oras[0].suprafata b. oras.nrLocuitori[0]/oras.suprafata[0]
c. nrLocuitori[0].oras/suprafata[0].oras d. nrLocuitori.oras[0]/suprafata.oras[0]
Problema 5
Un graf neorientat complet are 4 noduri. Indicaţi o valoare care NU poate fi numărul de muchii
ale unui subgraf al acestui graf.
a. 0 b. 1 c. 2 d. 3

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseu-
docod. S-a notat cu a%b restul ı̂mpărţirii
numărului natural a la numărul natural nenul
b şi cu [a] partea ı̂ntreagă a numărului real a.
a. Scrieţi ce se afişează ı̂n urma executării
algoritmului dacă se citesc, ı̂n această ordine,
numerele 6, 16, 4273, 1679, 3165, 16, 200, 167.
(6p.)
b. Dacă primele două numere citite sunt,
ı̂n această ordine, 2 şi 22, scrieţi o secvenţă de
3 4
numere distincte din intervalul 10 , 10 care
pot fi citite ı̂n continuare astfel ı̂ncât, ı̂n urma executării algoritmului, să se afişeze valoarea 2.
(6p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind adecvat prima structură
cât timp...execută cu o structură repetitivă de tip pentru...execută. (6p.)
Problema 2
ı̂n nodul respectiv şi cealaltă extremitate ı̂n rădăcina arborelui are lungimea x. Pe nivelul 0 se află
un singur nod (rădăcina). Un arbore cu rădăcină are 10 noduri şi este reprezentat prin vectorul
de ”taţi” (10,5,5,10,0,10,9,2,5,2). Enumeraţi trei dintre frunzele situate ı̂n arbore pe
niveluri impare. (6p.)
Problema 3
Într-o seră se folosesc vase pătrate, care conţin câte o singură floare (lalea, frezie sau narcisă).
Vasele sunt aşezate pe trei rânduri şi sunt aliniate ca ı̂n exemplu. Patru flori de acelaşi tip
formează un romb dacă vasele ı̂n care se află sunt dispuse ı̂n jurul unui alt vas, cu care fiecare are
ı̂n comun câte o latură.
Variabilele j şi ok sunt ı̂ntregi, iar variabila a este un tablou bidimensional cu 3 linii şi 15
coloane, cu elemente de tip char, ı̂n care fiecare linie, ı̂n ordine, memorează succesiunea de flori
aflate pe un rând al serei, notându-se cu L lalelele, cu F freziile şi cu N narcisele. Fiecare linie a
tabloului corespunde, ı̂n ordine, unui rând de vase din seră. Liniile şi coloanele sunt numerotate
ı̂ncepând de la 0.
Scrieţi secvenţa C/C++ de mai jos, ı̂nlocuind punctele de suspensie astfel ı̂ncât, ı̂n urma
executării secvenţei obţinute, variabila ok să aibă valoarea 1 dacă florile formează cel puţin un
romb, sau valoarea 0 ı̂n caz contrar.
Exemplu: În urma executării secvenţei pentru tabloul de mai jos, ok=1
(sunt evidenţiate 4 romburi). 6p.

Problema 1
Subprogramul rest are patru parametri:
6
x, y şi n, prin care primeşte câte un număr natural din intervalul 1, 10 , x¡y¡n;
k, prin care furnizează cea mai mare valoare naturală din intervalul [1,n] pentru care atât
restul ı̂mpărţirii la x, cât şi restul ı̂mpărţirii la y, sunt egale cu 2, sau 0 dacă nu există o
astfel de valoare.

Exemplu: pentru x=10, y=101 şi n=3000, subprogramul returnează numărul 2022 (pentru
numerele 2, 1012 şi 2022 atât restul ı̂mpărţirii la 10, cât şi restul ı̂mpărţirii la 101, este 2). (10p.)
Problema 2
Un text, de cel mult 250 de caractere, reprezintă o listă cu date de identificare ale invitaţilor la o
petrecere; fiecare invitat are un prenume şi un nume, care apar ı̂n listă ı̂n această ordine, urmate
de simbolul ; (punct şi virgulă), ca ı̂n exemplu. Numele şi prenumele sunt formate din câte un
singur cuvânt, compus din litere mari ale alfabetului englez, şi sunt separate printr-un spaţiu.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul precizat mai sus apoi,
de pe rândul următor, un cuvânt, x, şi afişează pe ecran, separate prin câte un spaţiu, numele
tuturor invitaţilor care au prenumele x, ca ı̂n exemplu, sau mesajul NU dacă nu există astfel de
invitaţi.
Exemplu: dacă lista este DAN MARIS; DANILA PREPELEAC; DAN POPA; EDANA
DAN; şi cuvântul x este DAN se afişează pe ecran MARIS POPA (10p.)
Problema 3
Se citeşte de la tastatură un număr natural, n (n " 1, 10 ), şi se cere să se scrie ı̂n fişierul text
9
p
bac.txt cel mai mare număr natural p cu proprietatea că numărul 45 este divizor al numărului
obţinut prin evaluarea produsului 1 2 3 ... n.
utilizate.
2
Exemplu: dacă n 14, fişierul conţine numărul 2 (45 2025 este divizor al lui 1 2 3 ... 14
= 87 178 291 200)

Varianta 4
2.2.1 Subiectul I
Problema 1
Indicaţi expresia C/C++ cu valoarea 2022.
a. 4044/4/2 b. 4044/(4*2) c. 1011*1+1 d. 1011*(1+1)
Problema 2 int f(int n,int p)

{ if(n==0) return 0;
Subprogramul f este definit alăturat. Indicaţi valoarea else if(p==0) return n*10+2;
parametrului x pentru care f(x,3) are valoarea 2022. else return f(n/10,p-1);
}
a. 120234 b. 122023 c. 202345 d. 220223
Problema 3
Utilizând metoda backtracking, se generează toate posibilităţile de a expune câte trei maşini
produse ı̂n România, din gama Dacia, din mulţimea Dokker (negru), Duster (negru), Lodgy (gri),
Logan (alb), Sandero (roşu), astfel ı̂ncât să nu fie expuse simultan două maşini de aceeaşi culoare,
Sandero să NU apară pe prima poziţie, iar Logan să NU fie ı̂nainte de Dokker sau Duster.
Două soluţii sunt distincte dacă au cel puţin o maşină diferită sau dacă ordinea maşinilor este
diferită.
Primele cinci soluţii generate sunt, ı̂n această ordine:
(Dokker, Lodgy, Logan),
(Dokker, Lodgy, Sandero),
(Dokker, Logan, Lodgy),
(Dokker, Logan, Sandero),
(Dokker, Sandero, Lodgy).
Indicaţi penultima soluţie, ı̂n ordinea generării acestora.
a. Logan, Lodgy, Sandero b. Logan, Sandero, Lodgy

c. Lodgy, Dokker, Logan d. Lodgy, Logan, Dokker
Problema 4
Variabilele s şi d permit memorarea câte unui şir cu maximum strcpy(s,"info@rocnee.eu");
50 de caractere. s[strlen(s)-3]=’\0’;
strcpy(d,strchr(s,’@’)+1);
Indicaţi şirul memorat prin intermediul variabilei d ı̂n
urma executării secvenţei alăturate.
a. inf@r b. info@ c. rocnee d. rocnu
Problema 5
Într-un arbore cu 7 noduri, numerotate de la 1 la 7, nodul 1 este rădăcină şi pentru orice nod
numerotat cu i (i"[1,7]), dacă se notează cu F(i) numărul de descendenţi direcţi (”fii”) ai săi,
atunci F(i)=0, dacă i este ”frunză”, altfel F(i)=i+1.
Indicaţi numărul maxim de ”fraţi” ai nodului 7.
a. 4 b. 3 c. 2 d. 1

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseudocod. S-
a notat cu a%b restul ı̂mpărţirii numărului natural a
la numărul natural nenul b şi cu [c] partea ı̂ntreagă a
numărului real c.
a. Scrieţi ce se afişează ı̂n urma executării algorit-
mului dacă se citeşte numărul 1237518. (6p.)
b. Scrieţi două numere din intervalul [100,999] care
pot fi citite, astfel ı̂ncât, pentru fiecare dintre acestea,
ı̂n urma executării algoritmului, să se afişeze două nu-
mere. (6p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind structura repetă...până
când cu o structură repetitivă cu test iniţial. (6p.)
Problema 2
Un graf neorientat cu 6 noduri, numerotate de la 1 la 6, are muchiile [1,2], [1,3], [1,4], [1,5], [2,3],
[2,4], [2,5], [3,5], [4,6], [5,6]. Scrieţi mulţimea muchiilor unui subgraf al acestui graf, care să fie
complet şi să aibă un număr maxim de noduri. (6p.)
Problema 3
struct sala
Pentru o sală de spectacole se memorează următoarele informaţii speci-
{ int nrLocuri;
fice: numărul de locuri disponibile şi preţul biletului pentru un loc. int pret;
Variabilele i şi s sunt ı̂ntregi, iar variabila t memorează informaţiile } t[15];
specifice pentru fiecare dintre cele 15 săli de spectacole dintr-un oraş.
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia variabila s să memoreze suma totală
obţinută ı̂n urma vânzării biletelor pentru un festival de teatru care s-ar desfăşura simultan ı̂n
toate sălile, iar acestea ar fi ocupate complet. (6p.)

Problema 1
Subprogramul patrate are trei parametri:
n, prin care primeşte un număr natural (n " 2, 10 );

9
n şi 2 & x $ y
2 2
x şi y, prin care furnizează câte un număr natural cu proprietatea că x y
sau valoarea 0, prin fiecare dintre aceştia, dacă nu există două astfel de numere. Dacă sunt
mai multe astfel de valori, se furnizează cele corespunzătoare unei valori minime a lui x.

Exemplu: pentru n 400, după apel, x 2 şi y 10, iar pentru n 16 sau n 24, după
apel, x 0 şi y 0. (10p.)
Problema 2
Suprafaţa unei scene a fost ı̂mpărţită ı̂n zone dispuse ca elementele unui tablou bidimensional cu
număr egal de linii şi coloane. Fiecare instrument are alocată o zonă şi este identificat printr-
un număr natural. Dirijorul hotărăşte eliminarea tuturor instrumentelor plasate pe diagonala
principală a tabloului şi rearanjarea celor păstrate, prin deplasarea unora dintre acestea cu câte o
poziţie spre stânga, astfel ı̂ncât să nu existe zone intermediare libere, ca ı̂n exemplu.
Scrieţi un program C/C++ care citeşte de la tastatură numere naturale din intervalul [2,102],
şi anume n şi elementele unui tablou bidimensional cu n linii şi n coloane, reprezentând numerele
de identificare ale instrumentelor, ı̂n ordinea plasării lor iniţiale pe scenă. Programul modifică
apoi tabloul ı̂n memorie corespunzător hotărârii dirijorului şi afişează pe ecran tabloul obţinut,
fiecare linie a tabloului pe câte o linie a ecranului, elementele de pe aceeaşi linie fiind separate
Problema 3
Numim secvenţă progresivă a unui şir crescător de numere naturale un subşir al acestuia, format
din termeni aflaţi pe poziţii consecutive ı̂n şirul dat, cu proprietatea că fiecare termen apare ı̂n
subşir de un număr de ori egal cu valoarea sa. Lungimea secvenţei este egală cu numărul de
termeni ai acesteia.
6 6
Fişierul bac.txt conţine un şir crescător de cel mult 10 numere naturale din intervalul 1, 10 ,
astfel ı̂ncât orice termen al şirului apare de un număr de ori cel mult egal cu valoarea sa. Numerele
sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran lungimea maximă a unei secvenţe progresive din şirul aflat ı̂n
fişier. Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare şi al memoriei
utilizate.
Exemplu: dacă fişierul conţine numerele 1 2 2 3 4 4 4 4 6 6 6 6 6 6 7 7 7 8 8 8 8 8 8 8 8 atunci
pe ecran se afişează valoarea 10.

Varianta 1
2.3.1 Subiectul I
Problema 1
Indicaţi valoarea expresiei C/C++ alăturate.
a. 0 b. 0.55 c. 10 d. 55
struct produs
Problema 2 { char denumire[50];
Variabilele x şi valoare sunt declarate alăturat. Indicaţi o instrucţiune float cantitate, pret;
de atribuire corectă din punctul de vedere sintactic. } x;
float valoare;
a. x=("apa minerala",10,2.5); b. x.produs.pret=2.5;
c. x.denumire[5]= "Borsec"; d. valoare=2*x.cantitate*x.pret;
Problema 3
La o sală de sport se organizează antrenamente pentru sporturi din mulţimea tenis, fotbal, volei,
handbal, baschet, astfel ı̂ncât o persoană poate opta pentru un pachet de antrenamente pentru
două sau trei sporturi, dar nu poate alege fotbal şi baschet ı̂n acelaşi pachet.
Utilizând metoda backtracking se generează toate posibilităţile unei persoane de a opta pentru
un pachet de antrenamente ı̂n cadrul sălii de sport.
Două pachete sunt distincte dacă diferă prin cel puţin un sport ales. Primele cinci soluţii
generate sunt, ı̂n această ordine:
{tenis, fotbal},
{tenis, fotbal, volei},
{tenis, fotbal, handbal},
{tenis, volei},
{tenis, volei, handbal}.
Indicaţi soluţia generată imediat după fotbal, handbal.
a. {volei, handbal} b. {fotbal, handbal, baschet}
c. {handbal, baschet} d. {volei, handbal, baschet}
Problema 4
Un graf neorientat cu 6 noduri, numerotate de la 1 la 6, are muchiile [1,2], [1,3], [2,3], [4,6]. Indicaţi
numărul de componente conexe ale acestuia.
a. 1 b. 3 c. 5 d. 6
Problema 5
Într-un arbore cu rădăcină un nod se află pe nivelul n dacă lanţul elementar care are o extremitate
ı̂n nodul respectiv şi cealaltă extremitate ı̂n rădăcina arborelui are lungimea n. Pe nivelul 0 se
Un arbore cu rădăcină are 12 noduri, numerotate de la 1 la 12, şi este reprezentat prin vectorul
de ”taţi” (2,4,2,0,4,4,x,6,x,x,y,y).
Indicaţi un set de valori pe care le pot avea x şi y, ştiind că pe ultimul nivel există cinci noduri
frunză şi că un singur nod este numerotat cu o valoare egală cu numărul său de descendenţi direcţi
(”fii”) de tip ”frunză”.
a. x=11 y=12 b. x=8 y=3 c. x=3 y=8 d. x=3 y=3

Problema 1
real c.
a. Scrieţi ce se afişează ı̂n urma executării algoritmului dacă
se citeşte numărul 56. (6p.)
b. Scrieţi două numere din intervalul [10,99] care pot fi
citite, astfel ı̂ncât, pentru fiecare dintre acestea, ı̂n urma exe-
cutării algoritmului, să se afişeze valoarea 1. (6p.)
dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind adecvat a doua structură
cât timp...execută cu o structură repetitivă cu test final. (6p.)
Problema 2
Subprogramul f este definit alăturat. int f(int a,int b)
Scrieţi două valori din intervalul [2000,2025] pentru variabila { if(a<=b) return a;
return f(a-1,b+1);
ı̂ntreagă x, astfel ı̂ncât, pentru fiecare dintre acestea, f(2022,x) să aibă
}
valoarea 2022. (6p.)
Problema 3
Variabilele s şi id permit accesul la câte un şir de maximum 50 de caractere, şirul accesat prin
id fiind iniţial vid, iar cel accesat prin s memorând, ı̂n această ordine, separate printr-un spaţiu,
prenumele şi numele unei persoane, fiecare fiind format numai din litere ale alfabetului englez.
Scrieţi o secvenţă de instrucţiuni C/C++ astfel ı̂ncât, ı̂n urma executării acesteia, şirul accesat
prin id să memoreze numele persoanei menţionate, urmat de 2022.
Declaraţi corespunzător eventualele alte variabile utilizate.

Exemplu: dacă şirul accesat prin variabila s este Ana Popescu atunci şirul accesat prin
variabila id este Popescu2022 (6p.)

Problema 1
Subprogramul secventa are un singur parametru, n, prin care primeşte un număr natural (n "
9
10, 10 ) ı̂n care nu există secvenţe de mai mult de două cifre identice aflate pe poziţii consecutive.
Subprogramul ı̂nlocuieşte ı̂n n fiecare secvenţă 22 cu câte o secvenţă 20 şi furnizează, prin
acelaşi parametru, numărul obţinut.
Dacă nu se ı̂nlocuieşte nicio secvenţă, subprogramul furnizează numărul nemodificat.
Exemplu: dacă n=202233228, după apel n=202033208. (10p.)
Problema 2
Pentru prevenirea eroziunii la Marea Neagră, autorităţile au hotărât ı̂nnisiparea unei plaje. Plaja
a fost ı̂mpărţită ı̂n parcele de formă pătrată cu latura de 1 metru, dispuse ca elementele unui
tablou bidimensional, reţinându-se nivelul fiecărei parcele, măsurat ı̂n metri, de la nivelul mării.
Înnisiparea se realizează doar pe acele parcele care au nivelul strict mai mic decât al celei mai
joase dintre parcelele vecine cu ea, adăugând nisip, astfel ı̂ncât cele două să aibă acelaşi nivel.
Două parcele sunt vecine dacă au o latură comună.
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale din intervalul
2
2, 10 , m şi n, apoi elementele unui tablou bidimensional cu m linii şi n coloane, numere naturale
din intervalul [1,10], reprezentând nivelurile parcelelor, ı̂n ordinea dispunerii acestora pe plajă.
Programul afişează pe ecran cantitatea totală de nisip adăugată,
măsurată ı̂n metri cubi. Exemplu: pentru m=5, n=4 şi tabloul
alăturat, se vor ı̂nnisipa parcelele marcate, pentru a fi aduse la
nivelul parcelelor vecine corespunzătoare, şi se va afişa valoarea 7
(1+3+1+2).
Problema 3
9
Fişierul bac.txt conţine numere naturale din intervalul 1, 10 , astfel: pe prima linie două numere,
x şi y (x $ y), iar pe a doua linie un şir de cel mult 10 numere, ordonate crescător. Numerele
6
aflate pe aceeaşi linie a fişierului sunt separate prin câte un spaţiu.

Se cere să se afişeze pe ecran numărul de
valori distincte din şirul aflat pe a doua linie a
fişierului care aparţin intervalului [x,y]. Proiectaţi un algoritm eficient din punctul de vedere al
timpului de executare şi al memoriei utilizate.
Exemplu: dacă fişierul are conţinutul alăturat, pe ecran se afişează 6

Varianta 5
2.4.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg. Indicaţi o expresie care are valoarea 1 dacă şi
numai dacă expresia C/C++ alăturată are valoarea 1.
a. !(x<3 && x>=10) b. !(x<3 || x>=10)

c. x<3 && !(x>=10) d. !(x<3) || x>=10
Problema 2
Subprogramul f este definit incomplet, alăturat. Indicaţi
o expresie cu care pot fi ı̂nlocuite punctele de suspensie
pentru ca f(n,3) să aibă valoarea 1 pentru orice număr
prim n (n " 2, 10 ) şi valoarea 0 ı̂n caz contrar.
4
a. y+2 b. y-2 c. y*2 d. y/2
Problema 3
Utilizând metoda backtracking, se generează toate posibilităţile de a forma platouri de câte trei
fructe distincte din mulţimea {măr, gutuie, prună, caisă, piersică}, astfel ı̂ncât pe acelaşi platou
nu se află o gutuie şi o piersică simultan. Două platouri sunt distincte dacă ele conţin cel puţin
un fruct diferit.
Primele patru soluţii generate sunt, ı̂n această ordine, (măr, gutuie, prună), (măr, gutuie,
caisă), (măr, prună, caisă), (măr, prună, piersică).
Indicaţi soluţia generată imediat după (gutuie, prună, caisă).
a. (caisă, piersică, măr) b. (gutuie, prună, piersică)
c. (mar, caisă, piersică) d. (prună, caisă, piersică)
Problema 4
Variabila j este de tip ı̂ntreg, iar variabila A memorează un tablou bidimensional cu 100 de linii şi
100 de coloane, numerotate de la 0 la 99. Indicaţi valoarea variabilei j, dacă elementul A[20][j] se
află pe diagonala secundară a tabloului.
a. 20 b. 49 c. 79 d. 80
Problema 5
Un graf neorientat are 7 noduri, numerotate de la 1 la 7, şi 8 muchii, dintre care şase sunt: [1,2],
[2,4], [2,7], [3,4], [4,5], [4,6].
Ştiind că unul dintre lanţurile elementare care au lungimea maximă este 1, 2, 7, 5, 4, 6, indicaţi
care ar putea fi celelalte două muchii ale grafului.
a. [1,4] şi [4,7] b. [1,4] şi [5,7] c. [2,5] şi [4,7] d. [3,6] şi [5,7]

Problema 1
a. Scrieţi ce se afişează ı̂n urma executării algoritmului
dacă se citesc, ı̂n această ordine, valorile 21 şi 47. (6p.)
b. Dacă pentru variabila m se citeşte numărul 5, scrieţi
două valori care pot fi citite pentru variabila n astfel ı̂ncât,
ı̂n urma executării algoritmului, pentru fiecare dintre aces-
tea, valoarea afişată să fie 10. (6p.)
dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat,
ı̂nlocuind adecvat prima structură cât timp...execută cu
o structură repetitivă cu test final. (6p.)
Problema 2
Un arbore cu 9 noduri, numerotate de la 1 la 9, are muchiile [1,8], [2,3], [2,5], [2,7], [4,5], [5,6],
[5,8], [8,9]. Scrieţi două noduri care pot fi alese drept rădăcină, astfel ı̂ncât nodul 5 să aibă doi
”fraţi”. (6p.)
Problema 3
struct meteo
Variabila x, declarată alăturat, memorează simultan un an calendaristic
{ int an, temperatura;
şi temperatura medie a aerului, măsurată ı̂n grade Celsius, ı̂nregistrată } x;
ı̂n Bucureşti ı̂n anul respectiv.
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia să se afişeze pe ecran mesajul
o
CALDUROS dacă temperatura menţionată a fost strict mai mare decât 11 C, mesajul RACOROS
o
dacă temperatura menţionată a fost strict mai mică decât 10 C, sau mesajul NORMAL ı̂n orice
alt caz. (6p.)

Problema 1
Subprogramul schimb are trei parametri:
n şi x, prin care primeşte câte un număr natural (n " 0, 10 , x " 1, 9);
8
p, prin care primeşte un număr natural reprezentând poziţia unei cifre a numărului n (0 & p).
Poziţiile cifrelor sunt numerotate de la dreapta la stânga, astfel: cifra unităţilor este pe
poziţia 0, cifra zecilor este pe poziţia 1 ş.a.m.d.
Subprogramul transformă numărul n, ı̂nlocuind cifra de pe poziţia p cu cifra x, şi furnizează
numărul obţinut tot prin parametrul n. Scrieţi definiţia completă a subprogramului.
Exemplu: dacă n=12587, x=6 şi p=3, după apel, n=16587. (10p.)
Problema 2
Se consideră o vocală oarecare a alfabetului englez, notată cu v, şi o consoană oarecare a alfabetului
englez, notată cu c. Litera v se numeşte vocală prietenă a lui c dacă ı̂n şirul literelor alfabetului
englez, ordonat lexicografic, v ı̂l precede pe c, iar ı̂ntre v şi c nu există nicio vocală. Se consideră
vocale literele a, e, i, o, u.
Exemplu: e este vocală prietenă pentru consoanele f, g şi h, dar nu este vocală prietenă pentru
consoanele d şi j.
Un elev vrea să transmită unui prieten o parolă, codificată. Parola este formată dintr-un singur
cuvânt de cel mult 50 de caractere, litere mici ale alfabetului englez, cel puţin una fiind consoană.
Codificarea se face prin ı̂nlocuirea fiecărei consoane cu vocala sa prietenă, ca ı̂n exemplu.
Scrieţi un program C/C++ care citeşte de la tastatură un cuvânt, reprezentând o parolă de
tipul precizat şi determină, ı̂n memorie, forma codificată a acesteia. Programul afişează pe ecran
parola codificată obţinută.
Exemplu: pentru parola rame se afişează oaie, iar pentru parola sport se afişează ooooo (10p.)
Problema 3
Numim secvenţă paritară a unui şir de numere naturale un subşir al acestuia, format din
termeni cu aceeaşi paritate, aflaţi pe poziţii consecutive ı̂n şirul dat. Lungimea secvenţei este
egală cu numărul de termeni ai acesteia.
6
Fişierul bac.txt conţine un şir de cel puţin două şi cel mult 10 numere naturale din intervalul
9
0, 10 .
Numerele sunt separate prin câte un spaţiu, iar ı̂n şir există cel puţin doi termeni cu aceeaşi
paritate pe poziţii consecutive.
Se cere să se afişeze pe ecran numărul secvenţelor paritare de lungime maximă din şirul aflat
ı̂n fişier, precum şi această lungime maximă. Numerele afişate sunt separate printr-un spaţiu.
utilizate.
Exemplu: dacă fişierul conţine numerele
2 3 5 1 7 9 8 4 4 11 15 17 21 11 6 11 15 17 21 11 6 5 2 6 4 0 16
atunci pe ecran se afişează valorile 4 5
Capitolul 3
BAC 2021

Varianta 7
3.1.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi memorează un număr nenul. Indicaţi expresia C/C++ cu valoarea
1 dacă 2021 este divizor al lui x.
a. x/(x/2021)==0 b.x/(x%2021)==0 c.x%(x/2021)==0 d. x%(x\%2021)==0
Problema 2
Utilizând metoda backtracking se generează toate valorile naturale formate cu cifre ale numărului
2021 şi care sunt strict mai mici decât acesta. Primele 12 soluţii generate sunt, ı̂n această ordine,
0, 1, 10, 100, 1000, 1001, 1002, 101, 1010, 1011, 1012, 102. Indicaţi două soluţii care se generează
pe poziţii consecutive, ı̂n această ordine.
a. 2002, 2020 b. 2020, 21 c. 122, 1221 d. 21, 22
Problema 3 struct masina

Variabilele x şi y sunt declarate alăturat. { char model[51];
int an;
Indicaţi o instrucţiune de atribuire corectă din punctul de vedere }x[10],y;
sintactic.
a. x[1]=y; b. x.an[1]=y.an;
c. x[1].an.masina=y.an.masina; d. model.x[1]=model.y;
Problema 4
Un arbore cu 11 noduri, numerotate de la 1 la 11, este reprezentat prin vectorul de ”taţi”
(9,3,4,6,4,8,6,0,4,4,4). Indicaţi numărul de descendenţi direcţi (”fii”) ai nodului 4.
a. 2 b. 3 c. 5 d. 6
28
Problema 5
Indicaţi numărul de noduri ale unui graf neorientat, complet, cu 210 muchii.
a. 14 b. 15 c. 20 d. 21

Problema 1

numărul natural nenul b şi cu a b operaţia de interschimbare
a valorilor variabilelor a şi b.
a. Scrieţi succesiunea de caractere afişate ı̂n urma executării
algoritmului dacă se citesc, ı̂n această ordine, numerele 2 şi 9.
(6p.)
b. Dacă pentru n se citeşte numărul 79, scrieţi două numere
nenule care pot fi citite pentru m astfel ı̂ncât, ı̂n urma executării
algoritmului, pentru fiecare dintre acestea, să se afişeze de 40
de ori caracterul *. (6p.)
c. Scrieţi programul C/C++ corespunzător algoritmului dat, fără a utiliza eventuale funcţii pre-
definite pentru operaţia de interschimbare. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat, ı̂nlocuind structura cât timp...execută
cu o structură repetitivă cu test final. (6p.)
Problema 2
Subprogramul f este definit alăturat.
Scrieţi ce valori au f(2), respectiv f(21). (6p.)
Problema 3 strcpy(x,"bac2021");
Variabila i este de tip ı̂ntreg, iar variabila x permite cout<<x+3<<endl; | printf("\%s\n",x+3);
for(i=0;i<strlen(x);i++)
memorarea unui şir cu cel mult 100 de caractere.
if(strchr("0123456789",x[i])==0)
Scrieţi ce se afişează ı̂n urma executării secvenţei cout<<x[i]<<’!’; | printf("\%c! ",x[i]);
alăturate. (6p.)

Problema 1
Două numere se numesc oglindite dacă fiecare se obţine din celălalt, prin parcurgerea cifrelor aces-
tuia de la dreapta la stânga. Două numere se numesc impar-oglindite dacă numerele obţinute
din acestea, prin ı̂ndepărtarea tuturor cifrelor lor pare, sunt oglindite.
Subprogramul imog are trei parametri:
9
a x şi y, prin care primeşte câte un număr natural din intervalul [0,10 ];
a rez, prin care furnizează valoarea 1 dacă x şi y sunt impar-oglindite sau valoarea 0 ı̂n caz
contrar.
Exemplu: dacă x=523 şi y=84356, după apel rez=1,
iar dacă x=523 şi y=84536 sau x=523 şi y=84576 sau x=40 şi y=86, după apel rez=0. (10p.)
Problema 2
Scrieţi un program C/C++ care citeşte de la tastatură numere naturale: n (n"[2,20]), k (k"[2,n])
9
şi n n numere din intervalul [0,10 ], elemente ale unui tablou bidimensional cu n linii şi n coloane.
Programul transformă tabloul ı̂n memorie, interschimbând şirul elementelor situate pe linia a k-a,
ı̂n stânga diagonalei principale, parcurse de la stânga la dreapta, cu şirul elementelor situate pe
coloana a k-a, deasupra diagonalei principale, parcurse de sus ı̂n jos, ca ı̂n exemplu. Elementele
tabloului obţinut sunt afişate pe ecran, fiecare linie pe câte o linie a ecranului, cu elementele
fiecărei linii separate prin câte un spaţiu.
Problema 3
Se consideră şirul 1, 3, 7, 13, 21, 31, 43 ... definit astfel: f0 1, iar fn fn1 2 n, dacă n ' 1
(unde n este un număr natural).
Se citesc de la tastatură două numere naturale din intervalul [1,10 ], x şi y (x $ y), reprezentând
9
doi termeni aflaţi pe poziţii consecutive ı̂n şirul dat, şi se cere să se scrie ı̂n fişierul text bac.out,
separaţi prin câte un spaţiu, toţi termenii şirului mai mici sau egali cu y, ı̂n ordine inversă a
apariţiei lor ı̂n şir.
Proiectaţi un algoritm eficient din punctul de vedere al spaţiului de memorie şi al timpului de
executare.
Exemplu: dacă x 21 şi y 31, fişierul conţine valorile
31 21 13 7 3 1

Varianta 1
3.2.1 Subiectul I
Problema 1
Indicaţi o expresie C/C++ care are valoarea 1 dacă şi numai dacă valorile variabilelor ı̂ntregi x şi
y sunt numere pare.
a. x%2==0 && (y+1)%2!=0 b. (x-y)/2==0

c. (x+y)%2==0 && (x-y)%2==0 d. x%2==y%2
Problema 2 int f(int n,int c)

{ if(n==0) return 0;
Subprogramul f este definit alăturat. Indicaţi valorile else
pe care le pot avea parametrii n şi c, astfel ı̂ncât, ı̂n if(n%10==c) return f(n/10,c);
urma apelului, f(n,c) să aibă valoarea 2021. else return n%10+10*f(n/10,c);
}
a. n=2021 \c si c=0 b. n=200211 \c si c=2
c. n=312032 \c si c=3 d. n=720721 \c si c=7
Problema 3
Variabila m memorează elementele unui tablou bidimensional cu 100 de linii şi 100 de coloane,
numerotate de la 0 la 99. Indicaţi expresia C/C++ prin care poate fi accesat un element aflat pe
diagonala secundară a tabloului.
a. m[42/42] b. m[42|42] c. m[42]:[57] d. m[42][57]
Problema 4
Un graf neorientat are 6 noduri, numerotate de la 1 la 6, şi muchiile [1,2], [1,3], [2,3], [3,4], [3,5],
[4,5], [5,6]. Indicaţi un ciclu elementar al acestui graf.
a. 1,2,3 b. 1,2,3,1 c. 1,2,3,4,5,3,1 d. 1,2,3,4,5,6,1
Problema 5
ı̂n nodul respectiv şi cealaltă extremitate ı̂n rădăcina arborelui are lungimea x. Pe nivelul 0 se
Într-un arbore cu rădăcină toate nodurile de pe acelaşi nivel au un număr egal de ”fii” şi nu
există două niveluri diferite cu acelaşi număr de noduri. Indicaţi numărul minim de noduri de pe
nivelul 3.
a. 12 b. 9 c. 8 d. 5

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseudocod. S-a notat
cu a b operaţia de interschimbare a valorilor variabilelor a şi
b.
a. Scrieţi ce se afişează ı̂n urma executării algoritmului dacă
se citesc, ı̂n această ordine, numerele 8 şi 5. (6p.)
b. Dacă pentru variabila x se citeşte valoarea 10, scrieţi
două numere care pot fi citite pentru variabila y, astfel ı̂ncât,
ı̂n urma executării algoritmului, pentru fiecare dintre acestea,
cifra 2 să fie afişată doar de trei ori. (6p.)
dat, fără a utiliza eventuale subprograme predefinite pentru in-
terschimbare. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat, ı̂nlocuind structura pentru...execută
cu o structură repetitivă cu test iniţial. (6p.)
Problema 2
Utilizând metoda bactracking se generează toate grupurile de cel puţin două păsări cântătoare din
mulţimea cinteză, ciocârlie, mierlă, privighetoare, scatiu, astfel ı̂ncât mierla şi privighetoarea să
nu fie ı̂n acelaşi grup. Două grupuri diferă prin cel puţin o pasăre. Primele patru soluţii generate
sunt, ı̂n această ordine: (cinteză, ciocârlie), (cinteză, ciocârlie, mierlă), (cinteză, ciocârlie, mierlă,
scatiu), (cinteză, ciocârlie, privighetoare). Scrieţi următoarele două soluţii generate imediat după
(ciocârlie, privighetoare, scatiu). (6p.)
Problema 3 struct fractie

În declararea alăturată, variabilele f şi fs memorează ı̂n câmpurile a şi {
int a,b;
b numărătorul, respectiv numitorul câte unei fracţii. Fără a utiliza alte
} f,fs;
variabile, scrieţi o secvenţă de instrucţiuni care să memoreze ı̂n variabila
2020
fs fracţia obţinută prin scăderea din fracţia 2021 a fracţiei memorate ı̂n variabila f. (6p.)

Problema 1
Subprogramul divPrim are doi parametri:
a n, prin care primeşte un număr natural (n " 2, 10 );
9
a s, prin care furnizează suma divizorilor primi ai lui n care apar la o putere impară ı̂n
descompunerea ı̂n factori primi a acestuia.
Exemple: pentru n 360, după apel s 7 (360 23 32 51, deci s 2 5),
iar pentru n 16, după apel s 0. (10p.)
Problema 2
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale n şi k, apoi n
cuvinte, separate prin ¡Enter¿. Fiecare cuvânt este format din cel mult 10 caractere, numai litere
mici ale alfabetului englez, iar numerele citite sunt din intervalul [1,20]. 5 2
Programul afişează pe ecran, pe linii separate, primele k cuvinte dintre cele citite norii
cumulus
pentru care ultima literă este o vocală, sau doar mesajul nu exista dacă nu există k
pluteau
astfel de cuvinte. Se consideră vocale literele a, e, i, o, u. pe
Exemplu: dacă se citesc datele alăturate, se afişează pe ecran: cer
norii
pluteau (10p.)
Problema 3
Numărul natural a se numeşte sufix al numărului natural b dacă a este egal cu b sau dacă b se
poate obţine din a prin alipirea la stânga a unor noi cifre.
Fişierul bac.txt conţine pe prima linie un număr natural x (x " 100, 999), iar pe a doua
5 9
linie un şir de cel mult 10 numere naturale din intervalul 0, 10 . Numerele din şir sunt separate
Se cere să se afişeze pe ecran ultimii doi termeni ai şirului, aflaţi pe poziţii consecutive ı̂n
acesta, care ı̂l au drept sufix pe numărul x. Numerele sunt afişate ı̂n ordinea ı̂n care apar ı̂n şir,
separate printr-un spaţiu, iar dacă nu există doi astfel de termeni, se afişează pe ecran mesajul nu
exista. Proiectaţi un algoritm eficient din punctul de vedere al memoriei utilizate şi al timpului
de executare.
Exemplu: dacă fişierul conţine 210
numerele alăturate, atunci pe 3445 210 893210 1245 1210 3210 15210 67120 20210 12
ecran se afişează 3210 15210

Varianta 4
3.3.1 Subiectul I
Problema 1
Variabilele x şi y sunt de tip real (x j 2).
Indicaţi o expresie C/C++ corespunzătoare expresiei aritmetice alăturate.
a. (x+y/5+x-y/2)/x+2 b. (x+y)/5+(x-y)/2/(x+2)
c. ((x+y)/5+(x-y)/2)/x+2 d. ((x+y)/5+(x-y)/2)/(x+2)
Problema 2 int f(int n)

Subprogramul f este definit alăturat. { if (n!=0)
return (n%2)*(n%10)+f(n/10);
Indicaţi valoarea lui f(1234). return 0;
}
a. 0 b. 4 c. 6 d. 10
Problema 3
Utilizând metoda backtracking se generează toate numerele formate din cifre distincte, cifre a
căror sumă să fie 6.
Primele patru soluţii generate sunt, ı̂n această ordine: 1023, 1032, 105 şi 1203.
Indicaţi cea de a şasea soluţie generată.
a. 1230 b. 132 c. 123 d. 15
Problema 4
Unui arbore cu 10 noduri i se adaugă o muchie, cu extremităţile ı̂n două dintre nodurile sale.
Indicaţi numărul ciclurilor elementare pe care le conţine graful obţinut.
a. 0 b. 1 c. 9 d. 10
Problema 5
Un graf neorientat are 21 de noduri, numerotate de la 1 la 21; pentru oricare două noduri distincte
ale sale, numerotate cu i, respectiv cu j, există muchia [i,j] dacă şi numai dacă ultima cifră a lui i
este egală cu ultima cifră a lui j.
Indicaţi numărul valorilor nule din matricea de adiacenţă a grafului.
a. 2*21-10*10 b. 21*21-11 c. 21*21-2*12 d. 2*21*21-13

Problema 1
a. Scrieţi ce se afişează ı̂n urma executării algorit-
mului dacă se citesc, ı̂n această ordine, numerele 15,
3, 4. (6p.)
b. Scrieţi două seturi distincte de date de intrare,
astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
fiecare dintre acestea să se afişeze valoarea 0. (6p.)
c. Scrieţi programul C/C++ corespunzător algorit-
mului dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat, ı̂nlocuind structura pentru...execută
Problema 2
Variabila s poate memora un şir de cel mult 20 strcpy(s,"ROMANIA");
i=strlen(s)-1;
de caractere, variabila aux este de tip char, iar
for(j=3;j>=0;j--)
celelalte variabile sunt de tip ı̂ntreg.
{ aux=s[i]; s[i]=s[i-j]; s[i-j]=aux;
Scrieţi şirul memorat prin intermediul vari- i=i-j;
abilei s ı̂n urma executării secvenţei alăturate. }
(6p.)
Problema 3 struct date

Variabila a memorează datele personale ale fiecăruia dintre cei 30 de { char CNP[14];
int anNastere;
angajaţi (codul numeric personal - CNP, anul naşterii) şi venitul lunar
};
al acestuia. struct angajat
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia pentru { struct date dp;
primul angajat să se iniţializeze anul naşterii cu valoarea 2000, iar ven- int venit;
itul cu valoarea 4000. (6p.) } a[30];

Problema 1
3
Un număr natural n se numeşte cub perfect dacă există un număr natural b, astfel ı̂ncât n b .
Subprogramul cuburi are un singur parametru, n, prin care primeşte un număr natural (n "
3
1, 10 ). Subprogramul afişează pe ecran, separate prin câte un spaţiu, ı̂n ordine descrescătoare,
primele n cuburi perfecte nenule.
Exemplu: dacă n 5 atunci, după apel, se afişează pe ecran numerele
125 64 27 8 1 (10p.)
Problema 2
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale din intervalul
2
2, 10 , k şi n, şi construieşte ı̂n memorie un tablou bidimensional cu n linii şi n coloane, astfel
ı̂ncât parcurgând diagonala principală, de sus ı̂n jos, să se obţină un şir strict crescător format din
primii n multipli naturali nenuli ai lui k şi parcurgând fiecare linie a sa, de la stânga la dreapta,
să se obţină câte un şir strict crescător de numere naturale consecutive.
Programul afişează pe ecran tabloul obţinut, fiecare linie a tabloului pe câte o linie a ecranului,
elementele de pe aceeaşi linie fiind separate prin câte un spaţiu.
Exemplu: pentru k 3 şi n 4 se obţine tabloul de mai jos
(10p.)
Problema 3
Numim pereche asemenea x, y două numere naturale cu cel puţin două cifre, x şi y, cu
proprietatea că ultimele două cifre ale lui x sunt egale cu ultimele două cifre ale lui y, dispuse
eventual ı̂n altă ordine.
5
Fişierul numere.in conţine numere naturale din intervalul 10, 10 : pe prima linie două
numere na şi nb, pe a doua linie un şir A de na numere, iar pe a treia linie un şir B de nb numere.
Numerele aflate pe aceeaşi linie a fişierului sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran numărul de perechi asemenea x, y , cu proprietatea că x este un
termen al şirului A, iar y este un termen al şirului B.
Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare.

Capitolul 4
BAC 2020

Varianta 6
a Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu.
a Timpul de lucru efectiv este de 3 ore.
a În grafurile din cerinţe oricare arc/muchie are extremităţi distincte şi oricare două arce/-
4.1.1 Subiectul I
Problema 1
Indicaţi valoarea expresiei C/C++ alăturate. 3+5.0/2+2
a. 2 b. 5 c. 6 d. 7.5
Problema 2 void f(int i, int v[4])

Variabila v memorează un tablou unidimensional cu 4 elemente, { if(i>=3) v[i]=v[i]+1;
else f(i+1,v);
numerotate ı̂ncepând de la 0. Subprogramul f este definit alăturat.
cout<<v[i];
Indicaţi setul de elemente pe care le poate avea tabloul memorat }
ı̂n v, ı̂n ordinea ı̂n care apar ı̂n acesta, astfel ı̂ncât, ı̂n urma apelului de mai jos, să se afişeze pe
ecran 2020.
f(0,v);
a. -1,1,0,2 b. 0,2,0,1 c. 1,-1,0,1 d. 2,0,1,0
Problema 3
Utilizând metoda backtracking se generează toate variantele prin care patru persoane pot plăti o
consumaţie totală de 200 de lei ı̂n următoarele condiţii:
a fiecare plăteşte o sumă nenulă, divizibilă cu 10;
a primul plăteşte mai mult decât al doilea, al doilea mai mult decât al treilea, iar acesta mai
mult decât al patrulea.
O soluţie constă ı̂n patru valori, reprezentând, ı̂n ordine, sumele plătite de fiecare dintre cele
patru persoane. Primele patru soluţii generate sunt, ı̂n această ordine: (70, 60, 40, 30), (70, 60,
50, 20), (80, 50, 40, 30), (80, 60, 40, 20). Indicaţi cea de a şasea soluţie, ı̂n ordinea generării
acestora.
a. (80,60,45,15) b. (80,60,50,10) c. (80,70,30,20) d. (80,70,40,10)
36
Problema 4
(7,5,6,5,7,0,6,3,3,8). Indicaţi numărul de noduri ”frunză” ale acestui arbore.
a. 2 b. 3 c. 5 d. 6
Problema 5 0 1 0 1 1
1 0 1 0 0
Un graf neorientat cu 5 noduri este reprezentat prin matricea de adiacenţă alăturată.
0 1 0 1 0
Indicaţi numărul grafurilor parţiale conexe ale acestuia care sunt diferite de graful 1 0 1 0 0
dat. 1 0 0 0 0
a. 4 b. 6 c. 8 d. 30

Problema 1
real c.
a. Scrieţi valorile afişate dacă se citeşte numărul 240107.
(6p.)
b. Scrieţi cel mai mic şi cel mai mare număr din intervalul
5 6
10 , 10 , cu cifre distincte, care pot fi citite astfel ı̂ncât, pentru
fiecare dintre acestea, ı̂n urma executării algoritmului, toate
valorile afişate să fie nenule. (6p.)
dat. (10p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat,
ı̂nlocuind adecvat a doua structură repetă...până când cu o structură repetitivă de alt tip.
(6p.)
Problema 2
Variabila c memorează, pentru un calculator, capacitatea memoriei (interne şi externe), măsurată
ı̂n GB, şi o literă, corespunzătoare tipului monitorului acestuia. ştiind că expresiile C/C++ de
mai jos au ca valori litera corespunzătoare tipul monitorului şi două numere naturale din inter-
6
valul 1, 10 , reprezentând capacitatea memoriei interne, respectiv capacitatea memoriei externe
a calculatorului, scrieţi definiţia unei structuri cu eticheta calculator, care permite memorarea
datelor despre un calculator, şi declaraţi corespunzător variabila c.
c.monitor c.memorie.interna c.memorie.externa (6p.)
Problema 3
Variabilele i şi j sunt de tip ı̂ntreg, iar variabila a memorează un
tablou bidimensional cu 9 linii şi 9 coloane, numerotate de la 0 la
8, având iniţial toate elementele egale cu simbolul egal (=). Scrieţi
secvenţa de mai jos, ı̂nlocuind punctele de suspensie, astfel ı̂ncât,
ı̂n urma executării secvenţei obţinute, variabila a să memoreze
tabloul alăturat.
for(i=0;i<9;i++)
for(j=0;j<9;j++)
.................. (6p.)

Problema 1
Subprogramul suma are doi parametri, a şi b, prin care primeşte câte un număr natural din
4
intervalul 1, 10 . Subprogramul returnează suma divizorilor naturali comuni lui a şi b.
Exemplu: dacă a=20 şi b=12, atunci subprogramul returnează valoarea 7 (1+2+4=7). (10p.)
Problema 2
Numim rotire spre stânga a unui cuvânt format din cel puţin trei litere operaţia prin care prima
sa literă se mută la final, iar toate celelalte litere se mută cu o poziţie spre stânga.
Exemplu: ı̂n urma rotirii spre stânga a cuvântului ilumina se obţine cuvântul luminai.
Un text are cel mult 100 de caractere, iar cuvintele sale sunt formate din litere mici ale
alfabetului englez şi sunt separate prin câte un spaţiu. Scrieţi un program C/C++ care citeşte
de la tastatură un text de tipul menţionat mai sus şi ı̂l transformă ı̂n memorie prin rotirea spre
stânga a fiecărui cuvânt al său format din cel puţin trei litere, ca ı̂n exemplu. Programul afişează
pe ecran textul obţinut sau mesajul nu exista, dacă ı̂n text nu există niciun cuvânt de cel puţin
trei litere.
Exemplu: pentru textul: un palc mic de scolarite ilumina sala
se afişează pe ecran: un alcp icm de colarites luminai alas (10p.)
Problema 3
Un şir finit se numeşte palindromic dacă parcurgându-l termen cu termen, de la stânga la dreapta
sau de la dreapta la stânga se obţine acelaşi şir de valori.
Exemplu: şirul 12, 13, 16, 13, 12 este palindromic.
6 3
Fişierul bac.in conţine un şir de cel mult 10 numere naturale din intervalul 1, 10 , separate
prin câte un spaţiu. Se cere să se afişeze pe ecran mesajul DA, dacă numerele din şir pot fi
rearanjate, astfel ı̂ncât să formeze un şir palindromic, sau mesajul NU ı̂n caz contrar. Proiectaţi
un algoritm eficient din punctul de vedere al timpului de executare.
Exemplu: dacă fişierul conţine numerele 100 30 100 30 500 30 30 se afişează pe ecran DA

Varianta 2
4.2.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi poate memora un număr din intervalul [1000,2000].
(x-999)%1000
Indicaţi valoarea minimă pe care o poate avea expresia C/C++ alăturată.
a. 0 b. 2 c. 999 d. 1000
Problema 2 void f(int x)

{ if(x>=2)
Subprogramul f este definit alăturat. { if(x%2==0) cout<<0;
Indicaţi ce se afişează ı̂n urma apelului de mai jos. f(x/2);
}
f(9); else cout<<7;
cout<<x;
a. 91 b. 942 c. 0071 d. 0071249 }
Problema 3
Utilizând metoda backtracking, se generează toate meniurile care cuprind câte patru feluri dis-
tincte de mâncare din mulţimea {aperitiv, desert, legume, paste, salată, supă}, fiecare
meniu respectând următoarele condiţii:
a dacă există aperitiv, este servit primul;
a dacă există desert, este servit ultimul;
a NU sunt servite legume şi salată ı̂n acelaşi meniu;
a dacă există paste şi supă ı̂n acelaşi meniu, pastele NU sunt servite ı̂nainte de supă.
Două meniuri sunt distincte dacă diferă prin cel puţin un fel de mâncare sau prin ordinea
servirii acestora. Primele cinci meniuri generate sunt, ı̂n această ordine: (aperitiv, legume,
paste, desert), (aperitiv, legume, supă, desert), (aperitiv, legume, supă,
paste), (aperitiv, paste, legume, desert), (aperitiv, paste, salată, desert).
Indicaţi al şaselea meniu generat.
a. (aperitiv, salată, paste, desert) b. (aperitiv, salată, supă, desert)
c. (aperitiv, salată, supă, paste) d. (aperitiv, supă, legume, desert)
Problema 4
Un graf orientat cu 5 vârfuri, numerotate de la 1 la 5, este reprezentat alăturat.
Indicaţi numărul de componente tare conexe ale grafului.
a. 1 b. 2 c. 3 d. 4
Problema 5
Un arbore cu rădăcină are 20 de noduri, dintre care 10 noduri de tip ”frunză”. Indicaţi numărul
maxim de noduri care au acelaşi ”tată” ı̂n acest arbore.
a. 5 b. 7 c. 10 d. 15

Problema 1
S-a notat cu a%b restul ı̂mpărţirii numărului natural a
numărului real c.
a. Scrieţi ce se afişează dacă se citesc, ı̂n această
ordine, numerele 5, 127, 2019, 1005, 7, 1900. (6p.)
b. Dacă primul număr citit este 2, scrieţi un set
3 4
de numere distincte din intervalul 10 , 10 care pot fi
citite ı̂n continuare astfel ı̂ncât, ı̂n urma executării algo-
ritmului, să se afişeze mesajul niciunul. (6p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat, ı̂nlocuind adecvat structura pen-
tru...execută cu o structură repetitivă de alt tip. (6p.)
Problema 2
Variabila c memorează date specifice unui cerc: coordonatele reale (abscisa şi ordonata), ı̂n planul
xOy, ale centrului cercului, precum şi lungimea razei acestuia. ştiind că expresiile C/C++ de
mai jos au ca valori numere reale reprezentând datele specifice ale unui cerc, scrieţi definiţia unei
structuri cu eticheta figura, care permite memorarea datelor precizate, şi declaraţi corespunzător
variabila c.
c.centru.x c.centru.y c.raza (6p.)
Problema 3
a b c d e f g
Variabilele i şi j sunt de tip ı̂ntreg, iar variabila m memorează un tablou bidi- + a b c d e f
mensional cu 7 linii şi 7 coloane, numerotate de la 0 la 6, cu elemente de tip char. + + a b c d e
Iniţial, fiecare element memorează caracterul *. Fără a utiliza alte variabile, + + + a b c d
scrieţi secvenţa de instrucţiuni de mai jos, ı̂nlocuind punctele de suspensie astfel + + + + a b c
ı̂ncât, ı̂n urma executării secvenţei obţinute, variabila m să memoreze tabloul + + + + + a b
alăturat. + + + + + + a
for(i=0;i<7;i++)
for(j=0;j<7;j++)
.................. (6p.)

Problema 1
Subprogramul multiplu are un singur parametru, n, prin care primeşte un număr natural (n "
4
1, 10 ). Subprogramul returnează cel mai mic multiplu nenul al lui n cu proprietatea că este
pătrat perfect. Scrieţi definiţia completă a subprogramului.
Exemplu: dacă n 72 sau n 144, subprogramul returnează numărul 144 (144=122). (10p.)
Problema 2
Numim citat ı̂ntr-un text o secvenţă de caractere din acel text care ı̂ncepe cu un caracter ¡ şi se
termină cu un caracter ¿, celelalte caractere ale secvenţei fiind diferite de ¡ şi ¿.
Un text de cel mult 100 de caractere (litere mici ale alfabetului englez, spaţii şi caracterele ¡
şi ¿) conţine cel puţin un citat. Textul nu conţine alte caractere ¡ şi ¿ decât cele care mărginesc
citatele, şi oricare două citate nu au nici caractere ¡ şi ¿ şi nici alte caractere ı̂n comun.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul precizat şi ı̂l transformă
ı̂n memorie prin ı̂nlocuirea tuturor literelor mici cuprinse ı̂n citate cu literele mari corespunzătoare,
celelalte rămânând nemodificate, ca ı̂n exemplu. Programul afişează pe ecran textul obţinut.
Exemplu: pentru textul
mai bine sa fii un <om de valoare> decat un <om de succes>
se afişează mai bine sa fii un <OM DE VALOARE> decat un <OM DE SUCCES> (10p.)
Problema 3
Se numeşte vârf ı̂ntr-un şir de numere naturale un termen al şirului care este strict mai mare decât
fiecare dintre cei doi termeni vecini cu el, aflaţi ı̂n şir pe poziţia din stânga, respectiv din dreapta
sa.
6 9
prin câte un spaţiu. Se cere să se afişeze pe ecran vârful din şirul aflat ı̂n fişier pentru care
valoarea absolută a diferenţei dintre cei doi vecini ai săi este minimă. Dacă există mai multe astfel
de numere, se afişează cel mai mare dintre ele, iar dacă nu există niciun vârf, se afişează pe ecran
mesajul nu exista. Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare
şi al spaţiului de memorie utilizat.
Exemplu: dacă fişierul conţine şirul 2 7 10 5 6 2 1 3 20 17 9 11 7 3 10 6 2
se afişează pe ecran 11

Varianta 5
4.3.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi poate memora un număr natural din intervalul x%2020
9
0, 10 . Indicaţi valoarea maximă pe care o poate avea expresia C/C++ alăturată.
a. 20.2 b. 2019 c. 2020 d. 495049
Problema 2
void f(int x)
Subprogramul f este definit alăturat. {
Indicaţi apelul ı̂n urma căruia simbolul * se afişează de trei ori. cout<<"*";
if(x>5) f((x+1)/2);
a. f(30); b. f(21); c. f(17); d. f(8); }
Problema 3
Utilizând metoda backtracking se generează toate modalităţile de a prepara o băutură din câte
3 sau 4 tipuri de fructe distincte din mulţimea {căpşune, mere, pepene, pere, portocale}.
Primele patru soluţii generate sunt, ı̂n această ordine: (căpşune, mere, pepene), (căpşune,
mere, pepene, pere), (căpşune, mere, pepene, portocale), (căpşune, mere, pere).
Indicaţi cea de a şasea soluţie generată.
a. (pepene, pere, portocale) b. (mere, pepene, pere, portocale)
c. (căpşune, mere, portocale) d. (căpşune, mere, pere, pepene)
Problema 4
(8,6,4,2,3,0,4,2,7). Indicaţi un ”frate” al nodului 4.
a. 1 b. 2 c. 7 d. 8
Problema 5
Un graf neorientat eulerian cu 5 noduri are un nod cu gradul 4. Indicaţi numărul minim de muchii
ale grafului.
a. 4 b. 6 c. 8 d. 10

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseudocod. S-
a notat cu a%b restul ı̂mpărţirii numărului natural a
numărului real c.
a. Scrieţi ce se afişează dacă se citeşte numărul
247388. (6p.)
b. Scrieţi două numere din intervalul [102,103), cu
cifre distincte, care pot fi citite astfel ı̂ncât, pentru fiecare
dintre acestea, ı̂n urma executării algoritmului, să se
afişeze DA. (6p.)
d. Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat, ı̂nlocuind adecvat structura
repetă...până când cu o structură repetitivă cu test iniţial. (6p.)
Problema 2
Variabila p memorează simultan, pentru fiecare dintre cele 20 de tipuri de procesoare dintr-un
depozit, următoarele date: producătorul (o literă mare a alfabetului englez), frecvenţa procesorului
(număr natural) şi preţul produsului (număr real). Ştiind că expresiile C/C++ de mai jos au ca
valori producătorul primului procesor, respectiv frecvenţa şi preţul acestuia, scrieţi definiţia unei
structuri cu eticheta procesor, care permite memorarea datelor despre un procesor, şi declaraţi
corespunzător variabila p.
p[0].producator p[0].frecventa p[0].pret (6p.)
Problema 3
Variabilele i, j şi k sunt de tip ı̂ntreg, iar variabila a memorează un tablou bidimensional cu 6 linii
şi 4 coloane, numerotate ı̂ncepând de la 0, cu elemente numere naturale din intervalul [0,50].
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia să se rearanjeze elementele pare
situate pe coloana a 3-a a tabloului, astfel ı̂ncât acestea să fie ordonate crescător, de sus ı̂n jos, ı̂n
cadrul aceleiaşi coloane, iar celelalte elemente ale tabloului să ı̂şi păstreze poziţiile, ca ı̂n exemplu.

Problema 1
Un număr natural nenul se numeşte p-număr dacă are aceeaşi paritate cu suma divizorilor săi
pozitivi. Exemplu: 10 şi 25 sunt p-numere (10 are aceeaşi paritate cu 18=1+2+5+10, iar 25 are
aceeaşi paritate cu 31=1+5+25).
Subprogramul kpn, are trei parametri, a, b şi k, prin care primeşte câte un număr natural din
intervalul 1, 10 (a & b). Subprogramul returnează cel de al k-lea p-număr din intervalul [a,b]
6
sau -1, dacă nu există cel puţin k astfel de numere ı̂n acest interval.
Exemplu: dacă a=27, b=50 şi k=3, atunci subprogramul returnează 34. (10p.)
Problema 2
Două cuvinte distincte se numesc ı̂n oglindă dacă fiecare dintre ele se obţine prin citirea literelor
celuilalt de la dreapta la stânga.
Exemplu: animate şi etamina sunt ı̂n oglindă, iar pentru cuvântul reper nu există un cuvânt
cu care să fie ı̂n oglindă.
Se consideră un text cu cel mult 100 de caractere, ı̂n care cuvintele sunt formate din litere mici
ale alfabetului englez şi sunt separate prin câte un spaţiu. Scrieţi un program C/C++ care citeşte
de la tastatură un text de tipul menţionat mai sus şi ı̂l transformă ı̂n memorie, ı̂nlocuind fiecare
cuvânt cu număr impar de litere cu acel cuvânt cu care el este ı̂n oglindă, dacă acesta există, ca
ı̂n exemplu.
Programul afişează pe ecran textul obţinut sau mesajul nu exista, dacă ı̂n text nu s-a ı̂nlocuit
niciun cuvânt.
Exemplu:
pentru textul: era o selectie reper de desene animate prezenta
se obţine textul: are o selectie reper de desene etamina prezenta
iar pentru textul: un reper pentru desene
se afişează pe ecran mesajul: nu exista (10p.)
Problema 3
6 9
Fişierul bac.txt conţine un şir de cel mult 10 numere naturale din intervalul 0, 10 , separate
Se cere să se afişeze pe ecran, separate printr-un spaţiu, două numere naturale a şi b (a $ b),
astfel ı̂ncât oricare termen al şirului care are exact două cifre să aparţină intervalului a, b, iar
valoarea expresiei b a să fie minimă. Dacă şirul nu are niciun termen de două cifre, pe ecran se
afişează mesajul nu exista. Proiectaţi un algoritm eficient din punctul de vedere al timpului de
executare şi al spaţiului de memorie utilizat.
Exemplu: dacă fişierul conţine valorile 7 2 40 5 11 15 10 122 18 350
se afişează pe ecran numerele 9 41.
Capitolul 5
BAC 2019

Varianta 1
5.1.1 Subiectul I
Problema 1
|
Variabilele x şi y sunt ı̂ntregi. Indicaţi expresia C/C++ echivalentă cu cea | (x<3)&&(y>=5)
alăturată. |
a. !((x<3)||(y>=5)) b. !(x>=3)&&(y<5)
c. !(!(x<3)||!(y>=5)) d. !((x>=3)&&(y<5))
Problema 2
Subprogramul f este incomplet definit alăturat. | void f(int m, int n, int d)
| { if(n%d==0 && m%d==0)
Indicaţi expresia cu care pot fi ı̂nlocuite punctele de
| cout<<d; | printf("%d",d);
suspensie, astfel ı̂ncât, ı̂n urma apelului de mai jos, să se | else f(.........);
afişeze cel mai mare divizor comun al numerelor nenule | }
memorate ı̂n variabilele ı̂ntregi x şi y.
a. m,n,d+1 b. m,n,d-1 c. m+1,n+1,d d. m-1,n-1,d
Problema 3
Utilizând metoda backtracking, se generează toate băuturile obţinute amestecând sucurile a cel
puţin două fructe distincte din mulţimea {afine, caise, lămâi, mere, pere}.
Primele cinci soluţii obţinute sunt, ı̂n această ordine:
(afine, caise), (afine, caise, lămâi), (afine, caise, lămâi, mere),
(afine, caise, lămâi, mere, pere) şi (afine, caise, lămâi, pere).
A şasea soluţie este:
a. (afine, caise, mere) b. (afine, caise, mere, pere)
c. (afine, mere, pere) d. (afine, lămâi, mere, pere)
44
Problema 4
Indicaţi un lanţ elementar ı̂n graful neorientat cu 5 noduri, numerotate
de la 1 la 5, reprezentat alăturat.
a. 1,2,3,1 b. 1,2,3,4 c. 1,2,3,4,5 d. 1,3,2,1,5
Problema 5
Indicaţi valorile ce pot reprezenta numărul de fii ai fiecăruia dintre cele şase noduri ale unui arbore
cu rădăcină.
a. 0,0,0,1,2,3 b. 0,0,0,0,2,3 c. 0,0,0,3,3,3 d. 1,1,1,1,1,1

Problema 1
real c.
a) Scrieţi valoarea afişată dacă se citesc, ı̂n această ordine,
numerele 10 şi 3. (6p.)
b) Dacă pentru k se citeşte numărul 5, scrieţi trei numere
care pot fi citite pentru n astfel ı̂ncât, ı̂n urma exe-
cutării algoritmului, pentru fiecare dintre acestea, val-
oarea afişată să fie 10. (6p.)
c) Scrieţi programul C/C++ corespunzător algoritmului dat. (10p.)
d) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂nlocuind prima structură cât
timp...execută cu o structură de tip pentru...execută. (6p.)
Problema 2
Variabila e, declarată alăturat, memorează informaţii despre un
eveniment din anul 2019 (numărul de ordine şi data desfăşurării
sale), iar variabila d memorează o dată calendaristică din acelaşi
an. Scrieţi o expresie care are valoarea 1 dacă şi numai dacă data
memorată ı̂n variabila d este anterioară datei desfăşurării eveni-
mentului corespunzător variabilei e. (6p.)
Problema 3
Variabilele i şi j sunt de tip ı̂ntreg, iar variabila a memorează un tablou bidi-
mensional cu 5 linii şi 5 coloane, numerotate de la 1 la 5, având iniţial toate
elementele nule. Fără a utiliza alte variabile decât cele menţionate, scrieţi
secvenţa de instrucţiuni de mai jos, ı̂nlocuind punctele de suspensie astfel ı̂ncât,
ı̂n urma executării secvenţei obţinute, variabila a să memoreze tabloul alăturat.
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
.................. (6p.)

Problema 1
Subprogramul Egal are un parametru, n, prin care primeşte un număr natural cu cel puţin o cifră
impară (n " 10, 10 ). Subprogramul returnează valoarea 1 dacă toate cifrele impare ale lui n
9
sunt egale ı̂ntre ele sau valoarea 0 ı̂n caz contrar. Scrieţi definiţia completă a subprogramului.
Exemplu: dacă n=7727470 sau n=7240 atunci subprogramul returnează 1, iar dacă
n=7921470 atunci subprogramul returnează 0. (10p.)
Problema 2
Într-un text cu cel mult 100 de caractere cuvintele sunt formate numai din litere mari şi mici ale
alfabetului englez şi sunt separate prin câte un spaţiu.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul precizat, apoi un număr
natural, n (n " 1, 10 ), şi afişează pe ecran, pe linii separate, cuvintele din text care au exact n
2
litere.
Cuvintele sunt afişate ı̂n ordinea apariţiei lor ı̂n text, iar dacă nu există niciun astfel de cuvânt,
se afişează pe ecran mesajul nu exista.
Exemplu: dacă se citeşte textul Fat Frumos este cel mai viteaz iar n=6, se afişează pe
ecran:
Frumos
viteaz (10p.)
Problema 3
Şirul f este definit astfel: f1 x; f2 y; f3 z; fi fi1 fi2 fi3 , unde x, y, z şi i sunt
numere naturale nenule, i % 3.
De exemplu, dacă x 1, y 2 şi z 4 şirul este: 1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, ...
Se citesc de la tastatură un număr natural, n (n " 1, 10 ), apoi trei numere naturale din
4
2
intervalul 1, 10 , x, y şi z, reprezentând, ı̂n această ordine, primii trei termeni ai şirului precizat
mai sus. Se cere să se scrie ı̂n fişierul bac.txt primii n termeni ai şirului, separaţi prin câte un
spaţiu, ı̂n ordine inversă a apariţiei lor ı̂n şir.
Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare şi al spaţiului
de memorie utilizat.
Exemplu: dacă n 10, x 1, y 2 şi z 4 fişierul conţine numerele: 14 13 11 10 8 7 5 4 2 1
a) Descrieţi ı̂n limbaj natural algoritmul proiectat, justificând eficienţa acestuia. (2p.)
b) Scrieţi programul C/C++ corespunzător algoritmului proiectat. (8p.)

Varianta 4
5.2.1 Subiectul I
Problema 1
Indicaţi numerele pe care le pot memora variabilele ı̂ntregi x şi y, astfel
ı̂ncât valoarea expresiei C/C++ alăturate să fie 1.
a. x=4, y=2 b. x=6, y=3

c. x=8, y=4 d. x=10, y=0
Problema 2
Subprogramul f este definit alăturat. Valoarea lui
f(6) este:
a. 6 b. 5 c. 2 d. 1
Problema 3
Variabila x este de tip char şi memorează o literă mică a alfabetului englez. Indicaţi expresia
C/C++ care are valoare nenulă dacă şi numai dacă litera memorată ı̂n variabila x este o vocală.
Se consideră vocale literele a, e, i, o, u.
a. strcmp(x,"aeiou")==0
b. strchr("aeiou",x)
c. ’a’<=x && x<=’u’
d. x==a || x==e || x==i || x==o || x==u
Problema 4
Utilizând metoda backtracking, se generează, ı̂n ordine strict descrescătoare, toate numerele nat-
urale de câte patru cifre distincte din mulţimea {0, 1, 2, 3, 4, 5}. Primele şase numere generate
sunt, ı̂n această ordine: 5432, 5431, 5430, 5423, 5421, 5420. Al şaptelea număr generat este:
a. 5415 b. 5413 c. 5342 d. 5340
Problema 5
Un graf neorientat are 20 de noduri şi 10 muchii. Numărul maxim de componente conexe pe care
le poate avea acest graf este:
a. 5 b. 10 c. 16 d. 20

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseudocod. S-a
notat cu a%b restul ı̂mpărţirii numărului natural a la
numărul natural nenul b.
ordine, numerele 4, 3, 11 şi 25. (6p.)
b) Dacă pentru m, n şi p se citesc numerele 3, 5,
respectiv 1, scrieţi două numere care pot fi citite pentru
q astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
c) Scrieţi programul C/C++ corespunzător algorit-
mului dat. (10p.)
d) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel
dat, ı̂nlocuind structura cât timp...execută cu o structură repetitivă de tip pentru...execută.
(6p.)
Problema 2
Un graf orientat cu 6 vârfuri, numerotate de la 1 la 6, are arcele (1,2), (1,4), (2,5), (2,6), (3,5),
(4,1), (5,1), (6,5). Scrieţi un drum elementar de lungime maximă din graful dat. (6p.)
Problema 3
Variabila fig, declarată alăturat, memorează lungimea razei unui
cerc şi coordonatele centrului acestuia, ı̂n sistemul de coordonate
xOy. Scrieţi o secvenţă de instrucţiuni prin care se iniţializează
variabila fig, astfel ı̂ncât cercul corespunzător acesteia să aibă
raza 1 şi centrul ı̂n originea sistemului de coordonate. (6p.)

Problema 1
Subprogramul Impare are un singur parametru, n, prin care primeşte un număr natural (n "
9
1, 10 ), cu cel puţin o cifră impară. Subprogramul ı̂nlocuieşte fiecare cifră impară a lui n cu
cea mai mare cifră pară strict mai mică decât ea (astfel cifra 1 se ı̂nlocuieşte cu cifra 0, cifra 3
cu cifra 2 etc.) şi furnizează numărul obţinut tot prin parametrul n. Scrieţi definiţia completă a
subprogramului.
Exemplu: dacă n=235690, atunci, după apel, n=224680, iar dacă n=15690, atunci, după
apel, n=4680. (10p.)
Problema 2
Un tablou bidimensional cu număr impar de coloane este numit simetric faţă de coloana din mijloc
dacă, pe fiecare linie a tabloului, elementele dispuse simetric faţă de elementul din mijloc al liniei
respective au valori egale.
Scrieţi un program C/C++ care citeşte de la tastatură două numere
naturale din intervalul [3,21], m şi n (n impar), şi elementele unui tablou
4
bidimensional cu m linii şi n coloane, numere naturale din intervalul 0, 10 .
Programul afişează pe ecran mesajul DA, dacă tabloul este simetric faţă de
coloana din mijloc, sau mesajul NU ı̂n caz contrar.
Exemplu: pentru m=4, n=5 şi tabloul alăturat, se afişează pe ecran DA (10p.)
Problema 3
Un termen al unui şir de numere se numeşte vârf local al acestuia dacă nu există niciun alt termen
mai mare sau egal cu el care să ı̂l preceadă ı̂n şir sau dacă este egal cu termenul vecin anterior,
iar acesta este vârf local.
6
Fişierul bac.txt conţine un şir format din cel puţin două şi cel mult 10 numere naturale
3
din intervalul 0, 10 , separate prin câte un spaţiu. Se cere să se afişeze pe ecran, separate prin
câte un spaţiu, toate vârfurile locale ale şirului aflat ı̂n fişier. Proiectaţi un algoritm eficient din
punctul de vedere al timpului de executare şi al spaţiului de memorie utilizat.
Exemplu: dacă fişierul conţine numerele 7 4 9 10 10 10 8 10 10 8 30 se afişează pe ecran 7 9
10 10 10 30

Varianta 2
5.3.1 Subiectul I
Problema 1
O expresie C/C++ care are valoarea 0 este:
a. ’m’<’n’ b. ’m’==’M’
c. ’M’==’m’+’N’-’n’ d. ’N’==’M’+1
Problema 2
Subprogramul f este definit alăturat. Indicaţi ce se
f(75,30);
a. 75 30 45 b. 75 45 15 c. 75 45 15 15 d. 75 30 45 15
Problema 3
Utilizând metoda backtracking, se generează toate torturile formate din trei straturi de tipuri
distincte de cremă din mulţimea {caramel, ciocolată, frişcă, nuci, vanilie}. Ultimul
strat este de frişcă sau de vanilie, iar aceste tipuri de cremă nu pot apărea pe primele două straturi.
Două torturi cu straturi din aceleaşi tipuri de cremă sunt diferite dacă acestea sunt dispuse ı̂n altă
ordine. Primele patru soluţii generate sunt, ı̂n această ordine: (caramel, ciocolată, frişcă),
(caramel, ciocolată, vanilie), (caramel, nuci, frişcă), (caramel, nuci, vanilie).
A cincea soluţie este:
a. (ciocolată, caramel, frişcă) b. (ciocolată, nuci, frişcă)
c. (nuci, caramel, vanilie) d. (nuci, ciocolată, vanilie)
Problema 4
Numărul de noduri ale unui arbore cu 4 muchii este:
a. 2 b. 3 c. 4 d. 5
Problema 5
Valorile care pot reprezenta gradele nodurilor unui graf neorientat, cu 6 noduri, sunt:
a. 1,0,0,2,2,2 b. 2,2,3,4,0,3 c. 2,2,5,5,0,1 d. 6,5,4,3,2,1

Problema 1
Algoritmul alăturat este reprezentat ı̂n pseudocod. S-a notat cu
a%b restul ı̂mpărţirii numărului natural a la numărul natural
nenul b şi cu [c] partea ı̂ntreagă a numărului real c.
a) Scrieţi valoarea afişată dacă se citeşte numărul 27102.
(6p.)
b) Scrieţi trei numere distincte din intervalul [10,9999] care
pot fi citite, astfel ı̂ncât ı̂n urma executării algoritmului, pentru
c) Scrieţi programul C/C++ corespunzător algoritmului
dat. (10p.)
d) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat,
ı̂nlocuind prima structură cât timp...execută cu o structură
de tip pentru...execută. (6p.)
Problema 2
Fiind date două şiruri de caractere a şi b, ı̂l numim pe a sufix al lui b dacă a este egal cu b sau
dacă b se poate obţine din a prin alipirea la stânga a unor noi caractere.
Variabilele a şi b pot memora câte un şir cu cel mult 20 de caractere. Scrieţi o secvenţă de
instrucţiuni ı̂n urma executării căreia variabila a să memoreze un sufix al lui b format din trei
caractere, sau şirul nedeterminat, dacă nu există un astfel de sufix.
Exemplu: dacă b memorează şirul centaur, atunci a memorează şirul aur, iar dacă b mem-
orează şirul au, atunci a memorează şirul nedeterminat. (6p.)
Problema 3
În declarările alăturate, variabila p memorează coordonatele
unui punct ı̂n sistemul de coordonate xOy, iar variabila c mem-
orează datele caracteristice ale unui cerc: lungimea razei şi co-
ordonatele centrului său. Scrieţi o expresie care are valoarea 1
dacă şi numai dacă punctul corespunzător variabilei p coincide
cu centrul cercului corespunzător variabilei c. (6p.)

Problema 1
Subprogramul MaxImp are doi parametri, a şi b, prin care primeşte câte un număr natural (2 &
a $ b & 400). Subprogramul returnează cel mai mare număr natural din intervalul [a,b] pentru
care produsul divizorilor săi impari pozitivi este strict mai mare decât el ı̂nsuşi sau 0, dacă nu
există niciun astfel de număr. Scrieţi definiţia completă a subprogramului.
Exemplu: dacă a=14 şi b=19, atunci subprogramul returnează 18 (1 3 9 27 % 18). (10p.)
Problema 2
Numim pătrat de dimensiune m al unui tablou bidimensional tabloul obţinut din acesta păstrând
doar elementele aflate pe primele m linii şi pe primele m coloane ale sale.
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural, n (n " 2, 20),
apoi elementele unui tablou bidimensional cu n linii şi n coloane, numere naturale din intervalul
4
0, 10 .
Programul determină un pătrat de dimensiune maximă al tabloului citit, cu
toate elementele egale, şi afişează pe ecran valoarea acestei dimensiuni.
Exemplu: pentru n=5 şi tabloul alăturat, se afişează pe ecran 3. (10p.)
Problema 3
6
3
0, 10 , separate prin câte un spaţiu. şirul are cel puţin un termen par şi cel puţin un termen
impar. Se cere să se afişeze pe ecran termenii şirului, separaţi prin câte un spaţiu, astfel ı̂ncât
toţi cei impari să apară ı̂naintea tuturor celor pari, şi atât subşirul format din cei impari, cât şi
subşirul format din cei pari, să fie ı̂n ordine crescătoare, ca ı̂n exemplu. Proiectaţi un algoritm
eficient din punctul de vedere al timpului de executare.
Exemplu: dacă fişierul conţine numerele 12 2 3 1 2 5 se afişează pe ecran: 1 3 5 2 2 12
Capitolul 6
BAC 2018

Varianta 9
6.1.1 Subiectul I
Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare răspunsului corect.
Problema 1
|
Variabila x este de tip ı̂ntreg. Indicaţi o expresie care are valoarea 1 dacă şi | x<=3 || x>10
numai dacă expresia C/C++ alăturată are valoarea 1. (4p.) |
a. !(x<3 && x<10) b. x>=3 && !(x>=10)

c. !(x<3 || x<=10) d. !(x>3) || !(x<=10)
Problema 2
numărul natural nenul b şi cu [a] partea ı̂ntreagă a numărului
real a.
numerele 5, 3, 9, 206, 200, 80, 24. (6p.)
b) Dacă pentru variabila n se citeşte numărul 4, iar pentru
variabila a se citeşte numărul 2, scrieţi un set de numere dis-
tincte din intervalul [10,99] care pot fi citite ı̂n continuare astfel
ı̂ncât, ı̂n urma executării algoritmului, să se afişeze valoarea 4.
(4p.)
c) Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat,
ı̂nlocuind adecvat prima structură cât timp...execută cu o
structură de tip pentru...execută. (6p.)
d) Scrieţi programul C/C++ corespunzător algoritmului
dat. (10p.)

Pentru fiecare dintre itemii 1 şi 2 scrieţi pe foaia de examen litera corespunzătoare
răspunsului corect.
Problema 1
Un arbore cu 9 noduri, numerotate de la 1 la 9, este reprezentat prin vectorul de ”taţi” (3, 3, 0,
5, 2, 5, 2, 5, 8). Descendenţii direcţi (”fii”) ai nodului cu eticheta 5 sunt: (4p.)
a. 2 7 b. 2 8 c. 3 3 0 d. 4 6 8
51
Problema 2
Numărul de noduri ale unui graf neorientat fără cicluri, cu 26 de muchii şi 12 componente conexe
este: (4p.)
a. 18 b. 28 c. 38 d. 48
Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.
Problema 3
Variabila d, declarată alăturat, memorează ı̂n câmpul mic cel mai mic di-
2
vizor, strict mai mare decât 1, al numărului natural din intervalul 2, 10 ,
memorat ı̂n câmpul nr.
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia, pentru numărul memorat ı̂n câmpul
nr al variabilei d, se afişează pe ecran mesajul prim, dacă numărul este prim, mesajul patrat dacă
numărul este pătratul unui număr prim, sau două numere naturale, separate printr-un spaţiu,
reprezentând cel mai mic şi cel mai mare dintre divizorii proprii pozitivi ai săi. Divizorii proprii
pozitivi ai unui număr sunt divizori pozitivi diferiţi de 1 şi de el ı̂nsuşi.
Exemplu: dacă ı̂n câmpul nr se memorează numărul 12, iar ı̂n câmpul mic se memorează
numărul 2, se afişează pe ecran
26
iar dacă ı̂n câmpul nr se memorează numărul 9, iar ı̂n câmpul mic se memorează numărul 3, se
afişează pe ecran mesajul
patrat (6p.)
Problema 4
Variabilele i şi j sunt de tip ı̂ntreg, iar variabila a memorează un tablou
bidimensional cu 9 linii şi 9 coloane, numerotate de la 1 la 9, având
iniţial toate elementele nule.
Fără a utiliza alte variabile, scrieţi secvenţa de instrucţiuni de mai
jos, ı̂nlocuind punctele de suspensie astfel ı̂ncât, ı̂n urma executării
secvenţei obţinute, variabila a să memoreze tabloul alăturat.
for(i=1;i<=9;i++)
for(j=1;j<=9;j++)
.................. (6p.)
Problema 5
Un text are cel mult 100 de caractere şi este format din cuvinte, numere naturale şi spaţii.
Cuvintele sunt formate numai din litere mici ale alfabetului englez. Cuvintele şi numerele sunt
separate prin câte un spaţiu, ca ı̂n exemplu.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul menţionat mai sus şi
afişează pe ecran numărul din text care ı̂ncepe cu cea mai mare cifră, ca ı̂n exemplu. Dacă există
mai multe astfel de numere, se afişează doar unul dintre acestea, iar dacă textul nu conţine niciun
număr, se afişează pe ecran mesajul nu exista.
am 190 de nuci si 70 de castane
se afişează
70 (10p.)

Problema 1
Subprogramele f1 şi f2 sunt definite mai jos.
Cel mai mare divizor comun al lui 30 şi 50 se obţine ı̂n urma apelului: (4p.)
a. f1(30,50) b. f2(30,50) c. f1(30/2,50) d. f2(30/2,50)
Problema 2
Utilizând metoda backtracking, se generează toate posibilităţile de a forma cutii cu bomboane de
tipuri distincte din mulţimea {fondante, caramele, dropsuri, acadele}.
ı̂ntr-o cutie sunt cel puţin două tipuri de bomboane, dar nu pot fi şi dropsuri şi acadele simultan.
Două cutii sunt distincte dacă ele conţin cel puţin un tip diferit de bomboane.
Primele patru soluţii generate sunt, ı̂n această ordine, (fondante, caramele), (fondante,
caramele, dropsuri), (fondante, caramele, acadele), (fondante,dropsuri).
Scrieţi a cincea şi a şasea soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Un număr natural este numit echilibrat dacă suma cifrelor sale de pe poziţii pare este un număr par,
iar suma cifrelor sale de pe poziţii impare este un număr impar. Poziţiile cifrelor sunt numerotate
de la dreapta la stânga, astfel: cifra unităţilor este pe poziţia 0, cifra zecilor este pe poziţia 1
ş.a.m.d.
Subprogramul echilibrat are un singur parametru, n, prin care primeşte un număr natural
(" 10, 10 ). Subprogramul returnează valoarea 1 dacă n este echilibrat sau valoarea 0 ı̂n caz
9
contrar.
Exemplu: dacă n=25163912, subprogramul returnează valoarea 1, iar dacă n=11211, subpro-
gramul returnează valoarea 0. (10p.)
Problema 4
Numim secvenţă ı̂ncadrată a unui şir de numere naturale un subşir al acestuia, format din ter-
meni aflaţi pe poziţii consecutive ı̂n şirul dat, subşir care ı̂ncepe şi se termină cu aceeaşi valoare.
Lungimea secvenţei este egală cu numărul de termeni ai acesteia.
6
[0, 9]. Numerele sunt separate prin câte un spaţiu. ı̂n şir există cel puţin doi termeni egali.
Se cere să se determine secvenţele ı̂ncadrate din acest şir care au lungime maximă şi să se
afişeze pe prima linie a ecranului lungimea maximă determinată, iar pe următoarea linie, pentru
fiecare astfel de secvenţă, valoarea primului său termen. Numerele de pe a doua linie sunt afişate
ı̂n ordine strict crescătoare, separate prin câte un spaţiu.
Exemplu: dacă fişierul bac.txt conţine numerele

Varianta 2
a În rezolvările cerute, identificatorii utilizaţi trebuie să respecte precizările din enunţ (bold),
iar ı̂n lipsa unor precizări explicite, notaţiile trebuie să corespundă cu semnificaţiile asociate aces-
tora (eventual ı̂n formă prescurtată).
a În programele cerute, datele de intrare se consideră corecte, validarea acestora nefiind nece-
sară.
6.2.1 Subiectul I
Problema 1
Variabilele x şi y sunt de tip ı̂ntreg şi memorează câte un număr natural
nenul. O expresie echivalentă cu cea alăturată poate fi: (4p.)
a. x%y==y%x && y>1 b. (x+y)%y==0 || y>=1

c. (x/y)*y==x && y>=2 d. x%y==0 || y>2
Problema 2
Algoritmul alăturat este reprezentat ı̂n pseudocod
numărul natural nenul b şi cu [a] partea ı̂ntreagă a numărului
real a.
a) Scrieţi numărul afişat dacă se citeşte valoarea 2018. (6p.)
3
b) Scrieţi patru numere distincte din intervalul 10, 10 care
pot fi citite astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
fiecare dintre acestea, să se afişeze valoarea 100. (4p.)
ı̂nlocuind adecvat structura pentru...execută cu o atribuire.
(6p.)
d) Scrieţi programul C/C++ corespunzător algoritmului dat.
(10p.)

Problema 1
În declararea alăturată, variabila m memorează, pentru fiecare dintre
cele 20 de medicamente dintr-o farmacie, preţul, precum şi date despre
substanţa activă specifică: doza şi codul acesteia. O expresie a cărei
valoare reprezintă codul substanţei active specifice din primul medica-
ment este: (4p.)
a. m[0].cod.substanta b. m[0].substanta.cod
c. m.cod.substanta[0] d. m.substanta.cod[0]
Problema 2
Într-un graf orientat cel puţin două vârfuri au gradul intern 2, cel puţin un vârf are gradul intern
3 şi cel puţin un vârf are gradul extern 3. Numărul minim de vârfuri ale grafului este: (4p.)
a. 3 b. 4 c. 5 d. 6
Problema 3
Un arbore are 9 noduri, numerotate de la 1 la 9, şi muchiile [1,2], [1,6], [1,8], [1,9], [2,3], [2,7],
[4,5], [5,7]. Scrieţi trei noduri care ar putea fi alese drept rădăcină astfel ı̂ncât nodul 2 să aibă un
număr minim de descendenţi. (6p.)
Problema 4
iniţial toate elementele egale cu -1.
for(i=0;i<9;i++)
for(j=0;j<9;j++)
.................. (6p.)
Problema 5
Fiind dat un cuvânt s, format numai din litere, şi un cod c, de aceeaşi lungime cu s, format numai
din cifre, numim codificare a lui s pe baza codului c operaţia de construire a unui nou şir, ı̂n care
iniţial se copiază prima literă din s, apoi, parcurgând de la stânga la dreapta restul şirului s, se
adaugă litera curentă la ı̂nceputul noului şir, dacă cifra corespunzătoare de pe aceeaşi poziţie ı̂n c
este pară, sau la finalul noului şir, ı̂n caz contrar.
Exemplu: dacă şirul s este etalon, iar codul este 025843 se obţine cuvântul oltean (iniţial
şirul conţine litera e, apoi se adaugă, ı̂n ordinea parcurgerii lui s, literele t, l şi o la ı̂nceput, iar
restul literelor la final).
Scrieţi un program C/C++ care citeşte de la tastatură două cuvinte, notate cu s şi c, fiecare
2
având cel mult 10 caractere, s fiind format doar din litere mici ale alfabetului englez, iar c fiind
format doar din cifre. După primul cuvânt se tastează Enter. Programul construieşte ı̂n memorie
şi afişează pe ecran cuvântul obţinut prin codificarea lui s pe baza lui c, dacă cele două cuvinte
au aceeaşi lungime, sau mesajul cod incorect, ı̂n caz contrar.
Problema 1
O companie organizează cursuri de programare ı̂n limbaje din mulţimea {PHP, Java, Python,
C#, SQL}, astfel ı̂ncât o persoană poate opta pentru un curs ı̂n care se studiază un număr par de
limbaje, dar nu poate alege Java şi Python ı̂n acelaşi curs.
Utilizând metoda backtracking se generează toate posibilităţile unei persoane de a opta pentru
un curs ı̂n cadrul ofertei companiei. Două cursuri sunt distincte dacă diferă prin cel puţin un limbaj
sau prin ordinea ı̂n care se studiază limbajele. Primele cinci soluţii generate sunt, ı̂n această or-
dine: (PHP, Java), (PHP, Java, C#, SQL), (PHP, Java, SQL, C#), (PHP, Python), (PHP,
Python, C#, SQL).
Soluţia generată imediat după (Java, PHP, SQL, C#) este: (4p.)
a. (Java, C#) b. (Java, PHP, C#, SQL)

c. (SQL, Python) d. (SQL, Java, C#, PHP)
Problema 2
Subprogramul f este definit alăturat. Scrieţi trei valori
naturale pe care le poate avea variabila ı̂ntreagă x astfel
ı̂ncât, ı̂n urma apelului de mai jos, pentru fiecare dintre
acestea, să NU se afişeze niciun caracter *
f(’e’,x); (6p.)
Problema 3
Subprogramul resturi are patru parametri, n, x, y şi r, prin care primeşte câte un număr natural
9
din intervalul 1, 10 , r¡x¡y¡n. Subprogramul returnează numărul de valori naturale din intervalul
[1,n] pentru care atât restul ı̂mpărţirii la x, cât şi restul ı̂mpărţirii la y, sunt egale cu r.
Exemplu: pentru n=200, x=5, y=14 şi r=2, subprogramul returnează numărul 3 (pentru
numerele 2, 72 şi 142 atât restul ı̂mpărţirii la 5, cât şi restul ı̂mpărţirii la 14, este 2). (10p.)
Problema 4
Numim secvenţă neuniformă a unui şir de numere naturale un subşir al acestuia, format din
termeni aflaţi pe poziţii consecutive ı̂n şirul dat, cu proprietatea că oricare trei termeni aflaţi pe
poziţii consecutive sunt diferiţi. Lungimea secvenţei este egală cu numărul de termeni ai acesteia.
6
Fişierul bac.txt conţine un şir de cel mult 10 numere naturale din intervalul [0,9].
Numerele sunt separate prin câte un spaţiu, iar ı̂n şir există cel puţin trei termeni diferiţi pe
poziţii consecutive.
Se cere să se afişeze pe ecran lungimea maximă a unei secvenţe neuniforme a şirului aflat ı̂n
fişier. Proiectaţi un algoritm eficient din punctul de vedere al timpului de executare şi al memoriei
utilizate.
7713775333789
atunci pe ecran se afişează valoarea 4
b) Scrieţi programul C/C++ corespunzător algoritmului descris. (8p.)

Varianta 1
6.3.1 Subiectul I
Problema 1
Variabilele x, y şi z sunt de tip ı̂ntreg şi memorează câte un număr
natural nenul. Dacă expresia C/C++ alăturată are valoarea 1, indicaţi
şirul crescător format cu valorile acestor variabile, ı̂n ordinea precizată
mai jos. (4p.)
a. x, y, z b. y, z, x c. z, x, y d. z, y, x
Problema 2
S-a notat cu a%b restul ı̂mpărţirii numărului natural a la numărul
natural nenul b şi cu [a] partea ı̂ntreagă a numărului real a.
b) Scrieţi patru numere ı̂ntregi care pot fi citite astfel ı̂ncât, ı̂n
urma executării algoritmului, pentru fiecare dintre acestea, să se afişeze
numărul 722. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm echivalent cu cel dat, ı̂nlocuind
adecvat structura repetă...până când cu o structură repetitivă cu
test iniţial. (6p.)
d) Scrieţi programul C/C++ corespunzător algoritmului dat. (10p.)
Problema 1
Expresia strlen(”2018”) are valoarea: (4p.)
a. 4 b. 5 c. 6 d. 7
Problema 2
Un graf orientat este complet dacă pentru oricare două vârfuri i şi j ale sale există fie ambele arce
(i,j) şi (j,i), fie doar unul dintre acestea.
Un graf orientat are 5 vârfuri şi 20 de arce. Pentru a obţine un graf parţial al său cu două
componente tare conexe, fiecare dintre acestea fiind grafuri complete, unul cu 3 vârfuri, iar celălalt
cu 2 vârfuri, numărul minim de arce care pot fi eliminate este: (4p.)
a. 2 b. 3 c. 6 d. 10
Problema 3
În declararea alăturată, câmpurile cat şi rest memorează câtul, re-
spectiv restul ı̂mpărţirii a două numere naturale nenule.
Scrieţi o secvenţă de instrucţiuni ı̂n urma executării căreia se memo-
rează ı̂n variabila rezultat câtul şi restul ı̂mpărţirii ı̂ntregi a numărului 2018 la numărul natural
memorat ı̂n variabila x, dacă acesta este nenul, sau se afişează pe ecran mesajul impartire
nepermisa, ı̂n caz contrar. (6p.)
Problema 4
Un arbore cu 8 noduri, numerotate de la 1 la 8, este reprezentat prin matricea
de adiacenţă alăturată.
Scrieţi trei noduri care pot fi alese drept rădăcină astfel ı̂ncât fiecare nod
să admită cel mult doi descendenţi direcţi (fii). (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural n (n " 2, 10 ) şi un şir
2
4
de n numere naturale din intervalul 0, 10 şi construieşte ı̂n memorie un tablou bidimensional cu
n linii şi n coloane, numerotate ı̂ncepând de la 0, astfel ı̂ncât parcurgând orice coloană numerotată
cu un număr par, de jos ı̂n sus, sau orice coloană numerotată cu un număr impar, de sus ı̂n jos,
se obţine şirul citit, ca ı̂n exemplu.
Problema 1
Subprogramul f este definit alăturat. Indicaţi ce se
f(7);
(4p.)
a. 10 b. 010 c. 101 d. 1010
Problema 2
Utilizând metoda backtracking, se generează toate posibilităţile de a forma seturi de câte 5 instru-
mente de scris distincte din mulţimea {stilou, pană, toc, creion, pensulă}, astfel ı̂ncât ı̂n
fiecare set creionul precede stiloul şi pana. Două seturi sunt distincte dacă instrumentele sunt
dispuse ı̂n altă ordine.
Primele cinci soluţii generate sunt, ı̂n această ordine,
(toc, creion, stilou, pană, pensulă),
(toc, creion, stilou, pensulă, pană),
(toc, creion, pană, stilou, pensulă),
(toc, creion, pană, pensulă, stilou),
(toc, creion, pensulă, stilou, pană).
Scrieţi cea de a şasea şi cea de a şaptea soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Subprogramul interval are un singur parametru, n, prin care primeşte un număr natural (n "
6
3, 10 ). Subprogramul returnează cel mai mic număr natural x (n¡x) care NU este prim, cu
proprietatea că ı̂n intervalul [n,x] există un singur număr prim.
Exemplu: dacă n=8, subprogramul returnează numărul 12.
Problema 4
Primii termeni ai şirului definit alăturat (unde n
este un număr natural nenul) sunt:
0, 3, 8, 15, 24, 35, 48, 63, 80 ....
9
Se citesc de la tastatură două numere naturale din intervalul 0, 10 , x şi y, reprezentând
valorile a doi termeni aflaţi pe poziţii consecutive ı̂n şirul dat (x¡y), şi se cere să se scrie ı̂n
fişierul text bac.txt, ı̂n ordine strict descrescătoare, separaţi prin câte un spaţiu, toţi termenii
şirului mai mici sau egali cu y.
utilizate.
Exemplu: dacă se citesc numerele
48 63
fişierul bac.txt conţine numerele
63 48 35 24 15 8 3 0
Capitolul 7
BAC 2017

Varianta 3
a În rezolvările cerute, identificatorii utilizaţi trebuie să respecte precizările din enunţ (bold), iar
ı̂n lipsa unor precizări explicite, notaţiile trebuie să corespundă cu semnificaţiile asociate acestora
(eventual ı̂n formă prescurtată).
a În programele cerute, datele de intrare se consideră corecte, validarea acestora nefiind necesară.
7.1.1 Subiectul I
Problema 1
Indicaţi expresia C/C++ care are valoarea 1 dacă şi numai dacă numărul natural memorat ı̂n
variabila ı̂ntreagă x are exact trei cifre. (4p.)
a. x/1000==0 && x/100!=0 b. x/1000==0 || x/100!=0
c. x%1000==0 && x%100!=0 d. x%1000==0 || x%100!=0
Problema 2
Se consideră algoritmul alăturat, reprezentat ı̂n pseudocod. S-a
notat cu a%b restul ı̂mpărţirii numărului natural a la numărul
natural nenul b.
numerele 7, 4. (6p.)
b) Scrieţi patru seturi de date de intrare, numere naturale
din intervalul [2,9], care pot fi citite astfel ı̂ncât, ı̂n urma exe-
cutării algoritmului, pentru fiecare dintre acestea, să se afişeze
valoarea 7. (4p.)
ı̂nlocuind adecvat structura cât timp...execută cu o structură
repetitivă cu test final. (6p.)
dat. (10p.)

Problema 1
(5,4,6,0,3,2,6,9,7). Rădăcina arborelui este: (4p.)
a. 1 b. 4 c. 6 d. 8
60
Problema 2
Într-un graf neorientat două cicluri sunt disjuncte dacă nu au niciun nod
comun.
Pentru graful neorientat cu 9 noduri, reprezentat alăturat, se construieşte
o mulţime formată din cicluri elementare, cu proprietatea că oricare două
dintre acestea sunt disjuncte.
Numărul maxim de cicluri dintr-o astfel de mulţime este: (4p.)
a. 1 b. 2 c. 3 d. 4
Problema 3
Variabila p memorează simultan numărul de vârfuri ale unui poligon (număr natural din intervalul
2
3, 10 ) şi coordonatele vârfurilor acestuia (abscisa şi ordonata) ı̂n sistemul de coordonate xOy
(numere reale).
Ştiind că expresiile C/C++ de mai jos au ca valori numărul de vârfuri ale unui poligon,
abscisa, respectiv ordonata primului său vârf, scrieţi definiţia unei structuri cu eticheta poligon,
care permite memorarea datelor despre un poligon, şi declaraţi corespunzător variabila p.
p.numar
p.varf[0].x
p.varf[0].y (6p.)
Problema 4

iniţial toate elementele egale cu caracterul *.
for(i=0;i<9;i++)
for(j=0;j<9;j++)
.................. (6p.)
Problema 5
Se consideră un text cu cel mult 100 de caractere, ı̂n care cuvintele sunt formate din litere mari
ale alfabetului englez şi sunt separate prin câte un spaţiu.
afişează pe ecran, pe câte un rând, cuvintele care cuprind cel puţin o notă muzicală. Dacă nu
există astfel de cuvinte, se afişează pe ecran mesajul nu exista.
Notele muzicale sunt DO, RE, MI, FA, SOL, LA, SI.

Problema 1
Utilizând metoda backtracking se generează, ı̂n ordine crescătoare, toate numerele naturale pare
cu trei cifre, cu proprietatea că nu există două cifre egale alăturate şi suma cifrelor este 10. Primele
cinci numere generate sunt, ı̂n această ordine: 136, 154, 172, 190, 208. Al şaselea număr generat
este: (4p.)
a. 217 b. 226 c. 262 d. 280
Problema 2
Subprogramul f este definit alăturat. Scrieţi ce se
f(4); (6p.)
Problema 3
Subprogramul identice are doi parametri, a şi b, prin care primeşte câte un număr natural
(10 & a & b & 10 ). Subprogramul afişează pe ecran toate numerele naturale din intervalul [a,b]
6
care au toate cifrele identice. Numerele afişate sunt separate prin câte un spaţiu, iar dacă nu
există astfel de numere, se afişează pe ecran mesajul nu exista.
Exemplu: pentru a=700 şi b=1500 se afişează pe ecran
777 888 999 1111. (10p.)
Problema 4
Numim inserare a unui şir A ı̂ntr-un şir B introducerea, ı̂ntre două elemente ale şirului B, a tuturor
elementelor lui A, pe poziţii consecutive, ı̂n ordinea ı̂n care apar ı̂n A.
6
Fişierul bac.in conţine numere naturale din intervalul 1, 10 : pe prima linie numerele m
şi n, iar pe fiecare dintre următoarele două linii câte un şir de m, respectiv de n numere ı̂ntregi
ordonate strict crescător. Numerele aflate pe aceeaşi linie a fişierului sunt separate prin câte un
spaţiu, iar numerotarea elementelor ı̂n şiruri ı̂ncepe de la 1.
Se cere să se afişeze pe ecran poziţia din al doilea şir ı̂ncepând de la care poate fi inserat primul
şir, astfel ı̂ncât şirul obţinut să fie strict crescător. Dacă nu există o astfel de poziţie, se afişează
pe ecran mesajul imposibil.
Proiectaţi un algoritm eficient din punctul de vedere al spaţiului de memorie utilizat şi al
46
15 16 17 19
7 10 12 20 30 40
se poate obţine şirul 7, 10, 12, 15, 16, 17, 19, 20, 30, 40 şi se afişează pe ecran 4 iar dacă fişierul
conţine numerele
46
15 16 17 19
7 14 18 20 30 40
sau numerele
46
1234
7 15 18 20 30 40
se afişează pe ecran mesajul imposibil

Varianta 4
7.2.1 Subiectul I
Problema 1
Indicaţi o expresie C/C++ care are valoarea 1 dacă şi numai dacă numărul natural memorat ı̂n
variabila ı̂ntreagă x are exact o cifră. (4p.)
a. x%10==x b. x/10==x c. x%10==x/10 d. (x%10)/10==x
Problema 2
Se consideră algoritmul alăturat, reprezentat ı̂n pseu-

docod.
a) Scrieţi ce se afişează dacă se citeşte numărul 3.
(6p.)
b) Scrieţi un număr care poate fi citit, astfel ı̂ncât,
ı̂n urma executării algoritmului numărul de simboluri #
afişate să fie 100. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm echivalent cu cel
dat, ı̂nlocuind adecvat prima structură pentru...execută
d) Scrieţi programul C/C++ corespunzător algorit-
mului dat. (10p.)
Problema 1
Indicaţi şirul afişat pe ecran ı̂n urma executării instrucţiunii următoare:

cout<<strstr("veni,vidi,vici","vi");
(4p.)
a. vidi b. vidi,vici c. 2 d. 6
Problema 2
Se consideră un graf neorientat cu 7 noduri şi 21 de muchii. Indicaţi numărul minim de muchii
care pot fi eliminate, astfel ı̂ncât graful parţial obţinut să aibă două componente conexe, cu cel
puţin două noduri fiecare. (4p.)
a. 6 b. 8 c. 10 d. 12
Problema 3
În declararea alăturată, variabila x memorează numele
unui elev şi cele două medii semestriale obţinute de
acesta la informatică.
Scrieţi o secvenţă de instrucţiuni C/C++ ı̂n urma executării căreia să se afişeze pe ecran prima
literă a numelui şi, pe linia următoare, media anuală la informatică a acestui elev. (6p.)
Exemplu: dacă elevul are numele Popescu, iar cele două medii sunt sunt 9, respectiv 10, se
afişează pe ecran
P
9.5
Problema 4
Într-un graf orientat două circuite sunt distincte dacă ele diferă prin cel puţin un arc.
Scrieţi matricea de adiacenţă a unui graf orientat cu 5 vârfuri şi 6 arce, care are două circuite
elementare distincte. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale din intervalul [3,50],
n şi m, şi elementele unui tablou bidimensional cu n linii şi m coloane, numere naturale din
4
intervalul 0, 10 .
Programul modifică ı̂n memorie tabloul dat, atribuind valoarea elementului aflat pe ultima
linie şi pe ultima coloană a tabloului fiecărui element aflat pe conturul acestuia (pe prima linie,
ultima linie, prima coloană, ultima coloană), apoi afişează pe ecran tabloul modificat, câte o linie
a tabloului pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
Problema 1
Utilizând metoda backtracking se generează, ı̂n ordine strict crescătoare, toate numerele de trei
cifre din mulţimea 1, 2, 5, 7, 8, numere cu proprietatea că au cel mult două cifre impare.
Primele şapte numere generate sunt, ı̂n această ordine: 112, 118, 121, 122, 125, 127, 128.
Al optulea număr generat este: (4p.)
a. 151 b. 152 c. 157 d. 158

Problema 2
Subprogramul f este definit alăturat. Scrieţi valorile f(3,9) şi
f(1,1000). (6p.)
Problema 3
Subprogramul duplicare are un singur parametru, n, prin care primeşte un număr natural (n "
4
1, 10 ). Subprogramul furnizează, prin acelaşi parametru, numărul obţinut din n prin inserarea,
după fiecare cifră pară din scrierea lui, a unei cifre egale cu jumătate din aceasta.
Exemplu: dacă n=2380 după apel, n=2138400, iar dacă n=35 după apel, n=35. (10p.)
Problema 4
Numim secvenţă pară ı̂ntr-un şir o succesiune de termeni ai şirului cu proprietatea că sunt numere
pare şi că se află pe poziţii consecutive ı̂n şir; orice secvenţă are cel puţin doi termeni şi este
maximală ı̂n raport cu proprietatea precizată (dacă i se adaugă un alt termen, secvenţa ı̂şi pierde
această proprietate). Lungimea secvenţei este egală cu numărul termenilor săi.
6 9
Fişierul bac.txt conţine un şir de cel mult 10 numere naturale din intervalul 0, 10 . Nu-
merele din şir sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran numărul de secvenţe pare de lungime maximă din şir.
Proiectaţi un algoritm eficient din punctul de vedere al spaţiului de memorie utilizat şi al
Exemplu: dacă fişierul bac.txt conţine valorile
1 2 3 4 6 10 2 8 5 7 9 4 6 10 121 20 4 11 10 2 5 2 6 8 10 16
se afişează pe ecran numărul 2.

Varianta 7
7.3.1 Subiectul I
Problema 1
Expresia C/C++ alăturată are valoarea: 3+7/4+3
a. 1 b. 5.5 c. 7 d. 7.75
(4p.)
Problema 2
Se consideră algoritmul alăturat, reprezentat ı̂n pseudocod.
numărului real c.
a) Scrieţi ce se afişează dacă se citesc, ı̂n această ordine,
numerele 4, 5, 24, 3, 45. (6p.)
b) Dacă primul număr citit este 3, scrieţi un set de nu-
mere distincte care pot fi citite ı̂n continuare, astfel ı̂ncât, ı̂n
urma executării algoritmului, să se afişeze valoarea 1. (4p.)
ı̂nlocuind adecvat prima structură cât timp...execută cu o
structură de tip pentru...execută. (6p.)
dat. (10p.)

Problema 1
În declararea alăturată, ı̂n câmpurile s şi d ale structurii sunt memorate ex-
tremitatea stângă, respectiv dreaptă ale fiecăruia dintre cele 20 de intervale
ı̂nchise. O expresie C/C++ a cărei valoare este extremitatea stângă a primu-
lui interval este: (4p.)
a. v[0].s b. s.v[0] c. v(0).s d. s(0).v
Problema 2
Într-un arbore cu 50 de noduri, numerotate de la 1 la 50, rădăcina este nodul 1, iar tatăl oricărui
alt nod i al său este nodul numerotat cu [i/2]. Lungimea lanţului cu o extremitate ı̂n nodul 14 şi
cealaltă extremitate ı̂n nodul 47 este: (4p.)
a. 5 b. 8 c. 16 d. 33
Problema 3
Un graf neorientat cu 4 noduri, numerotate de la 1 la 4, este reprezentat prin matricea
de adiacenţă alăturată. Scrieţi mulţimea nodurilor şi mulţimea muchiilor unui subgraf
al acestui graf, diferit de el ı̂nsuşi, ı̂n care cel puţin un nod să aibă gradul 1 şi cel puţin
un nod să aibă gradul 2. (6p.)
Problema 4
În secvenţa alăturată variabilele n şi i sunt de tip ı̂ntreg, iar
variabila s permite memorarea unui cuvânt, şir de cel mult 20
de caractere.
Cuvintele citite sunt formate din litere mici ale alfabetului englez şi sunt
separate prin Enter.
Fără a utiliza alte variabile, scrieţi secvenţa ı̂nlocuind punctele de suspensie
astfel ı̂ncât, ı̂n urma executării secvenţei obţinute, variabila n să memoreze
numărul de cuvinte citite pentru care subşirul format din ultimele trei caractere
ale lor coincide cu şirul are, iar acesta NU mai apare pe alte poziţii ı̂n cuvânt.
Exemplu: dacă se citesc cuvintele alăturate, variabila n are valoarea 3. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural par n (" 2, 50) şi
elementele unui tablou bidimensional cu n linii şi n coloane, numere reale, apoi transformă tabloul
ı̂n memorie, inserând o linie nouă, la mijlocul său, valoarea fiecărui element al acesteia fiind egală
cu media aritmetică a elementelor aflate pe coloana corespunzătoare lui ı̂n tabloul citit. Tabloul
obţinut se afişează pe ecran, câte o linie a tabloului pe câte o linie a ecranului, elementele fiecărei
linii fiind separate prin câte un spaţiu.
Problema 1
Subprogramul f este definit alăturat. Valoarea lui f(1234) este:

(4p.)
a. 0 b. 4 c. 6 d. 10
Problema 2
Fiind date o mulţime finită şi un set de perechi de forma (i,j), unde i şi j sunt elemente ale mulţimii,
se numeşte şir sortat topologic asociat mulţimii un şir format din toate elementele mulţimii, astfel
ı̂ncât pentru orice pereche (i,j) dintre cele date, elementul i să se găsească ı̂naintea lui j ı̂n şir.
Utilizând metoda backtracking, se generează toate şirurile sortate topologic ale mulţimii 1, 2,
3, 4, 5, 6, având ı̂n vedere perechile (4,6), (3,4), (3,1), (2,5). Primele trei soluţii generate sunt, ı̂n
această ordine: (2,3,1,4,5,6), (2,3,1,4,6,5), (2,3,1,5,4,6).
Scrieţi cea de a patra şi cea de a cincea soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Subprogramul triplete are trei parametri, a, b şi c, prin care primeşte câte un număr natural
4
din intervalul 0, 10 (a¡b). Subprogramul afişează pe ecran toate tripletele de numere naturale,
x, y şi z, soluţii ale ecuaţiei x+y+z=c, cu proprietatea că a & x & y & z & b.
Fiecare triplet afişat este ı̂ncadrat ı̂ntre acolade, iar numerele x, y şi z sunt afişate ı̂n această
ordine, separate prin câte o virgulă. Dacă nu există niciun triplet cu proprietatea cerută, se
afişează mesajul nu exista.
Exemplu: dacă a=2, b=4 şi c=8, se afişează pe ecran tripletele
{2,2,4}{2,3,3}
iar dacă a=5, b=8, c=8 se afişează pe ecran mesajul
nu exista. (10p.)
Problema 4
Un şir de numere este o progresie aritmetică de raţie r dacă oricare termen al său, cu excepţia
primului, se obţine din cel care ı̂l precede, prin adunarea la acesta a numărului r.
Exemplu: şirul 12, 14, 16, 18, 20 este o progresie de raţie 2.
6 3
Se cere să se verifice dacă există un număr natural r, astfel ı̂ncât toate numerele distincte din
şir să poată fi rearanjate, pentru a forma o progresie aritmetică de raţie r. Se afişează pe ecran
numărul r, sau mesajul NU, dacă nu există un astfel de număr.
180 30 80 280 130 330 230 30 30 330 80
se afişează pe ecran
50
Capitolul 8
BAC 2016

Varianta 4
8.1.1 Subiectul I
Problema 1
3
Variabilele x, y şi z sunt de tip ı̂ntreg şi memorează numere naturale din intervalul 1, 10 . Indicaţi
o expresie C/C++ care are valoarea 1 dacă şi numai dacă valoarea variabilei x este strict mai mare
decât valoarea oricăreia dintre variabilele y şi z. (4p.)
a. x*y>y*z && x*z>y*z b. x*z>x*y && y*z>y*x

c. y*z>x*z && y*x>z*x d. y*z>y*x && y*z>z*x
Problema 2
numărului real c.
a) Scrieţi valoarea afişată ı̂n urma executării algoritmu-
lui dacă se citeşte numărul 81112337. (6p.)
b) Scrieţi numărul de valori din intervalul [10000,99999]
care să ı̂nceapă cu cifra 1, care pot fi citite pentru vari-
abila n, astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
ı̂nlocuind structura cât timp...execută cu o structură
repetitivă de alt tip. (6p.)
dat. (10p.)
69
Problema 1
Variabilele i şi j sunt de tip ı̂ntreg, iar variabila m memorează un tablou bidimensional cu 5 linii şi
5 coloane, numerotate de la 0 la 4, cu elemente numere ı̂ntregi. O expresie C/C++ a cărei valoare
este egală cu produsul dintre primul element de pe linia i şi ultimul element de pe coloana j din
acest tablou este: (4p.)
a. m[0,i]*m[j,4] b. m(0,i)*m(j,4)
c. m(i)(0)*m(4)(j) d. m[i][0]*m[4][j]
Problema 2
Un graf orientat are 12 arce, 3 componente tare conexe, iar fiecare vârf al său are gradul interior
un număr nenul. Numărul maxim de noduri pe care le poate avea graful este: (4p.)
a. 12 b. 11 c. 9 d. 8
Problema 3
Un arbore cu 8 noduri, numerotate de la 1 la 8, este reprezentat prin următorul vector de ”taţi”
(3, 0, 2, 5, 2, 5, 1, 5). Determinaţi cel mai lung lanţ elementar care are o extremitate ı̂n rădăcină
şi enumeraţi nodurile sale, ı̂n ordinea apariţiei ı̂n acesta. (6p.)
Problema 4
Variabilele i şi s sunt ı̂ntregi, iar variabila p memorează, pen-
tru fiecare dintre cele 20 de zone de parcare ale unui oraş,
numărul de locuri ı̂nchiriate pe parcursul orei curente, pre-
cum şi preţul practicat de zona respectivă pentru ı̂nchirierea
unui loc pentru o oră.
Fără a utiliza alte variabile decât cele menţionate, scrieţi o secvenţă de instrucţiuni ı̂n urma
executării căreia variabila s să memoreze suma totală obţinută ı̂n urma ı̂nchirierii locurilor de
parcare din oraş pe parcursul orei curente. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură, ı̂n această ordine, un număr
natural n, apoi n cuvinte, separate prin Enter, urmate de un număr natural k.
Numerele citite sunt din intervalul [1,20], iar fiecare cuvânt este format din cel mult
20 de caractere, numai litere mici ale alfabetului englez. Cel puţin unul dintre cuvinte
are k litere.
Programul construieşte ı̂n memorie, apoi afişează pe ecran, un şir care să cuprindă
cuvintele citite, separate prin câte un spaţiu, astfel ı̂ncât toate cele care au k litere
să ocupe primele poziţii, iar celelalte să se regăsească ı̂n continuarea acestora, ı̂ntr-o
ordine oarecare.
Exemplu: dacă se citesc, ı̂n această ordine, datele alăturate, unul dintre şirurile obţinute
poate fi:
am un de cires mai (10p.)
Problema 1
Subprogramul f este definit alăturat. Indicaţi cea
mai mare valoare din intervalul [20,25] pe care o
poate avea variabila ı̂ntreagă x, astfel ı̂ncât, ı̂n urma
apelului de mai jos, să se afişeze numerele 2 4 16.
f(x,1); (4p.)
a. 21 b. 22 c. 23 d. 24
Problema 2
Utilizând metoda backtracking se generează, ı̂n ordine lexicografică, toate şirurile de câte 6 cifre
din mulţimea {0,1} cu proprietatea că au cel mult două cifre cu valori egale pe poziţii consecutive.
Primele 5 soluţii generate sunt, ı̂n această ordine: 001001, 001010, 001011, 001100, 001101. Scrieţi
a 7-a şi a 8-a soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Subprogramul minDivPrim are un singur parametru, n, prin care primeşte un număr natural
(n " 2, 10 ). Subprogramul returnează cel mai mic număr natural care are aceiaşi divizori primi
9
ca n.
Exemplu: dacă n=75, subprogramul returnează numărul 15, iar dacă n=7, subprogramul
returnează numărul 7. (10p.)
Problema 4
Se consideră şirul 1, -1, 2 ... definit astfel: f1 1, f2 1, iar fn 1 2 fn1 fn2 , dacă n ' 3
(unde n este un număr natural).
Se citeşte de la tastatură un număr natural, n (n " 1, 10 ), şi se cere să se scrie ı̂n fişierul
9
text bac.out, separaţi prin câte un spaţiu, primii n termeni ai şirului, ı̂n ordine inversă apariţiei
lor ı̂n acesta.
Pentru determinarea şi afişarea numerelor cerute se utilizează un algoritm eficient din punctul
de vedere al spaţiului de memorie şi al timpului de executare.
Exemplu: dacă n=3, fişierul conţine valorile
2 -1 1
a) Descrieţi ı̂n limbaj natural algoritmul utilizat, justificând eficienţa acestuia. (4p.)

Varianta 10
8.2.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg. Indicaţi o expresie C/C++ care are valoarea 1 dacă şi numai dacă
valoarea variabilei x are exact trei cifre. (4p.)
a. x%1000==0 || x%100!=0 b. x/1000==0 || x/100!=0

c. x%1000==0 && x%100!=0 d. x/1000==0 && x/100!=0
Problema 2
docod.
a) Scrieţi valorile afişate ı̂n urma executării algorit-
mului dacă se citesc, ı̂n această ordine, numerele 11, 30
şi 7. (6p.)
b) Scrieţi un set de valori care pot fi citite pentru
variabilele m, n şi x, astfel ı̂ncât, ı̂n urma executării al-
goritmului, să se afişeze două numere egale. (4p.)
dat, ı̂nlocuind structura cât timp...execută cu o structură
d) Scrieţi programul C/C++ corespunzător algorit-
mului dat. (10p.)
Problema 1
În declararea alăturată, variabila m memorează anul fabricaţiei
şi marca unei maşini. Indicaţi o expresie C/C++ care are val-
oarea 1 dacă şi numai dacă maşina a fost fabricată ı̂nainte de
anul 1950. (4p.)
a. m.an_fabricatie<1950 b. m.masina.an_fabricatie.m<1950
c. m(an_fabricatie)<1950 d. masina(an_fabricatie)<1950
Problema 2
Matricea de adiacenţă a unui graf neorientat cu 5 noduri are 6 elemente nenule. Numărul minim
de componente conexe ale grafului este: (4p.)
a. 1 b. 2 c. 3 d. 5
Problema 3
Un arbore cu 8 noduri, numerotate de la 1 la 8, are drept rădăcină nodul numerotat cu 7 şi
muchiile [1,7], [2,5], [3,5], [3,6], [4,7], [5,7], [5,8]. Enumeraţi nodurile care sunt descendenţi direcţi
(”fii”) ai nodului 5. (6p.)
Problema 4
În secvenţa de instrucţiuni de mai jos variabilele s1 şi s2 memorează câte un şir cu cel mult 20 de
caractere. Scrieţi ce se afişează pe ecran ı̂n urma executării secvenţei. (6p.)
strcpy(s1,"informatica");
cout<<strlen(s1); | printf("%d",strlen(s1));
strcpy(s2,"mate");
strcat(s2,strstr(s1,"ma"));
cout<<s2; | printf("%s",s2);
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural, n (n " 2
2, 10 ), şi
construieşte ı̂n memorie un tablou bidimensional, cu n linii şi n coloane, astfel:
prima coloană conţine, ı̂n ordine strict crescătoare, numerele naturale din intervalul [1,n];
toate elementele ultimei linii au valoarea n;
oricare alt element este obţinut prin ı̂nsumarea celor două elemente vecine cu el, aflate pe
coloana anterioară, unul pe aceeaşi linie cu el, iar celălalt pe linia următoare, ca ı̂n exemplu.
elementele fiecărei linii fiind separate prin câte un spaţiu.
Exemplu: pentru n=4 pe ecran se afişează: (10p.)
Problema 1
Subprogramul f este definit alăturat. Indicaţi ce se afişează
ı̂n urma apelului de mai jos.
f(2016); (4p.)
a. 6102 b. 2202012016 c. 2016201202 d. 20162012020
Problema 2
Având la dispoziţie cinci tipuri de prăjituri, cu pere, cu mure, cu afine, cu fragi, cu zmeură,
se utilizează metoda backtracking pentru a obţine toate posibilităţile de a forma platouri cu câte
trei tipuri de prăjituri diferite, ştiind că ı̂n cadrul unui platou nu contează ordinea de aşezare a
prăjiturilor şi că prăjiturile cu mure nu vor fi plasate pe acelaşi platou cu prăjiturile cu fragi.
Primele patru soluţii obţinute sunt, ı̂n această ordine: (pere, mure, afine), (pere, mure,
zmeură), (pere, afine, fragi), (pere, afine, zmeură).
Scrieţi cea de a cincea şi cea de a şasea soluţie, ı̂n ordinea obţinerii lor. (6p.)
Problema 3
Subprogramul cifreImpare are un singur parametru, n, prin care primeşte un număr natural
cu toate cifrele nenule (n " 1, 10 ). Subprogramul returnează numărul obţinut prin eliminarea
9
tuturor cifrelor impare din n, respectiv -1 dacă nu există astfel de cifre sau dacă toate cifrele lui
n sunt impare.
Exemplu: dacă n=23541 subprogramul returnează 24, iar dacă n=28 subprogramul re-
turnează -1. (10p.)
Problema 4
Fişierul numere.in conţine pe prima linie un număr natural n (n " 2, 10 ), iar pe a doua linie un
9
9
şir de cel mult 10 numere naturale din intervalul 1, n. Numerele din şir sunt ordonate crescător
şi sunt separate prin câte un spaţiu.
Se cere să se determine valorile naturale distincte din intervalul [1,n] care NU se găsesc ı̂n şirul
menţionat mai sus. Valorile determinate se afişează pe ecran ı̂n ordine strict crescătoare, separate
prin câte un spaţiu. Dacă nu există astfel de valori, se afişează pe ecran mesajul Nu exista.
Pentru determinarea valorilor cerute se utilizează un algoritm eficient din punctul de vedere
al memoriei şi al timpului de executare.
10
3448
se afişează pe ecran valorile
1 2 5 6 7 9 10

Varianta 7
8.3.1 Subiectul I
Problema 1
Variabilele x şi y sunt de tip real. Expresia C/C++ alăturată este echiva-
lentă cu expresia: (4p.)
a. x<=0 || y<=0 b. x<=0 && y<=0

c. x>0 || y>0 d. !(x>0) && !(y>0)
Problema 2
Se consideră algoritmul alăturat, reprezentat ı̂n
pseudocod.
numărului real c.
a) Scrieţi valoarea afişată ı̂n urma executării algoritmu-
lui dacă se citeşte numărul 12. (6p.)
b) Scrieţi cel mai mic şi cel mai mare număr care pot
fi citite, astfel ı̂ncât, pentru fiecare dintre acestea, valoarea
afişată să fie 16. (4p.)
dat, ı̂nlocuind structura pentru...execută cu o structură
dat. (10p.)
Problema 1
În declararea alăturată, câmpurile x şi y ale ı̂nregistrării reprezintă

numărătorul, respectiv numitorul unei fracţii. Indicaţi o expresie C/C++
care are valoarea 1 dacă şi numai dacă fracţia memorată ı̂n variabila f are
valoarea 1. (4p.)
a. (int x).f==(int y).f b. x.f.fractie==y.f.fractie

c. f.x==f.y d. x.y==y.x
Problema 2
Matricea de adiacenţă a unui graf neorientat cu 7 noduri are 10 elemente nenule. Numărul maxim
de componente conexe ale grafului este: (4p.)
a. 2 b. 3 c. 4 d. 5
Problema 3
În secvenţa de instrucţiuni de mai jos variabilele s1 şi s2 memorează câte un şir cu cel mult 20 de
caractere. Scrieţi ce se afişează pe ecran ı̂n urma executării secvenţei. (6p.)
strcpy(s1,"bacalaureat");
cout<<strlen(s1); | printf("%d",strlen(s1));
strcpy(s2,s1+5); s2[3]=’\0’;
cout<<s2; | printf("%s",s2);
Problema 4
Într-un graf orientat cu 7 vârfuri, numerotate de la 1 la 7, pentru oricare două vârfuri ale sale i şi
j există arcul (i,j) fie dacă j este divizor al lui i (i j j), fie dacă i şi j au aceeaşi paritate, iar i¡j.
Enumeraţi vârfurile pentru care gradul interior este mai mare sau egal cu cel exterior. (6p.)
Problema 5
2
Scrieţi un program C/C++ care citeşte de la tastatură numere naturale din intervalul 3, 10 , ı̂n
această ordine: n şi m, apoi elementele unui tablou bidimensional cu n linii şi m coloane, iar la
final un număr x.
Programul afişează pe ecran mesajul DA, dacă există cel puţin un element egal
cu x aflat pe conturul tabloului (format din prima linie, ultima linie, prima
coloană şi ultima coloană), sau mesajul NU ı̂n caz contrar.
Exemplu: pentru n=4, m=5, tabloul alăturat şi x=12, se afişează pe
ecran mesajul DA. (10p.)
Problema 1
Subprogramele f1 şi f2 sunt definite mai jos.
La apel, pentru parametrul n=5, returnează valoarea 120: (4p.)
a. at\ât f1, c\ât \c si f2 b. numai f1 c. numai f2 d. nici f1, nici f2
Problema 2
Utilizând metoda bactracking se generează ı̂n ordine lexicografică toate şirurile de 5 litere distincte
din mulţimea C, A, R, T, E, astfel ı̂ncât ı̂n fiecare şir litera T precede litera A. Primele trei soluţii
generate sunt, ı̂n această ordine: CERTA, CETAR, CETRA. Scrieţi cea de a patra şi cea de a
cincea soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Subprogramul duplicare are doi parametri:
n, prin care primeşte un număr natural (n " 1, 10 );
4
d, prin care furnizează numărul obţinut prin duplicarea fiecărei cifre pare a lui n sau -1 dacă
acesta nu are nicio cifră pară.

Exemplu: dacă n=2380, după apel d=2238800. (10p.)
Problema 4
6 9
Fişierul bac.txt conţine un şir de cel mult 10 numere naturale distincte din intervalul 0, 10 .
Numerele din şir sunt separate prin câte un spaţiu.
Se cere să se determine cei mai mari doi termeni pari din şir care sunt precedaţi de doar trei
termeni impari. Termenii determinaţi se afişează pe ecran, ı̂n ordine strict crescătoare, separaţi
printr-un spaţiu, iar dacă ı̂n şir nu există doi astfel de termeni, se afişează pe ecran mesajul Nu
exista.
Pentru determinarea termenilor ceruţi se utilizează un algoritm eficient din punctul de vedere
al spaţiului de memorie şi al timpului de executare.
4 3 5 312 27 30 14 212 11 15 17 400
se afişează pe ecran numerele
30 212
(4 este precedat de 0 numere impare, 312 este precedat de 2 numere impare, 30, 14 şi 212 sunt
precedate de 3 numere impare, iar 400 este precedat de 6 numere impare; dintre numerele 30, 14
şi 212 cele mai mari sunt 30 şi 212).
Capitolul 9
BAC 2015

Varianta 5
9.1.1 Subiectul I
Problema 1
Expresia C/C++ alăturată are valoarea: (4p.)
a. 4 b. 8 c. 9 d. 14
Problema 2
docod.
numărul natural nenul b şi cu [c] partea ı̂ntreagă a numărului real
c.
a) Scrieţi valoarea afişată dacă se citesc, ı̂n această ordine, nu-
merele 997 şi 1005. (6p.)
b) Dacă pentru m se citeşte numărul 54321, scrieţi cel mai mare
număr care poate fi citit pentru n astfel ı̂ncât, ı̂n urma executării
algoritmului, valoarea afişată să fie 0. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat,
ı̂nlocuind structura pentru...execută cu o structură de tip cât
timp...execută. (6p.)
(10p.)
Problema 1
În declarările alăturate, variabilele A şi B memorează coordonatele câte unui
punct ı̂n sistemul de coordonate xOy. Indicaţi expresia care are valoarea 1 dacă
şi numai dacă cele două puncte coincid. (4p.)
a. A[x]==B[x] && A[y]==B[y] b. A.x==B.x && A.y==B.y
c. x[A]==x[B] && y[A]==y[B] d. x.A==x.B && y.A==y.B
77
Problema 2
Un graf orientat cu 5 vârfuri, numerotate de la 1 la 5, este reprezentat

alăturat. Numărul maxim de arce care se pot elimina, astfel ı̂ncât graful
parţial obţinut să fie tare conex este: (4p.)
a. 2 b. 3 c. 4 d. 5
Scrieţi pe foaia de examen răspunsul pentru fiecare dintre

cerinţele următoare.
Problema 3
(4,4,0,3,6,3,2,7). Scrieţi un lanţ elementar care are o extremitate ı̂n rădăcina arborelui şi cealaltă
extremitate ı̂n una dintre frunzele acestuia. (6p.)
Problema 4
executării secvenţei obţinute, variabila a să memoreze tabloul alăturat. (6p.)
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
..................
Problema 5
Se consideră un text cu cel mult 100 de caractere, ı̂n care cuvintele sunt formate numai din litere
mari şi mici ale alfabetului englez şi sunt separate prin câte un spaţiu. Textul reprezintă numele
unei instituţii sau al unei organizaţii.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul precizat şi construieşte
ı̂n memorie, apoi afişează pe ecran, un şir de caractere ce reprezintă acronimul corespunzător
numelui citit. Acronimul este format din primul caracter al fiecărui cuvânt al numelui care ı̂ncepe
cu majusculă.
Exemplu: dacă şirul citit este
Universitatea de Arte Plastice BUCURESTI
se va obţine şirul
UAPB (10p.)

Problema 1
Utilizând metoda backtracking, se generează toate şiragurile formate din câte 5 pietre distincte din
mulţimea {opal, rubin, safir, smarald, topaz}. Două şiraguri sunt distincte dacă pietrele
sunt dispuse ı̂n altă ordine.
Primele patru soluţii obţinute sunt, ı̂n această ordine: (opal, rubin, safir,
smarald, topaz), (opal, rubin, safir, topaz, smarald), (opal, rubin, smarald,
safir, topaz) şi (opal, rubin, smarald, topaz, safir).
Indicaţi soluţia care trebuie eliminată din enumerarea următoare, astfel ı̂ncât cele rămase
să apară ı̂n ordinea generării lor, pe poziţii consecutive: (smarald, safir, opal, topaz,
rubin) (smarald, safir, topaz, opal, rubin) (smarald, safir, topaz, rubin,
opal) (smarald, topaz, opal, rubin, safir). (4p.)
a. (smarald, safir, opal, topaz, rubin) b. (smarald, safir, topaz, opal, rubin)
c. (smarald, safir, topaz, rubin, opal) d. (smarald, topaz, opal, rubin, safir)
Problema 2
Subprogramul F este definit alăturat. Scrieţi

ce se afişează ı̂n urma apelului de mai jos.
F(154678,3); (6p.)
Problema 3
Subprogramul DivImpar are doi parametri, a şi b, prin care primeşte două numere naturale din
5
intervalul 1, 10 . Subprogramul returnează cel mai mare divizor comun impar al numerelor a şi
b.
Exemplu: dacă a=30 şi b=60, subprogramul returnează valoarea 15. (10p.)
Problema 4
9
Fişierul date.in conţine un şir de cel mult un milion de numere naturale din intervalul 0, 10 ,
separate prin câte un spaţiu. şirul are cel puţin doi termeni pari şi cel puţin doi termeni impari.
Se cere să se afişeze pe ecran mesajul DA dacă şirul aflat ı̂n fişier are un subşir ordonat crescător,
format din toţi termenii pari ai săi, şi un subşir ordonat descrescător, format din toţi termenii
impari ai săi. Dacă nu există două astfel de subşiruri, programul afişează pe ecran mesajul NU.
Pentru verificarea proprietăţii cerute utilizaţi un algoritm eficient din punctul de vedere al
timpului de executare şi al memoriei necesare.
Exemplu: dacă fişierul date.in conţine numerele
7252438
se afişează pe ecran mesajul
DA
iar dacă fişierul conţine numerele
5272438
se afişează pe ecran mesajul
NU

Varianta 5
9.2.1 Subiectul I
Problema 1
Variabila ı̂ntreagă x memorează un număr natural cu cel puţin patru cifre nenule distincte. Ex-
presia C/C++ a cărei valoare este egală cu cifra sutelor acestui număr este: (4p.)
a. x/100 b. x%100 c. (x/10)%10 d. (x/100)%10
Problema 2
docod.
real c.
b) Dacă pentru variabila k se citeşte numărul 5, scrieţi cea
mai mică şi cea mai mare valoare care pot fi citite pentru vari-
abila n astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
ı̂nlocuind prima structură cât timp...execută cu o structură
repetitivă de tip pentru...execută. (6p.)
dat. (10p.)
Problema 1
Variabila c, declarată alăturat, memorează titlul şi preţul unei cărţi. Ex-
presia C/C++ a cărei valoare reprezintă preţul cărţii respective majorat
cu 50% este: (4p.)
a. c.pret*3/2 b. pret.c*3/2 c. c(pret)*3/2 d. pret[c]*3/2
Problema 2
Un arbore cu 37 de noduri, numerotate de la 1 la 37, are ca rădăcină nodul numerotat cu 1,Ó iar
tatăl fiecărui nod i (i " 2, 37) este numerotat cu partea ı̂ntreagă a rădăcinii pătrate a lui i ([ i]).
Numărul de frunze ale arborelui este: (4p.)
a. 36 b. 31 c. 21 d. 6
Problema 3
Un graf neorientat cu 8 noduri, numerotate de la 1 la 8, are muchiile [1,2], [1,6], [4,6], [3,6], [6,5],
[5,3], [3,4], [7,8], [8,2]. Enumeraţi trei noduri care nu aparţin niciunui ciclu ı̂n acest graf. (6p.)
Problema 4
Fiind date două şiruri de caractere a şi b, ı̂l numim pe a prefix al lui b dacă a este egal cu b sau
dacă b se poate obţine din a prin alipirea la dreapta a unor noi caractere.
Variabilele a şi b pot memora câte un şir cu cel mult 20 de caractere. ştiind că variabila b a
fost iniţializată cu un şir format dintr-un număr par de caractere, scrieţi o secvenţă de instrucţiuni
ı̂n urma executării căreia variabila a să memoreze un prefix al lui b a cărui lungime să fie jumătate
din lungimea lui b.
Exemplu: dacă b memorează şirul aurari, atunci a memorează şirul aur. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural, n (n " 2, 20), apoi n
4
numere naturale din intervalul 0, 10 , reprezentând, de la stânga la dreapta, ı̂n această ordine,
valorile elementelor aflate pe prima linie a unui tablou bidimensional cu n linii şi n coloane.
Programul construieşte ı̂n memorie tabloul, iniţializând celelalte elemente, astfel ı̂ncât fiecare linie
să se obţină prin permutarea circulară a elementelor liniei anterioare, de la stânga spre dreapta,
cu o poziţie, ca ı̂n exemplu.
Exemplu: dacă se citesc numerele n=4, apoi 1, 1, 3, 2, se obţine tabloul alăturat.
(10p.)

Problema 1
Utilizând metoda backtracking, se generează toate numerele naturale din intervalul [100,999] care
au suma cifrelor egală cu 5. Primele cinci soluţii obţinute sunt, ı̂n această ordine 104, 113, 122, 131,
140. Utilizând acelaşi algoritm, se generează toate numerele naturale din intervalul [1000,9999]
care au suma cifrelor egală cu 6. Al treilea număr generat este: (4p.)
a. 1005 b. 1023 c. 1031 d. 1041
Problema 2
Subprogramul F este definit alăturat. Scrieţi ce se afişează
ı̂n urma apelului de mai jos.
F(’d’); (6p.)
Problema 3
Şirul lui Fibonacci (1, 1, 2, 3, 5, 8, 13, 21,) se defineşte astfel:
f1 1, f2 1şifi fi1 fi2 pentru orice număr natural i, i ' 3.
Subprogramul Fibo are un singur parametru, n, prin care primeşte un număr natural (n "
1, 30). Subprogramul returnează al n-lea termen impar al şirului lui Fibonacci.
Exemplu: dacă n=6, subprogramul returnează numărul 21. (10p.)
Problema 4
2
Fişierul bac.txt conţine un şir de cel mult un milion de numere naturale din intervalul 0, 10 ,
separate prin câte un spaţiu.
Se cere să se determine toate perechile distincte formate din termeni ai şirului aflat ı̂n fişier, x
şi y (y x ' 2), astfel ı̂ncât să nu existe niciun termen al şirului care să aparţină intervalului x, y .
Numerele din fiecare pereche sunt afişate pe câte o linie a ecranului, ı̂n ordine strict crescătoare,
separate printr-un spaţiu, iar dacă nu există nicio astfel de pereche, se afişează pe ecran mesajul nu
exista. Pentru determinarea numerelor cerute utilizaţi un algoritm eficient din punctul de vedere
al timpului de executare.
5 9 0 8 10 11 12 13 15 14 6 7 40 10 0 0 5 41 95 7
atunci pe ecran se afişează, nu neapărat ı̂n această ordine, perechile
05
15 40
41 95

Varianta 2
a În rezolvările cerute, identificatorii utilizaţi trebuie să respecte precizările din enunţ (bold),
iar ı̂n lipsa unor precizări explicite, notaţiile trebuie să corespundă cu semnificaţiile asociate aces-
tora (eventual ı̂n formă prescurtată).
sară.
9.3.1 Subiectul I
Problema 1
variabila ı̂ntreagă n este divizibil cu 2, dar NU şi cu 5. (4p.)
a. !((n%2==1) || (n%5==0)) b. (n%2==0) && (n%5==0)
c. (n%10==0) || (n%5!=0) d. (n%10==0) && (n%2==0)
Problema 2

docod.
a) Scrieţi valorile afişate dacă se citesc, ı̂n această ordine,
b) Dacă pentru k se citeşte numărul 11, scrieţi cel mai mic
şi cel mai mare număr din intervalul [1,99] care pot fi citite
pentru n astfel ı̂ncât, ı̂n urma executării algoritmului, pentru
fiecare dintre acestea, ultima valoare afişată să fie 7. (4p.)
ı̂nlocuind a doua structură cât timp...execută cu o struc-
tură repetitivă de alt tip. (6p.)
dat. (10p.)

Problema 1
Variabila z, declarată alăturat, memorează partea reală şi partea imaginară a
unui număr complex. Expresia care are valoarea egală cu pătratul modulului
acestui număr (suma dintre pătratul părţii reale şi pătratul părţii imaginare)
este: (4p.)
a. complex(re)*complex(re)+complex(im)*complex(im)
b. complex.z(re)*complex.z(re)+complex.z(im)*complex.z(im)
c. re.z*re.z+im.z*im.z
d. z.re*z.re+z.im*z.im
Problema 2
Numărul maxim de muchii ale unui graf neorientat, cu 100 de noduri, care nu conţine niciun ciclu,
este: (4p.)
a. 50 b. 99 c. 100 d. 4950
Problema 3

(3,3,8,0,8,9,9,4,4,9). Enumeraţi toate nodurile de tip frunză ale arborelui. (6p.)
Problema 4
executării secvenţei obţinute, variabila a să memoreze tabloul alăturat.
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
.................. (6p.)
Problema 5
Se consideră un cuvânt format din cel puţin două şi cel mult 100 de caractere, numai litere mici
ale alfabetului englez.
Scrieţi un program C/C++ care citeşte de la tastatură un cuvânt de tipul precizat şi afişează
pe ecran mesajul DA ı̂n cazul ı̂n care cuvântul conţine doar consoane şi, eventual, vocala i, sau
mesajul NU ı̂n caz contrar.
Exemplu: pentru cuvântul inscriptibil sau cuvântul brr
se afişează mesajul
DA
iar pentru cuvântul inestimabil sau cuvântul iii
se afişează mesajul
NU (10p.)
Problema 1
Utilizând metoda backtracking, se generează toate parfumurile formate prin amestecarea a câte
3 esenţe distincte din mulţimea {ambră, cedru, iris, mosc, santal}. Primele patru soluţii
obţinute sunt, ı̂n această ordine: (ambră, cedru, iris), (ambră, cedru, mosc), (ambră,
cedru, santal) şi (ambră, iris, mosc). Indicaţi submulţimea care trebuie eliminată din
enumerarea următoare, astfel ı̂ncât soluţiile rămase să apară ı̂n ordinea generării lor: (ambră,
mosc, santal), (cedru, mosc, santal), (cedru, iris, mosc), (cedru, iris, santal).
(4p.)
a. (ambr\u a, mosc, santal) b. (cedru, mosc, santal)

c. (cedru, iris, mosc) d. (cedru, iris, santal)
Problema 2
Subprogramul F este definit alăturat. Scrieţi instrucţiunea prin
care se poate apela subprogramul pentru a afişa, ı̂n ordine strict
descrescătoare, toţi divizorii pozitivi proprii ai numărului 2015 (di-
vizori naturali diferiţi de 1 şi de 2015). (6p.)
Problema 3
Subprogramul NrPrime are un singur parametru, n, prin care
primeşte un număr natural (n " 0, 10 ). Subprogramul returnează numărul de cifre prime
9
ale lui n.
Exemplu: dacă n=1233405, atunci subprogramul returnează valoarea 4. (10p.)
Problema 4
Fişierul BAC.TXT conţine pe prima linie un număr natural, n (n " 2, 5000), şi pe a doua linie
un şir de 2 n numere naturale din intervalul [0,5]. Numerele aflate pe aceeaşi linie a fişierului
sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran valoarea obţinută ı̂nsumând toate produsele de forma x y, unde
x şi y sunt numere de paritate diferită, x fiind printre primii n termeni ai şirului aflat ı̂n fişier,
iar y printre ultimii n termeni ai acestui şir. Dacă nu există niciun astfel de produs, valoarea
cerută este nulă. Pentru determinarea numărului cerut utilizaţi un algoritm eficient din punctul
de vedere al timpului de executare şi al memoriei necesare.
Exemplu: dacă fişierul are conţinutul de mai jos
5
1200542310
pe ecran se afişează numărul 44
(1 4 1 2 1 0 2 3 2 1 0 3 0 1 0 3 0 1 5 4 5 2 5 0 44).
Capitolul 10
BAC 2014

Varianta 2
10.1.1 Subiectul I
Problema 1
Variabilele x, y şi z sunt de tip ı̂ntreg şi memorează câte un număr
natural nenul. Dacă expresia C/C++ alăturată are valoarea 1, indicaţi
şirul crescător format cu valorile acestor variabile, ı̂n ordinea precizată mai jos. (4p.)
a. x, y, z b. y, z, x c. z, x, y d. z, y, x
Problema 2
docod.
S-a notat cu x%y restul ı̂mpărţirii numărului natural x la
numărul natural nenul y şi cu [z] partea ı̂ntreagă a numărului real
z.
b) Scrieţi două numere de patru cifre distincte care pot fi citite
astfel ı̂ncât, ı̂n urma executării algoritmului, pentru fiecare dintre
acestea, să se afişeze valoarea 0. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂n care
să se ı̂nlocuiască structura cât timp...execută cu o structură
(10p.)

Problema 1
Pentru a putea memora un tablou bidimensional cu maximum 21 de elemente, numere reale,
variabila A se poate declara astfel: (4p.)
a. A[3..7] int; b. A[3][7] float;

c. int A[3;7]; d. float A[3][7];
86
Problema 2
Se consideră un graf neorientat conex şi fără cicluri, ı̂n care gradul oricărui nod este mai mic sau
egal cu 4. Dacă şase dintre nodurile sale au gradul egal cu 1, atunci numărul maxim de noduri cu
gradul egal cu 4 este: (4p.)
a. 0 b. 1 c. 2 d. 3
Problema 3
Scrieţi matricea de adiacenţă prin care poate fi reprezentat graful orientat

cu 5 vârfuri, numerotate de la 1 la 5, ilustrat ı̂n figura alăturată. (6p.)
Problema 4
Se consideră următoarea operaţie prin care se transformă un arbore cu rădăcină: se elimină din
arbore nodul ”frunză” numerotat cu valoarea minimă, marcându-se nodul ”tată” al acestuia.
Scrieţi vectorul de ”taţi” al unui arbore cu 6 noduri, numerotate de la 1 la 6, ı̂n care nodul 1
este rădăcină, ştiind că dacă asupra acestui arbore se efectuează de patru ori succesiv operaţia de
transformare menţionată mai sus, se marchează, ı̂n această ordine, nodurile 5, 1, 1, 1. (6p.)
Problema 5
Se consideră un text cu cel mult 100 de caractere, ı̂n care cuvintele sunt formate numai din litere
mici ale alfabetului englez şi sunt separate prin câte un spaţiu.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul menţionat mai sus
şi determină transformarea acestuia ı̂n memorie, astfel ı̂ncât din fiecare cuvânt format dintr-un
număr impar de litere (cel puţin trei) să se elimine litera aflată pe poziţia din mijloc, ca ı̂n exemplu.
Programul afişează pe ecran textul obţinut, iar dacă nu există niciun cuvânt modificat, afişează
pe ecran mesajul nu exista.
pictura prin aceea arata o pace profunda
se afişează
picura prin acea arta o pace profunda (10p)
Problema 1
Utilizând metoda backtracking, se generează toate posibilităţile de a obţine suma 4 cu numere

naturale nenule. Două sume sunt distincte dacă diferă prin cel puţin un termen. Soluţiile generate
sunt, ı̂n această ordine, 1+1+1+1, 1+1+2, 1+3, 2+2.
Aplicând acelaşi algoritm pentru a genera toate posibilităţile de a obţine suma 6, dacă prima
soluţie generată este 1+1+1+1+1+1, atunci soluţia 1+2+3 este generată: (4p.)
a. a 6-a b. a 7-a c. a 8-a d. a 9-a
Problema 2
Se consideră subprogramul f, definit alăturat. Scrieţi valorile

f(5,5) şi f(10,21). (6p.)
Problema 3
Un număr natural nenul se numeşte perfect dacă este egal cu suma divizorilor săi naturali strict
mai mici decât el.
Exemplu: 28 este număr perfect pentru că 28=1+2+4+7+14.
Se consideră subprogramul perfect, cu doi parametri, a şi b, prin care primeşte câte un număr
natural (2 & a $ b & 10 ). Subprogramul afişează pe ecran, separate prin câte un spaţiu, ı̂n ordine
9
descrescătoare, toate numerele perfecte din intervalul [a,b]. Dacă ı̂n interval nu există astfel de
numere, subprogramul afişează pe ecran mesajul nu exista.
Exemplu: pentru a=5 şi b=30, se afişează pe ecran: 28 6 (10p.)
Problema 4
Numim secvenţă uniformă a unui şir de numere naturale un subşir al acestuia, format din termeni
cu aceeaşi valoare, aflaţi pe poziţii consecutive ı̂n şirul dat. Lungimea secvenţei este egală cu
numărul de termeni ai acesteia.
Fişierul bac.txt conţine un şir de cel puţin două şi cel mult 1000000000 de numere naturale
9
din intervalul 0, 10 . Numerele sunt separate prin câte un spaţiu, iar ı̂n şir există cel puţin doi
termeni egali pe poziţii consecutive.
Se cere să se determine o secvenţă uniformă de lungime maximă ı̂n şirul aflat ı̂n fişier şi să se
afişeze pe ecran lungimea acestei secvenţe şi, pe o linie nouă, separaţi prin câte un spaţiu, termenii
acesteia. Dacă sunt mai multe astfel de secvenţe, se afişează doar termenii ultimei dintre acestea.
Pentru determinarea numerelor cerute se utilizează un algoritm eficient din punctul de vedere
al memoriei necesare şi al timpului de executare.
2 3 3 3 3 5 4 4 11 11 11 11 16 11 11 11 11 15 15
atunci pe ecran se afişează valorile
4
11 11 11 11

Varianta 4
10.2.1 Subiectul I
Problema 1
Valoarea expresiei C/C++ alăturate este: (4p.)
a. 6 b. 8 c. 11 d. 18
Problema 2
docod.
numărul natural nenul y şi cu [z] partea ı̂ntreagă a numărului
real z.
a) Scrieţi valorile afişate dacă se citeşte numărul 2352. (6p.)
b) Scrieţi două numere cu cel mult două cifre care pot fi citite
astfel ı̂ncât, ı̂n urma executării algoritmului, pentru fiecare din-
tre acestea, să se afişeze valorile 5 1. (4p.)
ı̂n care să se ı̂nlocuiască prima structură cât timp...execută
cu o structură repetitivă de alt tip. (6p.)
dat. (10p.)

Problema 1
Un graf orientat are 8 vârfuri, numerotate de la 1 la 8, şi arcele (1,7), (1,8), (3,5), (3,7), (4,3),
(4,7), (6,3), (6,5), (6,7), (6,8), (8,5), (8,7).
Numărul vârfurilor care au gradul extern nul este: (4p.)
a. 1 b. 2 c. 3 d. 4
Problema 2
Variabila s poate memora un şir cu maximum 20 de caractere.
ı̂n urma executării secvenţei de instrucţiuni alăturate se afişează:
(4p.)
a. 1b438 b. 1bcd8 c. ba2 d. bcd
Problema 3
Se consideră declararea alăturată. Scrieţi o secvenţă de instrucţiuni ı̂n
urma executării căreia să se afişeze pe ecran mesajul acceptat, dacă
momentul de timp corespunzător variabilei start precede momentul
de timp din aceeaşi oră, corespunzător variabilei stop, sau mesajul
respins ı̂n caz contrar. (6p.)
Problema 4
Considerăm că ı̂nălţimea unui arbore cu rădăcină este egală cu cea mai mare dintre lungimile
lanţurilor elementare care au o extremitate ı̂n rădăcină şi cealaltă extremitate ı̂n oricare dintre
”frunzele” arborelui.
Se consideră arborele cu 9 noduri, numerotate de la 1 la 9, şi muchiile [1,2], [2,3], [2,5], [3,7],
[4,5], [5,6], [5,8], [8,9]. Scrieţi nodurile care pot fi alese drept rădăcină, astfel ı̂ncât ı̂nălţimea
arborelui să fie maximă. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale, m şi n (3 & m & 50,
3 & n & 50), şi elementele unui tablou bidimensional cu m linii şi n coloane, numere naturale
cu cel mult patru cifre, apoi modifică tabloul ı̂n memorie, eliminând penultima linie şi penultima
coloană a acestuia, ca ı̂n exemplu.

Problema 1
Se consideră subprogramul f, definit alăturat.
Indicaţi ce valoare are f(15). (4p.)
a. 1 b. 7 c. 8 d. 10
Problema 2
Utilizând metoda backtracking, se generează toate posibilităţile de a forma şiraguri de câte
4 mărgele de culori distincte din mulţimea {roşu, galben, roz, albastru, violet}, astfel
ı̂ncât ı̂n fiecare şirag nu pot fi pe poziţii alăturate mărgele roşii şi galbene. Două şiraguri sunt
distincte dacă au cel puţin o mărgea de culoare diferită sau dacă ordinea culorilor mărgelelor este
diferită.
Primele cinci soluţii generate sunt, ı̂n această ordine, (roşu, roz, galben, albastru),
(roşu, roz, galben, violet), (roşu, roz, albastru, galben), (roşu, roz,
albastru, violet), (roşu, roz, violet, galben). Scrieţi cea de a şasea şi cea de a
şaptea soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Un interval cu proprietatea că există un singur număr natural, n (2n), pentru care valoarea
produsului 1 2 3 ... n aparţine acestui interval este numit interval factorial al lui n.
Exemplu: [5,8] şi [3,23] sunt intervale factoriale ale lui 3, dar [1,15] şi [7,10] nu sunt intervale
factoriale ale niciunui număr.
Se consideră subprogramul interval, cu trei parametri:
n, prin care primeşte un număr natural din intervalul [2,10].
a şi b, prin care furnizează câte un număr natural, astfel ı̂ncât expresia b-a să aibă valoare
maximă, iar [a,b] să fie interval factorial al lui n.
Exemplu: dacă n=3, după apel a=3 şi b=23. (10p.)
Problema 4
Un număr natural x, format din exact două cifre, este numit sub-număr al unui număr natural y
dacă cifrele lui x apar, ı̂n aceeaşi ordine, pe ranguri consecutive, ı̂n numărul y.
Exemplu: 21 este sub-număr al lui 12145, al lui 213, al lui 21, dar nu şi al lui 123 sau al lui
231.
9
Fişierul bac.txt conţine cel mult 1000000 de numere naturale din intervalul 10, 10 , separate
Se cere să se afişeze pe ecran, separate prin câte un spaţiu, sub-numerele care apar de cele mai
multe ori ı̂n scrierea numerelor din fişier. Pentru determinarea sub-numerelor cerute se utilizează
un algoritm eficient din punctul de vedere al timpului de executare.
atunci pe ecran se afişează valorile de mai jos, nu neapărat ı̂n această ordine:
77 21

Varianta 10
10.3.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi poate memora un număr natural cu cel mult două
cifre. Valoarea maximă pe care o poate avea expresia C/C++ alăturată este: (4p.)
a. 6 b. 14.14 c. 93 d. 693
Problema 2
a) Scrieţi valoarea afişată dacă se citesc, ı̂n această ordine, numerele
10, 8, 11, 1, 21, 0. (6p.)
b) Scrieţi un set de patru numere distincte din intervalul [0,9] care
pot fi citite astfel ı̂ncât, ı̂n urma executării algoritmului, să se afişeze
valoarea 0. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂n care
să se ı̂nlocuiască prima structură repetă...până când cu o structură
repetitivă cu test iniţial. (6p.)

Pentru fiecare dintre itemii 1 şi 2 scrieţi pe foaia de examen
litera corespunzătoare răspunsului corect.
Problema 1
Un arbore cu 4 noduri, numerotate de la 1 la 4, NU poate fi reprezentat prin vectorul de ”taţi”:
(4p.)
a. (0,1,2,3) b. (2,1,0,3) c. (4,4,4,0) d. (2,3,4,0)
Problema 2
Se consideră un graf neorientat complet, cu 9 noduri. Pentru a obţine un graf parţial al său cu
două componente conexe, fiecare dintre acestea fiind grafuri complete, numărul maxim de muchii
care pot fi eliminate este: (4p.)
a. 14 b. 18 c. 20 d. 24
Problema 3
Se consideră graful orientat cu 6 vârfuri, numerotate de la 1 la 6, reprezentat
prin matricea de adiacenţă alăturată. Scrieţi un drum elementar din graf, cu
extremitatea iniţială ı̂n vârful 4 şi extremitatea finală ı̂n vârful 6. (6p.)
Problema 4
Variabila s poate memora un şir cu maximum 20 de caractere, iar variabila i
este de tip ı̂ntreg.
Scrieţi ce se afişează ı̂n urma executării secvenţei de instrucţiuni de mai jos. (6p.)
strcpy(s,"BACALAUREAT");
cout<<strlen(s); | printf("%d",strlen(s));
i=0;
while (i<strlen(s)-1)
{ if(strchr("EAIOU",s[i])!=NULL) strcpy(s+i+1,s+i+2);
i++;
}
cout<<s; | printf("%s",s);
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale, m şi n (2 & m & 20,
2 & n & 20), şi construieşte ı̂n memorie un tablou bidimensional A, cu m linii şi n coloane, astfel
ı̂ncât parcurgându-l linie cu linie, de sus ı̂n jos, şi fiecare linie de la stânga la dreapta, să se obţină
şirul primelor n m numere naturale, pare, care NU sunt divizibile cu 5, ordonat strict crescător.
Exemplu: pentru m=4 şi n=3 se obţine tabloul alăturat. (10p.)
Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare

Problema 1
Utilizând metoda backtracking, se generează toate posibilităţile de a forma succesiuni de câte

5 genuri muzicale distincte din mulţimea {jazz, rock, latino, house, pop}, astfel ı̂ncât ı̂n
fiecare succesiune genul latino precede genul house. Două succesiuni sunt distincte dacă genurile
muzicale sunt ı̂n altă ordine.
Primele cinci soluţii generate sunt, ı̂n această ordine, (jazz, rock, latino, house,
pop), (jazz, rock, latino, pop, house), (jazz, rock, pop, latino, house), (jazz,
latino, rock, house, pop), (jazz, latino, rock, pop, house).
Imediat ı̂nainte de (pop, latino, house, jazz, rock) este generată soluţia: (4p.)
a. (rock, jazz, house, latino, pop) b. (rock, jazz, latino, house, pop)
c. (pop, latino, rock, house, jazz) d. (pop, rock, latino, house, jazz)
Problema 2
Se consideră subprogramul f, definit alăturat. Scrieţi două val-
ori naturale distincte din intervalul [1,50] pe care le poate avea
variabila ı̂ntreagă x, astfel ı̂ncât f(30,x) să aibă valoarea 5. (6p.)
Problema 3
Se consideră subprogramul triplete, cu un singur parametru, n, prin care primeşte o valoare
4
naturală din intervalul 2, 10 . Subprogramul afişează pe ecran toate tripletele de numere naturale
x, y, z cu proprietatea că x $ y $ z şi x y y z n. Fiecare triplet se afişează pe câte o linie
a ecranului, iar numerele din fiecare triplet sunt separate prin câte o virgulă şi ı̂ncadrate ı̂ntre
paranteze rotunde, ca ı̂n exemplu.
Exemplu: pentru n=8 se afişează pe ecran, nu neapărat ı̂n această ordine, tripletele:
(0,1,8)
(0,2,4)
(1,2,3) (10p.)
Problema 4
Fişierul bac.txt conţine pe prima linie un număr natural n (1 & n & 10 ), iar pe a doua linie cel
6
mult 1000000 de numere naturale de forma 10 (0 & p & 9), separate prin câte un spaţiu.
p
Se cere să se afişeze pe ecran numărul care ar apărea pe poziţia n ı̂n şirul ordonat crescător
obţinut din toate numerele aflate pe a doua linie a fişierului. Dacă şirul are mai puţin de n termeni,
se afişează pe ecran mesajul Nu exista.
Pentru determinarea numărului cerut se utilizează un algoritm eficient din punctul de vedere
5
100 100000 1 100000 1000 100 10
atunci pe ecran se afişează valoarea
1000
Capitolul 11
BAC 2013

Varianta 7
11.1.1 Subiectul I
Problema 1
Indicaţi expresia care are valoarea 1 dacă şi numai dacă numărul natural memorat ı̂n variabila
ı̂ntreagă x are exact două cifre. (4p.)
a. x/100==0 && x>9 b. x/100==0 || x<100

c. x%100==0 && x<100 d. x%100==0 || x>9
Problema 2
docod.
a) Scrieţi ce se afişează dacă pentru variabila a se citeşte valoarea
5, iar pentru variabila b se citeşte valoarea 9. (6p.)
b) Dacă pentru variabila a se citeşte valoarea 10, scrieţi numărul
care poate fi citit pentru variabila b astfel ı̂ncât, ı̂n urma executării
algoritmului, caracterul # să fie afişat de exact trei ori. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂n
care să se ı̂nlocuiască structura pentru...execută cu o structură

Problema 1
Variabila a memorează elementele unui tablou bidimensional cu 100 de linii şi 100 de coloane,
numerotate de la 1 la 100. Un element aflat pe diagonala secundară a tabloului poate fi accesat
prin: (4p.)
a. a[1][3] b. a[15][15] c. a[16][24] d. a[42][59]
94
Problema 2
Într-un arbore cu rădăcină considerăm că un nod se află pe nivelul x dacă lanţul elementar care
are o extremitate ı̂n nodul respectiv şi cealaltă extremitate ı̂n rădăcina arborelui are lungimea x.
Pe nivelul 0 se află un singur nod (rădăcina).
Se consideră un arbore cu rădăcină, cu patru niveluri. Toate nodurile de pe acelaşi nivel (cu
excepţia ultimului nivel) au un număr egal (nenul) de descendenţi direcţi (”fii”) şi nu există două
niveluri cu acelaşi număr de noduri. Numărul minim de noduri de pe nivelul 3 este: (4p.)
a. 6 b. 8 c. 9 d. 12
Problema 3
În declararea alăturată, variabilele f şi fs memorează ı̂n câmpurile a şi
b numărătorul, respectiv numitorul câte unei fracţii. Scrieţi o secvenţă
de instrucţiuni C/C++ care să memoreze ı̂n variabila fs fracţia obţinută
prin ı̂nsumarea fracţiei memorate ı̂n variabila f şi a fracţiei 23 . (6p.)
Problema 4
Scrieţi toate ciclurile elementare distincte ale unui graf neorientat cu 6 noduri, numerotate de la
1 la 6, şi muchiile [1,2], [1,3], [1,5], [3,4], [3,5], [4,5], [5,6].
Două cicluri se consideră distincte dacă ele diferă prin cel puţin o muchie. (6p.)
Problema 5
Se consideră un text cu cel mult 100 de caractere (litere mici ale alfabetului englez şi spaţii), ı̂n
care cuvintele sunt separate prin câte un spaţiu. Înaintea primului cuvânt şi după ultimul cuvânt
nu există spaţii.
determină transformarea acestuia ı̂n memorie prin ı̂nlocuirea fiecărui cuvânt format din trei litere
cu simbolul *. Programul afişează pe ecran textul obţinut.
bun este izvorul ce are apa rece
se afişează
* este izvorul ce * * rece (10p.)
Problema 1
Se consideră subprogramele f1 şi f2, definite mai jos.
Identificaţi subprogramul care, la apel, pentru parametrul n=10, returnează suma primelor 10
numere naturale. (4p.)
a. at\ât f1, c\ât \c si f2 b. numai f1 c. numai f2 d. nici f1, nici f2

Problema 2
Utilizând metoda backtracking se generează toate submulţimile cu cel mult patru elemente din
mulţimea {3, 5, 6, 7, 8}. Primele şase soluţii generate sunt, ı̂n această ordine: {3}, {3, 5}, {3, 5,
6}, {3, 5, 6, 7}, {3, 5, 6, 8}, {3, 5, 7}. Scrieţi cea de a şaptea şi cea de a opta soluţie, ı̂n ordinea
generării acestora. (6p.)
Problema 3
Se consideră subprogramul sub, cu trei parametri:
n, prin care primeşte un număr natural (2¡n¡50);
v, prin care primeşte un tablou unidimensional cu n elemente, numere naturale cu cel mult
4 cifre;
x, prin care primeşte un număr natural cu cel mult 4 cifre. Cel puţin unul dintre elementele
tabloului are valoarea x.
Subprogramul modifică ordinea valorilor din tablou, astfel ı̂ncât toate valorile egale cu x să ocupe
primele poziţii din v, iar celelalte valori să se regăsească ı̂n continuarea acestora.
Tabloul modificat este furnizat tot prin parametrul v.
Exemplu: dacă n=9, v=(2, 1, 0, 1, 7, 0, 1, 4, 5) şi x=1, atunci, după apel, o soluţie posibilă
este v=(1, 1, 1, 2, 0, 7, 0, 4, 5). (10p.)
Problema 4
Fişierul bac.txt conţine un şir de cel puţin trei şi cel mult 1000000 de numere naturale cu cel
mult nouă cifre. Numerele din şir sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran, separate printr-un spaţiu, două numere distincte, anume cel mai
mic număr par cu două cifre şi cel mai mare număr par cu două cifre care NU fac parte din şir.
Dacă nu există două astfel de valori, pe ecran se afişează mesajul Nu exista. Pentru deter-
minarea numerelor cerute se utilizează un algoritm eficient din punctul de vedere al timpului de
executare.
Exemplu: dacă fişierul bac.txt conţine valorile
7 2 40 5 10 15 11 12 18 350
se afişează pe ecran numerele 14 98.

Varianta 2
11.2.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi poate memora un număr natural cu cel mult două cifre.
Valoarea maximă pe care o poate avea expresia C/C++ alăturată este: (4p.)
a. 3 b. 24.75 c. 95 d. 396
Problema 2
pseudocod.
S-a notat cu x%y restul ı̂mpărţirii numărului natural
x la numărul natural nenul y şi cu [z] partea ı̂ntreagă a
numărului real z.
a) Scrieţi valoarea afişată dacă se citesc, ı̂n această or-
dine, numerele 19, 23 şi 2. (6p.)
b) Dacă pentru variabila a se citeşte valoarea 1, iar pen-
tru variabila c se citeşte valoarea 1, scrieţi toate numerele
naturale care pot fi citite pentru variabila b, astfel ı̂ncât, ı̂n
urma executării algoritmului, pentru fiecare dintre acestea,
să se afişeze valoarea 12. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat, ı̂n care să se ı̂nlocuiască structura
cât timp...execută cu o structură repetitivă cu test final. (6p.)
Problema 1
Expresia strlen(”bine”) are valoarea: (4p.)
a. 1 b. 4 c. 5 d. 6
Problema 2
Se consideră un graf orientat cu 6 vârfuri şi fără circuite. Numărul maxim de arce ale grafului
este: (4p.)
a. 5 b. 7 c. 10 d. 15
Problema 3
Se consideră declararea alăturată. Scrieţi o secvenţă de instrucţiuni
ı̂n urma executării căreia câmpul paritate al variabilei x să memoreze
litera p, dacă numărul memorat ı̂n câmpul v al acesteia este par, sau
litera i dacă numărul memorat ı̂n câmpul v al acesteia este impar.
(6p.)
Problema 4
Se consideră un arbore cu 5 noduri, dintre care doar trei au gradul egal cu 1. Scrieţi două valori
care să reprezinte gradele celorlalte două noduri. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale m şi n (2 & m & 50,
2 & n & 50) şi elementele unui tablou bidimensional cu m linii şi n coloane, numere naturale cu
cel mult patru cifre fiecare.
Programul determină coloanele care au toate elementele egale cu aceeaşi valoare şi, pentru
fiecare astfel de coloană afişează pe ecran valoarea respectivă.
Valorile afişate sunt separate prin câte un spaţiu, iar dacă nu există astfel de valori, programul
afişează pe ecran mesajul Nu exista.
Exemplu: pentru m=4, n=5 şi tabloul alăturat, se afişează pe ecran
numerele 3 7 7, nu neapărat ı̂n această ordine. (10p.)
Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare

Problema 1
Se consideră subprogramele f1 şi f2, definite mai jos.
y
La apel, pentru parametrii x 2 şi y 3, returnează x : (4p.)
a. atât f1, cât şi f2 b. numai f1 c. numai f2 d. nici f1, nici f2
Problema 2
Utilizând metoda backtracking se generează toate cuvintele de 5 litere din mulţimea {A, M},
cuvinte care ı̂ncep şi se termină cu M. Primele patru soluţii generate sunt, ı̂n această ordine:
MAAAM, MAAMM, MAMAM, MAMMM. Scrieţi cea de a cincea şi cea de a şasea soluţie, ı̂n
ordinea generării acestora. (6p.)
Problema 3
Se consideră subprogramul valuri, cu doi parametri:

n, prin care primeşte o valoare naturală 2 $ n $ 50;
v, prin care furnizează un tablou unidimensional cu 2 n elemente, valori ı̂ntregi din intervalul
1, 2 n.
Subprogramul construieşte tabloul v astfel ı̂ncât, ı̂n acesta, şirul elementelor impare să fie strict
crescător, iar şirul elementelor pare să fie strict descrescător. Primul element al tabloului este
impar, iar două elemente cu aceeaşi paritate nu pot ocupa poziţii consecutive ı̂n tablou, ca ı̂n
exemplu.
Exemplu: dacă n=4 atunci, după apel, v=( 1, 8, 3, 6, 5, 4, 7, 2). (10p.)
Problema 4
Se consideră şirul definit alăturat (unde n este un număr
natural nenul), ı̂n care nu există doi termeni cu aceeaşi par-
itate aflaţi pe poziţii consecutive:
1, 2, 3, 4, 7, 8, 15, 16 ....
Se citeşte de la tastatură un număr natural x, cu cel mult nouă cifre, termen al şirului dat, şi
se cere să se scrie ı̂n fişierul text bac.txt, ı̂n ordine strict descrescătoare, separaţi prin câte un
spaţiu, toţi termenii şirului care sunt mai mici sau egali cu x.
Pentru determinarea termenilor ceruţi se utilizează un algoritm eficient din punctul de vedere
al memoriei utilizate şi al timpului de executare.
Exemplu: dacă x=15, fişierul bac.txt conţine numerele
15 8 7 4 3 2 1

Varianta 6
11.3.1 Subiectul I
Problema 1
Valoarea expresiei C/C++ alăturate este: (4p.)
a. 6 b. 9 c. 9.5 d. 10
Problema 2
pseudocod.
numărului real z.
a) Scrieţi numărul afişat dacă pentru variabila a se
citeşte valoarea 65, iar pentru variabila b se citeşte val-
oarea 80. (6p.)
b) Dacă pentru variabila a se citeşte valoarea 1234,
scrieţi cel mai mare număr de patru cifre care poate fi
citit pentru variabila b astfel ı̂ncât, ı̂n urma executării
algoritmului, valoarea afişată să fie 5. (4p.)
pentru...execută cu o structură repetitivă cu test final. (6p.)

Problema 1
Variabila i este de tip ı̂ntreg (0 & i & 99), iar variabila a memorează elementele unui tablou
bidimensional cu 100 de linii şi 100 de coloane, numerotate de la 0 la 99. ı̂n limbajul C/C++, un
element aflat pe linia i şi pe diagonala principală a tabloului poate fi accesat prin: (4p.)
a. a[i,i] b. a(i,i) c. a(i)(i) d. a[i][i]

Problema 2
Se consideră un graf neorientat conex cu 50 de noduri şi 52 de muchii. Numărul minim de muchii
ce pot fi eliminate astfel ı̂ncât graful parţial obţinut să nu aibă niciun ciclu este: (4p.)
a. 1 b. 2 c. 3 d. 4
Problema 3
Se consideră arborele cu 8 noduri, numerotate de la 1 la 8, reprezentat prin vectorul de ”taţi”: (3,
0, 2, 5, 2, 5, 2, 5). Enumeraţi nodurile arborelui care au acelaşi ”tată” cu nodul 4. (6p.)
Problema 4
ı̂n declarările alăturate:
variabila p memorează coordonatele unui punct ı̂n sistemul de
coordonate xOy;
variabila d memorează ı̂n câmpurile A şi B coordonatele, ı̂n acelaşi
sistem de coordonate, ale vârfurilor din stânga - sus, respectiv
din dreapta - jos ale unui dreptunghi cu laturile paralele cu axele
sistemului de coordonate.
Scrieţi o expresie C/C++ care să aibă valoarea 1 dacă punctul core-
spunzător variabilei p se află ı̂n interiorul dreptunghiului corespunzător variabilei d (dar nu pe
laturile acestuia) sau valoarea 0 ı̂n caz contrar. (6p.)
Problema 5
Se consideră un text cu cel mult 100 de caractere (litere mici ale alfabetului englez şi spaţii), ı̂n
care cuvintele sunt separate prin unul sau mai multe spaţii. ı̂naintea primului cuvânt şi după
ultimul cuvânt nu există spaţiu.
determină transformarea acestuia ı̂n memorie prin eliminarea unor spaţii, astfel ı̂ncât ı̂ntre oricare
două cuvinte alăturate să rămână exact un spaţiu. Programul afişează pe ecran textul obţinut.
in vacanta plec la mare
se obţine şi se afişează
in vacanta plec la mare (10p.)

Problema 1
Se consideră subprogramul f, definit alăturat. Indicaţi ce se
f(3); (4p.)
a. 12 b. 123 c. 321 d. 3210
Problema 2
Utilizând metoda backtracking, se generează ı̂n ordine lexicografică toate şirurile de câte 5 litere
distincte din mulţimea {A, B, C, D, E}, astfel ı̂ncât ı̂n fiecare şir litera D precede literele A şi
B. Primele cinci soluţii generate sunt, ı̂n această ordine: CDABE, CDAEB, CDBAE, CDBEA,
CDEAB. Scrieţi cea de a şasea şi cea de a şaptea soluţie, ı̂n ordinea generării acestora. (6p.)
Problema 3
Se consideră subprogramul sub, cu trei parametri:
v, prin care primeşte un tablou unidimensional cu n elemente, numere naturale cu cel mult
4 cifre;
k, prin care primeşte un număr natural (1 $ k & n).
Subprogramul returnează suma primelor k elemente cu valoare impară ale tabloului. Dacă nu
există k elemente impare ı̂n tablou, subprogramul returnează valoarea -1.
Exemplu: dacă n=8, v=(2, 7, 6, 8, 3, 7, 5, 1), k=3, atunci subprogramul returnează valoarea
17 (7+3+7=17). (10p.)
Problema 4
Fiind date două numere a şi b, ı̂l numim pe a sufix al lui b dacă a este egal cu b sau dacă b se
poate obţine din a prin alipirea la stânga a unor noi cifre.
Exemplu: 12 este sufix al lui 12, iar 15 este sufix al lui 31415.
Fişierul bac.txt conţine pe prima linie un număr natural x, cu cel mult nouă cifre, iar pe a
doua linie un şir de cel puţin două şi cel mult 1000000 de numere naturale cu cel mult nouă cifre.
Numerele din şir sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran ultimul termen al şirului care are ca sufix numărul x. Dacă ı̂n şir
nu există o astfel de valoare, pe ecran se afişează mesajul Nu exista.
12
3445 89312 1245 12 67120 312 1234578
atunci pe ecran se afişează 312.
Capitolul 12
BAC 2012

Varianta 3
12.1.1 Subiectul I
Problema 1
Indicaţi expresia care are valoarea 1 dacă şi numai dacă numărul memorat ı̂n variabila ı̂ntreagă x
are exact două cifre, iar cifra unităţilor este nenulă. (4p.)
a. (x/10)*(x%10)!=0 && x/100==0

b. (x/10)*(x%10)!=0 && x%100==0
c. (x/10)+(x%10)!=0 || x/100==0
d. (x/10)+(x%10)!=0 || x%100==0
Testăm pentru x=12 (număr cu două cifre şi cifra unităţilor nenulă.
a. (12/10)*(12%10)!=0 && 12/100==0 --> 1*2!=0 && 0==0 --> 1&&1 --> 1
b. (12/10)*(12%10)!=0 && 12%100==0 --> 0*2!=0 && 12==0 --> 0&&0 --> 0 cazul b. "a picat"! (tr
c. (12/10)+(12%10)!=0 || 12/100==0 --> 0+2!=0 || 0==0 --> 1||1 --> 1
d. (12/10)+(12%10)!=0 || 12%100==0 --> 0+2!=0 || 12==0 --> 1||0 --> 1
Testăm pentru x=10 (număr cu două cifre şi cifra unităţilor nulă (trebuie să obţinem 0).
a. (10/10)*(10%10)!=0 && 10/100==0 --> 1*0!=0 && 0==0 --> 0&&1 --> 0
c. (10/10)+(10%10)!=0 || 10/100==0 --> 1+0!=0 || 0==0 --> 1||1 --> 1 cazul c. "a picat"! (trr
d. (10/10)+(10%10)!=0 || 10%100==0 --> 1+0!=0 || 10==0 --> 1||0 --> 1cazul d. "a picat"! (trr
A rămas nmumai cazul a.
a. (x/10)*(x%10)!=0 && x/100==0
Puteam să ne dăm seama pentru că:

(x/10) ne ”spune” dacă x are o cifră sau mai multe cifre
(x%10) ne ”spune” dacă x are ultima cifră nenulă sau nulă
(x/100) ne ”spune” dacă x are cel mult două cifre sau nu are cel mult două cifre
Problema 2
pseudocod.
ordine, numerele 5, 4. (6p.)
b) Dacă pentru a se citeşte valoarea 1, scrieţi toate
valorile naturale, cu exact o cifră fiecare, care pot fi citite
102
pentru n astfel ı̂ncât ı̂n urma executării algoritmului, pen-

tru fiecare dintre acestea, să se afişeze o valoare impară. (4p.)

Problema 1
Se consideră graful neorientat cu şase noduri, reprezentat alăturat.
Un subgraf al său este: (4p.)
Problema 2
Un arbore are 4 frunze, iar lungimea oricărui lanţ elementar care uneşte două noduri de tip frunză
este egală cu 6. Numărul minim de noduri ale unui astfel de arbore este: (4p.)
a. 6 b. 9 c. 13 d. 25
Problema 3
Se consideră declarările alăturate, ı̂n care variabila s memorează coor-
donatele (x abscisa, iar y ordonata), ı̂n sistemul de coordonate xOy, ale
extremităţilor unui segment. Scrieţi o expresie C/C++ care are valoarea
1 dacă şi numai dacă ambele extremităţi ale segmentului aparţin axei Ox
a sistemului de coordonate. (6p.)
Problema 4
În secvenţa de instrucţiuni de mai jos variabilele i şi j sunt de tip ı̂ntreg, iar variabila A memorează
un tablou bidimensional cu 5 linii şi 5 coloane, numerotate de la 1 la 5, cu elemente numere ı̂ntregi.
Fără a utiliza alte variabile, scrieţi una sau mai multe instrucţiuni care pot ı̂nlocui punctele
de suspensie astfel ı̂ncât, ı̂n urma executării secvenţei obţinute, tabloul memorat ı̂n variabila A să
aibă elementele din figura de mai jos.
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
............... (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură două cuvinte distincte, fiecare fiind format
din cel mult 30 de caractere, numai litere mici ale alfabetului englez. După primul cuvânt se
tastează Enter. Programul verifică dacă prin eliminarea unor litere din cel de al doilea cuvânt
se poate obţine primul cuvânt. ı̂n caz afirmativ programul afişează pe ecran mesajul DA, altfel
mesajul NU.
Exemple: dacă se citesc, ı̂n această ordine, cuvintele:
calut
bacalaureat
pe ecran se afişează mesajul DA
iar dacă se citesc, ı̂n această ordine, cuvintele:
calut
lacatus
pe ecran se afişează mesajul NU. (10p.)

Problema 1
Algoritmul de generare a tuturor numerelor naturale de 5 cifre, fiecare număr având toate cifrele
nenule şi distincte, este echivalent cu algoritmul de generare a: (4p.)
a. aranjamentelor de 9 elemente luate câte 5
b. combinărilor de 9 elemente luate câte 5
c. permutărilor a 5 elemente
d. submulţimilor unei mulţimi cu 9 elemente
Problema 2
Scrieţi valorile f(-6) şi f(20). (6p.)
Problema 3
Se consideră subprogramul minus, cu doi parametri:
n, prin care primeşte o valoare naturală 2¡n¡50;
v, prin care primeşte un tablou unidimensional cu n elemente,

numere ı̂ntregi cu cel mult 4 cifre. Cel puţin unul dintre elementele tabloului este nenul.
După fiecare element nenul din tablou, subprogramul inserează câte un nou element, cu aceeaşi val-
oare absolută, dar cu semn opus, ca ı̂n exemplu. Tabloul modificat, precum şi valoarea actualizată
a lui n, sunt furnizate tot prin parametrii v, respectiv n.
Scrieţi ı̂n limbajul C/C++ definiţia completă a subprogramului.
Exemplu: dacă n=5 şi v=(4, -5, 0, 9, 0),
atunci după apel n=8, iar v=(4, -4, -5, 5, 0, 9, -9, 0). (10p.)
Problema 4
Fişierul bac.txt conţine pe prima linie un număr natural par n cu cel mult patru cifre, iar pe
următoarea linie un şir de n numere naturale cu cel mult nouă cifre. Numerele din şir sunt ı̂n
ordine crescătoare şi sunt separate prin câte un spaţiu.
Se cere să se afişeze pe ecran cel mai mare număr din prima jumătate a şirului care să fie strict
mai mic decât oricare număr din a doua jumătate a şirului. Dacă ı̂n fişier nu se află o astfel de
valoare, pe ecran se afişează mesajul Nu exista.
Exemplu: dacă fişierul bac.txt are conţinutul
30
1 3 5 5 ... 5 5 7 10
aaaaaaaaaaa
de 26 de ori
atunci pe ecran se afişează 3, iar dacă fişierul are conţinutul
6
3 3 3 3 9 15
atunci pe ecran se afişează Nu exista.

Varianta 1
12.2.1 Subiectul I
Problema 1
aparţine mulţimii 1,2,3. (4p.)
a. x==1 && x==2 && x==3 b. !( x<=1 && x>=3 )

c. x==1 || x==2 || x==3 d. !( x<=1 || x>=3 )
Problema 2
docod.
real z.
a) Scrieţi numărul afişat dacă pentru variabila n se citeşte
valoarea 56413. (6p.)
b) Scrieţi toate numerele naturale, fiecare având exact pa-
tru cifre, care pot fi citite pentru variabila n astfel ı̂ncât, ı̂n
urma executării algoritmului, pentru fiecare dintre acestea să
se afişeze valoarea 40. (4p.)
cât timp...execută cu o structură repetitivă de alt tip. (6p.)

Problema 1
Se consideră graful orientat cu 7 vârfuri, numerotate de la 1 la 7, şi arcele (1,2), (2,3), (3,4), (4,1),
(5,4), (7,5), (5,6). Numărul de vârfuri ale grafului care au gradul extern egal cu gradul intern
este: (4p.)
a. 2 b. 3 c. 4 d. 5
Problema 2
Se consideră graful neorientat cu cinci noduri, reprezentat alăturat.
Numărul minim de muchii ce trebuie adăugate astfel ı̂ncât, ı̂n graful
obţinut, ı̂ntre oricare două noduri distincte să existe cel puţin un lanţ
elementar de lungime 2, este: (4p.)
a. 1 b. 2 c. 3 d. 4
Problema 3
Se consideră declarările alăturate, ı̂n care variabila s memorează coordo-

natele, ı̂n sistemul de coordonate xOy, ale extremităţilor unui segment.
Scrieţi o instrucţiune care afişează pe ecran pătratul lungimii seg-
mentului corespunzător variabilei s. (6p.)
Problema 4
ı̂n secvenţa de instrucţiuni de mai jos variabilele i şi j sunt de tip ı̂ntreg, iar variabila A memorează
un tablou bidimensional cu 5 linii şi 5 coloane, numerotate de la 1 la 5. Elementele tabloului sunt
numere ı̂ntregi.
de suspensie astfel ı̂ncât, ı̂n urma executării secvenţei obţinute, tabloul memorat ı̂n variabila A să
aibă elementele din figura de mai jos.
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
.................. (6p.)
Problema 5
Se consideră două şiruri de caractere a, de lungime na şi b, de lungime nb.
Şirul a este numit prefix al şirului b dacă na & nb şi subşirul lui b determinat de primele sale
na caractere coincide cu a. Şirul a este numit sufix al şirului b dacă na & nb şi subşirul lui b
determinat de ultimele sale na caractere coincide cu a.
Scrieţi un program C/C++ care citeşte de la tastatură două cuvinte, fiecare fiind format din
cel mult 30 de caractere, numai litere mici ale alfabetului englez. După primul cuvânt se tastează
Enter. Programul afişează pe ecran, separate prin câte un spaţiu, toate sufixele primului cuvânt
care sunt prefixe ale celui de al doilea cuvânt, ca ı̂n exemplu. Dacă nu există astfel de subşiruri,
se afişează pe ecran mesajul NU EXISTA.
Exemple:
dacă se citesc, ı̂n ordine, cuvintele
rebele
elegant
se afişează (nu neapărat ı̂n această ordine) subşirurile: e ele
iar dacă se citesc, ı̂n ordine, cuvintele
strai
rai
se afişează subşirul rai (10p.)

Problema 1
Utilizând metoda backtracking se generează, ı̂n ordine lexicografică, toate şirurile de 5 cifre din
mulţimea {0, 1, 2}, cu proprietatea că nu există două cifre pare pe poziţii consecutive.
Primele opt şiruri generate sunt, ı̂n această ordine: 01010, 01011, 01012, 01101, 01110, 01111,
01112, 01121. Al nouălea şir generat este: (4p.)
a. 01120 b. 01201 c. 01210 d. 10101
Problema 2
Se consideră subprogramul f, definit alăturat. Scrieţi ce
se afişează ı̂n urma apelului de mai jos.
f(9); (6p.)
Problema 3
Se consideră subprogramul dublu, cu doi parametri:
v, prin care primeşte un tablou unidimensional cu n elemente, numere ı̂ntregi cu cel mult 4
cifre. Cel puţin unul dintre elementele tabloului este strict pozitiv.
După fiecare element strict pozitiv din tablou, subprogramul inserează câte un nou element, cu
aceeaşi valoare, ca ı̂n exemplu. Tabloul modificat, precum şi valoarea actualizată a lui n, sunt
furnizate tot prin parametrii v, respectiv n.
Exemplu: dacă n=6 şi v=(4, -5, 0, 9, 9, -2), atunci după apel
n=9, iar v=(4, 4, -5, 0, 9, 9, 9, 9, -2). (10p.)
Problema 4
Un număr natural cu cel puţin două cifre se numeşte x-ordonat dacă toate cifrele sale sunt ı̂n ordine
crescătoare şi valoarea absolută a diferenţei dintre oricare două cifre aflate pe poziţii consecutive
este egală cu x.
Exemple: numărul 2468 este 2-ordonat, numărul 147 este 3-ordonat; numerele 179 sau 131
nu sunt de tipul menţionat.
Se citeşte de la tastatură un număr natural x (1 & x & 8) şi se cere scrierea ı̂n fişierul BAC.TXT
a tuturor numerelor naturale distincte x-ordonate. Fiecare număr este scris pe câte o linie a
fişierului.
Pentru determinarea numerelor cerute se utilizează un algoritm eficient din punctul de vedere

Varianta 4
12.3.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi memorează un număr natural. Expresia
alăturată are valoarea 0 dacă şi numai dacă expresia x%5 are valoarea: (4p.)
a. 1 b. 2 c. 3 d. 4
Problema 2
Se consideră algoritmul alăturat, reprezentat
ı̂n pseudocod.
S-a notat cu x%y restul ı̂mpărţirii numărului nat-
ural x la numărul natural nenul y.
a) Scrieţi valoarea afişată dacă se citesc, ı̂n
această ordine, numerele 7, 5. (6p.)
b) Scrieţi două seturi de date de intrare, formate
din numere naturale cu cel mult două cifre fiecare,
astfel ı̂ncât ı̂n urma executării algoritmului, pentru

Problema 1
ı̂ntr-un arbore cu rădăcină considerăm că un nod se află pe nivelul x dacă lanţul elementar care
are o extremitate ı̂n nodul respectiv şi cealaltă extremitate ı̂n rădăcina arborelui are lungimea x.
Pe nivelul 0 se află un singur nod (rădăcina).
Se consideră arborele cu 7 noduri, numerotate de la 1 la 7, reprezentat prin vectorul de ”taţi”
(0,1,1,3,4,2,3). Mulţimea tuturor nodurilor aflate pe nivelul 2 este: (4p.)
a. {1, 2, 6} b. {2, 3} c. {4, 7} d. {4, 6, 7}
Problema 2
Se consideră graful neorientat cu şase noduri, reprezentat alăturat.
Numărul minim de muchii ce trebuie adăugate, astfel ı̂ncât ı̂n graful
obţinut fiecare nod să aparţină unui ciclu, este: (4p.)
a. 1 b. 2 c. 4 d. 5
Problema 3
Se consideră declararea alăturată, ı̂n care variabilele t1 şi t2 memorează
lungimile laturilor a două triunghiuri.
Scrieţi o expresie C/C++ care are valoarea 1 dacă şi numai dacă
triunghiul corespunzător variabilei t1 are perimetrul strict mai mare decât perimetrul triunghiului
corespunzător variabilei t2. (6p.)
Problema 4
Se consideră două şiruri de caractere a, de lungime na şi b, de lungime nb.
Şirul a este numit sufix al şirului b dacă na & nb şi subşirul lui b determinat de ultimele sale
na caractere coincide cu a.
În secvenţa de instrucţiuni de mai jos variabila i este de tip ı̂ntreg, iar variabila s memorează
un şir cu cel mult 20 de caractere.
de suspensie astfel ı̂ncât, ı̂n urma executării secvenţei obţinute, să se afişeze pe ecran, ı̂n ordinea
descrescătoare a lungimii, separate prin câte un spaţiu, toate sufixele şirului memorat ı̂n variabila
s, ca ı̂n exemplu.
Exemplu: pentru şirul elevi se afişează: elevi levi evi vi i
for(i=0;i<strlen(s);i++)
.................. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural n (2¡n15) şi construieşte
ı̂n memorie un tablou bidimensional cu n linii şi n coloane ı̂n care:
toate elementele din prima coloană au valoarea 1;
ultima linie conţine, ı̂n ordine strict crescătoare, numerele naturale din intervalul [1, n];
oricare alt element este obţinut prin ı̂nsumarea celor două elemente vecine cu el, aflate pe
linia imediat următoare şi pe aceeaşi coloană cu el, respectiv pe aceeaşi linie cu el şi pe
coloana anterioară, ca ı̂n exemplu.
Programul afişează pe ecran tabloul obţinut, fiecare linie a tabloului pe

câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un
spaţiu.
Exemplu: pentru n=4 pe ecran se afişează tabloul alăturat.
(10p.)
Problema 1
Utilizând metoda backtracking se generează, ı̂n ordine lexicografică, toate şirurile de maximum 4
litere distincte din mulţimea {a, v, i, o, n}. Primele 5 şiruri generate sunt, ı̂n această ordine: a,
ai, ain, aino, ainv. Imediat după şirul avn se generează: (4p.)
a. avi b. avni c. avo d. iano
Problema 2
Scrieţi valorile f(3,4) şi f(2,20). (6p.)
Problema 3
Se consideră subprogramul zero, cu doi parametri:
v, prin care primeşte un tablou unidimensional cu 2 n elemente, numere naturale cu cel

mult 4 cifre. Numărul de elemente pare este egal cu numărul de elemente impare.
Elementele au indici de la 1 la 2 n.
Subprogramul modifică tabloul astfel ı̂ncât elementele impare să aibă indici impari, iar ele-
mentele pare să aibă indici pari. Tabloul modificat este furnizat tot prin parametrul v.
Exemplu: dacă n=5 şi v=(4, 5, 0, 9, 10, 7, 15, 3, 8, 10),
atunci după apel o soluţie posibilă este: v=(5, 4, 9, 0, 15, 10, 7, 8, 3, 10). (10p.)
Problema 4
Fişierul bac.txt conţine pe prima linie un număr natural par n cu cel mult 3 cifre, iar pe
următoarea linie un şir de n numere naturale cu cel mult nouă cifre. Numerele din şir sunt
separate prin câte un spaţiu.
Se cere să se afişeze pe ecran mesajul Da dacă ı̂n şir există un element care să fie strict mai
mare decât jumătate dintre numerele din şir.
Dacă ı̂n şir nu se află o astfel de valoare, pe ecran se afişează mesajul Nu.
Exemplu: dacă fişierul bac.txt are conţinutul
6
8 34 34 34 5 34
atunci pe ecran se afişează Nu, iar dacă fişierul are conţinutul
8
1 5 6 12 3 12 12 9
atunci pe ecran se afişează Da.
Capitolul 13
BAC 2011

Varianta 9
13.1.1 Subiectul I
Problema 1
Indicaţi care dintre expresiile C/C++ de mai jos are valoarea 1 dacă şi numai dacă numărul
memorat ı̂n variabila ı̂ntreagă x aparţine reuniunii de intervale 3, 1 < 1, 3. (4p.)
a. x>=-3 && x<=-1 && x>=1 && x<=3

b. !(x<-3 || x>-1) || !(x<1 || x>3)
c. x>=-3 || x<=-1 || x>=1 || x<=3
d. !(x<-3 && x>3 && x>-1 || x<1)
Problema 2
Se consideră algoritmul alăturat, descris ı̂n pseu-
docod.
a. Scrieţi numerele care se afişează ı̂n urma executării
algoritmului, ı̂n ordine, dacă pentru n se citeşte valoarea 5,
iar pentru k se citeşte valoarea 2. (6p.)
b. Dacă pentru variabila k se citeşte valoarea 5, scrieţi
cea mai mică şi cea mai mare valoare care pot fi citite pen-
tru variabila n astfel ı̂ncât, ı̂n urma executării algoritmului,
ultimul număr care se afişează, pentru fiecare dintre aceste
valori, să fie 7. (6p.)
c. Scrieţi ı̂n pseudocod un algoritm care să conţină o
singură structură repetitivă ı̂n loc de două şi care să fie
echivalent cu cel dat. (4p.)
d. Scrieţi programul C/C++ corespunzător algoritmu-
lui dat. (10p.)

Pentru fiecare dintre itemii 1 şi 2 scrieţi pe foaia de examen litera corespunzătoare răspunsului
corect.
Problema 1
Numim pădure un graf neorientat ı̂n care fiecare componentă conexă a sa este un arbore. Orice
pădure cu cel puţin doi arbori este un graf care: (4p.)
a. are cicluri şi este conex b. are cicluri şi nu este conex
c. nu are cicluri şi este conex d. nu are cicluri şi nu este conex
111
Problema 2
Se consideră graful orientat cu 6 vârfuri, numerotate de la 1 la 6, şi mulţimea arcelor (1,4), (2,1),
(2,4), (2,6), (4,1), (4,6). Numărul de subgrafuri ale sale, fiecare având mulţimea arcelor (1,4),
(2,1), (2,4), (4,1), este: (4p.)
a. 2 b. 3 c. 4 d. 5
Problema 3
Se consideră graful neorientat cu 5 noduri, numerotate de la 1 la 5, reprezentat
prin listele de adiacenţă alăturate.
Enumeraţi nodurile care fac parte din componenta conexă a grafului dat care
are cele mai puţine noduri. (6p.)
Problema 4
În secvenţa de instrucţiuni de mai jos variabilele i şi j sunt de tip ı̂ntreg şi variabila A este de tip
tablou bidimensional cu 5 linii şi 5 coloane, numerotate de la 0 la 4, cu elemente numere ı̂ntregi.
Fără a utiliza alte variabile, scrieţi o instrucţiune care poate ı̂nlocui punctele de suspensie astfel
ı̂ncât, ı̂n urma executării secvenţei obţinute, tabloul memorat ı̂n variabila A să aibă elementele
din figura de mai jos. Înainte de executarea secvenţei toate elementele tabloului sunt nule.
for(i=0;i<5;i++)
for(j=0;j<5;j++)
.............. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură un număr natural n (2 & n & 20) şi apoi n
cuvinte distincte, fiecare fiind format din cel mult 20 de caractere, numai litere mici ale alfabetului
englez. La introducerea datelor, după fiecare cuvânt se tastează Enter. Programul afişează pe
ecran numărul de cuvinte dintre ultimele n-1 citite, care ı̂ncep cu primul cuvânt citit.
Exemplu: dacă n=5 şi cuvintele citite sunt:
bun
buncar
bunici
abundent
bunavoie
pe ecran se afişează 3 (deoarece numai cuvintele buncar, bunici şi bunavoie ı̂ncep cu bun).
(10p.)
Problema 1
Se consideră subprogramele recursive C1 şi C2, definite mai jos.
La apel, returnează valoarea celui mai mare divizor comun al celor două numere naturale
nenule primite ca parametri: (4p.)
a. numai C1 b. numai C2 c. at\ât C1 c\ât si C2 d. nici C1 nici C2
Problema 2
Având la dispoziţie cinci mărgele de culori diferite, roşu, galben, verde, albastru, violet,
se utilizează metoda backtracking pentru a obţine toate posibilităţile de a forma şiruri de câte trei
mărgele, ştiind că ı̂n cadrul unui şir contează ordinea de asezare a mărgelelor.
Culorile mărgelelor, corespunzătoare primelor patru soluţii obţinute sunt, ı̂n această ordine:
(roşu, galben, verde), (roşu, galben, albastru), (roşu, galben, violet), (roşu,
verde, galben).
Scrieţi ultimele două soluţii generate, ı̂n ordinea obţinerii lor. (6p.)
Problema 3
Subprogramul inserare are doi parametri:
n, prin care primeşte un număr natural (2 & n & 20);
a, prin care primeşte un tablou unidimensional care memorează un şir de n numere naturale,
fiecare cu cel mult 4 cifre. Cel puţin un element al tabloului este număr par.
Subprogramul modifică tabloul astfel ı̂ncât după fiecare termen par al şirului inserează valoarea
2011 şi furnizează, tot prin parametrii n şi a, valorile actualizate ale datelor primite.
Exemplu: dacă n=7 şi a=(1, 4, 5, 3, 82, 6, 2) atunci, după apel,
n=11 şi a=(1, 4, 2011, 5, 3, 82, 2011, 6, 2011, 2, 2011). (10p.)
Problema 4
Se citesc de la tastatură două numere naturale s1 şi s2 (0 $ s1 & 18, 0 & s2 & 18) şi se cere scrierea
ı̂n fisierul BAC.TXT, fiecare pe câte o linie, ı̂n ordine strict crescătoare, a tuturor numerelor
naturale cu exact 5 cifre, pentru care suma primelor două cifre este egală cu s1, iar suma ultimelor
două cifre este egală cu s2. Pentru determinarea numerelor indicate se utilizează un algoritm
eficient din punct de vedere al timpului de executare.
Exemplu: dacă s1=8, iar s2=7, atunci 35725 este unul dintre numerele care respectă propri-
etatea cerută (3+5=8 si 2+5=7).

Varianta 6
13.2.1 Subiectul I
Problema 1
Se consideră secvenţa de mai jos:
if (x+y>6)
if (x-y<3) cout<<1;
else cout<<2;
else cout<<3;
Valorile ı̂ntregi pozitive ale variabilelor x şi y pentru care se afişează valoarea 2 pot fi: (4p.)
a. x=1 şi y=4 b. x=4 şi y=1
c. x=5 şi y=2 d. x=5 şi y=3
Problema 2
Se consideră algoritmul alăturat, descris ı̂n pseu-
docod.
S-a notat cu x%y restul ı̂mpărţirii numărului natural x
la numărul natural nenul y.
a. Scrieţi numărul care se afişează ı̂n urma executării
algoritmului dacă pentru variabila a se citeşte valoarea 6,
iar pentru variabila b valoarea 11. (6p.)
b. Dacă pentru variabila a se citeşte valoarea 10 scrieţi
valoarea care poate fi citită pentru variabila b astfel ı̂ncât
ı̂n urma executării algoritmului să se afişeze numărul 52.
(4p.)
c. Scrieţi ı̂n pseudocod un algoritm care să NU folosească structura repetitivă cu test iniţial
şi care să fie echivalent cu cel dat. (6p.)
d. Scrieţi programul C/C++ corespunzător algoritmului dat. (10p.)

Problema 1
Se consideră variabila y, declarată alăturat. O instrucţiune de atribuire
corectă din punct de vedere sintactic este: (4p.)
a. y.a=y.b-’a’; b. y=(1,’a’,2,3);
c. y.s2.a=34; d. y(b)=’a’;
Problema 2
Numărul maxim de noduri de grad 0 pe care le poate avea un graf neorientat
cu 10 noduri şi 7 muchii este: (4p.)
a. 5 b. 6 c. 9 d. 10
Problema 3
În secvenţa de program alăturată variabila a memorează un
tablou bidimensional cu 10 linii şi 10 coloane, numerotate
de la 1 la 10, cu elemente numere ı̂ntregi, iar toate celelalte
variabile sunt ı̂ntregi.
Scrieţi valoarea sumei elementelor de pe diagonala secundară a tabloului construit ı̂n urma
executării acestei secvenţe. (6p.)
Problema 4
Se consideră graful orientat cu 5 vârfuri reprezentat prin matricea de adiacenţă
alăturată. Scrieţi mulţimea vârfurilor unui subgraf al acestuia care are un număr
maxim de vârfuri izolate. (6p.)
Problema 5
Scrieţi un program ı̂n limbajul C/C++ care citeşte de la tastatură un şir de cel mult 20 de
caractere (litere mari şi mici ale alfabetului englez), construieşte ı̂n memorie şi afişează pe ecran
un şir de caractere format din vocalele ce NU apar ı̂n şirul citit. Vocalele menţionate pot apărea
ı̂n şirul obţinut ı̂n orice ordine. Dacă şirul citit de la tastatură conţine toate vocalele, programul
afisează pe ecran mesajul SIRUL VID. Se consideră vocale literele
a, e, i, o, u, A, E, I, O, U.
Exemplu: dacă se citeşte textul fULminAnta o soluţie poate fi şirul EIOeou (10p.)

Problema 1
Utilizând metoda backtracking se generează toate valorile naturale formate cu cifre ale numărului
356 şi care sunt strict mai mici decât acesta. Primele cinci numere generate sunt, ı̂n această
ordine, 3, 33, 333, 335, 336. Scrieţi al câtelea număr generat este 5. (4p.)
a. 7 b. 9 c. 10 d. 15
Problema 2
Se consideră subprogramul f, definit alăturat. Scrieţi ce valori au
f(0), respectiv f(14). (6p.)
Problema 3
Subrogramul schimb are trei parametri:
v, prin care primeşte un tablou unidimensional care memorează un şir de n numere naturale,
fiecare având cel mult patru cifre;
k, un număr natural (1¡k¡n-1).
Subprogramul deplasează primele k elemente ale tabloului circular spre stânga, cu câte o poziţie,
şi restul elementelor circular spre dreapta, cu câte o poziţie, ca ı̂n exemplu. Tabloul modificat este
furnizat tot prin parametrul v.
Problema 4
Fişierul text bac.txt conţine un şir de cel puţin trei şi cel mult 100000000 de numere ı̂ntregi,
fiecare având cel mult 8 cifre. Numerele sunt separate prin câte un spaţiu.
Se consideră că un şir format din cel puţin trei termeni formează o progresie aritmetică dacă
diferenţa dintre oricare termen al acestuia şi cel aflat pe poziţia consecutivă ı̂n şir este constantă.
Se cere să se citească numerele din fişierul bac.txt şi să se afişeze pe ecran numărul maxim
de termeni ai unei secvenţe din şir, secvenţă care formează o progresie aritmetică.
Dacă nu există nicio astfel de secvenţă, se afişează pe ecran mesajul NU EXISTA.
Se utilizează un algoritm eficient din punct de vedere al timpului de executare şi al memoriei
folosite.
Exemplu: dacă fisierul conţine numerele
pe ecran se afişează valoarea 5 (corespunzătoare secvenţei 9 4 -1 -6 -11).


Varianta 3
13.3.1 Subiectul I
Problema 1
Expresia C/C++
!(-20>=x) && (x<=-10) || (x>=-5) && !(x>5)
are valoarea 1 dacă şi numai dacă valoarea memorată de variabila reală x aparţine reuniunii de
intervale: (4p.)
a. , 10 < 5, b. 20, 10 < 5, 5
c. 20, 10 < 5, 5 d. 20, 10 < 5, 5
Problema 2
Se consideră algoritmul alăturat, descris ı̂n pseudocod.
real z.
a. Scrieţi numărul care se afişează ı̂n urma executării algorit-
mului dacă pentru variabila n se citeşte valoarea 1034, iar pentru
variabila m valoarea 1234. (6p.)
b. Scrieţi toate perechile distincte de valori naturale, de câte
două cifre fiecare, valori care pot fi citite pentru variabilele n
si m astfel ı̂ncât, ı̂n urma executării algoritmului, pentru fiecare
dintre acestea, numărul afişat să fie 86. (6p.)
c. Scrieţi ı̂n pseudocod un algoritm care să nu folosească
structuri repetitive şi care să fie echivalent cu cel dat. (4p.)
d. Scrieţi programul C/C++ corespunzător algoritmului dat. (10p.)
Problema 1
Se consideră graful orientat cu 6 vârfuri, numerotate de la 1 la 6, reprezentat
prin listele de adiacenţă alăturate. Două drumuri sunt distincte dacă diferă
prin cel puţin un arc.
Numărul de drumuri elementare distincte de la vârful 2 la vârful 3 este: (4p.)

a. 0 b. 1 c. 2 d. 3
Problema 2
Frunzele arborelui cu rădăcină, având 8 noduri, numerotate de la 1 la 8, reprezentat prin vectorul
”de taţi” (6,6,5,0,6,4,4,7) sunt: (4p.)
a. 1,2,3,8 b. 1,2,8 c. 3,7 d. 4,6,7
Problema 3
Structura cu numele CARTE permite memorarea unui număr real, reprezentând valoarea expri-
mată ı̂n euro a unei cărţi, a unui număr ı̂ntreg, reprezentând numărul de pagini ale cărţii, şi a
unui şir de caractere reprezentând titlul cărţii, format din cel mult 50 de caractere.
Scrieţi ı̂n limbajul C/C++ o definiţie a structurii menţionate şi declaraţi o variabilă x de acest
tip. Denumiţi sugestiv câmpurile acestei structuri. (6p.)
Problema 4
În secvenţa de program alăturată variabila a mem-
orează un şir cu cel mult 100 de caractere, iar vari-
abilele i si̧ k sunt de tip ı̂ntreg.
Scrieţi şirul afisat pe ecran ı̂n urma executării
secvenţei. (6p.)
Problema 5
Scrieţi un program C/C++ care citeşte de la tastatură două numere naturale n şi m (2 $ n & 24,
2 $ m & 24) şi construieste ı̂n memorie un tablou bidimensional cu n linii şi m coloane, ı̂n care
orice element aflat pe ultima linie sau pe ultima coloană are valoarea 1 şi oricare alt element este
egal cu ultima cifră a sumei celor două elemente alăturate lui, aflate pe aceeaşi linie şi pe coloana
din dreapta, respectiv pe aceeasi coloană şi pe linia următoare, ca ı̂n exemplu.
Programul afişează pe ecran tabloul obţinut, câte o linie a tabloului pe câte
o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
(10p.)
Exemplu: pentru n=4 şi m=5 se afişează tabloul alăturat.

Problema 1
Utilizând metoda backtracking se generează ı̂n ordine crescătoare numere naturale de câte patru
cifre din mulţimea A={1,2,3,4,5}, numere care nu conţin două cifre impare alăturate. Primele opt
numere generate sunt, ı̂n această ordine, 1212, 1214, 1221, 1222, 1223, 1224, 1225, 1232. Numărul
de valori generate care au cifra miilor egală cu 2 şi cifra unităţilor egală cu 4 este: (4p.)
a. 20 b. 16 c. 12 d. 9
Problema 2
Scrieţi ce se afişează ı̂n urma apelului de mai jos pentru
subprogramul f, definit alăturat.
f(12345); (6p.)
Problema 3
Subprogramul inter are patru parametri:
na, nb prin care primeşte câte un număr natural
(0¡na¡100, 0¡nb¡100);
a, b prin care primeşte câte un tablou unidimen-
sional care memorează câte o mulţime de na, re-
spectiv nb numere naturale, fiecare având cel mult
patru cifre.
Subprogramul returnează numărul de elemente aparţinând intersecţiei celor două mulţimi
menţionate.
Scrieţi ı̂n limbajul C/C++ definiţia completă a subprogramului inter.
Exemplu: pentru na=4, a=(35,149,72,3798), nb=5, b=(72,151,149,9,623), ı̂n urma apelului,
subprogramul returnează valoarea 2. (10p.)
Problema 4
Fişierul BAC.TXT conţine un şir de cel puţin 11 şi cel mult un milion de numere naturale,
despărţite prin câte un spaţiu. Fiecare număr are cel puţin două şi cel mult nouă cifre. Primul
termen al şirului are numărul de ordine 1, al doilea are numărul de ordine 2 etc.
Se citeşte şirul din fişier şi se cere ca, utilizând un algoritm eficient din punct de vedere al
timpului de executare, să se determine şi să se afişeze pe ecran numărul de ordine al unui termen
al şirului care este precedat ı̂n fişier de un număr maxim de valori care au cifra zecilor egală cu
a sa. Dacă sunt mai mulţi termeni cu această proprietate, se afişează numărul de ordine doar al
unuia dintre ei.
Exemplu: dacă fişierul BAC.TXT conţine numerele
12 36 265
:
18 139 19 32 34 112 14 68
:
pe ecran se afişează 10 (numărul de ordine al termenului 14).

Capitolul 14
BAC 2010

Varianta 1
14.1.1 Subiectul I
Problema 1
Dintre expresiile C/C++ de mai jos, cea care are valoarea 1 dacă şi numai dacă numărul memorat
ı̂n variabila ı̂ntreagă x aparţine intervalului ı̂nchis [-5,5] este: (4p.)
a. abs(x)<=5 b. (x>-5) && (x<5)

c. !(x<-5) || !(x>5) d. !(x<-5) && (x>5)
Problema 2
Se consideră algoritmul alăturat descris ı̂n pseu-
docod.
numărului real z.
a) Scrieţi numerele afişate dacă pentru variabila a se
citeste valoarea 5789. (6p.)
b) Scrieţi cel mai mare număr de patru cifre care poate
fi citit pentru variabila a astfel ı̂ncât, ı̂n urma executării
algoritmului, valoarea afişată pentru variabila ok să fie 1.
(4p.)
cât timp...execută cu o structură repetitivă de alt tip. (6p.)

Problema 1
Pentru ca graful orientat cu 5 vârfuri, reprezentat ı̂n figura alăturată,
să devină graf tare conex, numărul minim de arce care trebuie adăugate
acestuia este: (4p.)
a. 1 b. 2 c. 3 d. 4
119
Problema 2
Se consideră arborele cu rădăcină, având 10 noduri, numerotate de la 1 la 10, reprezentat prin
vectorul de ”taţi” t=(2,5,1,1,0,3,3,7,4,6). Rădăcina arborelui este nodul numerotat cu: (4p.)
a. 0 b. 2 c. 5 d. 10
Problema 3
Se consideră variabila t, declarată alăturat, care memorează coordo-
natele, ı̂n planul xOy, ale vârfurilor A, B şi C ale unui triunghi.
Scrieţi o instrucţiune care iniţializează cu valoarea 0 coordonata
x a vârfului A al triunghiului respectiv. (6p.)
Problema 4
În secvenţa de instrucţiuni de mai jos, variabila p este de tip ı̂ntreg, iar variabila s memorează un
şir de cel mult 20 de caractere, numai litere mici ale alfabetului englez.
Scrieţi instrucţiunile care pot ı̂nlocui punctele de suspensie astfel ı̂ncât, ı̂n urma executării
secvenţei, să se afişeze pe ecran toate literele şirului memorat de variabila s, cu excepţia vocalelor
e şi i.
Literele se afişează ı̂n ordinea apariţiei lor ı̂n şir.
Exemplu: dacă şirul memorat ı̂n variabila s este
estetician, se va afişa sttcan. (6p.)
Problema 5
Într-un tablou bidimensional, cu elemente având valori numai ı̂n mulţimea {0,1}, numim linii
”complementare” două linii cu proprietatea că oricare două elemente ale acestora, aflate pe aceeaşi
coloană, sunt diferite.
Scrieţi un program C/C++ care citeste de la tastatură două numere naturale, m şi n (2 &
m & 20, 2 & n & 20), şi m n valori din mulţimea {0,1}, reprezentând elementele unui tablou
bidimensional cu m linii şi n coloane.
Programul afişează pe ecran numărul de linii ale tabloului care sunt ”comple-
mentare” cu ultima linie a acestuia.
Exemplu: dacă m=5, n=3, pentru tabloul alăturat se afişează pe ecran
valoarea 2. (10p.)
Problema 1
Algoritmul de generare a tuturor numerelor naturale formate din exact trei cifre, toate cifre impare,
poate fi similar cu algoritmul de generare a: (4p.)
a. aranjamentelor b. combinărilor
c. elementelor unui produs cartezian d. permutărilor
Problema 2
Se consideră subprogramul p, definit alăturat.
Scrieţi ce valori au p(-4), respectiv p(4). (6p.)
Problema 3
Subprogramul ordonare are doi parametri:
n, prin care primeste un număr natural (3n20);
a, prin care primeste un tablou unidimensional care memorează un şir de n numere naturale,
fiecare cu cel mult 4 cifre. Cel puţin doi termeni ai şirului sunt numere pare si cel puţin unul
este număr impar.
Subprogramul modifică tabloul astfel ı̂ncât termenii impari ai şirului să nu ı̂si schimbe poziţiile,
iar cei pari să formeze un subsir crescător, ca ı̂n exemplu.
Exemplu: dacă n=7 şi a=(1,4, 5, 3, 82, 6, 2) atunci, după apel,
a=(1, 2, 5, 3, 4, 6, 82). (10p.)
Problema 4
Pentru un număr natural nenul, n , se consideră suma
ı̂n care s-a notat cu [x] partea ı̂ntreagă a numărului real x şi k! 1 2 3 ... k 1 k.
a) Scrieţi un program C/C++ care citeste de la tastatură un număr natural nenul n (n¡1000) şi
determină, utilizând un algoritm eficient din punct de vedere al timpului de executare şi al mem-
oriei utilizate, valoarea sumei S(n) corespunzătoare numărului citit, apoi scrie valoarea obţinută
ı̂n fişierul BAC.TXT. (6p.)
Exemplu: pentru n=4 ı̂n fişier se scrie valoarea 5, calculată ca mai jos:
b) Descrieţi succint, ı̂n limbaj natural (3-4 rânduri), algoritmul utilizat la punctul a) si
justificaţi eficienţa acestuia. (4p.)

Varianta 8
14.2.1 Subiectul I
Problema 1
Se consideră definite trei variabile de tip int: x, y şi z. O expresie C/C++ care are valoarea 1
dacă şi numai dacă x, y şi z au valori identice este: (4p.)
a. x==y && x==z b. x==y==z
c. x==y || x==z || y==z d. !( x!=y && x!=z)
Problema 2
docod.
a) Scrieţi numărul afişat ı̂n urma executării algoritmului
dacă pentru n se citeste valoarea 6. (6p.)
b) Scrieţi o valoare care poate fi citită pentru n astfel
ı̂ncât să se afişeze valoarea 55. (4p.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel
dat, care să conţină o singură structură repetitivă. (6p.)
dat. (10p.)
Problema 1
Se consideră un graf neorientat cu 6 noduri şi 9 muchii. Numărul de muchii ce trebuie adăugate,
pentru ca graful obţinut să fie complet, este: (4p.)
a. 5 b. 6 c. 12 d. 15
Problema 2
Se consideră secvenţa de instrucţiuni alăturată, ı̂n care vari-
abilele i şi j sunt de tip ı̂ntreg, iar variabila s poate memora
un şir de cel mult 20 de caractere.
Şirul afişat ı̂n urma executării secvenţei este: (4p.)
a. aureatbacal b. bacalaureab c. taealaureat d. taerualacab
Problema 3
Se consideră un arbore cu rădăcină având 6 noduri, numerotate de la 1 la 6, şi muchiile [1, 2], [1,
3], [2, 4], [3, 5], [3, 6]. Considerând că rădăcina este nodul numerotat cu 1 şi că ea este situată pe
nivelul 0 al arborelui, scrieţi toate nodurile situate pe nivelul 2 al arborelui dat. (6p.)
Problema 4
Variabilele e1 şi e2, declarate alăturat, memorează numele şi data nas-
terii pentru câte un elev.
Ştiind că cei doi elevi sunt născuţi ı̂n ani diferiţi, scrieţi secvenţa de
instrucţiuni care afişează pe ecran numele elevului de vârstă mai mare.
(6p.)
Problema 5
Scrieţi un program C/C++ care citeste de la tastatură un număr natural, n (2n20), si construieste
ı̂n memorie tabloul bidimensional cu n linii şi n coloane, având proprietăţile:
toate elementele situate pe diagonala principală sunt nule;
fiecare linie conţine, ı̂ncepând cu diagonala principală, de la dreapta la stânga, un şir strict
crescător de numere consecutive, iar ı̂ncepând cu diagonala principală, de la stânga la
dreapta, tot un şir strict crescător de numere consecutive.
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe câte o
linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin câte un spaţiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat. (10p.)

Problema 1
Utilizând metoda backtracking se generează toate numerele pare cu câte trei cifre, cifre care
aparţin mulţimii 7, 8, 1, 6, 2, 3. Primele 4 soluţii generate sunt, ı̂n această ordine: 778, 776, 772,
788.
Cea de a 8-a soluţie generată este: (4p.)
a. 712 b. 716 c. 718 d. 782
Problema 2
Se consideră subprogramul f, definit alăturat. Scrieţi două
numere naturale din intervalul deschis (20,30), care pot fi
memorate ı̂n variabilele ı̂ntregi x1, şi respectiv x2, astfel ı̂ncât
valoarea lui f(x1,3) să fie 29, iar valoarea lui f(3,x2) să fie 1.
(6p.)
Problema 3
Se consideră şirul s, construit după regula alăturată.
Subprogramul sir primeşte prin parametrul n un număr
natural (3¡n¡20) şi furnizează prin parametrul a un tablou
unidimensional care memorează primii n termeni ai şirului s, definit după regula de mai sus,
astfel ı̂ncât numerele impare să ocupe primele poziţii ı̂n tablou, iar cele pare să fie memorate ı̂n
continuarea celor impare.
Scrieţi definiţia completă a subprogramului sir.
Exemplu: dacă n=6, primii sase termeni ai şirului sunt 1, 1, 2, 5, 13, 34, iar, după apel,
tabloul construit poate fi (1,1,5,13,2,34). (10p.)
Problema 4
Fişierul bac.in conţine pe prima linie un număr natural n (3¡n¡1000), iar pe următoarea linie, un
şir de n numere naturale distincte, de cel mult nouă cifre fiecare. Numerele din şir sunt separate
prin câte un spaţiu şi cel puţin două dintre ele au ultima cifră egală cu 5.
a) Scrieţi un program C/C++ care citeste toate numerele din fişier si, utilizând un algoritm
eficient din punct de vedere al timpului de executare şi al memoriei utilizate, determină si afişează
pe ecran cele mai mari două numere din şir care au ultima cifră egală cu 5. Numerele determinate
sunt afişate ı̂n ordine crescătoare, separate printr-un spaţiu. (6p.)
Exemplu: dacă fişierul bac.in are conţinutul alăturat, pe

ecran se vor afişa, ı̂n această ordine, numerele: 25 85
b) Descrieţi succint, ı̂n limbaj natural (3-4 rânduri), algoritmul utilizat la punctul a) si

Varianta 10
14.3.1 Subiectul I
Problema 1
Indicaţi care dintre expresiile C/C++ de mai jos are valoarea 1 dacă şi numai dacă numărul
natural memorat ı̂n variabila ı̂ntreagă n este divizibil cu 2 şi cu 7. (4p.)
a. !( (n%2==1) || (n%7!=0) ) b. (n%2==0) && (n%7!=0)
c. (n%2==0) || !(n%7==0) d. (n%7==2) && (n%2==7)
Problema 2
docod:
numărului real z.
a) Scrieţi numărul afişat dacă pentru variabila n se
citeste valoarea 64598. (6p.)
b) Scrieţi toate numerele de exact trei cifre care pot fi
citite pentru variabila n astfel ı̂ncât, pentru fiecare dintre
acestea, numărul afişat ı̂n urma executării algoritmului să
fie 24. (4p.)
repetă...până când cu o structură repetitivă de alt tip. (6p.)

Problema 1
Se consideră declararea alăturată, ı̂n care variabila FIG memorează coor-
donatele, ı̂n planul xOy, ale centrului unui cerc, precum şi lungimea razei
acestuia. O expresie C/C++ care are valoarea 1 dacă şi numai dacă centrul
cercului se află pe prima bisectoare a sistemului de coordonate al planului
xOy este: (4p.)
a. centru(x)==centru(y) b. FIG.cerc.x==FIG.cerc.y
c. FIG(x)==FIG(y) d. FIG.x==FIG.y
Problema 2
O matrice de adiacenţă prin care poate fi reprezentat graful orientat cu 3
vârfuri, reprezentat ı̂n figura alăturată, este: (4p.)
a. 0 1 0 b. 0 0 1 c. 0 0 0 d. 0 1 0
0 0 1 0 0 1 0 0 1 1 0 1
0 0 0 0 0 0 0 0 1 0 1 0
Problema 3
În secvenţa de instrucţiuni de mai jos, variabilele i şi j sunt de tip ı̂ntreg şi se consideră că
variabila A memorează elementele, iniţial nule, ale unui tablou bidimensional, cu 5 linii şi 5
coloane, numerotate de la 0 la 4.
Fără a utiliza şi alte variabile decât cele menţionate mai sus, scrieţi o instrucţiune care poate
ı̂nlocui punctele de suspensie astfel ı̂ncât, ı̂n urma executării secvenţei, tabloul memorat ı̂n variabila
A să aibă elementele din figura de mai jos. (6p.)
Problema 4
Se consideră arborele cu rădăcină, având 10 noduri, numerotate de la 1 la 10, cu vectorul de ”taţi”
t=(3,3,8,0,8,9,9,4,4,9). Enumeraţi toate nodurile arborelui care au exact doi fii. (6p.)
Problema 5
Se consideră un text cu cel mult 100 de caractere, format din cuvinte şi numere, separate prin
unul sau mai multe spaţii. Cuvintele sunt formate numai din litere ale alfabetului englez. Toate
numerele sunt reale, pozitive şi sunt formate numai din parte ı̂ntreagă sau din parte ı̂ntreagă şi
parte fracţionară, separate prin punctul zecimal (.).
Scrieţi un program C/C++ care citeste de la tastatură textul, pe care ı̂l transformă, eliminând
din componenţa sa toate numerele care au parte fracţionară. Programul afişează apoi pe ecran
textul obţinut. (10p.)
Exemplu: dacă textul citit este
Reprezentat cu 4 zecimale PI este 3.1415 si e este 2.7182
se va afişa pe ecran textul:
Reprezentat cu 4 zecimale PI este si e este

Problema 1
Se consideră subprogramul p, definit alăturat.
Valoarea lui p(210, 49) este: (4p.)
a. 1 b. 2 c. 3 d. 4
Problema 2
Având la dispoziţie cinci flori diferite, lalea, narcisă, mac, frezie, garoafă, se utilizează
metoda backtracking pentru a obţine toate posibilităţile de a forma un aranjament floral, sti-
ind că se folosesc toate cele cinci flori şi contează ordinea de asezare a acestora. Primele patru
soluţii obţinute sunt, ı̂n această ordine: (lalea, narcisă, mac, frezie, garoafă), (lalea,
narcisă, mac, garoafă, frezie), (lalea, narcisă, frezie, mac, garoafă), (lalea,
narcisă, frezie, garoafă, mac).
Scrieţi ultimele două soluţii generate, ı̂n ordinea obţinerii lor. (6p.)
Problema 3
Subprogramul tablou are trei parametri:
n şi k, prin care primeste câte un număr natural (3 & n & 20, 2 & k & 10);
a, prin care furnizează un tablou unidimensional care memorează un şir crescător de n k
termeni, din mulţimea primelor n numere naturale nenule, fiecare astfel de număr fiind ı̂n
şir de exact k ori.
Exemplu: dacă n=4, k=3 atunci, după apel, a=(1,1,1,2,2,2,3,3,3,4,4,4). (10p.)
Problema 4
Fişierul BAC.TXT conţine, ı̂n ordine crescătoare, cel puţin două şi cel mult 10000 de numere
naturale. Numerele sunt separate prin câte un spaţiu şi au cel mult 9 cifre fiecare.
Cel puţin un număr din fişier este par.
a) Scrieţi un program C/C++ care citeste toate numerele din fişier si, printr-un algoritm
eficient din punct de vedere al timpului de executare şi al memoriei utilizate, determină si afişează
pe ecran, ı̂n ordine strict crescătoare, separate prin câte un spaţiu, toate numerele pare care apar
ı̂n fişier. Fiecare număr se va afişa o singură dată. (6p.)
Exemplu: dacă fişierul are conţinutul de mai jos
1 1 2 2 2 7 10 10 10 10 24
pe ecran se afişează, ı̂n această ordine, numerele 2 10 24.
b) Descrieţi ı̂n limbaj natural (aproximativ 3-4 rânduri) algoritmul utilizat la punctul a) şi
Part II
Indicaţii de rezolvare
127
Capitolul 15
BAC 2023
15.1 Model
Varianta MODEL
a Se punctează orice modalitate de rezolvare corectă a cerinţelor.
a Nu se acordă punctaje intermediare, altele decât cele precizate explicit ı̂n barem. Nu se
acordă fracţiuni de punct.
a Se acordă zece puncte din oficiu. Nota finală se calculează prin ı̂mpărţirea la zece a puncta-
jului total acordat pentru lucrare.
a Utilizarea unui tip de date care depăşeşte domeniul de valori precizat ı̂n enunţ (de exemplu
tipuri ı̂ntregi cu semn pentru memorarea numerelor naturale, dimensiune a tablourilor) este accep-
tată din punctul de vedere al corectitudinii programului, dacă acest lucru nu afectează funcţionarea
sa.
15.1.1 Subiectul I
1b 2d 3a 4c 5d 5 4p.
1. a) Răspuns corect: 90 6p.

1. b) Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare dintre cele
două numere conform cerinţei (oricare dintre
numerele 70, 71, 72, 73, 74).
1. c) Pentru program corect 10p. (*) Se acordă numai 2p. dacă doar una dintre
- declarare a variabilelor 1p. instrucţiunile de decizie este conform cerinţei.
- citire date 1p.
- afişare date 1p.
- instrucţiune de repetitivă 2p.
- instrucţiuni de decizie (*) 3p.
- atribuiri 1p.
- corectitudine globală a programului 1p.
128
1. d) Pentru algoritm pseudocod corect 6p. (*) Se acordă punctajul chiar dacă algoritmul
- utilizare a unei structuri repetitive cu obţinut nu este echivalent cu cel dat.
test iniţial a (*) 2p. Se va puncta orice formă de structură repet-
- aspecte specifice ale secvenţei obţinute itivă conform cerinţei (cât timp...execută,
prin ı̂nlocuire, conform cerinţei (**) 3p. while...do etc.).
- algoritm complet, corectitudine (**) Se acordă câte 1p. pentru fiecare as-
globală a algoritmului 1p. pect specific (iniţializare a contorului, expre-
sie logică pentru test iniţial, actualizare a con-
torului) conform cerinţei.
2. Pentru rezolvare corectă 6p. Se acordă numai 2p. dacă s-a adăugat cel
puţin o muchie cu extremităţi cu grad iniţial
impar, dar fără obţinerea unui graf eulerian,
şi numai 4p. dacă s-a obţinut un graf eule-
rian dar numărul de muchii adăugate nu este
conform cerinţei.
3. Pentru rezolvare corectă 6p. (*) Se acordă câte 1p. pentru fiecare as-
-acces la un element al tabloului 1p. pect specific (valori ordonate descrescător pe
-atribuire a valorilor indicate conform 4p. linii, valori ordonate crescător pe coloane,
cerinţei (*) 1p. poziţionare faţă de diagonala secundară,
-corectitudine globală a secvenţei corespondenţă elemente suport-valori) con-
form cerinţei.
1. Pentru subprogram corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect
- antet al subprogramului (*) 3p. al antetului (structură, parametri de intrare,
- determinare a numărului cerut (**) 6p. parametru de ieire) conform cerinţei. (**) Se
- declarare a variabilelor locale, - corec- acordă câte 1p. pentru fiecare aspect (algo-
titudine globală a subprogramului 1p. ritm de bază pentru numărarea unui ir de val-
ori, identificare a unui divizor, identificare a unui
număr impar, divizori suport număraţi, identifi-
care a unui număr cu trei divizori impari, valori
suport din interval numărate) conform cerinţei.
2. Pentru program corect 10p. (*) Se acordă câte 1p. pentru fiecare as-
-declarare a unei variabile care să mem- pect (identificare a unui cuvânt, identificare
oreze un ir de caractere 1p. a unui cuvânt complet/prescurtat, identificare
-citire a datelor 1p. a cuvântului corespunzător celui prescurtat,
-determinare a irului cerut (*) nlocuire a unui subir cu un alt subir, cuvinte
-afişare a datelor 6p. suport nlocuite/păstrate, construire n memorie
-declarare a variabilelor simple, corecti- ca ir de caractere) conform cerinţei.
tudine globală a programului1) 1p.
1p
3. a) Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
- coerenţă a descrierii algoritmului (*) 1p. ales nu este eficient
- justificare a unor elemente de eficienţă 1p.
3. b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul este
- operaţii cu fişiere: declarare, pregătire principial corect, dar nu oferă rezultatul cerut
ı̂n vederea citirii, citire din fişier 1p. pentru toate seturile de date de intrare.
- determinare a valorilor cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un al-
- utilizare a unui algoritm eficient (***) 1p. goritm liniar, care utilizează eficient memoria.
- declarare a variabilelor, afiare a O soluţie posibilă determină, pe măsura citirii
datelor, corectitudine globală a progra- din fiier, valoarea ultimei temperaturi reprezen-
mului 1p. tative (tr) şi poziţia acesteia (ptr), pe baza
temperaturii curente (x) i a poziţiei acesteia
(px), care se actualizează la fiecare pas. Poziţia
curentă px se afiează doar dacă se ntâlnete o
temperatură mai mare decât tr (x%tr), sau dacă
temperatura curentă este egală cu tr (x=tr), dar
cele două valori nu sunt pe poziţii consecutive n
ir (px%ptr+1); valoarea lui ptr se actualizează

pentru fiecare x'tr (ptr px), iar valoarea lui tr

se actualizează pentru fiecare x%tr (tr x).
1) Corectitudinea globală vizează structura, sintaxa, alte aspecte neprecizate ı̂n barem.

Varianta Simulare
a Se acordă zece puncte din oficiu. Nota finală se calculează prin ı̂mpărţirea la zece a puncta-
a Utilizarea unui tip de date care depăşeşte domeniul de valori precizat ı̂n enunţ (de exemplu
tipuri ı̂ntregi cu semn pentru memorarea numerelor naturale, dimensiune a tablourilor) este accep-
tată din punctul de vedere al corectitudinii programului, dacă acest lucru nu afectează funcţionarea
sa.
15.2.1 Subiectul I
1d 2b 3a 4d 5c 5 4p.

trei numere conform cerinţei (oricare dintre
valorile 521, 531, 5021, 5031).
1. c) Pentru program corect 10p. (*) Se acordă numai 2p. dacă numai una
- declarare a variabilelor 1p. dintre instrucţiunile repetitive este conform
- citire a datelor 1p. cerinţei.
- afişare a datelor 1p.
- instrucţiune de decizie 2p.
- instrucţiuni repetitive (*) 3p.
- atribuiri 1p.
1. d) Pentru algoritm pseudocod corect 6p. (*) Se acordă punctajul chiar dacă algorit-
- utilizare a unei structuri repetitive de mul obţinut nu este echivalent cu cel dat. Se
tip pentru...execută (*) 2p. va puncta orice formă de structură repetitivă
- aspecte specifice ale secvenţei obţinute conform cerinţei (pentru...execută, for...do
prin ı̂nlocuire, conform cerinţei (**) 3p. etc.).
- algoritm complet, corectitudine (**) Se acordă câte 1p. pentru fiecare aspect
globală a algoritmului1) 1p. specific (valoare de iniţializare a contorului,
valoare finală a contorului, doar actualizare
implicită a contorului) conform cerinţei.
2. Pentru rezolvare corectă 6p. Se acordă numai 2p. dacă s-a adăugat cel
puţin o muchie cu extremităţi cu grad iniţial
impar, dar fără obţinerea unui graf eulerian,
şi numai 4p. dacă s-a obţinut un graf eule-
rian dar numărul de muchii adăugate nu este
conform cerinţei.
-acces la un element al tabloului 1p. pect specific (valori ordonate descrescător pe
-atribuire a valorilor indicate conform linii, valori ordonate crescător pe coloane,
cerinţei (*) 4p. poziţionare faţă de diagonala secundară,
-corectitudine globală a secvenţei 1p. corespondenţă elemente suport-valori) con-
form cerinţei.
- antet al subprogramului (*) 3p. al antetului (structură, parametri de intrare,
- determinare a numărului cerut (**) 6p. parametru de ieşire) conform cerinţei.
- declarare a variabilelor locale, corecti- (**) Se acordă câte 1p. pentru fiecare aspect (al-
tudine globală a subprogramului 1p. goritm de bază pentru numărarea unui şir de val-
ori, identificare a unui divizor, identificare a unui
număr impar, divizori suport număraţi, identifi-
care a unui număr cu trei divizori impari, valori
suport din interval numărate) conform cerinţei.
- declarare a unei variabile care să mem- pect (identificare a unui cuvânt, identificare
oreze un şir de caractere 1p. a unui cuvânt complet/prescurtat, identificare
- citire a datelor 1p. a cuvântului corespunzător celui prescurtat,
- determinare a şirului cerut (*) ı̂nlocuire a unui subşir cu un alt subşir, cuvinte
- afişare a datelor 6p. suport ı̂nlocuite/păstrate, construire ı̂n memorie
- declarare a variabilelor simple, corec- ca şir de caractere) conform cerinţei.
titudine globală a programului
1p.
1p
- coerenţă a descrierii algoritmului (*) 1p. ales nu este eficient.
- justificare a unor elemente de eficienţă 1p.
- determinare a valorilor cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un al-
- utilizare a unui algoritm eficient (***) 1p. goritm liniar, care utilizează eficient memoria.
- declarare a variabilelor, afişare a O soluţie posibilă determină, pe măsura citirii
datelor, corectitudine globală a progra- din fişier, valoarea ultimei temperaturi reprezen-
mului 1p. tative (tr) şi poziţia acesteia (ptr), pe baza tem-
peraturii curente (x) şi a poziţiei acesteia (px),
care se actualizează la fiecare pas.
Poziţia curentă px se afişează doar dacă se
ı̂ntâlneşte o temperatură mai mare decât tr
(x % tr), sau dacă temperatura curentă este
egală cu tr (x tr), dar cele două valori nu
sunt pe poziţii consecutive ı̂n şir (px % ptr 1);
valoarea lui ptr se actualizează pentru fiecare
x ' tr (ptr px), iar valoarea lui tr se actual-
izează pentru fiecare x % tr (tr x)
1) Corectitudinea globală vizează structura, sintaxa, alte aspecte neprecizate ı̂n barem.

Varianta 6
Se punctează orice modalitate de rezolvare corectă a cerinţelor.
Nu se acordă punctaje intermediare, altele decât cele precizate explicit ı̂n barem. Nu se
Se acordă zece puncte din oficiu. Nota finală se calculează prin ı̂mpărţirea la zece a puncta-
Utilizarea unui tip de date care depăşeşte domeniul de valori precizat ı̂n enunţ (de exemplu
tipuri ı̂ntregi cu semn pentru memorarea numerelor naturale, dimensiune a tablourilor) este
acceptată din punctul de vedere al corectitudinii programului, dacă acest lucru nu afectează
funcţionarea sa.
15.3.1 Subiectul I
1c 2a 3d 4b 5c 5 4p.
1. a) Răspuns corect: 233223222 6p. Se acordă numai 1p. dacă s-a scris doar
prima cifră corect, numai 2p. dacă s-au
scris doar primele trei cifre corect, numai 4p.
dacă s-au scris doar primele şase cifre corect
sau dacă, ı̂n plus faţă de cifrele cerute, s-au
scris şi alte caractere.
două numere conform cerinţei (oricare din-
tre numerele 6,7,8,9).
1. c) Pentru program corect 10p. (*) Se acordă numai 2p. dacă doar una
-variabile declarate, conform cerinţei 1p. dintre instrucţiunile repetitive este conform
-date citite, conform cerinţei 1p. cerinţei.
-date afişate, conform cerinţei 1p.
-instrucţiuni repetitive, conform
cerinţei (*) 4p.
-instrucţiune de decizie, conform
cerinţei 2p.
-corectitudine globală a programului 1p.
-structură repetitivă de tipul cerut mul obţinut nu este echivalent cu cel dat.
utilizată (*) 2p. Se va puncta orice formă de structură repet-
-aspecte specifice ale secvenţei obţinute itivă conform cerinţei (cât timp...execută,
prin ı̂nlocuire, conform cerinţei (**) 3p. while...do etc.).
-algoritm complet, corectitudine (**) Se acordă câte 1p. pentru fiecare as-
globală a algoritmului 1p. pect specific (iniţializare a contorului, ex-
presie logică pentru test iniţial, actualizare
a contorului) conform cerinţei.
2. Răspuns corect: 4, 5, 6, 7 6p. Se acordă numai 3p. dacă s-au precizat con-
form cerinţei doar descendenţii direcţi (fiii)
nodului indicat.
3. Pentru rezolvare corectă 6p. (*) Se acordă câte 1p. pentru fiecare aspect
-prefixe determinate, conform cerinţei specific (identificare a unui prefix, acces la
(*) 4p. prima literă a unui prefix, acces la ultima
-afişare a unor şiruri 1p. literă a unui prefix, prefixe suport determi-
-corectitudine globală a secvenţei 1p. nate) conform cerinţei.
3.1. Pentru subprogram corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect
-antet al subprogramului, conform al antetului (structură, parametru de intrare,
cerinţei (*) 3p. parametri de ieşire) conform cerinţei. (**)
-numere determinate, conform cerinţei Se acordă numai 3p. dacă s-a determinat o
(**) 6p. pereche (x,p) cu proprietatea cerută, dar x nu
-variabile locale declarate conform este cel mai mic număr cu această proprietate.
cerinţei, corectitudine globală a subpro-
gramului 1p.
3.2. Pentru program corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect
-variabilă de tip tablou bidimensional, specific (acces la cel puţin un element vecin
declarată conform cerinţei 1p. pe linia anterioară, acces la cel puţin un ele-
-date citite, conform cerinţei 1p. ment vecin pe coloana din dreapta, ı̂ncadrare
-memorare a valorilor elementelor, con- a elementelor ı̂n dimensiunile tabelei, valori şi
form cerinţei (*) 6p. elemente suport pe prima linie, valori şi el-
-date afişate ı̂n formatul indicat, con- emente suport aflate pe diagonala secundară
form cerinţei 1p. sau ı̂n stânga acesteia, valori şi elemente su-
-variabile simple, declarate conform port aflate ı̂n dreapta diagonalei secundare),
cerinţei, corectitudine globală a progra- conform cerinţei.
mului 1p
3.3. a) Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
-descriere coerentă a algoritmului, con- ales nu este eficient.
form cerinţei (*) 1p. (**) Se acordă numai 3p. dacă algoritmul este
-elemente de eficienţă justificate, con- principial corect, dar nu oferă rezultatul cerut
form cerinţei 1p. pentru toate seturile de date de intrare.
3.3. b) Pentru program corect 8p. (***) Se acordă punctajul numai pentru un al-
-operaţii cu fişiere: declarare, pregătire goritm liniar, care utilizează eficient memoria.
ı̂n vederea citirii, citire din fişier 1p. O soluţie posibilă determină, pe măsura citirii
-valori determinate, conform cerinţei datelor, valorile minime şi maxime curente
(*),(**) 5p. (minc, maxc, iniţializate cu 109+1, respectiv
-eficienţă a algoritmului, conform cu -109-1) dintre cele citite, poziţia curentă ı̂n
cerinţei (***) 1p. şir (p), precum şi valorile cerute pmin şi pmax.
-variabile declarate, afişare a datelor Pentru fiecare valoare citită (x), p este incre-
conform cerinţei, corectitudine globală mentat; dacă xı̂[minc,maxc], atunci se actu-
a programului 1p. alizează, după caz, pmin (la prima apariţie
a unui astfel de caz) sau pmax (la fiecare
apariţie a unui astfel de caz), care primesc
valoarea curentă a lui p; dacă x[minc,maxc],
se actualizează, după caz, minc (dacă x¡minc)
sau maxc (dacă x¿maxc). Valorile cerute sunt
pmin şi pmax.
Corectitudinea globală vizează structura, sintaxa, alte aspecte neprecizate ı̂n barem.

Varianta 5
funcţionarea sa.
15.4.1 Subiectul I
1d 2c 3c 4b 5a 5 4p.

două numere conform cerinţei (oricare numere
din intervalul cerut, cu cifre ı̂n ordine strict
descrescătoare).
-variabile declarate, conform cerinţei 1p. instrucţiunile de decizie este conform cerinţei.
-date citite, conform cerinţei 1p.
-instrucţiune repetitiv, conform cerinei 2p.
-instrucţiuni de decizie, conform
cerinţei (*) 3p.
-atribuiri, conform cerinţei 1p.
-structură repetitivă de tipul cerut (*) 2p. obţinut nu este echivalent cu cel dat.
-aspecte specifice ale secvenţei obţinute Se va puncta orice formă de structură repet-
prin ı̂nlocuire, conform cerinţei (**) 3p. itivă conform cerinţei (repetă...până când,
-algoritm complet, corectitudine repetă...cât timp, execută...cât timp, repeat
globală a algoritmului 1p. ...until etc.).
(**) Se acordă numai 2p. dacă doar unul din-
tre aspectele specifice (expresie logică pentru
test final, echivalenţă pentru cazul x=0) este
conform cerinţei.
2. Răspuns corect: 6p. Se acordă câte 3p. pentru fiecare soluţie con-
(mare, râu) form cerinţei.
(ocean, ploaie, râu)
- structură/ı̂nregistrare definită, con- pect (definire principial corectă a unei struc-
form cerinţei (*) 4p. turi/ı̂nregistrări, câmpuri de pe primul nivel,
- variabilă declarată conform cerinţei 1p. câmpuri de pe al doilea nivel, etichetă/nume)
- corectitudine globală a secvenţei 1p. conform cerinţei.
-antet al subprogramului, conform al antetului (structură, parametru de intrare)
cerinţei (*) 2p. conform cerinţei.
-proprietate verificată, conform cerinţei (**) Se acordă câte 1p. pentru fiecare as-
(**) 6p. pect specific (identificare a unui divizor al unui
-instrucţiune/instrucţiuni de returnare număr, algoritm de bază pentru calculul sumei
a rezultatului, conform cerinţei 1p. unei serii de valori, divizori suport ı̂nsumaţi,
-variabile locale declarate conform ı̂mpărţire reală pentru raport, algoritm prin-
cerinţei, corectitudine globală a subpro- cipial corect de verificare a unei proprietăţi,
gramului 1p. numere suport verificate) conform cerinţei.
2. Pentru program corect 10p. (*) Se acordă câte 2p. pentru fiecare aspect
-variabilă de tip tablou bidimensional, specific (algoritm de bază pentru determinare
declarată conform cerinţei 1p. a valorii maxime dintr-o serie de valori, de-
-date citite conform cerinţei 1p. terminare a poziţiei unui maxim ı̂ntr-o serie
-valori cu proprietatea cerută determi- de valori, valori suport verificate pentru deter-
nate (*) 6p. minarea unui maxim pentru fiecare secţiune)
-date afişate ı̂n format conform cerinţei 1p. conform cerinţei.
-variabile simple declarate conform
cerinţei, corectitudine globală a progra-
mului 1p.
3. b) Pentru program corect 8p. (***) Se acordă punctajul numai pentru un
-operaţii cu fişiere: declarare, pregătire algoritm liniar.
ı̂n vederea citirii, citire din fişier 1p. O soluţie posibilă utilizează doi vectori de
-valoare determinată, conform cerinţei frecvenţă, pf şi sf, ı̂n care pf[i] memorează
(*),(**) 5p. numărul de apariţii ale prefixului i ı̂n nu-
-eficienţă a algoritmului, conform merele din fişier, iar sf[i] memorează numărul
cerinţei (***) 1p. de apariţii ale sufixului i ı̂n numerele din fişier.
-variabile declarate, afişare a datelor Pe parcursul citirii datelor, se determină,
conform cerinţei, corectitudine globală pentru fiecare număr x citit (x%99), su-
a programului 1p. fixul (x%100), respectiv prefixul ([x/10] sau
[x/100], ı̂n funcţie de numărul de cifre ale lui
x) şi se actualizează corespunzător cei doi vec-
tori de frecvenţă.
După citirea tuturor numerelor se contor-
izează toate valorile x"[10,99] pentru care
sf[x]=pf[x] şi sf[x]neq0.

Varianta 7
funcţionarea sa.
15.5.1 Subiectul I
1b 2c 3a 4b 5d 5 4p.

1. b) Pentru răspuns corect 6p. Se acordă numai 2p. dacă s-au precizat pa-
tru numere, dar acestea nu conduc la scrierea
valorii cerute, şi numai 4p. dacă s-au precizat
patru numere care conduc la scrierea valorii
cerute, dar nu toate aparţin intervalului indi-
cat.
O soluţie corectă este un şir de forma x, 0, y, 0,
unde x şi y sunt numere din intervalul indicat.
-variabile declarate, conform cerinţei 1p. instrucţiunile repetitive este conform cerinţei.
-date citite, conform cerinţei 1p.
-instrucţiuni repetitive, conform
cerinţei (*) 3p.
-instrucţiune de decizie, conform
cerinţei 2p.
-atribuiri, conform cerinţei 1p.
-structură repetitivă de tipul cerut (*) 2p. obţinut nu este echivalent cu cel dat.
-aspecte specifice ale secvenţei obţinute Se va puncta orice formă de structură
prin ı̂nlocuire, conform cerinţei (**) 3p. repetitivă conform cerinţei (pentru...execută,
-algoritm complet, corectitudine for...do etc.).
globală a algoritmului 1p. (**) Se acordă câte 1p. pentru fiecare aspect
specific (expresie iniţială a contorului, expresie
finală a contorului, doar actualizare automată
a contorului) conform cerinţei.
2. Răspuns corect: 2,3 6p. Se acordă numai 3p. dacă s-a scris doar un
nod conform cerinţei şi numai 4p. dacă s-au
scris şi alte noduri ı̂n plus faţă de cele corecte.
-câmpuri ale ı̂nregistrării, accesate con- specific (atribuire a unei valori variabilei a, ac-
form cerinţei 1p. ces la primul caracter al unui şir, constantă
-date determinate, conform cerinţei (*) 4p. de tip caracter cu sintaxă adecvată, valoare
-corectitudine globală a secvenţei 1p. atribuită ı̂n funcţie de preţ) conform cerinţei.
-antet al subprogramului, conform al antetului (structură, parametru de intrare)
cerinţei (*) 2p. conform cerinţei.
-valori determinate, conform cerinţei (**) Se acordă câte 2p. pentru fiecare aspect
(**) 6p. (determinare a unui divizor, identificare a unui
-date afişate, conform cerinţei 1p. număr prim/care nu este prim, divizori suport
-variabile locale declarate conform determinaţi) conform cerinţei.
cerinţei, corectitudine globală a subpro-
gramului 1p.
-variabilă de tip tablou bidimensional, pect (identificare a unui pătrat situat ı̂n inte-
declarată conform cerinţei 1p. riorul tabloului, identificare a unui pătrat cu
-date citite conform cerinţei 1p. o latură pe prima linie/coloană a tabloului,
-valoare determinată conform cerinţei identificare a unui pătrat cu o latură pe ul-
(*) 6p. tima linie/coloană a tabloului, determinare a
-date afişate, conform cerinţei 1p. valorii unui pătrat, algoritm principial corect
-variabile simple declarate conform de determinare a unei valori maxime, pătrate
cerinţei, corectitudine globală a progra- suport verificate pentru determinarea valorii
mului 1p. maxime) conform cerinţei.
3. b) Pentru program corect 8p. (***) Se acordă punctajul numai pentru un
-operaţii cu fişiere: declarare, pregătire algoritm liniar.
ı̂n vederea citirii, citire din fişier 1p. O soluţie posibilă utilizează doi vectori de
-valoare determinată, conform cerinţei frecvenţă, fie aceştia a şi b, unde ai este
(*),(**) 5p. numărul apariţiilor valorii i ı̂n primul şir, iar
-eficienţă a algoritmului, conform bi este numărul apariţiilor valorii i ı̂n al doilea
cerinţei (***) 1p. şir; vectorii sunt completaţi pe măsura citirii
-variabile declarate, afişare a datelor datelor din fişier, iar numărul afişat se obţine
conform cerinţei, corectitudine globală ulterior prin ı̂nsumarea valorilor min(ai ,bi ).
a programului 1p.
Capitolul 16
BAC 2022

Varianta Simulare
acordă fracţiuni de punct. Se acordă zece puncte din oficiu. Nota finală se calculează prin
ı̂mpărţirea la zece a punctajului total acordat pentru lucrare.
a Utilizarea unui tip de date care depăşeşte domeniul de valori precizat ı̂n enunţ (de ex-
emplu tipuri ı̂ntregi cu semn pentru memorarea numerelor naturale, dimensiune a tablourilor)
este acceptată din punctul de vedere al corectitudinii programului, dacă acest lucru nu afectează
corectitudinea ı̂n funcţionarea programului.
16.1.1 Subiectul I
1d 2b 3c 4a 5c 5 4p.

1. b) Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare aspect
(număr de valori scrise, primul număr, al
doilea număr) conform cerinţei.
Cele două numere conform cerinţei sunt de
forma 22xy, unde x şi y sunt cifre impare.
-declarare a variabilelor 1p. instrucţiunile repetitive este conform cerinţei.
-citire a datelor 1p.
-afişare a datelor 1p.
-instrucţiune de decizie 2p.
-instrucţiuni repetitive (*) 3p.
-atribuiri 1p.
- utilizare principial corectă a unei obţinut nu este echivalent cu cel dat.
structuri pentru...execută (*) 2p. (**) Se acordă câte 1p. pentru fiecare as-
- aspecte specifice ale secvenţei obţinute pect (expresie limită inferioară contor, expre-
prin ı̂nlocuire, conform cerinţei (**) 3p. sie limită superioară contor, doar actualizare
- algoritm complet, corectitudine automată contor) conform cerinţei.
globală a algoritmului 1p.
139
2. Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare dintre cele
trei noduri conform cerinţei (oricare dintre
nodurile 1, 3, 4, 6).
3. Răspuns corect 6p. (*) Se acordă câte 1p. pentru fiecare aspect
-acces la un element al tabloului 1p. (poziţionare a elementelor care compun un
-verificare a proprietăţii cerute (*) 4p. romb, valoare comună a elementelor care com-
-corectitudine globală a secvenţei 1p. pun un romb, algoritm de bază pentru verifi-
carea unei proprietăţi, elemente suport verifi-
cate) conform cerinţei.
- antet subprogram (*) 3p. al antetului (structură, parametri de intrare,
- determinare a valorii cerute (**) 6p. parametru de ieşire) conform cerinţei.
- declarare a tuturor variabilelor locale, (**) Se acordă câte 2p. pentru fiecare
tratare a cazului 0, corectitudine aspect (identificarea unui număr corespunzător
globală a subprogramului 1p. restului cerut, algoritm de bază pentru de-
terminarea ultimei/celei mai mari valori cu o
anumită proprietate dintr-o serie, valori su-
port cu proprietatea cerută identificate) conform
cerinţei.
2. Pentru program corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect spe-
- declarare a unei variabile care să cific (identificarea unui cuvânt ı̂n cadrul unui şir,
memoreze un şir de caractere 1p. identificarea unui cuvânt egal cu un cuvânt dat
- citire a datelor ı̂n ordinea indicată 1p. x, identificarea unui nume corespunzător unui
- determinare a cuvintelor/numelor prenume, tratare a cazului ı̂n care cuvântul x
cerute (*) 6p. dat corespunde unui nume, caractere utile ı̂ntr-
- tratare a cazului NU şi afişare fie a un nume, cuvinte suport identificate) conform
numelor ı̂n formatul cerut, fie a cerinţei.
mesajului indicat 1p.
- declarare a variabilelor simple,
corectitudine globală a programului 1p
- justificare a elementelor de eficienţă 1p.
ı̂n vederea scrierii, scriere ı̂n fişier 1p. pentru toate seturile de date de intrare.
- determinare a valorii cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un al-
- utilizare a unui algoritm eficient (***) 1p. goritm cel mult liniar care utilizează eficient
- declarare a variabilelor, citire a memoria.
2
datelor, corectitudine globală a progra- O soluţie posibilă are ı̂n vedere că 45 3
mului 1p. 5 şi parcurge numerele naturale din intervalul
2, n, determinând pentru fiecare număr curent
k numărul t de apariţii ale lui 3, respectiv
numărul c de apariţii ale lui 5, ı̂n descompunerea
ı̂n factori primi a lui k, şi realizând pe par-
curs suma tuturor valorilor t determinate (st),
respectiv suma tuturor valorilor c determinate
(sc). Valoarea cerută este min st©2, sc.
O altă soluţie posibilă determină valorile st şi sc
astfel:
st=[n/3]+[n/32]+[n/33]+[n/34]+ ...+0
sc=[n/5]+[n/52]+[n/53]+[n/54]+ ...+0
Valoarea cerută este min st©2, sc.

Varianta 4
16.2.1 Subiectul I
1d 2c 3a 4c 5b 5 4p.
1. a) Răspuns corect: 37 23 6p. Se acordă numai 3p. dacă numai una dintre
valori este conform cerinţei sau numai 4p.
dacă, pe lângă valorile cerute, sunt scrise şi
alte valori.
1. b) Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare număr
conform cerinţei (valori de forma xyz cu
proprietatea că xy şi yz sunt numere prime).
1. c) Pentru program corect 10p. (*) Se acordă numai 2p. dacă doar una
-declarare a variabilelor 1p. dintre instrucţiunile de decizie este conform
-citire a datelor 1p. cerinţei.
-instrucţiuni de decizie (*) 3p.
-instrucţiune repetitivă 2p.
-atribuiri 1p.
1. d) Pentru algoritm pseudocod corect 6p. (*) Se acordă punctajul chiar dacă
-utilizare a unei structuri repetitive cu algoritmul obţinut nu este echivalent cu
test iniţial (*) 2p. cel dat. Se va puncta orice formă de
-expresie logică pentru test iniţial structură repetitivă conform cerinţei (cât
ı̂n secvenţa obţinută prin ı̂nlocuire, timp...execută, while...do etc.).
conform cerinţei 2p.
-algoritm complet, corectitudine
2. Răspuns corect: 6p. Se acordă numai 3p. dacă s-au precizat
[1,2], [1,3], [1,5], nodurile/muchiile unui subgraf complet dar
[2,3], [2,5], [3,5] care are 3 noduri, şi numai 4p. dacă s-au
precizat doar nodurile unui subgraf conform
cerinţei.
3. Pentru răspuns corect 6p. (*) Se acordă câte 2p. pentru fiecare
-acces la un câmp al unei ı̂nregistrări 1p. aspect specific (algoritm de bază pentru
-determinare a sumei cerute (*) 4p. determinarea sumei unei serii de valori,
-corectitudine globală a secvenţei 1p. valori suport ı̂nsumate) conform cerinţei.
-antet subprogram (*) 3p. al antetului (structură, parametru de intrare,
-determinare a valorilor cerute (**) 6p. parametri de ieşire) conform cerinţei.
-declarare a tuturor variabilelor locale, (**) Se acordă câte 1p. pentru fiecare as-
corectitudine globală a subprogramului 1p. pect (identificare a unor perechi de valori
corespunzătoare produsului cerut, algoritm de
bază pentru determinarea unei prime apariţii
a unei valori sau perechi / a unei valori
minime ı̂ntr-o serie, perechi de valori suport
verificate/obţinute pentru determinarea lui x
minim, valori strict mai mari decât 1, ordine a
valorilor x şi y, tratare caz 0) conform cerinţei.
3.2. Pentru program corect 10p. (*) Se acordă câte 2p. pentru fiecare aspect
-declarare a unei variabile care să mem- specific (algoritm de bază de deplasare spre
oreze un tablou bidimensional 1p. stânga, ı̂n memorie, a unor elemente de pe
-citire a datelor 1p. o linie, identificare a unui element aflat pe
-modificare a tabloului (*) 6p. diagonala principală, elemente suport elimi-
-afişare a unui tablou ı̂n formatul cerut 1p. nate/păstrate) conform cerinţei.
-declarare a variabilelor de tip simplu,
corectitudine globală a programului 1p
3.3. a) Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
-descriere coerentă a algoritmului (*) 1p. ales nu este eficient.
-justificare a elementelor de eficienţă 1p.
3.3. b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul este
-operaţii cu fişiere: declarare, pregătire principial corect, dar nu oferă rezultatul cerut
-determinare a valorii cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un al-
-utilizare a unui algoritm eficient (***) 1p. goritm liniar care utilizează eficient memoria.
-declarare a variabilelor, afişare a O soluţie posibilă parcurge datele din fişier
datelor, corectitudine globală a progra- memorând ultimele două valori citite (fie ele x,
mului 1p. y), lungimea secvenţei curente de valori egale
(fie ea ny) şi lungimea secvenţei progresive
curente (lgcrt); pentru fiecare pereche (x,y)
pentru care x=y se incrementează ny; la fi-
nalul fiecărei secvenţe de valori egale (xneqy),
dacă ny=x se actualizează corespunzător lgcrt
şi, după caz, lungimea maximă cerută, iar al-
tfel, dacă ny¡x, se reiniţializează lgcrt cu 0.
Pentru ultima secvenţă de valori egale se ac-
tualizează datele la final.

Varianta 4
16.3.1 Subiectul I
1c 2d 3a 4b 5c 5 4p.

două numere prime conform cerinţei, şi numai
câte 2p. pentru fiecare dintre cele două nu-
mere prime dar care nu aparţin intervalului.
-atribuiri 1p.
-utilizare a unei structuri repetitive cu obţinut nu este echivalent cu cel dat.
test final (*) 2p. Se va puncta orice formă de structură
-aspecte specifice ale secvenţei obţinute repetitivă conform cerinţei (repetă...până
prin ı̂nlocuire, conform cerinţei (**) 3p. când, do...while, repetă...cât timp,
-algoritm complet, corectitudine execută...până când, execută...cât timp etc.).
globală a algoritmului 1p. (**) Se acordă numai 2p. dacă doar unul din-
tre aspectele specifice (condiţie de echivalenţă
pentru prima iteraţie, expresie logică pentru
test final) este conform cerinţei.
2. Răspuns corect 6p. Se acordă câte 3p. pentru fiecare dintre cele
două valori conform cerinţei (oricare dintre
numerele 2022, 2023, 2024, 2025).
3. Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare aspect
(identificare a unui cuvânt ı̂n cadrul unui şir,
copiere a unui şir ı̂ntr-un alt şir/concatenare
a două şiruri, secvenţe suport copiate ı̂n şirul
destinaţie) conform cerinţei.
-antet al subprogramului (*) 2p. al antetului (structură, parametru de intrare-
-determinare a valorii cerute (**) 6p. ieşire) conform cerinţei.
-furnizare a rezultatului prin (**) Se acordă câte 1p. pentru fiecare as-
parametrul indicat 1p. pect (identificare a unei cifre, identificare a
-declarare a tuturor variabilelor locale, unei perechi de cifre de pe poziţii consecu-
corectitudine globală a subprogramului 1p. tive, ı̂nlocuire a unei cifre, secvenţe suport
ı̂nlocuite, ordine a cifrelor, secvenţe suport
păstrate - inclusiv cifrele nule de la finalul
numărului) conform cerinţei.
-declarare a unei variabile care să mem- pect specific (identificare a două parcele vecine
oreze un tablou bidimensional 1p. pentru cel puţin unul dintre cazurile de plasare
-citire a elementelor tabloului 1p. a acestora, algoritm de bază pentru deter-
-determinare a valorii cerute (*) 6p. minarea unei valori minime dintr-o serie de
-afişare a datelor 1p. maximum patru, parcele vecine suport pen-
-declarare a variabilelor simple, citire a tru determinarea minimului - pentru toate
datelor simple, corectitudine globală a cazurile particulare, identificare a unei parcele
programului 1p. care se ı̂nnisipează, algoritm de bază pentru
ı̂nsumarea unei serii de valori, valori suport
ı̂nsumate) conform cerinţei.
-descriere coerentă a algoritmului (*) - 1p. ales nu este eficient.
justificare a elementelor de eficienţă 1p.
-declarare a variabilelor, afişare a Se memorează ultimele două valori citite, ı̂n
datelor, corectitudine globală a progra- această ordine, ant şi crt, precum şi numărul
mului 1p. cerut, nr.
O soluţie posibilă iniţializează numărul ant
cu 0 şi parcurge datele din fişier citind val-
oarea curentă crt (eventual cât timp crt&y),
incrementând numărul nr pentru fiecare val-
oare distinctă din şir (crtjant) din intervalul
cerut (crt'x şi crt&y); valoarea ant se actual-
izează la fiecare pas.

Varianta 5
16.4.1 Subiectul I
1b 2a 3d 4c 5b 5 4p.

două numere conform cerinţei (orice număr
natural din intervalul [10,14]).
-atribuiri 1p.
-utilizare a unei structuri repetitive cu mul obţinut nu este echivalent cu cel dat.
test final (*) 2p. Se va puncta orice formă de structură repet-
-expresie logică pentru test final ı̂n itivă conform cerinţei (repetă...până când,
secvenţa obţinută prin ı̂nlocuire, con- do...while, repetă...cât timp, execută...cât
form cerinţei 3p. timp etc.).
-algoritm complet, corectitudine
2. Răspuns corect: 2 8 6p. Se acordă câte 3p. pentru fiecare nod conform
cerinţei.
3. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă a fost tratat con-
-accesul la un câmp al unei ı̂nregistrări 1p. form cerinţei un singur caz, numai 3p. dacă
-tratare a tuturor cazurilor, conform au fost tratate conform cerinţei numai două
cerinţei (*) 4p. cazuri.
-corectitudinea globală a secvenţei 1p.
-antet subprogram (*) 3p. al antetului (structură, parametri de intrare,
-determinare a valorii cerute (**) 6p. parametru de ieşire) conform cerinţei.
-declarare a tuturor variabilelor locale, (**) Se acordă câte 2p. pentru fiecare as-
corectitudine globală a subprogramului 1p. pect (acces la o cifră a unui număr, or-
dine a cifrelor numărului obţinut, cifre suport
ı̂nlocuite/păstrate - inclusiv a cifrelor nule de
la finalul numărului) conform cerinţei.
-declarare a unei variabile care să specific (acces la un caracter al unui şir, iden-
memoreze un şir de caractere 1p. tificare a unei vocale/consoane, algoritm de
-citire a datelor 1p. bază pentru determinarea primei valori cu o
-determinare a şirului conform formei anumită proprietate dintr-o serie/a unei vo-
codificate (*) 6p. cale prietene, ı̂nlocuire a unui caracter ı̂ntr-un
-afişare a datelor 1p. şir, caractere suport ı̂nlocuite/păstrate, trans-
-declarare a variabilelor de tip simplu, formare ı̂n memorie) conform cerinţei.
corectitudine globală a programului 1p.
-determinare a valorilor cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un al-
-declarare a variabilelor, afişare a O soluţie posibilă parcurge datele din fişier
datelor, corectitudine globală a progra- şi memorează ı̂n variabilele x şi y ul-
mului 1p. timii doi termeni citiţi; dacă x%2 j
y%2, iniţializează lungimea secvenţei curente,
iar dacă x%2 y%2, incrementează
lungimea secvenţei curente şi actualizează,
după caz, lungimea maximă şi incrementează
sau iniţializează numărul secvenţelor cerute.
Capitolul 17
BAC 2021

Varianta 7
17.1.1 Subiectul I
1c 2b 3a 4c 5d 5 4p.
1. a) Răspuns corect: **** 6p. Se acordă numai 3p. dacă s-au scris 5 sau doar
3 simboluri *.
două numere conform cerinţei (oricare două
dintre numerele 1, 157, 158).
1. c) Pentru program corect 10p. (*) Se acordn̆umai 1p. dacă doar una dintre
-declarare variabile 1p. instrucţiunile de decizie este conform cerinţei.
-citire date 1p.
-afişare date 1p.
-atribuiri precizate ı̂n algoritmul dat 1p.
-implementare a operaţiei de
interschimbare 1p.
28
1. d) Pentru algoritm pseudocod corect 6p. (*) Se acordă numai 2p. dacă algoritmul
-echivalenţă a prelucrării realizate, are o structură repetitivă conform cerinţei,
conform cerinţei (*) 5p. principial corectă, dar nu este echivalent cu
-corectitudine globală a algoritmului 1p. cel dat.
Se va puncta orice formă corectă de structură

repetitivă conform cerinţei.
2. Pentru rezolvare corectă 6p. Se acordă câte 3p. pentru fiecare dintre cele
două valori conform cerinţei.
f(2)=2
f(21)=10
3. Răspuns corect 6p. Se acordă câte 2p. pentru fiecare aspect
2021 (subşir de cifre, succesiune de litere şi !, linii
b!a!c! separate) conform cerinţei.
28
147
-antet subprogram (*) 3p. al antetului (structură, parametri de intrare,
-declarare a tuturor variabilelor locale, 1p. (**) Se acordă câte 1p. pentru fiecare aspect
corectitudine globală a subprogramului (identificare a unei cifre pare/impare, succe-
siune de cifre obţinute ı̂n ordinea parcurgerii
stânga-dreapta, succesiune de cifre obţinute
ı̂n ordinea parcurgerii dreapta-stânga, identi-
ficare a unei cifre comune / distincte, cifre su-
port / numere formate din cifrele suport ver-
ificate, tratare a cazului ı̂n care nu există cifre
impare ı̂n niciun număr) conform cerinţei.
-declarare a unei variabile care să 1p. pect specific (identificare a unui element sit-
memoreze un tablou bidimensional 1p. uat pe linia cerută ı̂n stânga diagonalei prin-
-citire a datelor 6p. cipale, identificare a unui element situat pe
-transformare a tabloului conform 1p. coloana cerută deasupra diagonalei principale,
cerinţei (*) 1p plasare a unor elemente de pe linia sursă pe
-afişare a datelor coloana destinaţie, plasare a unor elemente de
-declarare a variabilelor simple, corec- pe coloana sursă pe linia destinaţie, valori su-
titudine globală a programului port deplasate/nemodificate, transformare ı̂n
memorie) conform cerinţei.
-coerenţă a descrierii algoritmului (*) 1p. ales nu este eficient.
-operaţii cu fişiere: declarare, pregătire 1p. principial corect, dar nu oferă rezultatul cerut
ı̂n vederea scrierii, scriere ı̂n fişier pentru toate seturile de date de intrare.
-declarare a variabilelor, citire a 1p. O soluţie posibilă determină valoarea lui n,
datelor, corectitudine globală a progra- corespunzătoare termenului fn y, pe baza
mului expresiei n y x©2; se generează ter-
menii şirului mai mici decât y pe baza relaţiei
fn x y 2 n 1, unde x, y şi n se actu-
alizează corespunzător, la fiecare pas.
O altă soluţie posibilă nu utilizează deloc val-
oarea lui x, ci deduce formula termenului gen-
eral ca fiind fn 1 n n 1 şi determină val-
oarea lui n corespunzătoare termenului fn y
2
rezolvând ecuaţia n n y 1 0; se
generează termenii fn ai şirului pe baza for-
mulei deduse, unde n se actualizează core-
spunzător, la fiecare pas.

Varianta 1
acordă fracţiuni de punct. Se acordă zece puncte din oficiu. Nota finală se calculează prin
ı̂mpărţirea la zece a punctajului total acordat pentru lucrare.
a Utilizarea unui tip de date care depăşeşte domeniul de valori precizat ı̂n enunţ (de ex-
emplu tipuri ı̂ntregi cu semn pentru memorarea numerelor naturale, dimensiune a tablourilor)
este acceptată din punctul de vedere al corectitudinii programului, dacă acest lucru nu afectează
corectitudinea ı̂n funcţionarea programului.
17.2.1 Subiectul I
1a 2d 3d 4b 5c 5 4p.
1. a) Răspuns corect: 1111121121 6p. Se acordă numai 1p. dacă doar prima cifră
este conform cerinţei, numai 2p. dacă doar
primele două cifre sunt conform cerinţei, nu-
mai 3p. dacă doar primele patru cifre sunt
conform cerinţei, numai 5p. dacă doar primele
şapte cifre sunt conform cerinţei.
două numere conform cerinţei (6, 15).
-declarare a variabilelor 1p. instrucţiunile de decizie este conform cerinţei.
-implementare a operaţiei de
interschimbare 1p.
-atribuiri precizate ı̂n algoritmul dat 1p.
-utilizare a unei structuri repetitive cu obţinut nu este echivalent cu cel dat.
test iniţial (*) 2p. Se va puncta orice formă explicită de
-aspecte specifice ale secvenţei obţinute structură repetitivă conform cerinţei (cât
prin ı̂nlocuire, conform cerinţei (**) 3p. timp...execută, while... do etc.).
-algoritm complet, corectitudine (**) Se acordă câte 1p. pentru fiecare aspect
globală a algoritmului 1p. (iniţializare contor, expresie logică pentru test
iniţial, actualizare contor) conform cerinţei.
2. Răspuns corect 6p. Se acordă câte 3p. pentru fiecare dintre cele
(ciocârlie, scatiu) două soluţii conform cerinţei. Se acordă punc-
(mierlă, scatiu) tajul şi dacă soluţiile nu sunt grupate ı̂ntre
paranteze/acolade.
3. Pentru răspuns corect 6p. (*) Se acordă numai 2p. dacă doar numitorul
-acces la câmpurile unei structuri 2p. sau doar numărătorul au fost calculate con-
-atribuiri conform cerinţei (*) 3p. form cerinţei.
-corectitudine globală a secvenţei 1p.
-antet al subprogramului (*) 3p. al antetului (structură, parametru de intrare,
-declarare a tuturor variabilelor locale, 1p. (**) Se acordă câte 1p. pentru fiecare as-
corectitudine globală a subprogramului pect (identificare a unui divizor, identificare
a unui număr/divizor prim, identificare a put-
erii unui divizor ı̂n descompunerea ı̂n factori
primi, identificare a unei puteri impare, al-
goritm de bază pentru ı̂nsumarea unei serii
de valori, valori suport ı̂nsumate) conform
cerinţei.
-declarare a unei variabile care să mem- specific (parcurgere a unei serii de cuvinte, ac-
oreze un şir de caractere 1p. ces la ultima literă a unui cuvânt, identificare
-citire a tuturor datelor 1p. a unei vocale/consoane, algoritm de bază pen-
-determinare a cuvintelor cerute (*) 5p. tru numărarea unei serii de valori, cuvinte su-
-afişare a datelor şi tratare a cazului nu port numărate) conform cerinţei.
exista (**) 2p. (**) Se acordă numai 1p. dacă s-au afişat atât
-declarare a variabilelor simple, corecti- unele cuvinte, cât şi mesajul indicat.
tudine globală a programului 1p.
3. b) Pentru program corect 8p. (*) Se acordă punctajul chiar dacă algoritmul
-operaţii cu fişiere: declarare, pregătire 1p. ales nu este eficient.
ı̂n vederea citirii, citire din fişier (**) Se acordă numai 3p. dacă algoritmul este
-determinare a valorilor cerute (*),(**) 5p. principial corect, dar nu oferă rezultatul cerut
-utilizare a unui algoritm eficient (***) 1p. pentru toate seturile de date de intrare.
-declarare a variabilelor, afişare a 1p. (***) Se acordă punctajul numai pentru un al-
datelor, corectitudine globală a progra- goritm liniar care utilizează eficient memoria.
mului O soluţie posibilă citeşte prima valoare din
fişier (x), apoi, pe măsura citirii celorlalte
valori, memorează valoarea curentă (crt), şi
penultima valoare citită (ant), precum şi ul-
timele două numere cu proprietatea cerută (pu
şi u, iniţializate cu -1); ant se actualizează la
fiecare pas (ant=crt), iar pu şi u se actual-
izează doar dacă crt mod 1000=x şi ant mod
1000=x (pu=ant şi u=crt).

Varianta 4
17.3.1 Subiectul I
1d 2b 3a 4b 5c 5 4p.
1. a) Răspuns corect: 3 4 6 8 9 15 6p. Se acordă câte 1p. pentru fiecare număr con-
form cerinţei.
1. b) Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare set de date
conform cerinţei (orice triplet de numere nat-
urale nenule, n, x, y, unde x&n şi x=y).
-atribuiri 1p.
-utilizare a unei structuri repetitive cu 2p. obţinut nu este echivalent cu cel dat.
test iniţial (*) Se va puncta orice formă de structură repet-
-aspecte specifice ale secvenţei obţinute 3p. itivă conform cerinţei (cât timp...execută,
prin ı̂nlocuire, conform cerinţei (**) while... do etc.).
-algoritm complet, corectitudine 1p. (**) Se acordă câte 1p. pentru fiecare aspect
globală a algoritmului (iniţializare contor, expresie logică pentru test
iniţial, actualizare contor) conform cerinţei.
2. Răspuns corect 6p. Se acordă numai 1p. dacă doar ultimele 3
ARMONIA litere sunt conform cerinţei, numai 3p. dacă
doar ultimele 4 litere sunt conform cerinţei,
numai 5p. dacă doar ultimele 6 litere sunt
conform cerinţei.
3. Pentru răspuns corect 6p.
-acces la un câmp de pe primul nivel al 2p.
structurii
-acces la un câmp de pe al doilea nivel 2p.
al structurii
-atribuire a valorilor indicate pentru 1p.
datele angajatului precizat
-antet subprogram (*) 2p. al antetului (structură, parametru de intrare)
-determinare a valorilor cerute (**) 4p. conform cerinţei.
-afişare a datelor (***) 3p. (**) Se acordă câte 2p. pentru fiecare aspect
-declarare a tuturor variabilelor locale, (determinare/identificare a unui cub perfect,
corectitudine globală a subprogramului 1p. cuburi perfecte suport determinate) conform
cerinţei.
(***) Se acordă numai 1p. dacă valorile sunt
afişate, dar nu ı̂n ordinea cerută.
-declarare a unei variabile care să mem- 1p. specific (identificare a poziţiei elementelor sit-
oreze un tablou bidimensional uate pe diagonala principală, plasare pe linii
-citire a datelor 1p. a unor valori consecutive la stânga diagonalei
-construire a tabloului conform cerinţei 6p. principale, plasare pe linii a unor valori con-
(*) secutive la dreapta diagonalei principale, mul-
-afişare a datelor 1p. tipli ai lui k suport pe diagonala principală,
-declarare a variabilelor simple, corecti- 1p. valori suport plasate ı̂n afara diagonalei princi-
tudine globală a programului pale, construire ı̂n memorie) conform cerinţei.
3. b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul
-operaţii cu fişiere: declarare, pregătire 1p. este principial corect, dar nu oferă rezultatul
ı̂n vederea citirii, citire din fişier cerut pentru toate seturile de date de intrare.
-determinare a valorii cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un
-utilizare a unui algoritm eficient (***) 1p. algoritm liniar.
-declarare a variabilelor, afişare a 1p.
datelor, corectitudine globală a progra- O soluţie posibilă utilizează un vector de
mului frecvenţă v ı̂n care vi reprezintă numărul de
valori x din şirul A pentru care i=x%100
(i"[0,99]). Vectorul v se actualizează pe
măsura parcurgerii celei de a doua linii a
fişierului. Se determină numărul cerut nr pe
măsura parcurgerii numerelor de pe a treia
linie a fişierului: pentru fiecare număr curent
y din şirul B se determină ultimele două
cifre ale sale, c1 şi c2 şi numerele i şi j, unde
i=c1*10+c2, iar j=c2*10+c1, apoi se adună la
nr valoarea vi şi, dacă ijj, se adună la nr şi vj .
O altă soluţie utilizează câte un vector de

frecvenţă pentru fiecare şir, va şi vb, cu
aceeaşi semnificaţie ca mai sus. Vectorii se
completează pe măsura citirii fiecărui şir, iar
numărul cerut se obţine la final, prin parcurg-
erea vectorului vb şi pentru fiecare i"[0,99], se
determină ultimele două cifre ale sale, c1 şi c2
şi numărul j, unde j=c2*10+c1, apoi se adună
la nr valoarea vbi vai şi, dacă ijj, se adună la
nr şi vbi vaj .
Capitolul 18
BAC 2020

Varianta 6
a Se punctează oricare alte modalităţi de rezolvare corectă a cerinţelor.
a Nu se acordă punctaje intermediare, altele decât cele precizate explicit prin barem. Nu se
acordă fracţiuni de punct. Se acordă 10 puncte din oficiu. Nota finală se calculează prin ı̂mpărţirea
punctajului total acordat pentru lucrare la 10.
a Utilizarea unui tip de date care depăşeşte domeniul de valori precizat ı̂n enunţ este acceptată
dacă acest lucru nu afectează corectitudinea ı̂n funcţionarea programului.
18.1.1 Subiectul I
1d 2b 3c 4c 5a 5 4p.
1.a) Răspuns corect: 1 1 1 0 0 6p. Se acordă numai 2p. dacă s-a precizat conform
cerinţei, pe poziţia corespunzătoare, doar o
valoare, numai 3p. dacă sunt precizate con-
form cerinţei, pe poziţiile corespunzătoare,
doar două valori, numai 4p. dacă sunt
precizate conform cerinţei, pe poziţiile core-
spunzătoare, doar trei valori şi numai 5p. dacă
sunt precizate conform cerinţei, pe poziţiile
corespunzătoare, doar patru valori sau dacă,
ı̂n plus faţă de valorile cerute, sunt afişate şi
alte valori.
1.b) Răspuns corect: 6p. Pentru fiecare număr dintre cele două se
102468 acordă câte 3p. dacă este conform cerinţei şi
986420 numai câte 1p. dacă are ı̂n scrierea sa 5 cifre
pare distincte, dar nu este minim/maxim sau
nu aparţine intervalului indicat.
1.c) Pentru program corect 10p. (*) Se acordă numai 2p. dacă doar una dintre
- declarare a variabilelor 1p. instrucţiunile repetitive este conform cerinţei.
- citire a datelor 1p.
- atribuiri 1p.
153
1.d) Pentru algoritm pseudocod corect 6p. (*) Se acordă numai 2p. dacă algoritmul are o
- echivalenţă a prelucrării realizate, structură repetitivă de tipul cerut, principial
conform cerinţei (*) 5p. corectă, dar nu este echivalent cu cel dat.
- corectitudine globală a algoritmului 1p. Se va puncta orice formă de structură repeti-
tivă de tipul cerut.
- definire a structurii/ı̂nregistrării (*) 4p. pect specific (definire principial corectă a
- declarare a variabilei conform cerinţei 1p. unei structuri/ı̂nregistrări, câmp de tip sim-
- corectitudine globală a secvenţei1) 1p. plu de date, câmp de tip structurat de date,
etichetă/nume) conform cerinţei.
-acces la un element al tabloului 1p. specific (valori suport utilizate, corespondenţă
-atribuire a valorilor indicate ele- valori-elemente suport) conform cerinţei.
mentelor tabloului (*) 4p.
-corectitudine globală a secvenţei1) 1p.
-antet subprogram (*) 2p. al antetului (structură, parametri de intrare)
-determinare a valorii cerute (**) 6p. conform cerinţei.
-instrucţiune/instrucţiuni de returnare (**) Se acordă câte 2p. pentru fiecare aspect
a rezultatului 1p. specific (algoritm principial corect pentru cal-
-declarare a tuturor variabilelor locale, culul unei sume, determinare a unui divizor al
corectitudine globală a subprogramului 1p. unui număr, divizori comuni suport) conform
cerinţei.
- declarare a unei variabile care să mem- pect specific (identificare a unui cuvânt cu cel
oreze un şir de caractere 1p. puţin 3 litere, mutare a literelor unui cuvânt
- citire a datelor 1p. spre stânga, mutare a primei litere a unui
- transformare a şirului conform cerinţei cuvânt la final, litere suport, cuvinte suport
(*) 6p. rotite/nerotite, transformare ı̂n memorie) con-
- afişare a datelor şi tratare a cazului nu form cerinţei.
exista 1p.
- declarare a variabilelor simple, corec-
titudine globală a programului 1p.
a) Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul este
- verificare a proprietăţii cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un al-
- utilizare a unui algoritm eficient (***) 1p. goritm liniar (de complexitate O(n)).
- declarare a variabilelor, afişare a O soluţie posibilă utilizează un vector de
datelor, corectitudine globală a progra- 1p. frecvenţă, ap (ap[x]=numărul de apariţii ale
mului lui x ı̂n şirul aflat ı̂n fişier), având iniţial
toate elementele nule, care se actualizează pe
măsura citirii datelor din fişier; după citirea
datelor, se parcurge vectorul de frecvenţă şi
la final se afişează DA dacă există cel mult o
valoare impară ı̂n acest vector.

Varianta 2
dacă acest lucru nu afectează corectitudinea ı̂n funcţionarea programului (de exemplu, pentru
numere naturale sunt acceptate şi tipuri de date care permit memorarea numerelor ı̂ntregi).
18.2.1 Subiectul I
1a 2d 3a 4b 5c 5 4p.
1.a) Răspuns corect: 2020 6p.

1.b) Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare aspect spe-
cific (număr de valori scrise, prima valoare, a
doua valoare) conform cerinţei.
Se punctează valori din intervalul indicat, cu
cifrele ı̂n ordine strict crescătoare.
- declarare a variabilelor 1p. instrucţiunile repetitive este conform cerinţei.
- atribuiri 1p.
- corectitudine globală a programului1) 1p.
- corectitudine globală a algoritmului1) 1p. Se punctează orice formă de structură repeti-
tivă de tipul cerut (cât timp ... execută, repetă
... până când, repetă ... cât timp, execută ...
până când, execută ... cât timp etc.).
- definire a structurii/ı̂nregistrării (*) 4p. specific (definire principial corectă a unei
- declarare a variabilei conform cerinţei 1p. structuri/ı̂nregistrări, câmp de tip simplu,
- corectitudine globală a secvenţei1) 1p. câmp de tip structurat, etichetă/nume)
conform cerinţei.
Se punctează câmpul de tip struc-
turat, conform cerinţei, atât dacă struc-
tura/ı̂nregistrarea corespunzătoare este
definită separat cât şi dacă este definită ı̂n
cadrul structurii/ı̂nregistrării cerute.
- acces la un element al tabloului 1p. pect specific (identificare a elementelor din
- atribuire a valorilor cerute (*) 4p. stânga diagonalei principale, identificare a el-
- corectitudine globală a secvenţei1) 1p. ementelor de pe diagonala principală, iden-
tificare a elementelor din dreapta diagonalei
principale, corespondenţă elemente-caractere
suport) conform cerinţei.
- antet subprogram (*) 2p. al antetului (structură, parametru de intrare)
- determinare a valorii cerute (**) 6p. conform cerinţei.
- instrucţiune/instrucţiuni de returnare (**) Se acordă câte 2p. pentru fiecare aspect
a rezultatului 1p. specific (multiplu, pătrat perfect, minim) con-
- declarare a tuturor variabilelor locale, form cerinţei.
corectitudine globală a subprogramului 1p.
- declarare a unei variabile care poate specific (identificare a ı̂nceputului unui citat,
memora un şir de caractere 1p. identificare a finalului unui citat, identificare
- citire a datelor 1p. a unei litere dintr-un citat/din afara unui ci-
- transformare a şirului conform cerinţei tat, transformare a unei litere mici ı̂n litera
(*) 6p. mare corespunzătoare, caractere suport trans-
- afişare a datelor 1p. formate, transformare ı̂n memorie) conform
- declarare a variabilelor simple, corec- cerinţei.
3.a) Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
3.b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul este
- determinare a valorii cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un
- utilizare a unui algoritm eficient (***) 1p. algoritm liniar (de complexitate O(n)), care
- declarare a variabilelor, afişare a utilizează eficient memoria.
datelor şi tratare a cazului nu exista, 1p. O soluţie posibilă determină numărul cerut pe
corectitudine globală a programului măsura citirii datelor din fişier: se memorează
ultimele trei numere citite şi, dacă penultimul
număr citit este vârf, se actualizează, după
caz, numărul cerut, având ı̂n vedere calculul
corect al diferenţei indicate.

Varianta 5
dacă acest lucru nu afectează corectitudinea ı̂n funcţionarea programului (de exemplu, pentru
numere naturale sunt acceptate şi tipuri de date care permit memorarea numerelor ı̂ntregi).
18.3.1 Subiectul I
1b 2c 3c 4d 5b 5 4p.
1.a) Răspuns corect: 5NU 6p. Se acordă câte 3p. pentru fiecare dintre cele
două valori conform cerinţei; se acordă punc-
tajul şi dacă valorile sunt scrise pe linii diferite
sau separate prin spaţiu.
1.b) Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare dintre cele
două numere conform cerinţei (orice număr
din intervalul cerut, format cu cifrele distincte
x, y şi z, ı̂n orice ordine, cu proprietatea că
2 (x+y)=z şi z¿5) sau numai câte 2p. pentru
fiecare dintre cele două numere care conduc
la afişarea mesajului indicat, dar nu au cifre
distincte sau nu aparţin intervalului precizat.
- declarare a variabilelor 1p. instrucţiunile de decizie este conform cerinţei.
- instrucţiuni de decizie (*) 3p.
- instrucţiune repetitivă 2p.
- atribuiri 1p.
- corectitudine globală a algoritmului 1p. Se punctează orice formă de structură repeti-
tivă de tipul cerut.
- definire a structurii/ı̂nregistrării (*) 4p. pect specific (definire principial corectă a
- declarare a variabilei conform cerinţei 1p. unei structuri/ı̂nregistrări, câmp de tip char,
- corectitudine globală a secvenţei 1p. câmpuri de tip numeric, etichetă/nume) con-
form cerinţei.
- acces la un element al tabloului 1p. pect specific (algoritm de ordonare princip-
- ordonare a elementelor indicate (*) 4p. ial corect, elemente pare ordonate, poziţii ele-
- corectitudine globală a secvenţei 1p. mente pare/impare, coloană suport) conform
cerinţei.
- antet subprogram (*) 2p. al antetului (structură, parametri de intrare)
- determinare a valorii cerute (**) 6p. conform cerinţei.
- instrucţiune/instrucţiuni de returnare (**) Se acordă câte 1p. pentru fiecare aspect
a rezultatului şi tratare a cazului -1 1p. specific (identificare a unui divizor, algoritm
- declarare a tuturor variabilelor locale, principial corect de determinare a unei sume,
corectitudine globală a subprogramului 1p. algoritm principial corect de numărare, iden-
tificare a unui p-număr, numere din interval,
al k-lea număr) conform cerinţei.
- declarare a unei variabile care să mem- specific (identificare a unui cuvânt, cuvinte de
oreze un şir de caractere 1p. lungime pară/impară, obţinere a unui cuvânt
- citire a datelor 1p. ı̂n oglindă, cuvinte distincte ı̂n oglindă, cu-
- transformare a şirului conform cerinţei vinte suport, transformare ı̂n memorie) con-
(*) 6p. form cerinţei.
- afişare a datelor şi tratare a cazului nu
exista 1p.
- declarare a variabilelor simple, corec-
- justificare a elementelor de eficienţă 1p.
- determinare a valorilor cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un
- utilizare a unui algoritm eficient (***) 1p. algoritm liniar (de complexitate O(n)), care
- declarare a variabilelor, afişare a utilizează eficient memoria.
datelor şi tratare a cazului nu exista, Pe măsura citirii datelor din fişier, se memo-
corectitudine globală a programului 1p. rează cel mai mic (x), respectiv cel mai mare
(y) număr de două cifre din şir, care se actu-
alizează, după caz, la fiecare pas. Numerele
cerute sunt x-1, respectiv y+1.
Capitolul 19
BAC 2019

Varianta 1
19.1.1 Subiectul I
1c 2b 3a 4b 5b 5 4p.

1.b) Pentru răspuns corect: 6p. Se acordă câte 2p. pentru fiecare dintre cele
trei numere conform cerinţei (oricare dintre
numerele 45, 46, 47, 48, 49).
-declarare variabile 1p. instrucţiunile repetitive este conform cerinţei.
-citire date 1p.
-afişare date 1p.
-atribuiri 2p.
-echivalenţă a prelucrării realizate, structură repetitivă conform cerinţei, princip-
conform cerinţei (*) 5p. ial corectă, dar nu este echivalent cu cel dat.
-corectitudine globală a algoritmului 1p. Se va puncta orice formă corectă de structură
2. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă doar unul din-
-acces la câmpurile de pe primul nivel tre cazuri (date ı̂n aceeaşi lună, date ı̂n luni
al ı̂nregistrării 1p. diferite) s-a tratat conform cerinţei.
-acces la câmpurile de pe al doilea nivel
al ı̂nregistrării 1p.
-verificare a condiţiei impuse (*) 3p.
159
3. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă s-au atribuit val-
-acces la un element al tabloului 1p. ori conform cerinţei doar elementelor situate
-atribuire a valorilor indicate ele- sub diagonala principală sau doar elementelor
mentelor tabloului (*) 4p. situate deasupra diagonalei principale.
-verificare a proprietăţii cerute (**) 6p. conform cerinţei.
a rezultatului 1p. al cerinţei (identificare a unei cifre pare/im-
-declarare a tuturor variabilelor locale, pare, cifre suport, algoritm principial corect
corectitudine globală a subprogramului 1p. de verificare a unei proprietăţi).
2. Pentru program corect 10p. (*) Se acordă câte 2p. pentru fiecare aspect al
-declarare a unei variabile care să mem- cerinţei (obţinere a unui cuvânt, determinare a
oreze un şir de caractere 1p. Iungimii unui cuvânt, cuvinte suport conform
-citire a datelor 1p. cerinţei).
-determinare a cuvintelor cerute (*) 6p.
-afişarea a datelor ı̂n formatul cerut şi
tratare a cazului nu exista 1p.
-declarare a variabilelor simple, corecti-
3a) Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
3b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul este
ı̂n vederea scrierii, scriere ı̂n fişier 1p. pentru toate seturile de date de intrare.
-declarare a variabilelor, citire a O soluţie posibilă generează termenii şirului
datelor, corectitudine globală a progra- 1p. deducând forma generală a unui astfel de ter-
mului men (pentru i ' 1): dacă i este par, fi
i©2 1 z x y, iar dacă i este impar,
fi i©2z i©2 1x.

Varianta 4
19.2.1 Subiectul I
1a 2b 3b 4b 5c 5 4p.


1.b) Pentru răspuns corect 6p. Se acordă câte 3p. Pentru fiecare număr con-
form cerinţei (oricare dintre numerele 25, 26,
30, 31, 32).
-declarare variabile 1p. instrucţiunile de decizie este conform cerinţei.
-citire date 1p.
-afişare date 1p.
-atribuiri 1p.
-corectitudine globală a programului1 1p.
-echivalenţă a prelucrării realizate, con- structură repetitivă conform cerinţei, princip-
form cerinţei (*) 5p. ial corectă, dar nu este echivalent cu cel dat.
al cerinţei (drum, drum elementar, lungime
maximă).
3. Pentru rezolvare corectă 6p. (*) Se acordă câte 1p. pentru fiecare câmp
-acces la câmpurile de pe primul nivel iniţializat conform cerinţei.
-acces la câmpurile de pe al doilea nivel
-iniţializare a datelor cu valorile cerute
(*) 3p.
1. Pentru subprogram corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect al
-antet subprogram (*) 2p. antetului (structură, declarare parametru de
-determinare a numărului cerut (**) 6p. intrareieşire) conform cerinţei.
-furnizare a rezultatului prin (**) Se acordă câte 1p. pentru fiecare as-
parametrul indicat 1p. pect al cerinţei (acces la o cifră, identificare
-declarare a tuturor variabilelor locale, cifre pare/impare, includere ı̂n rezultat a unei
corectitudine globală a subprogramului 1p. cifre, includere ı̂n rezultat a tuturor cifrelor
pare suport nemodificate - inclusiv cazul cu
cifra unităţilor 0, includere ı̂n rezultat a tu-
turor cifrelor obţinute prin ı̂nlocuirea cifrelor
impare, ordine a cifrelor).
-declarare a unei variabile care să mem- al cerinţei (algoritm principial corect de ver-
oreze un tablou bidimensional 1p. ificare a unei proprietăţi, identificare a unei
-citire a datelor 1p. perechi de elemente simetrice faţă de coloana
-verificare a proprietăţii cerute (*) 6p. indicată, elemente/linii suport).
-afişare a mesajului conform cerinţei 1p.
tudine globală a programului1) 1p.
3.b) Pentru program corect 8p. (**) Se acordă numai 3p. dacă algoritmul este
-utilizare a unui algoritm eficient (***) 1p. goritm liniar, care utilizează eficient memoria.
-declarare a variabilelor, afişare a O soluţie posibilă determină, pe măsura citirii
datelor, corectitudine globală a progra- 1p. din fişier, valoarea ultimului vârf local şi
mului poziţia acestuia (fie acestea m şi pm). Val-
oarea curentă x citită de pe poziţia px este
afişată numai dacă x¿m sau dacă x=m şi
px=pm+1 (cazuri ı̂n care pm şi eventual m
sunt actualizate).

Varianta 2
19.3.1 Subiectul I
1b 2c 3a 4d 5b 5 4p.

1.b) Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare număr con-
form cerinţei (oricare dintre numerele 11, 101,
110, 1001, 1010, 1100).
-declarare variabile 1p. instrucţiunile repetitive este conform cerinţei.
-citire date 1p.
-afişare date 1p.
-atribuiri 1p.
2. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru fiecare aspect
al cerinţei (obţinere a unui sufix al şirului,
lungime sufix, memorare a datelor ı̂n variabila
indicată).
-acces la câmpurile de pe primul nivel al cerinţei referitor la condiţia impusă (ab-
al ı̂nregistrării 1p. scisă, ordonată, operatori logici utilizaţi con-
-acces la câmpurile de pe al doilea nivel form cerinţei).
-verificare a condiţiei impuse (*) 3p.
-corectitudine globală a expresiei 1p.
1. Pentru subprogram conform cerinţei 10p. (*) Se acordă câte 1p. pentru fiecare aspect
-antet subprogram (*) 2p. al antetului (structură, declarare parametri de
-determinare a numărului cerut (**) 6p. intrare) conform cerinţei.
a rezultatului şi tratare a cazului 0 1p. al cerinţei (divizori suport, algoritm principial
-declarare a tuturor variabilelor locale, corect de calcul al unui produs, număr maxim
corectitudine globală a subprogramului 1p. cu proprietatea cerută).
-declarare a unei variabile de tip tablou 1p. pect al cerinţei (elemente care formează un
-citire a datelor 1p. pătrat, pătrat cu elemente egale, dimensiune
-determinare a valorii cerute (*) 6p. maximă).
-justificare a unor elemente de eficienţă 1p.
-determinare a valorilor cerute (*),(**) 5p. (***) Se acordă punctajul numai pentru un
-utilizare a unui algoritm eficient (***) 1p. algoritm liniar.
-declarare a variabilelor, afişare a O soluţie posibilă utilizează un vector de
datelor, corectitudine globală a progra- 1p. frecvenţă (ı̂n care vi este numărul de apariţii
mului ale valorii i) actualizat pe măsura citirii din
fişier. Vectorul de frecvenţă este parcurs de
două ori după completarea sa, mai ı̂ntâi par-
curgând indicii impari i, afişând de vi ori
fiecare valoare i, şi apoi, analog, pentru indicii
pari.
Capitolul 20
BAC 2018

Varianta 9
a Se acordă 10 puncte din oficiu. Nota finală se calculează prin ı̂mpărţirea punctajului total
acordat pentru lucrare la 10.
a Se vor lua ı̂n considerare atât implementările concepute pentru compilatoare pe 16 biţi, cât
şi cele pentru compilatoare pe 32 de biţi.
20.1.1 Subiectul I
1. Răspuns corect: d 4p.

2a. Răspuns corect: 2 6p.
2.b) Pentru răspuns corect: 4p. Se acordă câte 1p. pentru fiecare dintre cele
patru numere din intervalul cerut, valori de
forma 4 k, unde k este număr impar.
2.c) Pentru algoritm pseudocod corect 6p. (*) Se acordă numai 2p. dacă algoritmul are o
-echivalenţă a prelucrării realizate, con- structură repetitivă de tipul indicat, principial
form cerinţei (*) 5p. corectă, dar nu este echivalent cu cel dat.
2.d) Pentru program corect 10p. (*) Se acordă numai 2p. dacă doar una dintre
-declarare a tuturor variabilelor 1p. instrucţiuni este corectă.
-citire conform cerinţei 1p.
-afişare conform cerinţei 1p.
-instrucţiune de decizie conform
cerinţei 2p.
-instrucţiuni repetitive conform cerinţei
(*) 3p.
-atribuiri conform cerinţei 1p.

2. Răspuns corect: c 4p.
164
3. Pentru rezolvare corectă 6p.

-acces la câmpul unei ı̂nregistrări 1p.
-determinare şi afişare a divizorului
cerut 2p.
-tratare a cazului prim 1p.
-tratare a cazului patrat 1p.
4. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru atribuirea valorilor
indicate elementelor din fiecare zonă specifică
a tabloului (diagonala principală, sub diag-
onala principală, deasupra diagonalei princi-
pale).
-declarare a unei variabile care să mem- pect al cerinţei (identificare cuvânt/număr din
oreze un şir de caractere 1p. şir, comparare numere ı̂n funcţie de prima
-citire a şirului 1p. cifră/lexicografic, algoritm principial corect de
-determinare a numărului cerut (*) 6p. determinare a unei valori maxime).
-afişare date şi tratare a cazului nu ex-
ista 1p.
-declarare variabile simple, corectitu-
dine globală a programului 1p.
1. Răspuns corect: b 4p.

2. Răspuns corect: 6p. Se acordă câte 2p. pentru fiecare aspect al
(fondante, acadele) cerinţei (prima soluţie scrisă, a doua soluţie
(caramele, dropsuri) scrisă, ordinea soluţiilor)
-structură antet principial corectă pen- cerinţei (identificare a unei cifre a unui număr,
tru un subprogram de tipul cerut 1p. identificare a poziţiei unei cifre, algoritm prin-
-declarare a parametrului 1p. cipial corect pentru determinarea unei sume,
-verificare a proprietăţii cerute (*) 6p. cifre suport pentru cele două sume, paritate
-returnare a rezultatului 1p. poziţii, paritate sume).
-declarare a tuturor variabilelor locale,
4a. Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă metoda
-coerenţă a explicării metodei (*) 1p. aleasă nu este eficientă.
-justificare a unor elemente de eficienţă,
conform cerinţei 1p
4b. Pentru program corect 8p. (*) Se acordă punctajul chiar dacă soluţia pro-
-operaţii cu fişiere: declarare, pregătire pusă nu prezintă elemente de eficienţă.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 3p. dacă algoritmul este
-determinare a valorilor cerute (*, **) 5p. principial corect, dar nu oferă rezultatul cerut
-afişare a datelor conform cerinţei, (***) Se acordă punctajul numai pentru un
declarare a tuturor variabilelor, corec- algoritm liniar.
titudine globală a programului 1p. O soluţie posibilă utilizează doi vectori de
apariţii, p şi u, ı̂n care pentru fiecare val-
oare i citită din fişier se actualizează pi , prima
poziţie pe care este ı̂ntâlnită valoarea i, respec-
tiv ui , ultima poziţie pe care este ı̂ntâlnită val-
oarea i. Numerele cerute corespund valorilor
i pentru care ui pi 1 are valoare maximă.

Varianta 2
20.2.1 Subiectul I

2.b) Pentru răspuns corect: 4p. Se acordă câte 1p. pentru fiecare număr con-
form cerinţei (de exemplu 68, 86, 608, 806,
680, 860).
-echivalenţă a prelucrării realizate, con- atribuire conform cerinţei, principial corectă,
form cerinţei (*) 5p. dar algoritmul nu este echivalent cu cel dat.
-corectitudine globală a algoritmului 1p. O soluţie posibilă ı̂nlocuieşte, ı̂n cadrul al-
goritmului, structura precizată cu atribuirea

s sxx
-declarare a tuturor variabilelor 1p. instrucţiunile repetitive este conform cerinţei.
-citire date 1p.
-afişare date 1p.
cerinţei 2p.
-instrucţiuni repetitive corecte (*) 3p.
-atribuiri corecte 1p.

2. Răspuns corect: b (sau a) 4p.
3. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru fiecare nod conform
cerinţei (oricare dintre nodurile 1,6,8,9).
4. Pentru rezolvare corectă 6p. (*) Se acordă numai 1p. dacă au fost atribuite
-acces la un element al tabloului 1p. valori doar elementelor uneia dintre diagonale.
-atribuire a valorii 0 elementelor indi- (**) Se acordă numai 1p. dacă s-au atribuit
cate (*) 2p. valorile precizate unor elemente ale tabloului,
-atribuire a valorilor nenule elementelor dar nu tuturor celor indicate ı̂n cerinţă.
indicate (**) 2p.
-declarare a cel puţin unei variabile care pect al cerinţei (identificare cifre pare/impare,
să memoreze un şir de caractere 1p. plasare a unor litere la ı̂nceputul unui cuvânt,
-citire a şirurilor 1p. plasare a unor litere la finalul unui cuvânt, or-
-determinare a şirului conform cerinţei dine a literelor, corespondenţă plasare litere/-
(*) 6p. paritate cifre, transformare ı̂n memorie).
-afişare date şi tratare caz cod incorect 1p.
1. Răspuns corect: a 4p.

2. Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare valoare con-
form cerinţei (orice număr mai mare sau egal
cu 5).
-structură antet principial corectă a al cerinţei (identificare a unui număr cu pro-
unui subprogram de tipul cerut 1p. prietatea cerută pentru resturi, algoritm de
-declarare corectă a parametrilor 1p. numărare principial corect, numere din inter-
-determinare a numărului cu propri- valul cerut).
etatea cerută (*) 6p.
-returnare a rezultatului 1p.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 3p. dacă algoritmul este
-determinare a valorii cerute (*, **) 5p. principial corect, dar nu oferă rezultatul cerut
-afişare a datelor, declarare a tuturor (***) Se acordă punctajul numai pentru un al-
variabilelor, corectitudine globală a goritm liniar, care utilizează eficient memoria.
programului 1p. O soluţie posibilă parcurge datele din fişier,
memorând tripletul format din ultimele valori
citite, lungimea secvenţei curente, precum şi
lungimea maximă determinată; pentru fiecare
valoare curentă citită se actualizează triple-
tul, lungimea secvenţei curente, dacă tripletul
are proprietatea cerută şi, după caz, lungimea
maximă cerută.

Varianta 1
20.3.1 Subiectul I

2.b) Pentru răspuns corect: 4p. Se acordă câte 1p. pentru fiecare dintre nu-
merele cerute (oricare patru dintre 722, -722,
712, -712, 702, -702).
-corectitudine globală a algoritmului 1p. Se va puncta orice formă de structură repeti-
tivă conform cerinţei.
-instrucţiuni de decizie corecte (*) 3p.
-instrucţiune repetitivă corectă 2p.

-acces corect la câmpurile ı̂nregistrării 2p.
-determinare şi memorare a valorilor
conform cerinţei 2p.
-corectitudine globală a secvenţei1 1p.
4. Pentru răspuns corect 6p. Se acordă câte 2p. pentru fiecare dintre
nodurile cerute (oricare trei dintre nodurile 3,
4, 5, 7, 8).
-declarare a unei variabilei de tip tablou cerinţei (valori citite memorate pe coloane de
bidimensional 1p. sus ı̂n jos, valori citite memorate pe coloane
-citire a datelor 1p. de jos ı̂n sus, coloane suport).
-memorare a valorilor elementelor (*) 6p.
-afişare a unui tablou 1p.

2. Răspuns corect: 6p. Se acordă câte 2p. pentru fiecare as-

(toc, creion, pensulă, pană, stilou) pect al cerinţei (conţinut prima soluţie
(toc, pensulă, creion, stilou, pană) scrisă, conţinut a doua soluţie scrisă, ordinea
soluţiilor).
-structură antet principial corectă 1p. al cerinţei (algoritm de determinare a unui
-declarare a parametrului 1p. număr prim, cel mai mic număr care nu este
-determinare a numărului cu propri- prim conform cerinţei).
4a. Pentru răspuns corect 2p. (*) Se acordă punctajul chiar dacă algoritmul
-coerenţă a explicării metodei (*) 1p. ales nu este eficient.
ı̂n vederea scrierii, scriere ı̂n fişier 1p. (**) Se acordă numai 3p. dacă algoritmul este
-determinare a valorilor cerute (*, **) 5p. principial corect, dar nu oferă rezultatul cerut
-citirea şi afişare a datelor, declarare (***) Se acordă punctajul numai pentru un al-
a tuturor variabilelor, corectitudine goritm liniar, care utilizează eficient memoria.
globală a programului 1p. O soluţie posibilă generează termenii şirului
astfel: dacă w, x şi y sunt termeni aflaţi
pe poziţii consecutive ı̂n şir, x şi y fiind
cunoscuţi/calculaţi, atunci w=2*x-y+2.
Capitolul 21
BAC 2017

Varianta 3
21.1.1 Subiectul I

2.b) Pentru răspuns corect: 4p. Se acordă câte 1p. pentru fiecare dintre se-
turile cerute (oricare dintre seturile 2,4; 4,2;
4,5; 5,4; 5,6; 6,5; 7,7).
-declarare variabile 1p. instrucţiuni este conform cerinţei.
-citire date 1p.
-afişare date 1p.
cerinţei 2p.
(*) 3p.

170
3. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă doar unul dintre
-definire principial corectă a unei struc- câmpuri este conform cerinţei.
turi/ı̂nregistrări 2p.
-câmpuri ale structurii/ı̂nregistrării def-
inite conform cerinţei (*) 3p.
-declarare variabilă 1p.
4. Pentru rezolvare corectă 6p. (*) Se acordă punctajul chiar dacă, suplimen-
-acces la un element al tabloului 1p. tar elementelor suport indicate, s-a atribuit
-atribuire a uneia dintre valorile indi- valoarea şi altor elemente
cate elementelor corespunzătoare (*) 2p.
-atribuire a celei de a doua din-
tre valorile indicate elementelor core- 3p.
spunzătoare
-declarare a unei variabile care să mem- al cerinţei (căutare a unui subşir ı̂ntr-un şir,
oreze un şir de caractere 1p. identificare a unui cuvânt conform cerinţei, cu-
-citire a şirului 1p. vinte suport).
-determinare a cuvintelor conform
cerinţei (*) 6p.
-afişare a cuvintelor şi tratare a cazului
nu exista 1p.

2. Răspuns corect: 1234123121 6p. Se acordă numai 3p. dacă răspunsul este
parţial corect şi include secvenţa 1234123.
-structură antet principial 1p. cerinţei (identificare/construire a unui număr
-declarare corectă a parametrilor 1p. conform cerinţei, numere suport).
-determinare a numerelor cu propri-
-afişare a datelor şi tratare a cazului nu
exista 1p.
-justificare a unor elemente de eficienţă
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 2p. pentru algoritm
-determinare a valorii cerute (*, **) 4p. principial corect, dar care nu conduce la rezul-
-afişare a datelor şi tratare a cazului im- tatul cerut pentru toate cazurile.
posibil 1p. (***) Se acordă punctajul numai pentru un al-
-declarare a variabilelor, corectitudine O soluţie posibilă memorează prima şi ultima
globală a programului 1p. valoare din primul şir ı̂n variabilele p, respectiv
u, apoi, pe măsura citirii celui de al doilea şir,
se determină numărul k de termeni ai acestuia
cu proprietatea că primii k 1 sunt strict mai
mici decât p, iar al k-lea este strict mai mare
decât u. Poziţia cerută este k.

Varianta 4
21.2.1 Subiectul I

2a. Răspuns corect: #2#1#3#2# 6p. Se acordă numai 3p. dacă datele sunt parţial
corecte şi includ secvenţa #2#
2.b) Răspuns corect: 50 4p.
2.d) Pentru program corect 10p. (*) Se acordă numai 1p. dacă s-a scris o
-declarare variabile 1p. instrucţiune de decizie, dar expresia logică nu
-citire date 1p. este conform cerinţei.
-afişare date 1p. (**) Se acordă numai 2p. dacă doar una dintre
-instrucţiune de decizie conform instrucţiunile repetitive este conform cerinţei.
cerinţei (*) 3p.
(**) 3p.

3. Pentru rezolvare corectă 6p. (*) Se acordă numai 1p. dacă doar un câmp
-acces la câmpurile ı̂nregistrării (*) 2p. este accesat corect.
-acces la prima literă a numelui 1p. (**) Se acordă numai 1p. dacă media se cal-
-expresie corectă pentru calculul mediei culează corect doar dacă rezultatul este un
(**) 2p. număr ı̂ntreg.
-afişare a datelor conform cerinţei 1p.
4. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru fiecare parametru
al matricei de adiacenţă (dimensiuni, număr
de valori nenule/nule, elemente nenule core-
spunzătoare numărului de circuite elementare
ale grafului) conform cerinţei.
-declarare a variabilei de tip tablou 1p. pect al cerinţei (identificare elemente de pe
-citire a tabloului 1p. prima linie, identificare elemente de pe ul-
-modificare a tabloului (*) 6p. tima linie, identificare elemente de pe prima
-afişare a datelor ı̂n formatul cerut 1p. coloană, identificare elemente de pe ultima
-declarare şi citire a variabilelor simple, coloană, valoare plasată pe contur, modificare
corectitudine globală a programului 1p. ı̂n memorie).

2. Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare valoare
afişată conform cerinţei:
f(3,9)=3
f(1,1000)=25
-structură antet principial corectă 1p. cerinţei (identificare a unei cifre a numărului,
-declarare corectă a parametrului 1p. identificare a unei cifre pare, inserare a unei
-determinare a numărului cu propri- cifre ı̂ntr-un număr, păstrare a ordinii cifrelor,
etatea cerută (*) 6p. inserare a valorilor corespunzătoare doar după
-furnizare a rezultatului 1p. cifre pare, inserare corectă după cifrele nule de
-declarare a tuturor variabilelor locale, la sfârşitul numărului).
-determinare a valorii cerute (*, **) 5p. principial corect, dar care nu conduce la rezul-
-utilizare a unui algoritm eficient (***) 1p. tatul cerut pentru toate cazurile.
-afişare a datelor, corectitudine globală (***) Se acordă punctajul numai pentru un
a programului 1p. algoritm liniar (de complexitate O(n)), care
utilizează eficient memoria.
O soluţie posibilă parcurge o dată fişierul
memorând numărul de termeni pari de pe
poziţii consecutive din secvenţa curentă,
număr care se incrementează la ı̂ntâlnirea
fiecărui termen par, respectiv se iniţializează
cu 0 la ı̂ntâlnirea fiecărui termen impar. La
fiecare pas se actualizează, după caz, numărul
de termeni din secvenţa pară de lungime
maximă şi numărul de astfel de secvenţe.

Varianta 7
21.3.1 Subiectul I

2.b) Pentru răspuns corect: 4p. Se acordă punctajul pentru oricare set de trei
numere prime distincte sau de două numere
prime distincte şi valoarea 1.
-declarare a tuturor variabilelor 1p. instrucţiunile repetitive este conform cerinţei.
-citire corectă 1p.
-instrucţiune de decizie corectă 2p.

3. Pentru rezolvare corectă 6p. (*) Se acordă numai 1p. dacă s-a precizat
-mulţime a nodurilor, conform cerinţei mulţimea nodurilor unui subgraf, dar acesta
(*) 3p. nu este conform cerinţei.
-mulţime a muchiilor, conform cerinţei (**) Se acordă numai 1p. dacă s-a precizat
(**) 3p. mulţimea muchiilor subgrafului, dar acesta nu
este conform cerinţei.
4. Pentru răspuns corect 6p. (*) Se acordă câte 1p. pentru fiecare aspect
-expresie de iniţializare a contorului 1p. conform cerinţei (căutare a unui subşir, poziţie
-expresie de incrementare a contorului 1p. a subşirului, frecvenţă a subşirului).
-expresie de identificare a unui cuvânt
conform cerinţei (*) 3p.
-corectitudine globală a secvenţei1) 1p.
-declarare a variabilei de tip tablou de (algoritm principial corect de calcul al unei
numere reale 1p. medii, elemente suport pentru determinarea
-citire a tabloului 1p. valorii unui element inserat, inserare a unei
-modificare a tabloului (*) 5p. linii, plasare ı̂n tablou a mediilor calculate,
-afişare a datelor ı̂n formatul cerut (**) 2p. transformare ı̂n memorie) conform cerinţei.
-declarare şi citire a variabilelor simple, (**) Se acordă numai 1p. dacă s-au afişat
corectitudine globală a programului 1p. datele, dar numărul de elemente afişate sau
formatul de afişare nu este conform cerinţei.

(2,3,4,1,5,6) (2,3,4,1,6,5) pect al cerinţei (conţinut prima soluţie
scrisă, conţinut a doua soluţie scrisă, ordinea
soluţiilor).
3. Pentru subprogram corect 10p. (*) Se acordă numai 2p. dacă un singur aspect
-structură antet principial corectă 1p. (soluţii ale ecuaţiei, valori din intervalul [a,b])
-declarare corectă a parametrilor 1p. este conform cerinţei.
-determinare a tripletelor cerute (*) 3p. (**) Se acordă câte 1p. pentru fiecare aspect
-afişare a datelor ı̂n formatul cerut (**) 3p. (ı̂ncadrare ı̂ntre acolade, separare prin virgulă,
-tratare a cazului nu exista 1p. ordine valori ı̂n cadrul tripletului) conform
-declarare a tuturor variabilelor locale, cerinţei.
-determinare a raţiei şi verificare a pro- principial corect, dar care nu conduce la rezul-
prietăţii cerute (*, **) 5p. tatul cerut pentru toate cazurile.
-utilizare a unui algoritm eficient (***) 1p. (***) Se acordă punctajul numai pentru un
-afişare a datelor, corectitudine globală algoritm liniar (de complexitate O(n)).
a programului 1p. O soluţie posibilă citeşte datele din fişier şi,
pe măsura citirii, marchează cu 1, ı̂ntr-un vec-
tor caracteristic, termenii şirului; se determină
valoarea r ca numărul de valori nule din vec-
torul caracteristic aflate ı̂ntre primele două el-
emente egale cu 1 ale acestuia, apoi se par-
curge vectorul şi se verifică dacă ı̂ntre oricare
două elemente succesive egale cu 1 există r
valori nule. Raţia progresiei este r 1.
Capitolul 22
BAC 2016

Varianta 4
22.1.1 Subiectul I

-citire date 1p.
-afişare date 1p.
-instrucţiuni de decizie conform cerinţei
(*) 3p.
-instrucţiune repetitivă conform
cerinţei 2p.

176
3. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru fiecare parametru
-enumerare a nodurilor unui lanţ 2p. conform cerinţei (lanţ elementar, lungime
-parametri pentru lanţ (*) 4p. maximă).
4. Pentru rezolvare corectă 6p. (*) Se acordă numai 1p. dacă s-a utilizat oper-
-acces la câmpurile unui element al atorul de selecţie al unui câmp, dar nu conform
tabloului (*) 3p. cerinţei.
-determinare a sumei cerute (**) 3p. (**) Se acordă numai 1p. dacă algoritmul de
calcul al unei sume este principial corect, dar
nu conduce la rezultatul cerut.
-declarare corectă a unei variabile care cerinţei (plasare a cuvintelor de lungime k con-
să memoreze mai multe cuvinte 1p. form cerinţei, plasare a cuvintelor de lungime
-citire a datelor 1p. diferită de k conform cerinţei, construire şir ı̂n
-determinare a şirului cerut (*) 6p. memorie).
-afişare a datelor ı̂n formatul cerut 1p.

010011 cerinţei (conţinut prima soluţie, conţinut a
010100 doua soluţie, ordinea soluţiilor).
3. Pentru subprogram corect 10p. (*) Se acordă numai 3p. dacă s-a determinat
-structură antet principial corectă 1p. un număr cu aceiaşi divizori primi, dar nu este
-declarare corectă a parametrului 1p. cel mai mic.
-determinare a numărului cerut (*) 6p.
-coerenţă a descrierii metodei (*) 2p. aleasă nu este eficientă.
-justificare a unor elemente de eficienţă (**) Se acordă punctajul pentru elementele
(**) 2p de eficienţă justificate, conform cerinţei, chiar
dacă metoda aleasă nu este optimă.
ı̂n vederea scrierii, scriere ı̂n fişier 1p. (**) Se acordă numai 2p. pentru un algoritm
-citire date, determinare şi afişare a val- principial corect, dar care nu conduce la rezul-
orilor cerute (*, **) 4p. tatul cerut.
algoritm liniar (de complexitate O(n)), care
O soluţie posibilă se bazează pe forma gen-
erală a unui termen: fi i 1©2, dacă i este
impar, respectiv fi i©2, dacă i este par.

Varianta 10
22.2.1 Subiectul I

2a. Răspuns corect: 14 28 6p.
2.b) Pentru răspuns corect 4p.
-citire date 1p.
-afişare date 1p.
-instrucţiuni de decizie conform cerinţei
(*) 3p.
-instrucţiune repetitivă conform
cerinţei 2p.

3. Răspuns corect: 2 3 8 6p. Se acordă numai 2p. dacă doar un nod este
conform cerinţei, numai 4p. dacă doar două
noduri sunt conform cerinţei sau dacă, ı̂n plus
faţă de răspunsul corect, au fost adăugate şi
alte noduri.
4. Pentru răspuns corect 6p.
-rezultat al primei instrucţiuni de
afişare 2p.
-rezultat al celei de a doua instrucţiuni
de afişare 3p.
-date (număr şi cuvânt) afişate pe
aceeaşi linie a ecranului 1p.
-declarare a unei variabile care să mem- al cerinţei (plasare valori pe prima coloană,
oreze un tablou bidimensional 1p. plasare valori pe ultima linie, plasare valori
-citire a datelor 1p. pe celelalte poziţii ale tabloului).
-construire a tabloului conform cerinţei
(*) 6p.

(pere, fragi, zmeură) cerinţei (prima soluţie scrisă, a doua soluţie
(mure, afine, zmeură) scrisă, ordinea soluţiilor).
3. Pentru subprogram corect 10p. (*) Se acordă câte 1p. pentru fiecare as-
-structură antet principial corectă 1p. pect al cerinţei (acces la o cifră a numărului,
-declarare a parametrului 1p. cifre pare/impare, cifre suport, obţinere rezul-
-determinare a numărului cerut (*) 6p. tat pentru număr cu cifre pare şi impare,
-returnare a rezultatului 1p. obţinere rezultat pentru număr doar cu cifre
-declarare a tuturor variabilelor locale, pare, obţinere rezultat pentru număr doar cu
corectitudine globală a subprogramului 1p. cifre impare).
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 2p. pentru un algoritm
-determinare şi afişare a valorilor cerute principial corect, dar care nu conduce la rezul-
(*, **) 3p. tatul cerut.
-tratare a cazului Nu exista 1p. (***) Se acordă punctajul numai pentru un al-
O soluţie posibilă afişează toate numerele nat-
urale din intervalul 1, x, unde x este primul
număr din fişier, apoi parcurge numerele din
fişier memorând, la fiecare pas, ultimele două
numere citite, x şi y, şi afişând toate numerele
naturale din intervalul x, y . La final, se
afişează numerele din intervalul y, n

Varianta 9
22.3.1 Subiectul I

2.b) Răspuns corect: 16 31 4p. Se acordă câte 2p. pentru fiecare valoare
menţionată corect.
-citire date 1p.
-afişare date 2p.
cerinţei 3p.
(*) 1p.

3. Pentru răspuns corect 6p. (*) Se acordă numai 2p. dacă numărul 11 este
-rezultat al primei instrucţiuni de scris singur pe linie.
afişare (*) 3p.
-rezultat al celei de a doua instrucţiuni
de afişare 3p.
4. Răspuns corect: 1 5 7 6p. Se acordă câte 2p. pentru fiecare vârf enu-
merat conform cerinţei.
-declarare a unei variabile de tip tablou al cerinţei (algoritm principial corect de veri-
bidimensional 1p. ficare a unei proprietăţi, linii suport, coloane
-citire a elementelor tabloului 1p. suport).
-verificare a proprietăţii cerute (*) 6p.
-declarare variabile simple, citire valori
variabile simple, corectitudine globală a
programului 1p.

2. Răspuns corect: CRETA CRTAE 6p. Se acordă câte 2p. pentru fiecare aspect al
cerinţei (prima soluţie scrisă, a doua soluţie
scrisă, ordinea soluţiilor)
-structură antet principial corectă 1p. al cerinţei (duplicare a unei cifre, cifre suport,
-declarare corectă a parametrilor 2p. tratare caz -1).
-determinare a numărului cerut (*) 6p.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 2p. pentru un algoritm
-determinare şi afişare a valorilor cerute principial corect, dar care nu conduce la rezul-
(*, **) 3p. tatul cerut.
-tratare a cazului Nu exista 1p. (***) Se acordă punctajul numai pentru un
-utilizare a unui algoritm eficient (***) 1p. algoritm liniar (de complexitate O(n)), care
O soluţie posibilă parcurge fişierul până când
s-au ı̂ntâlnit 3 termeni impari. Se parcurge
apoi fişierul ı̂n continuare până la final sau
până când se ı̂ntâlneşte un nou termen im-
par, memorând pe parcurs cele mai mari două
valori pare.
Capitolul 23
BAC 2015

Varianta 5
23.1.1 Subiectul I

- declarare variabile 1p. instrucţiuni este corectă.
- citire date 1p.
- afişare date 1p.
- instrucţiune de decizie corectă 2p.
- instrucţiuni repetitive corecte (*) 3p.
- atribuiri corecte 1p.

3. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru fiecare proprietate
a lanţului (extremitate iniţială, extremitate fi-
nală, lanţ elementar) conform cerinţei.
182
4. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă doar una dintre
- acces corect la un element al tabloului 1p. proprietăţile tabloului (alternanţă a valorilor
- atribuire a valorilor indicate ele- binare ı̂n cadrul unei linii/coloane, toate ele-
mentelor tabloului (*) 5p. mentele suport) este conform cerinţei.
- declarare corectă a unei variabile care al cerinţei (identificare a primei litere a unui
să memoreze un şir de caractere 1p. cuvânt, identificare a unei majuscule, obţinere
- citire a şirului 1p. a unui şir construit cu prima literă a unor cu-
- acces la un caracter al şirului 1p. vinte, caractere suport pentru acronim, con-
- construire şir conform cerinţei (*) 5p. struire ı̂n memorie).
- declarare variabile simple, corectitu-

2. Răspuns corect: 864157 6p. Se acordă numai 3p. pentru răspuns parţial
corect, care include secvenţa 864.
- antet subprogram (*) 2p. al antetului (structură, declarare parametri de
- determinare a numărului cerut (**) 6p. intrare) conform cerinţei.
- instrucţiune de returnare a rezultatu- (**) Se acordă câte 2p. pentru fiecare propri-
lui 1p. etate a numărului cerut (divizor comun, im-
- declarare a tuturor variabilelor locale, par, maxim).
- coerenţă a explicării metodei (*) 2p. aleasă nu este eficientă.
- explicare a unor elemente de eficienţă 2p
- operaţii cu fişiere: declarare, pregătire pusă nu prezintă elemente de eficienţă.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 2p. dacă s-a verificat
- verificare a proprietăţii indicate pen- proprietatea cerută doar pentru unul dintre
tru subşiruri (*,**) 3p. subşiruri sau dacă algoritmul este principial
- afişare a mesajului conform cerinţei 1p. corect, dar nu conduce la rezultatul cerut pen-
- utilizare a unui algoritm eficient (***) 1p. tru orice set de date de intrare.
(***) Se acordă punctajul numai pentru un
algoritm liniar (de complexitate O(n)), care
O soluţie posibilă parcurge cel mult o dată
fişierul memorând atât valoarea ultimului ter-
men par, precum şi pe cea a ultimului termen
impar şi comparându-le, după caz, cu valoarea
termenului curent.

Varianta 9
23.2.1 Subiectul I

2.b) Răspuns corect: 125, 624 4p. Se acordă câte 2p. pentru fiecare valoare con-
form cerinţei.
-declarare a tuturor variabilelor 1p. instrucţiuni este corectă.
-afişare corectă 1p.

3. Pentru răspuns corect: 6p. Se acordă câte 2p. pentru fiecare nod
enumerat conform cerinţei (oricare dintre
nodurile 1, 2, 7, 8).
4. Pentru rezolvare corectă 6p. Se acordă câte 2p. pentru fiecare aspect
al cerinţei (obţinere a unui prefix al şirului,
lungime prefix, memorare ı̂n variabila indi-
cată).
-declarare a variabilei de tip tablou 1p. cerinţei (plasare conform cerinţei a primului
-citire a elementelor aflate pe prima element al unei linii, plasare conform cerinţei
linie 1p. a celorlalte elemente ale unei linii, obţinere a
-memorare a valorilor elementelor con- tuturor elementelor tabloului).
form cerinţei (*) 6p.
-afişare a unui tablou bidimensional 1p.
-declarare şi citire a variabilelor simple,

2. Răspuns corect: dcba 6p. Se acordă numai 3p. pentru răspuns parţial
corect, care include secvenţa dcb, sau pentru
şirul abcd.
-antet subprogram (*) 2p. al antetului (structură, declarare parametru)
-determinare a numărului cerut (**) 6p. conform cerinţei.
a rezultatului 1p. al cerinţei (termen al şirului, termen impar,
-declarare a tuturor variabilelor locale, număr de ordine - inclusiv cazul ı̂n care n¡3).
-justificare a unor elemente de eficienţă 2p
-operaţii cu fişiere: declarare, pregătire pusă nu prezintă elemente de eficienţă. (**) Se
ı̂n vederea citirii, citire din fişier 1p. acordă câte 1p. pentru fiecare condiţie impusă
-determinare a perechilor cerute (*,**) 3p. perechilor x, y (y x ' 2, interval x, y care
-afişare a datelor conform cerinţei şi să nu conţină niciun termen al şirului, perechi
tratare a cazului nu exista 1p. distincte).
algoritm liniar (de complexitate O n).
O soluţie posibilă utilizează un vector de
apariţii (ı̂n care vi este 1 dacă valoarea i apare
ı̂n şir sau 0 altfel) actualizat pe măsura citirii
datelor din fişier. Vectorul de apariţii este
parcurs o singură dată după completarea sa,
memorându-se la fiecare pas ultimii doi indici
i şi j (i $ j) cu proprietatea că valorile vi şi vj
sunt nenule şi j i ' 2, care reprezintă fiecare
dintre perechile cerute.

Varianta 2
23.3.1 Subiectul I

2a. Răspuns corect: 3 2 1 3 2 1 3 6p. Se acordă numai 2p. dacă doar primele trei
numere sunt precizate corect, numai 4p. dacă
doar primele 6 numere sunt precizate corect
sau dacă sunt precizate, ı̂n plus, şi alte nu-
mere.
2.b) Răspuns corect: 5, 93 4p. Se acordă câte 2p. pentru fiecare număr pre-
cizat corect.
2.d) Pentru program corect 10p. (*) Se acordă numai 2p. dacă numai una din-
-declarare variabile 1p. tre instrucţiunile repetitive este corectă.
-citire date 1p.
-afişare date 1p.

3. Răspuns corect: 1, 2, 5, 6, 7, 10 6p. Se acordă câte 1p. pentru fiecare nod enu-
merat conform cerinţei.
4. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă doar o parte
-acces corect la un element al tabloului 1p. dintre elemente au valori conform cerinţei.
-atribuire a valorilor indicate ele-
mentelor tabloului (*) 5p.
-declarare corectă a unei variabile care pect al cerinţei (algoritm principial corect
să memoreze un şir de caractere 1p. de verificare a unei proprietăţi, identificare
-citire a datelor 1p. a unei vocale/consoane, tratarea cazului ı̂n
-verificare a proprietăţii cerute (*) 6p. care cuvântul conţine doar consoane, tratarea
-afişarea a mesajului 1p. cazului ı̂n care cuvântul conţine consoane şi
-declarare a variabilelor simple, corecti- litera i, tratarea cazului ı̂n care cuvântul
tudine a globală a programului 1p. conţine şi vocale diferite de litera i, tratarea
cazului ı̂n care cuvântul nu conţine nicio con-
soană).

al cerinţei: structură instrucţiune de apel,
primul parametru (2015), al doilea parametru
(oricare dintre numerele 2,3,4 sau 5).
-determinare a numărului cerut (**) 6p. conform cerinţei.
a rezultatului 1p. al cerinţei (acces la o cifră a numărului, cifre
-declarare a tuturor variabilelor locale, prime suport, algoritm de numărare principial
corectitudine globală a subprogramului 1p. corect).
-explicare a unor elemente de eficienţă 2p
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă câte 2p. pentru fiecare aspect
-determinare şi afişare a valorii cerute al cerinţei (produse conform cerinţei, sumă de
(*, **) 4p. produse).
-utilizarea unui algoritm eficient (***) 1p. (***) Se acordă punctajul numai pentru un
algoritm liniar (de complexitate O n), care
O soluţie posibilă se obţine calculând, pe
măsura citirii din fişier, pentru fiecare
jumătate a şirului, sumele termenilor pari (fie
acestea s1p şi s2p), respectiv sumele terme-
nilor impari (fie acestea s1i şi s2i).
Valoarea cerută este s1p s2i s1i s2p.
Capitolul 24
BAC 2014

Varianta 2
24.1.1 Subiectul I

2.b) Pentru răspuns corect 4p. Se acordă câte 2p. pentru fiecare număr
cu patru cifre distincte, ordonate strict de-
screscător.
-declarare a tuturor variabilelor 1p. instrucţiunile de decizie este corectă.
-citire date 1p.
-afişare date 1p.
-instrucţiuni de decizie corecte (*) 3p.

188
3. Pentru rezolvare corectă 6p. Se acordă numai 3p. dacă s-a scris o matrice
de adiacenţă a unui graf cu 5 vârfuri, dar care
nu corespunde grafului indicat.
4.Răspuns corect: (0,5,1,1,1,1) 6p. Se acordă câte 1p. pentru fiecare element
corect al vectorului.
-declarare corectă a unei variabile care cerinţei (determinare a numărului de litere ale
să memoreze un şir de caractere 1p. unui cuvânt, transformare cuvinte de lungime
-citire a şirului 1p. impară, transformare cuvinte cu cel puţin 3
-transformare a şirului conform cerinţei litere, eliminare a literei din mijloc a unui
(*) 6p. cuvânt, toate literele suport eliminate, trans-
-afişare date şi tratare caz nu exista 1p. formare ı̂n memorie).

form cerinţei.
f(5,5)=0 şi f(10,21)=28
-structură antet principial corectă a al cerinţei (identificarea unui divizor, algoritm
unui subprogram de tipul cerut 1p. de determinare a sumei unor divizori, identifi-
-declarare corectă a parametrilor 1p. carea unui număr perfect, identificarea tuturor
-determinare a numerelor cu propri- numerelor perfecte din intervalul cerut).
etatea cerută (*) 4p. (**) Se acordă numai 1p. dacă datele sunt
-afişare a datelor ı̂n ordinea cerută (**) afişate ı̂n ordine strict crescătoare.
-tratare caz nu exista 2p.
-declarare a tuturor variabilelor locale, 1p.
corectitudine globală a subprogramului
1p.
-explicare a unor elemente de eficienţă 2p
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă câte 1p. pentru fiecare din-
-determinare a valorilor cerute (*, **) 3p. tre aspectele cerinţei (determinarea lungimii
-utilizare a unui algoritm eficient (***) 1p. unei secvenţe uniforme, determinarea lungimii
-afişare a tuturor datelor, declarare maxime a unei secvenţe uniforme, deter-
a tuturor variabilelor, corectitudine minarea valorii corespunzătoare termenilor ul-
globală a programului 1p. timei secvenţe uniforme de lungime maximă).
(***) Se acordă punctajul numai pentru un al-
goritm liniar (de complexitate O(n)) care uti-
lizează eficient memoria.
O soluţie posibilă parcurge datele din fişier
şi memorează ı̂n variabilele x şi y ultimii doi
termeni citiţi; dacă x y, incrementează
lungimea secvenţei curente şi actualizează
lungimea maximă cerută, precum şi valoarea
corespunzătoare termenilor acesteia, iar dacă
x j y, iniţializează lungimea secvenţei curente
şi a valorii termenilor acesteia.

Varianta 4
24.2.1 Subiectul I

2a. Răspuns corect: 2 7 1 6p. Se acordă câte 2p. pentru fiecare valoare
2.b) Pentru răspuns corect 4p. Se acordă câte 2p. pentru fiecare valoare
menţionată corect, de exemplu 25, 50, 75.
-declarare variabile 1p. instrucţiunile repetitive este corectă.
-citire date 1p.
-afişare date 1p.

3. Pentru rezolvare corectă 6p. (*) Se acordă numai 2p. dacă se tratează
-acces corect la un câmp al unei corect doar unul dintre cele două cazuri posi-
ı̂nregistrări 2p. bile (acelaşi minut sau minute diferite).
-afişare a mesajelor conform cerinţei (*) 3p.
4. Răspuns corect: 7, 9 6p. (*) Se acordă doar 3p. dacă s-a menţionat
corect doar unul dintre noduri sau dacă s-au
menţionat şi alte noduri, care nu sunt conform
cerinţei.
-declarare corectă a variabilei de tip cerinţei (eliminare linie, eliminare coloană).
tablou 1p. (**) Se acordă numai 1p. dacă sunt afişate
-citire a tabloului 1p. toate elementele, dar nu ı̂n formatul cerut.
-accesare corectă a unui element al
tabloului 1p.
-modificare corectă a tabloului (*) 4p.
-afişare a unui tablou ı̂n formatul cerut
(**) 2p.
-declarare şi citire a variabilelor simple,

(roşu, roz, violet, albastru) pect al cerinţei (conţinut prima soluţie
(roşu, albastru, galben, roz) scrisă, conţinut a doua soluţie scrisă, ordinea
soluţiilor).
-structură antet principial corectă 1p. cerinţei (algoritm de determinare a unui pro-
-declarare corectă a parametrilor de in- dus factorial, determinare a limitei inferioare
trare 1p. a intervalului, determinare a limitei superioare
-declarare corectă a parametrilor de a intervalului).
ieşire 1p.
-determinare a numerelor cu propri-
-descriere coerentă a metodei (*) 2p. aleasă nu este eficientă.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă câte 1p. pentru fiecare dintre
-determinare a valorilor cerute (*, **) 3p. aspectele cerinţei (determinare a numărului
-utilizare a unui algoritm eficient (***) 1p. de apariţii ale unui sub-număr, determinare
-afişare a datelor, declarare a tuturor a numărului maxim de apariţii, determinare
variabilelor, corectitudine globală a a tuturor sub-numerelor cu număr maxim de
programului 1p. apariţii).
(***) Se acordă punctajul numai pentru un
algoritm liniar.
O soluţie posibilă utilizează un vector de
apariţii, v, ı̂n care se actualizează numărul
de apariţii vi pentru fiecare sub-număr i,
la parcurgerea fişierului şi prelucrarea core-
spunzătoare a termenilor şirului.
Numerele cerute corespund valorilor i pentru
care vi are valoare maximă.

Varianta 10
24.3.1 Subiectul I

2.b) Pentru răspuns corect 4p. Se acordă numai 1p. dacă al 4-lea număr
menţionat este 0, dar celelalte nu sunt con-
form cerinţei şi numai 3p. dacă doar primele
trei valori menţionate sunt conform cerinţei
(numere din mulţimea 4, 6, 7, 9).
-echivalenţă a prelucrării realizate, con- structură repetitivă cu test iniţial, principial
- corectitudine globală a algoritmului 1p. Se va puncta orice formă corectă de structură
-declarare corectă a tuturor variabilelor 1p. instrucţiuni este corectă.

3. Pentru răspuns corect 6p. Se acordă numai 3p. dacă s-a menţionat un
drum cu extremităţile indicate, dar nu este el-
ementar.
4. Răspuns corect: 11BAAARET 6p. Se acordă câte 3p. pentru fiecare dintre rezul-
tatele celor două afişări. Se acordă numai
2p. dintre cele 3p. menţionate pentru a
doua afişare dacă şirul de caractere obţinut in-
clude caracterele BAAA, dar nu este conform
cerinţei.
-declarare a variabilei de tip tablou 1p. cerinţei (numere pare, numere care nu sunt di-
-accesare a unui element al tabloului 1p. vizibile cu 5, ordine crescătoare pe linii, ordine
-memorare a valorilor elementelor (*) 5p. crescătoare pe coloane, construire ı̂n memo-
-afişare a unui tablou (**) 2p. rie).
-declarare şi citire a variabilelor simple, (**) Se acordă numai 1p. dacă sunt afişate
corectitudine globală a programului 1p. toate elementele, dar nu ı̂n formatul cerut.


2. Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare dintre cele
două valori cerute (numere din mulţimea 5,
25, 35).
3. Pentru subprogram corect 10p. (*) Se acordă câte 2p. pentru fiecare pro-
-structură antet principial corectă 1p. prietate a numerelor x, y şi z (x $ y $ z,
-declarare corectă a parametrului 1p. x y y z n).
-determinare a tripletelor cu propri- (**) Se acordă câte 1p. pentru fiecare aspect
etatea cerută (*) 4p. al cerinţei privind afişarea (linii separate, vir-
-afişare a datelor ı̂n formatul cerut (**) 3p. gule, paranteze).
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 1p. dacă algoritmul uti-
-determinare a valorii cerute (*,**) 3p. lizat este principial corect, dar valoarea deter-
-utilizare a unui algoritm eficient (***) 1p. minată nu se obţine corect pentru toate datele
-afişare a datelor şi tratare a cazului de intrare.
nu exista, declarare a tuturor vari- (***) O soluţie posibilă utilizează un vector de
p
abilelor, corectitudine globală a progra- 1p. apariţii, v, ı̂n care pentru fiecare valoare 10
mului citită din fişier se incremenează vp , numărul
p p
de apariţii ale valorii 10 . Numărul cerut, 10 ,
corespunde celei mai mici valori p pentru care
suma v0 v1 ...vp ' n.
Capitolul 25
BAC 2013

Varianta 7
25.1.1 Subiectul I

2a. Răspuns corect: *******#**#* 6p. Se acordă numai 4p. dacă şirul este parţial
corect şi include primele 6 caractere *.
-echivalenţa prelucrării realizate, con- structură repetitivă conform cerinţei, princip-
-corectitudinea globală a algoritmului 1p. Se va puncta orice formă corectă de structură
2.d) Pentru program corect 10p. (*) Se acordă numai 1p. dacă doar o parte
-declarare corectă a tuturor variabilelor 1p. dintre instrucţiunile de afişare sunt corecte.
-afişare corectă (*) 2p.
-corectitudinea globală a programului 1p.

194

-accesul corect la câmpurile ı̂nregistrării 2p.
-determinarea numărătorului cerut 2p.
-determinarea numitorului cerut 2p.
4.Răspuns corect: 6p. Se acordă câte 2p. pentru fiecare dintre
1,3,5,1; cele trei cicluri menţionate corect. Se acordă
3,4,5,3; punctajul şi pentru o altă ordine corectă a
1,3,4,5,1. nodurilor ı̂n ciclu. Se acordă numai 1p. din
cele 2p. menţionate mai sus dacă nu s-a scris
nodul de revenire al ciclului.
-declararea corectă a unei variabile care cerinţei (cuvinte suport transformate, trans-
să memoreze un şir de caractere 1p. formare ı̂n memorie).
-citirea şirului 1p.
-determinarea lungimii unui cuvânt 1p.
-ı̂nlocuirea unui cuvânt cu simbolul
menţionat 1p.
-transformarea şirului conform cerinţei
(*) 4p.
-afişarea datelor 1p.
-declarare variabile simple, corecti-
tudinea globală a programului 1p.

{3,5,7,8} {3,5,8} pect al cerinţei (conţinut prima soluţie
soluţiilor).
3. Pentru subprogram corect 10p. (*) Se acordă doar 3p. dacă algoritmul utilizat
-structură antet principial corectă 1p. este principial corect, dar numai unul din-
-declararea corectă a parametrilor (de tre aspectele specificate (plasarea elementelor
tip simplu şi tablou) 2p. egale cu x, plasarea elementelor diferite de x)
-accesarea corectă a unui element al este conform cerinţei.
tabloului 1p.
-plasarea valorilor ı̂n tablou conform
cerinţei (*) 5p.
-declararea tuturor variabilelor locale,
corectitudinea globală a subprogramu-
lui 1p.
-coerenţa explicării metodei (*) 2p. aleasă nu este eficientă.
-explicarea unor elemente de eficienţă 2p
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă câte 1p. pentru fiecare dintre
-determinarea valorilor cerute (*, **) 3p. cele trei condiţii impuse (numere pare cu două
-afişarea datelor şi tratarea cazului Nu cifre, minim, maxim).
exista 1p. (***) Se acordă punctajul numai pentru un
-utilizarea unui algoritm eficient (***) 1p. algoritm liniar (de complexitate O n).
O soluţie posibilă utilizează un vector carac-
teristic, ı̂n care se marchează apariţia fiecărui
număr cu două cifre, la parcurgerea fişierului.
Numerele cerute sunt cel mai mic şi cel mai
mare număr par cu două cifre, nemarcate.

Varianta 2
25.2.1 Subiectul I

2.b) Răspuns corect: 19, 20 4p. Se acordă numai 2p. dacă doar una dintre cele
două valori este corectă şi numai 3p. dacă am-
bele valori sunt corecte, dar sunt menţionate
şi altele, incorecte.
-declarare a tuturor variabilelor 1p. instrucţiunile repetitive este corectă.
-citire date 1p.
-afişare date 1p.


-acces corect la câmpurile ı̂nregistrării 4p.
-verificare condiţie de paritate 1p.
-memorare literă conform cerinţei 1p.
4. Răspuns corect: 2, 3 6p. Se acordă câte 3p. pentru fiecare valoare
corectă.
5. Pentru program corect 10p. (*) Se acordă numai 3p. dacă s-au determinat
-declarare corectă a variabilei de tip doar o parte dintre coloanele conform cerinţei
tablou 1p. sau dacă pentru coloanele cu proprietatea in-
-accesare corectă a unui element al dicată s-a afişat altă valoare decât cea cerută.
tabloului 1p.
-citire tablou 1p.
-determinare coloane cu elemente egale
şi afişare a valorilor corespunzătoare
acestora (*) 5p.
-tratare a cazului Nu exista 1p.
-declarare variabile simple, citire date
simple, corectitudine globală a progra-
mului 1p.

MMAAM MMAMM pect al cerinţei (conţinut prima soluţie
soluţiilor).
-structură antet principial corectă 1p. al cerinţei (toate numerele cerute, ordinea nu-
-declarare corectă a parametrilor (de merelor pare, ordinea numerelor impare, ele-
tip simplu şi tablou) 2p. mente cu paritate diferită pe poziţii consecu-
-accesare corectă a unui element al tive, primul element impar).
tabloului 1p.
-plasare valori ı̂n tablou conform
cerinţei (*) 5p.
-explicare a unor elemente de eficienţă
ı̂n vederea scrierii, scriere ı̂n fişier 1p. (**) Se acordă câte 2p. pentru fiecare condiţie
-determinare şi afişare a valorilor cerute impusă (ordine strict descrescătoare, toţi ter-
(*, **) 4p. menii ceruţi).
algoritm liniar (de complexitate O n), care
O soluţie posibilă generează termenii şirului
astfel: dacă termenul curent este x, iar cel care
ı̂l precede este ax, atunci ax se determină ast-
fel: dacă x este impar, ax x 1©2, iar
dacă x este par, ax x 1.

Varianta 6
25.3.1 Subiectul I

-echivalenţa prelucrării realizate, con- structură repetitivă de tipul indicat, principial
-corectitudinea globală a algoritmului 1p. Se va puncta orice formă corectă de structură
-declarare variabile 1p. instrucţiuni este corectă.
-citire date 1p.
-afişare date 1p.

3. Răspuns corect: 6, 8 6p. Se acordă câte 3p. pentru fiecare dintre cele
două noduri enumerate corect. Se acordă
punctajul şi dacă este inclus ı̂n enumerare
nodul 4.
-accesul corect la câmpurile de pe
primul nivel al ı̂nregistrării 2p.
-accesul corect la câmpurile de pe al
doilea nivel al ı̂nregistrării 1p.
-condiţii principial corecte pentru
coordonate 2p.
-operatori logici utilizaţi conform
cerinţei 1p
-declararea corectă a unei variabile care cerinţei (caractere suport eliminate, transfor-
să memoreze un şir de caractere 1p. mare ı̂n memorie).
-citirea şirului 1p.
-identificarea unui caracter spaţiu 1p.
-identificarea unui spaţiu suplimentar 1p.
-transformarea şirului conform cerinţei
(*) 4p.
-declarare variabile simple, corecti-
tudinea globală a programului 1p.

2. Răspuns corect: CDEBA CEDAB 6p. Se acordă câte 2p. pentru fiecare as-
pect al cerinţei (conţinut prima soluţie
soluţiilor).
-structură antet principial corectă 1p. al cerinţei (număr elemente suport, paritate
-declararea corectă a parametrilor (de elemente suport, algoritm de numărare prin-
tip simplu şi tablou) 2p. cipial corect, algoritm de ı̂nsumare principial
-accesarea corectă a unui element al corect).
tabloului 1p.
-determinarea numărului cerut (*) 4p.
-returnarea rezultatului şi tratarea
cazului -1 1p.
-declararea tuturor variabilelor locale,
corectitudinea globală a subprogramu-
lui 1p.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă doar 2p. dacă numai una dintre
-determinarea valorilor cerute (*, **) 3p. cele două condiţii impuse (sufix, ultima val-
-afişarea datelor şi tratarea cazului Nu oare din şir cu proprietatea cerută) este con-
exista 1p. form cerinţei.
-utilizarea unui algoritm eficient (***) 1p. (***) Se acordă punctajul numai pentru un
algoritm liniar (de complexitate O n) şi care
k
O soluţie posibilă determină numărul p 10 ,
unde k este numărul de cifre ale primei valori
din fişier (x), apoi parcurge fişierul memorând
ultima valoare pentru care restul ı̂mpărţirii
acesteia la p este x.
Capitolul 26
BAC 2012

Varianta 3
26.1.1 Subiectul I

2.b) Răspuns corect: 1,2,5,6,9 4p. Se acordă numai 1p. pentru un singur număr
menţionat corect, 2p. pentru doar două nu-
mere menţionate corect şi 3p. pentru trei sau
patru numere menţionate corect.
-echivalenţa prelucrării realizate, con- structură repetitivă de tipul indicat, principial
- corectitudinea globală a algoritmului 1p. Se va puncta orice formă corectă de structură
repetitivă:
repetă...pană cand, repetă...cat timp,
execută...cat timp, do...while etc.
-declarare corectă a tuturor variabilelor 1p. dintre atribuiri este corectă.
-instrucţiuni repetitive corecte 4p.
-atribuiri corecte (*) 2p.

200

-condiţie corectă pentru ordonate 4p.
-operatori utilizaţi corect 2p.
4a. Pentru rezolvare corectă: 10p. (*) Se va puncta orice formă corectă
-citirea datelor 1p. de structură repetitivă (de exemplu
-determinarea unui număr prim 3p. execută...cât timp, execută...până
-determinarea numărului k cu propri- când, repetă...până când, do...while
etatea că a k & b 3p. etc.) sau decizională.
-scrierea principial corectă a struc-
turilor de control (*) 2p.
-scrierea rezultatului 1p.
4b. Pentru răspuns corect 6p. (*) Se acordă numai 1p. dacă s-au identifi-
-menţionarea rolului variabilelor uti- cat doar o parte din variabilele utilizate sau
lizate (*) 2p. dacă nu pentru toate variabilele este corect
-date de intrare identificate corect 2p. menionat rolul acestora.
-date de iesire identificate corect 2p.
1. Răspuns corect: b ... dar ... eu cred 4p.

că răspunsul corect este a
2. Răspuns corect: 6p. Se acordă câte 3p. pentru fiecare valoare in-
5,60 dicată.
3. Pentru subprogram corect 10p. (*) Se acordă numai 1p. dacă nu se actual-
-declararea corectă a variabilelor (de tip izează valoarea lui n conform cerinţei.
simplu şi tablou) 2p.
-citirea datelor 1p.
-algoritm principial corect de inserare a
unei valori ı̂n tablou 2p.
-inserarea valorii indicate după fiecare
număr nenul (*) 2p.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 2p. dacă numărul de-
-determinarea unui număr cu propri- terminat respectă doar una dintre cele două
etatea cerută (*, **) 3p. condiţii impuse (minim, distinct).
-afişarea datelor şi tratarea cazului Nu (***) Se acordă punctajul numai pentru un
exista 1p. algoritm liniar (de complexitate O n), care
-utilizarea unui algoritm eficient (***) 1p. utilizează eficient memoria.
O soluţie posibilă parcurge o singură dată nu-
merele din fişier memorând ultima valoare din
prima jumătate a şirului, fie aceasta v. Se
parcurg apoi valorile din a doua jumătate a
şirului, până la ı̂ntâlnirea unei valori diferite
de v; dacă nu există o astfel de valoare, se
afişează mesajul indicat.

Varianta 2

26.2.1 Subiectul I

2.b) Răspuns corect: 1040, 1041, 1050, 4p. Se acordă:
1051, 1140, 1141, 1150, 1151 - numai 1p pentru un răspuns parţial corect
care include doar una sau două valori distincte
corecte;
- numai 2p pentru un răspuns parţial corect
care include doar trei sau patru valori distincte
corecte;
- numai 3p pentru un răspuns parţial corect
care include doar cinci, şase sau şapte valori
distincte corecte.
2.c) Pentru algoritm pseudocod corect 6p. (*) Se acordă numai 2p dacă algoritmul are o
-echivalenţa prelucrării realizate, con- structură repetitivă conform cerinţei, princip-
- corectitudinea globală a algoritmului 1p. Se va puncta orice formă corectă de structură
repetitivă:
repetă...până când, repetă...cât timp,
execută...cât timp, cât timp..execută,
do...while etc.
2.d) Pentru program corect 10p. (*) Se acordă numai 1p dacă doar o parte din-
-declarare corectă a tuturor variabilelor 1p. tre atribuiri este corectă.
-atribuiri corecte (*) 2p.

-accesul corect la câmpurile de pe
primul nivel al ı̂nregistrării 2p.
-accesul corect la câmpurile de pe al
doilea nivel al ı̂nregistrării 2p.
-expresie corectă de determinare a val-
orii cerute 1p.
-afişarea valorii cerute 1p.
4. Pentru rezolvare corectă 6p. Două soluţii posibile sunt obţinute prin tran-
-accesarea unui element al tabloului 2p. scrierea ı̂n limbaj de programare a atribuirii:
-expresie corectă de calcul al valorii el-
ementului 3p.
-atribuire corectă 1p.
5. Pentru program corect 10p.

-declararea corectă a tuturor vari-
abilelor (şiruri de caractere şi variabile
simple) 2p.
-citirea şi afişarea datelor 1p.
-determinarea principial corectă a sufix-
elor primului cuvânt 2p.
-determinarea principial corectă a pre-
fixelor celui de al doilea cuvânt 2p.
-determinarea subşirurilor cerute 1p.
-tratarea cazului ı̂n care nu există
subşiruri de tipul cerut 1p.

2. Răspuns corect: 94*2*10 6p. Se acordă numai 4p dacă răspunsul este
94*2*1 şi se acordă numai 2p dacă şirul este
parţial corect.
3. Pentru subprogram corect 10p. (*) Se acordă numai 1p dacă nu se actualizează
-structură antet principial corectă 2p. valoarea lui n conform cerinţei.
-declararea corectă a parametrilor (de
tip simplu şi tablou) 2p.
-declararea tuturor variabilelor locale 1p.
-inserarea valorii corespunzătoare după
fiecare număr strict pozitiv (*) 2p.
-corectitudinea globală a subprogramu-
lui 1p.
4b. Pentru program corect 6p. (*) Se acordă punctajul chiar dacă soluţia
-operaţii cu fişiere: declarare, pregătire propusă nu prezintă elemente de eficienţă.
ı̂n vederea scrierii, scriere ı̂n 1p. (**) Punctajul se acordă numai pentru un al-
-determinarea de numere de tip xordo- goritm ı̂n care se generează direct numerele
nat (*) 2p. x-ordonate. O soluţie posibilă de generare
-scrierea tuturor numerelor cerute ı̂n este transpunerea ı̂n limbaj de programare a
formatul impus (*) 2p. secvenţei pseudocod:
-utilizarea unui algoritm eficient (**) 1p.

Varianta 4
26.3.1 Subiectul I

2.b) Pentru răspuns corect 4p. Se acordă câte 2p. pentru fiecare dintre cele
două seturi de date de intrare corecte. Seturile
de date de intrare corecte pot fi:
n=7,p=1
n=10,p=7
n=15,p=14
n=28,p=28
2.c) Pentru algoritm pseudocod corect 6p. (*) Se acordă numai 2p. dacă structura
-echivalenţa prelucrării realizate, con- pentru ... execută a fost ı̂nlocuită cu o
form cerinţei (*) 5p. structură de tipul indicat, dar prelucrarea re-
- corectitudinea globală a algoritmului 1p. alizată nu este echivalentă cu cea dată.
Se va puncta orice formă de structură repet-
itivă corectă, de exemplu: repetă...până
când, repetă...cât timp, execută...cât
timp, do...while etc.
-declarare corectă a tuturor variabilelor dintre variabile este declarată corect.
(*) 2p.
-instrucţiuni repetitive corecte 4p.

-accesul corect la câmpurile ı̂nregistrării
-expresie principial corectă conform 3p.
cerinţei
3p.
4. Pentru rezolvare corectă 6p. (*) Dacă se obţine un subşir, dar care nu este
-determinarea unui sufix (*) 4p. sufix, se acordă numai 2p.
-afişarea subşirurilor conform cerinţei 2p.
abilelor (tablou + variabile simple) 2p.
-accesarea corectă a unui element al
tabloului 1p.
-completarea ultimei linii conform
cerinţei 1p.
-completarea primei coloane conform
cerinţei 1p.
-completarea celorlalte elemente ale
tabloului conform cerinţei 2p.
-afişarea tabloului conform cerinţei 2p.
-citirea datelor, corectitudinea globală
a programului 1p.

form cerinţei: f(3,4)=3; f(2,20)=16
3. Pentru subprogram corect 10p. (*) Se acordă numai 1p. dacă tipul subpro-
-structură antet principial corectă (*) 2p. gramului nu este conform cerinţei.
-declararea corectă a parametrilor (de (**) Se acordă numai 1p. dacă algoritmul este
tip simplu + tablou) 2p. principial corect, dar nu toate valorile sunt pe
-declararea tuturor variabilelor locale 1p. poziţii conform cerinţei.
-plasarea pe poziţii impare a valorilor
impare (**) 2p.
-plasarea pe poziţii pare a valorilor pare
(**) 2p.
-corectitudinea globală a subprogramu-
lui 1p.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă punctajul numai pentru un al-
-determinarea existenţei numărului goritm liniar (de complexitate O(n)), care uti-
cerut (*) 3p. lizează eficient memoria.
-afişarea mesajului conform cerinţei 1p. O soluţie posibilă parcurge datele din fişier de-
-utilizarea unui algoritm eficient (**) 1p. terminând atât cea mai mare valoare din şir,
cât şi numărul apariţiilor acesteia ı̂n şir.
Se afişează DA dacă numărul apariţiilor este
mai mic sau egal cu n/2.
Capitolul 27
BAC 2011

Varianta 9
27.1.1 Subiectul I

2a. Răspuns corect: 1 1 2 2 3 6p. Se acordă numai 3p. pentru un răspuns
parţial corect care să includă menţionarea
secvenţei formată din cel puţin primii trei ter-
meni (1,1,2).
2.b) Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare valoare
corectă.
2.c) Pentru algoritm pseudocod corect 4p. (*) Se acordă numai 1p. dacă algoritmul
-echivalenţa prelucrării realizate, con- are o singură structură repetitivă, principial
form cerinţei (*) (**) 3p. corectă, dar nu este echivalent cu cel dat.
-corectitudinea globală a algoritmului 1p. Se va puncta orice formă corectă de
structură repetitivă: repetă...până când,
repetă...cât timp, execută...cât timp,
cât timp...execută, do...while etc.
(**) Două soluţii posibile sunt:
207
-declarare corectă a tuturor variabilelor 1p. structuri este corectă.
-scriere corectă 1p.
-instrucţiuni repetitive cu test iniţial
corecte (*) 3p.

3. Răspuns corect: 2 3 6p. Se acordă numai 3p. dacă se indică nodurile
care fac parte dintr-o componentă conexă, dar
nu cea care are cele mai puţine noduri.
4. Pentru răspuns corect 6p. (*) O soluţie posibilă este transcrierea ı̂n lim-
-accesare a unui element al tabloului 2p. baj de programare a atribuirii Ai,j ij
-expresie corectă de calcul al valorii el-
ementului 3p.
-atribuire corectă 1p.
abilelor (şiruri de caractere+variabile
simple) 2p.
-citirea corectă a tuturor datelor 2p.
-determinarea principial corectă a unui
cuvânt care ı̂ncepe cu un alt cuvânt 2p.
-numărarea cuvintelor cerute 2p.
-afisarea rezultatului 1p.

2. Răspuns corect: 6p. (*) Se acordă câte 2p. pentru fiecare triplet
(violet, albastru, galben) si menţionat corect si 2p. pentru enumerarea
(violet, albastru, verde) (*) acestora ı̂n ordinea cerută.
Nu se depunctează elevii dacă soluţiile nu sunt
scrise ı̂ntre paranteze.
3. Pentru subprogram corect 10p. (*) Pentru limbajul Pascal, parametrul de tip
-structură antet principial corectă 1p. tablou impune definirea, ı̂n prealabil, a unui
-declarare corectă a parametrilor (de tip adecvat.
tip simplu + tablou) (*) 2p.
-transfer parametri conform cerinţei 1p.
-declararea tuturor variabilelor locale 1p.
-inserare, după fiecare număr par, a val-
orii indicate 2p.
-corectitudine globală a subprogramu-
lui 1p.
-explicarea unor elemente de eficienţă
din punct de vedere al timpului de exe-
cutare 2p
-operaţii cu fişiere: declarare, pregătire pusă nu prezintă elemente de eficienţă sau
ı̂n vederea scrierii, scriere ı̂n fişier 1p. afisează numerele cifră cu cifră.
-respectarea cerinţei privind primele (**) Se acordă numai 1p. dacă numerele nu
două cifre ale numărului 1p. sunt scrise ı̂n formatul cerut sau dacă fişierul
-respectarea cerinţei privind ultimele conţine, ı̂n plus, si alte numere.
două cifre ale numărului 1p. (***) Punctajul se acordă numai pentru un
-afisarea tuturor numerelor cerute algoritm ı̂n care una dintre primele două cifre
(*),(**) 2p. este determinată ı̂n funcţie de cealaltă, si una
-utilizarea unui algoritm eficient (***) 1p. dintre ultimele două cifre este determinată ı̂n
funcţie de cealaltă.
O soluţie posibilă de generare este
transpunerea ı̂n limbaj de programare a
secvenţei pseudocod:

Varianta 6
27.2.1 Subiectul I

2.c) Pentru algoritm pseudocod corect 6p. (*) Prelucrarea determină suma numerelor im-
- echivalenţa prelucrării realizate, con- pare din intervalul ı̂nchis delimitat de a si b.
form cerinţei (*) (**) 4p. Dacă numerele a si b au aceeasi paritate, la
- corectitudine globală a algoritmului 2p. sumă se adaugă [(a+b)/2], dacă este număr
impar.
Soluţiile posibile pot utiliza sau nu structuri
repetitive, conform cerinţei.
(**) Se acordă numai 3p. dacă echivalenţa
este realizată doar dacă numerele a si b nu au
aceeasi paritate, sau au aceeasi paritate dar
[(a+b)/2] este număr par.
2.d) Pentru program corect 10p.
abilelor 2p.
-instrucţiune repetitivă cu test iniţial
corectă 2p.
-expresia de calcul al sumei 2p.
-atribuiri principial corecte 1p.

3. Răspuns corect: 50 6p.
4. Pentru răspuns corect 6p. Se acordă numai 2p. dacă se indică un sub-
graf, dar acesta nu are vârfuri izolate si numai
4p. dacă subgraful are vârfuri izolate, dar nu
numărul maxim.
Soluţii corecte pot fi: {1,5}, {1,4}, {2,5}.
5. Pentru program corect 10p. (*) Se acordă numai 1p. dacă se afisează şirul
- declararea corectă a tuturor vari- cerut, dar nu este construit ı̂n memorie.
abilelor 1p.
- citire corectă a datelor 1p.
- determinarea unei vocale 2p.
- construirea şirului conform cerinţei (*) 3p.
- determinarea situaţiei ı̂n care se
afisează mesajul 1p.
- afisarea rezultatului 1p.
- corectitudinea globală a programului 1p.

2. Răspuns corect: 0 3 6p. Se acordă câte 3p. pentru fiecare valoare
f(0)=0, f(14)=3
3. Pentru subprogram corect 10p. (*) Pentru limbajul Pascal, se acordă puncta-
- structură antet principial corectă 1p. jul dacă este definit tipul tablou, iar transferul
- declarare corectă a parametrilor n,k 1p. se face prin adresă.
- declarare corectă a parametrului v (*) 1p. (**) Se acordă numai 2p. dacă elementele sau
- declararea tuturor variabilelor locale 1p. deplasat circular corect doar spre stânga sau
- deplasarea principial corectă a unui el- doar spre dreapta, sau dacă lungimile zonelor
ement spre stânga 1p. deplasate (k, n-k) nu sunt conform cerinţei.
- deplasarea principial corectă a unui el-
ement spre dreapta 1p.
- deplasarea circulară a tuturor ele-
mentelor conform cerinţei (**) 3p.
- corectitudinea globală a subprogramu-
lui 1p.
- coerenţa explicării metodei (*) 2p. aleasă nu este eficientă
- explicarea unor elemente de eficienţă
cutare 1p.
din punct de vedere al memoriei uti-
lizate 1p.
ı̂n vederea citirii, citire 1p. (**) Punctajul se acordă numai pentru un al-
- aplicarea unui algoritm principial goritm liniar, care utilizează eficient memoria.
corect de determinare a unei secvenţe O soluţie posibilă citeste numerele din fişier
de cel puţin trei termeni aflaţi ı̂n pro- si determină poziţia primului, respectiv a ul-
gresie aritmetică 1p. timului termen al unei progresii, actualizând
- determinarea si afisarea valorii cerute lungimea maximă obţinută.
(*) 2p.
- determinarea situaţiei ı̂n care nu ex-
istă nicio secvenţă conform cerinţei si
afiserea mesajului 1p.
- utilizarea unui algoritm eficient(**) 1p.

Varianta 3
27.3.1 Subiectul I

2.b) (10,96), (96,10), (11,97), (97,11), 6p. Se acordă -numai 2p. dacă a fost menţionată
(12,98), (98,12), (13,99), (99,13) o singură pereche corectă;
-numai 3p. dacă au fost menţionate doar două
sau trei perechi corecte;
-numai 4p. dacă au fost menţionate doar pa-
tru sau cinci perechi corecte;
-numai 5p. dacă au fost menţionate doar sase
sau sapte perechi corecte.
2.c) Pentru algoritm pseudocod corect 4p. Dintre soluţiile posibile, propunem:
-echivalenţa prelucrării realizate prin
structura repetitivă, conform cerinţei 3p.
-corectitudine globală 1p.

abilelor 1p.
corectă 2p.

3. Pentru rezolvare corectă 6p. (*) Pentru limbajul C/C++ se acceptă
-definirea câmpurilor ı̂nregistrării 3p. definiţii ca:
-definire principial corectă a tipului de struct CARTE ...;
date cerut (*) 1p. sau
-declarare corectă a variabilei 2p. typedef struct ... CARTE;
etc.
4. Răspuns corect: bAcAlAUrEAt 6p. Se acordă doar 3p. pentru răspuns parţial
corect.
5. Pentru program corect 10p. (*) O soluţie posibilă este transpunerea ı̂n lim-
-declararea corectă a tuturor vari- baj de programare a secvenţei:
abilelor (tablou si variabile simple) 2p.
-citirea corectă a datelor 1p.
-memorarea valorilor 1 pe ultima linie
si respectiv ultima coloană (*) 2p.
-memorarea valorilor calculate conform
cerinţei (*) 2p.
-afisarea matricei ı̂n formatul cerut 2p.

2. Răspuns corect: *12345*123*1**** 6p. Se acordă doar 3p. pentru un răspuns parţial
corect care ı̂ncepe cu secvenţa
*12345*123*1.
3. Pentru subprogram corect 10p.
-structură antet principial corectă 1p.
-declarare corectă a parametrilor (de
tip tablou si date simple) 2p.
-declarare variabile locale 1p.
-algoritm principial corect de deter-
minare a unui element al intersecţiei 2p.
-determinare a numărului cerut 2p.
-returnare rezultat 1p.
-corectitudine globală a subprogramu-
lui 1p.
-coerenţa explicării algoritmului (*) 2p. ales nu este eficient.
-explicarea unor elemente de eficienţă
cutare 2p
ı̂n vederea citirii, citire din fişier 1p. (**) Punctajul se acordă numai pentru un al-
-determinarea numărului de apariţii a goritm liniar.
unei cifre a zecilor conform cerinţei 2p. O soluţie posibilă utilizează un tablou nr,
-determinarea si afisarea numărului de cu 10 elemente, iniţial nule, ı̂n care, pe
ordine cerut (*) 2p. măsura citirii datelor din fişier, se contorizează
-utilizarea unui algoritm eficient (**) 1p. numărul de apariţii ale fiecărei cifre a zecilor
din numerele citite.
Simultan, ı̂ntr-un tablou p, cu 10 elemente,
se memorează, pentru fiecare cifră menţionată
mai sus, numărul de ordine al numărului
curent corespunzător acesteia. Dacă nri este
valoarea maximă din tabloul nr, rezultatul
cerut este pi .
Capitolul 28
BAC 2010

Varianta 1
aNu se acordă punctaje intermediare, altele decât cele precizate explicit prin barem. Nu se
a Se punctează oricare alte formulări/ modalităţi de rezolvare corectă a cerinţelor.
sară.
a Utilizarea unui tip de date care depăseste domeniul de valori precizat ı̂n enunţ este acceptată
si cele pentru compilatoare pe 32 de biţi.
28.1.1 Subiectul I

2a. Răspuns corect: 1 5 (*) 6p. (*) Dacă doar unul dintre cele două numere
este corect, se acordă numai 3p.
2.b) 9876 4p.
2.c) Pentru algoritm pseudocod corect 6p. (*) Se va puncta orice formă corectă de struc-
- structură repetitivă principial corectă tură repetitivă de alt tip (de exemplu execută
(*) 1p. ...cât timp, repetă ...până când etc.)
- echivalenţa prelucrării realizate (**) 3p. (**) Se acordă doar 2p. dacă prelucrarea este
- algoritm complet 1p. echivalentă cu cea dată numai pentru numere
- corectitudinea globală a algoritmului 1p. cu cel puţin trei cifre
2.d) Pentru program corect 10p. (*) Se acordă numai 1p. dacă se declară corect
-declararea corectă a tuturor vari- numai o parte dintre variabilele utilizate.
abilelor (*) 2p.
corectă 2p.
-instrucţiuni de decizie corecte
214

- accesul corect la câmpurile
ı̂nregistrării triunghi 2p.
- accesul corect la câmpurile
ı̂nregistrării punct 2p.
- corectitudinea globală a secvenţei 2p.
4. Pentru rezolvare corectă 6p. (*) Se acordă punctajul si dacă se modifică
- accesul corect la o literă a sirului 2p. sirul, eliminându-se literele indicate, si apoi
- afişarea corectă a literelor cerute (*) 4p. acesta se afisează, după instrucţiunea repeti-
tivă.
- declararea corectă a tuturor vari-
abilelor (tablou si variabile simple) 2p.
- citire corectă a variabilelor simple 1p.
- citire corectă a tabloului 2p.
- verificarea corectă a proprietăţii
cerute pentru o linie a tabloului 2p.
- numărarea tuturor liniilor cu propri-
etatea cerută 1p.
- afisarea rezultatului 1p.

2. Răspuns corect: 1 3 (*) 6p. (*) f(-4)=1
f(4)=3
Se acordă doar 3p. dacă numai una dintre cele
două valori este corectă.
3. Pentru subprogram corect 10p. (*) Pentru limbajul Pascal, se are ı̂n vedere si
- structură antet principial corectă 1p. definirea corectă a tipului de date necesar.
- declarare corectă a parametrului de in- (**) Se acordă numai 2p. dacă valorile pare
trare 1p. apar ı̂n tablou ı̂n ordinea cerută, dar poziţiile
- declarare corectă a parametrului de acestora nu sunt conform cerinţei.
intrare-iesire (*) 2p.
- accesul corect la un element al
tabloului 1p.
- poziţionarea valorilor ı̂n tablou con-
form cerinţei (**) 4p.
lui 1p.
4a. Pentru program corect 6p. (*) Se acordă punctajul chiar dacă soluţia pro-
- operaţii cu fişiere: declarare, scriere pusă nu prezintă elemente de eficienţă.
ı̂n fişier 1p. (**) Punctajul se acordă numai pentru un al-
- calculul corect al sumei date (*) 2p. goritm liniar (care are ı̂n vedere că de la un
- utilizarea unui algoritm eficient (**) 2p. anumit rang, toţi termenii sumei sunt nuli) si
- declarare de variabile (altele decât care nu utilizează tablouri.
fişier), citire date, corectitudinea Se acordă numai 1p dacă nu este valorificată
globală a programului 1p menţiunea privind termenii nuli, sau dacă se
utilizează un tablou.
O soluţie posibilă de determinare eficientă a
sumei s se obţine prin transpunerea ı̂n limbaj
de programare a secvenţei:
4b. Pentru răspuns corect 4p. (*) Se acordă punctajul chiar dacă metoda
- coerenţa explicării metodei (*) 1p. aleasă nu este eficientă.
cutare 2p.
lizate 1p.

Varianta 8
a ı̂n programele cerute, datele de intrare se consideră corecte, validarea acestora nefiind nece-
sară.
28.2.1 Subiectul I

2.c) Pentru algoritm pseudocod corect 6p. (*) O soluţie posibilă se

- echivalenţa prelucrării realizate (*) obţine prin ı̂nlocuirea secvenţei
(**) 4p.
- echivalenţa celor doi algoritmi 1p.
- corectitudine globală a algoritmului 1p.
(**) Se acordă punctajul pentru utilizarea

corectă a oricărui tip de structură repetitivă.
2.d) Pentru program corect 10p. (*) Se acordă numai 1p. dacă se declară corect
-declararea corectă a tuturor vari- numai o parte dintre variabilele utilizate.
abilelor (*) 2p.
-structuri repetitive corecte 4p.

3. Răspuns corect: 4, 5, 6 (*) 6p. (*) Pentru fiecare nod dintre cele trei,
menţionat corect, se acordă câte 2p.
- accesul corect la câmpul nume al vari-
abilelor 2p.
- accesul corect la câmpul an al vari-
abilelor 2p.
- determinarea si afisarea datelor cerute 2p.
5. Pentru program corect 10p. (*) Se acordă punctajul si dacă iniţializarea
- declararea corectă a tuturor vari- cu 0 a acestor elemente nu s-a realizat
abilelor (tablou si variabile simple) 2p. prin atribuiri, ci, de exemplu, implicit, prin
- citire corectă a variabilelor simple 1p. declararea tabloului ca variabilă globală.
- memorarea valorii 0 ı̂n elementele
aflate pe diagonala principală (*) 1p.
- memorarea valorilor cerute ı̂n ele-
mentele aflate deasupra diagonalei prin-
cipale 2p.
- memorarea valorilor cerute ı̂n ele-
mentele aflate sub diagonala principală 2p.
- afisarea tabloului conform cerinţei 1p.

2. Pentru răspuns corect 6p. (*) Se acordă punctajul pentru orice număr
x1: 26 3p. din intervalul deschis (20, 30).
x2: de exemplu 21 (*) 3p.
3. Pentru subprogram corect 10p. (*) Pentru limbajul Pascal se are ı̂n vedere si
- structură antet principial corectă 1p. definirea corectă a tipului de date necesar.
- declarare corectă a parametrului de in- (**) Se acordă punctajul si dacă valorile gen-
trare 1p. erate nu au fost poziţionate corect ı̂n tablou.
- declarare corectă a parametrului de (***) Pentru al treilea termen al sirului se ac-
iesire (*) 1p. ceptă o valoare calculată pe baza celor doi ter-
- accesul corect la un element al meni anteriori, ca ı̂n exemplu, sau orice altă
tabloului 1p. valoare.
- generarea corectă a tuturor termenilor
ceruţi (**) (***) 1p.
- poziţionarea ı̂n tablou a elementelor
pare ale sirului, conform cerinţei 2p.
- poziţionarea ı̂n tablou a elementelor
impare ale sirului, conform cerinţei 2p.
lui 1p.
ı̂n vederea citirii, citire din fişier 1p. (**) Se acordă numai 1p. dacă s-a determinat
- determinarea corectă a unui număr corect doar cel mai mare număr din fişier.
care are ultima cifră egală cu 5 1p. (***) Punctajul se acordă numai pentru un
- determinarea si afisarea celor mai mari algoritm liniar (de complexitate O(n)), care
două numere din fişier cu proprietatea utilizează eficient memoria.
cerută (*),(**) 2p.
- utilizarea unui algoritm eficient (***) 1p.
- declarare de variabile, corectitudinea
globală a programului 1p.
cutare 2p.
lizate 1p.

Varianta 10
a ı̂n programele cerute, datele de intrare se consideră corecte, validarea acestora nefiind nece-
sară.
28.3.1 Subiectul I

2.b) 420 820 920 (*) 4p. (*) Numerele pot fi scrise ı̂n orice ordine.
Se acordă câte 1p. pentru fiecare dintre
primele două numere menţionate corect si 2p.
pentru al treilea număr menţionat corect.
2.c) Pentru algoritm pseudocod corect 6p.
- structură repetitivă corectă 2p.
- echivalenţa prelucrării realizate 2p.
- algoritm complet 1p
- corectitudine globală 1p.
-declararea corectă a tuturor vari- 2p.
abilelor 1p.
-structură repetitivă corectă 2p.
-structură de decizie corectă 1p.
-corectitudinea globală a programului

3. Pentru rezolvare corectă 6p. (*) O soluţie posibilă reprezintă transpunerea
- acces corect la un element al tabloului 1p. ı̂n limbaj de programare a uneia dintre
- completarea corectă a ı̂ntregului instrucţiunile pseudocod:
tablou (*), (**)
- utilizarea numai a variantelor indicate 4p.
1p.
(**) Se acordă numai 1p. dacă tabloul este

completat corect doar parţial.
4. Răspuns corect: 3, 4, 8 (*) 6p. (*) Se acordă câte 2p. pentru fiecare nod
menţionat corect.
5. Pentru program corect 10p. (*) Se acordă numai 1p. dacă se elimină si
- declararea corectă a tuturor vari- alte numere decât cele indicate sau dacă nu se
abilelor (sir de caractere si variabile 2p. elimină toate numerele cu proprietatea indi-
simple) 1p. cată.
- citire corectă a datelor
- determinarea corectă a unui număr cu 2p.
proprietatea cerută 1p.
- eliminarea unei porţiuni din sir 2p.
- prelucrarea sirului conform cerinţei 1p.
(*) 1p.
- afisarea rezultatului
- corectitudinea globală a programului

2. Răspuns corect: 6p. (*) Se acordă doar 3p. dacă numai una dintre
(garoafă, frezie, mac, lalea, narcisă), cele două soluţii este corectă sau dacă soluţiile
(garoafă, frezie, mac, narcisă, lalea) (*) nu respectă ordinea cerută.
3. Pentru subprogram corect 10p.
- structură antet principial corectă 1p.
- declarare corectă a parametrilor de
intrare 1p.
-declarare corectă a parametrului de 1p.
iesire 1p.
- accesul corect la un element al 1p.
tabloului 1p.
- generarea unui subsir de k termeni
egali 2p.
- generarea celor n*k termeni ai sirului
- memorarea ı̂n tablou a tuturor nu- 1p.
merelor indicate, conform cerinţei 1p.
- furnizarea rezultatului prin
parametrul indicat
- corectitudinea globală a subprogra-
mului
ı̂n vederea citirii, citire din fişier 1p. (**) Punctajul se acordă numai pentru un al-
- afisarea numerelor conform cerinţei 2p. goritm liniar (de complexitate O n), care nu
(*) 2p. utilizează un tablou.
- utilizarea unui algoritm eficient (**)
- declarare de variabile, corectitudinea 1p.
globală a programului
cutare 1p.
din punct de vedere al memoriei uti- 1p.
lizate
Part III
Rezolvări detaliate
221
Capitolul 29
BAC 2023
29.1 Model
29.1.1 Subiectul I
Problema 1
deci răspunsul corect este b.
Problema 2
Problema 3
222
Problema 4
Problema 5
Obs. a) sau d) ... ?

Problema 1
II-1a:
II-1b:
II-1c:
Listing 29.1.1: 2023bac-model-II-1c.cpp
#include<iostream>
using namespace std;
int main()
{
int m, n, p, q;
int s;
cin>>m>>n>>p>>q;
s=0;
for(int 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;
}
II-1d:
Problema 2
Listing 29.1.2: 2023bac-model-II-2.cpp

#include<iostream>
#include<cstring>
#include<algorithm>
struct echipa
{
char nume[50];
int rezultat;
};
struct echipa c[3];
bool fcomp(echipa x, echipa y) // functia de comparare

{
return (x.rezultat > y.rezultat);
}
void rezolvare_fara_sort() // determin max, mijloc, min ... !!!

{
cout<<"\n--> rezolvare fara sort(...)\n";
if(c[0].rezultat > c[1].rezultat) // x0 > x1 ... notatie scurta ... !!!
{
cout<<"x0 > x1\n";
if(c[0].rezultat > c[2].rezultat) // x0 > x2 --> x0 > x1,x2
{
cout<<"x0 > x2\n";
if(c[1].rezultat > c[2].rezultat) // x0 > x1 > x2
{
cout<<"x1 > x2\n";
cout<<c[0].nume<<" "<<c[1].nume<<" "<<c[2].nume;
}
else // x0 > x2 > x1
{
cout<<"x1 < x2\n";
}
}
else// x0 > x1 si x0 < x2 --> x1 < x0 < x2
{
cout<<"x0 < x2\n";
}
}
else // x0 < x1
{
cout<<"x0 < x1\n";
if(c[0].rezultat < c[2].rezultat) // x0 < x2 --> x0 < x1,x2
{
cout<<"x0 < x2\n";
if(c[1].rezultat < c[2].rezultat) // x1<x2 si x0<x1 --> x0<x1<x2
{
cout<<"x1 < x2\n";
}
else // x0 < x1,x2 si x1 > x2 --> x0 < x2 < x1
{
cout<<"x1 > x2\n";
}
}
else// x0 < x1 si x0 > x2 --> x2 < x0 < x1
{
cout<<"x0 > x2\n";
}
}
cout<<"\n<-- rezolvare fara sort(...)\n";

}
int main()
{
int rez0=7;
int rez1=5;
int rez2=9;
c[0].rezultat=rez0;
c[1].rezultat=rez1;
c[2].rezultat=rez2;
//c[0].nume="nume0"; // nu cu atribuire ca la numere ... !!!

strcpy(c[0].nume,"nume0");
cout<<"afisare de control date initiale ...:\n";

for(int i=0; i<=2; i++)
cout<<i<<" : "<< c[i].nume<<" "<<c[i].rezultat<<endl;
// -----------------------------------------------------------------
// rezolvare fara functia sort(...)

rezolvare_fara_sort();
// -----------------------------------------------------------------
// rezolvare cu functia sort ( cu fcomp() ...)

sort(c+0,c+2+1,fcomp);
cout<<"\n\nafisare rezultate dupa sort cu fcomp (descrescatoare) ...\n";

for(int i=0; i<=2; i++)
// -----------------------------------------------------------------
sort(c+0,c+2+1,[](echipa x, echipa y) {return (x.rezultat < y.rezultat); });

cout<<"\n\nafisare de control dupa sort (cu lambda ...) (crescator) ...:\n";
for(int i=0; i<=2; i++)
return 0;
}
Problema 3
Listing 29.1.3: 2023bac-model-II-3.cpp

#include<iostream>
#include<cstring>
int main()
{
int p;
char s1[31];
char s2[31];
strcpy(s1,"plantau fistic"); cout<<"strcpy(s1,\"plantau fistic\") --> s1: "<<s1<<

endl;
p=strchr(s1,’ ’)-s1;
cout<<"p = "<<p<<endl;
strcpy(s2,s1+p+1); cout<<"strcpy(s2,s1+p+1) --> s2: "<<s2<<endl;

strcpy(s1+p-1,s2+2); cout<<"strcpy(s1+p-1,s2+2) --> s1: "<<s1<<endl;
strcpy(s2+1,s1+2); cout<<"strcpy(s2+1,s1+2) --> s2: "<<s2<<endl;
cout<<"cout<<p<<s2; --> "<<endl;

cout<<p<<s2;
return 0;
}

Problema 1
Listing 29.1.4: 2023bac-model-III-1.cpp

#include<iostream>
int DoiTrei(int n)
{
int c; // cifra
while(n!=0)
{
c=n%10;
if((c!=2) &&(c!=3)) return 0;
n=n/10;
}
return 1;
}
int main()
{
cout<<DoiTrei(2023);
return 0;
}
Problema 2

#include<iostream>
#include<fstream>
ifstream fin("2023bac-model-III-2.txt");
int n;
int a[101][101];
int nrzone=0;
bool ok;
const int tobogan=0;

const int leagan=1;
const int balansoar=2;
const int carusel=3;
void afisa()
{
for(int i=1; i<=n; i++)
{
for(int j=1; j<=n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
}
int main()
{
fin>>n; //cout<<"n = "<<n<<endl;

fin>>a[i][j];
//afisa();

{
{
// a[i][j] ... trebuie sa fie "carusel" ...
if(a[i][j] != carusel) continue;
// verific vecinii lui a[i][j] ...

ok=true;
// ---------------------------------------
// verific sus (prima linie nu are "sus")

if((i>1) && (a[i-1][j]==tobogan))
{
ok=false;
}
if(ok==false) continue;
// ---------------------------------------
// verific jos (ultima linie nu are ""jos")

if((i<n) && (a[i+1][j]==tobogan))
{
ok=false;
}
// ---------------------------------------
// verific stanga (prima coloana nu are "stanga")

if((j>1) && (a[i][j-1]==tobogan))
{
ok=false;
}
// ---------------------------------------
// verific dreapta (ultima coloana nu are "dreapta")

if((j<n) && (a[i][j+1]==tobogan))
{
ok=false;
}
// ---------------------------------------
// aici este ok ...

nrzone++;
cout<<i<<" ";
}// for j
}// for i
if(nrzone==0) cout<<"nu exista";
return 0;
}
Problema 3

#include<iostream>
#include<fstream>
ifstream fin("2023bac-model-III-3a.txt");
//ifstream fin("2023bac-model-III-3b.txt");
int n;
int main()
{
int minXp=1000001; // caut min par zona 1
int minXi=1000001; // caut min impar zona 1
int maxYp=-1; // caut max par zona 2
int maxYi=-1; // caut max impar zona 2
int k; // indice element in sirul din fisier

int xy; // valoare element din fisier; (k<=n --> x)
// minXp > maxYi si minXi > maxYp ... --> DA
fin>>n;
//cout<<"n = "<<n; // de control citire fisier ... !!!
k=0;
while(fin>>xy)
{
k++;
if(k <= n) // zona lui x
{
if(xy%2==0) // xy=par
{
if(xy < minXp) minXp=xy;
}
else // xy=impar
{
if(xy < minXi) minXi=xy;
}
}
else // zona lui y
{
if(xy%2==0) // xy=par
{
if(xy > maxYp) maxYp=xy;
}
else // xy=impar
{
if(xy > maxYi) maxYi=xy;
}
}
}
//cout<<"minXp = "<<minXp<<" minXi = "<<minXi<<endl;

//cout<<"maxYp = "<<maxYp<<" maxYi = "<<maxYi<<endl;
if((minXi >= maxYp) && (minXp >= maxYi))

cout<<"DA";
else
cout<<"NU";
return 0;
}
Descrierea algoritmului ı̂n limbaj natural: ...

Eficienţa: este un algoritm liniar care utilizează eficient memoria (pe măsură ce se citesc
datele din fişier, se actualizează informaţiile necesare şi se foloseşte spaţiu de memorie numai
pentru câteva variabile).

29.2.1 Subiectul I
Problema 1
a. 8©2 23%3 4 2 6
b. 20©2 39%3 10 0 10
c. 23©2 66%3 11 0 11
d. 43©2 20%3 21 2 23
Problema 2
Problema 3
Problema 4
Problema 5

Problema 1
II-1a:
II-1b:
n=521, 531, 5021, 5031 –¿ rez = 34
II-1c:
Listing 29.2.1: 2023bac-s0-II-1bc.cpp

#include<iostream>
void calcul(int n)
{
cout<<"--> calcul("<<n<<")\n";
int x, cn, p, c;
x=5;
do
{
cn=n; n=0; p=1;
do
{
c=cn%10;
if(c==x) c=5-x;
// x=5-->c=0; x=4-->c=1; x=3-->c=2; x=2-->c=3; x=1-->c=4
n=c*p+n; // pune cifra in fata numarului pe care il construieste ...
cn=cn/10;
p=p*10;
} while(!(cn==0));
x=x-1; // x=5,4,3,2,1, 0-->gata !!!

} while(!(x==0));
cout<<n;
return;
}
int main()
{
calcul(5174);
return 0;
}
II-1d:
Problema 2
Problema 3
Matricea este simetrică faţă de diagonala secundară deci ... este suficient să o ”ı̂ncărcăm” pe
jumătatea din NV sau pe jumătatea din SE şi ... să copiem simetric!
Listing 29.2.2: 2023bac-s0-II-3-v1.cpp

#include<iostream>
int a[6][6];
int main()
{
int i, j;
for(i=1; i<=5; i++)

{
for(j=1; j<=5; j++)
{
if(i+j <= 6 )
{
a[i][j]=5-j;
// simetricul lui a[i][j];

a[6-j][6-i]=a[i][j];
}
cout<<a[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
Dacă nu reuşim să ”vedem” o expresie pentru niciuna din cele două jumătăţi ... merită să
ı̂ncercăm prin calcul, astfel: să sperăm că aij este o combinaţie liniară ı̂ntre indicii i şi j, adică
aij ixjyz
şi să determinăm x, y şi z.
Pentru zona NV:

~
a11 4 1x1yz 1

a23 2 2x3yz 2

a32 3 3x2yz 3

Nu avem nevoie de regula lui Cramer aici ... putem să rezolvăm sistemul cu ce ştim din
gimnaziu ... parcă se numea ”metoda substituţiei”!
Scăzând (2)-(1) obţinem: x + 2y = -2 deci x = -2y - 2 (4)
Scăzând (3)-(2) obţinem: x - y = 1 deci x = y + 1 (5)
Din (4) şi (5) obţinem y+1 = -2y-2 de unde rezultă 3y = -3 adică y = -1 (6)
Înlocuind (6) ı̂n (5) obţinem x = -1 + 1 = 0 adică x = 0 (7)
În sfârşit ... ı̂nlocuind (6) şi (7) ı̂n (1) obţinem: 4 = 0 - 1 + z, adică z = 5 (8)
În concluzie ... pe zona de NV avem a[i][j] = 5 - j.
Pentru zona SE:
~
a35 2 3x5yz 1

a44 3 4x4yz 2

a53 4 5x3yz 3

Scăzând (2)-(1) obţinem: x - y = 1 deci x = y + 1 (4)
Scăzând (3)-(2) obţinem: x - y = 1 deci x = y + 1 (5) ... aceeaşi relaţie !!!
Din (4) şi (5) obţinem y + 1 = y + 1 deci ... nicio informaţie ı̂n plus! (6)
Înlocuind (6) sau (5) ı̂n sistemul iniţial (o speranţă deşartă!) obţinem:
~ ¬

a35 2 3 y 1 5 y z 1

¬

a44 3 4 y 1 4 y z 2

¬
a53 4 5 y 1 3 y z 3

şi calcuând ... obţinem:
~ ¬

a35 2 38yz 1

¬

a44 3 48yz 2

¬
a53 4 58yz 3

de unde rezultă: z+8y = -1 ... deci z=-1-8y (7) adică, altfel spus, sistemul este ”nedeterminat”!
Alegerea celor trei poziţii din zona SE a fost un pic cam nereuşită! Se pare că nu este prea
bine să le alegem pe diagonală! Încercăm alte trei poziţii!
~
a25 1 2x5yz 1

a35 2 3x5yz 2

a53 4 5x3yz 3

Scăzând (2)-(1) obţinem: x + 0 = 1 deci x = 1 (4)
Scăzând (3)-(2) obţinem: 2x - 2y = 2 deci x-y = 1 şi cum x=1 rezultă y=0 (5)
Înlocuind (4) şi (5) ı̂n (1) obţinem 1 = 2*1 + 5*0 + z adică z = -1 (6)
Acum am avut mai mult noroc!
În concluzie ... pe zona de SE avem a[i][j] = i - 1.

#include<iostream>

int a[6][6];
int main()
{
int i, j;
for(i=1; i<=5; i++)
{
for(j=1; j<=5; j++)
{
if(i+j <= 6 ) a[i][j]=5-j; else a[i][j]=i-1;
cout<<a[i][j]<<" ";
}
cout<<endl;
}
return 0;
}

Problema 1
Listing 29.2.4: 2023bac-s0-III-1.cpp

#include<iostream>
void NrImp(int x, int y, int & nr)

{
// 3 divizori --> 2 divizori (1 este divizor impar pentru orice numar)
nr=0;
int nrdivk; // nr divizorilor lui k

int d; // divizor
for(int k=x; k<=y; k++) // k = 9, 18, 25, 36, 49, 50 ... !!!
{
// k are numai 3 divizori impari?
if(k%2==1)
{
nrdivk=2; // sigur 1 si k sunt divizori impari
}
else
{
nrdivk=1; // sigur 1 este divizor impar si k nu este
}
d=3; // divizor de incercat
while(d*2<=k)
{
if(k%d==0) nrdivk++;
if(nrdivk>3) break;
d=d+2;
}
if(nrdivk==3)
{
nr++;
cout<<nr<<" : "<<k<<endl;
}
}// for k
return;
}
int main()
{
int nrmain;
NrImp(4,50,nrmain);
cout<<"\nnrmain = "<<nrmain<<endl;
return 0;
}
/*
[4,50]
9: 1, 3, 9
18: 1, 3, 9 impari numai !!!
25: 1, 5, 25
36: 1, 3, 9 impari numai
49: 1, 7, 49
50: 1, 5, 25 impari numai
*/
Problema 2

#include<iostream>
#include<cstring>
char text[101];
char sol[101]="";
char cuvant[100];
int ntext; // lungime text

int ncuvant; // lungime cuvant
char familia[]="FAMILIA";
char genul[]="GENUL";
char specia[]="SPECIA";
void calcul(char a[])

{
if(a[0]==familia[0])
{
strcat(sol,"fam."); strcat(sol," ");
}
else
if(a[0]==genul[0])
{
strcat(sol,"gen."); strcat(sol," ");
}
else // ca sa fie vizibil ... !!!
if(a[0]==specia[0])
{
strcat(sol,"spe."); strcat(sol," ");
}
return;
}// calcul()
int main()
{
char * pch; // pointer la char
cin.get(text,100); // numai primul cuvant ... spatiu = separator
//ntext=strlen(text); // lg sir caractere ... nu dim vector ... !!!

//cout<<text<<" --> "<<ntext<<endl;
pch = strtok(text," "); // prima citire
while (pch != NULL)

{
strcpy(cuvant,pch);
ncuvant=strlen(cuvant); // lg sir caractere ... nu dim vector ... !!!
if(cuvant[ncuvant-1]==’.’) calcul(cuvant);
else
{
strcat(sol,cuvant); strcat(sol," ");
}
//cout<<"sol = "<<sol<<endl; getchar();

pch = strtok (NULL, " ");
}
sol[strlen(sol)-1]=’\0’;
//cout<<"sol = \n"<<sol<<endl;
cout<<sol;
return 0;
}
Problema 3

#include<iostream>
#include<fstream>
ifstream fin("bac.txt");
int pas;
int valc; // valoarea curenta

int vala; // valoarea anterioara
int valmaxc; // valoarea maximacurenta
int main()
{
fin>>valc;
pas=1;
valmaxc=valc;
vala=valc;
cout<<pas<<" ";
while(fin>>valc)
{
pas++;
if(valc > valmaxc)

{
cout<<pas<<" ";
valmaxc=valc;
}
else
if(valc==valmaxc)
{
if(vala != valc)
{
cout<<pas<<" ";
valmaxc=valc;
}
}
vala=valc;
}
return 0;
}


29.3.1 Subiectul I
Problema 1
Problema 2
Listing 29.3.1: 2023bac-s1-I-2rd.cpp

#include<iostream>
int f(int n, int k)

{
if(n==0 || k==0) return 0;
return n%k+10*f(n/k,k);
}
int main()
{
cout<<f(35,3);
return 0;
}
/*
1022
*/
Problema 3
Problema 4
Problema 5

Problema 1
Listing 29.3.2: 2023bac-s1-II-1crd.cpp

#include<iostream>
int main()
{
int n,i,j;
cin>>n;
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
if(j <= i) cout<<"2";
else cout<<"3";
}
}
return 0;
}
Listing 29.3.3: 2023bac-s1-II-1drd.cpp

#include<iostream>
int main()
{
int n,i,j;
cin>>n;
i=1;
while(i<=n)
//for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
if(j <= i) cout<<"2";
else cout<<"3";
}// for j
i=i+1;
}// for i
return 0;
}
Problema 2
Problema 3
Listing 29.3.4: 2023bac-s1-II-3rd.cpp

#include<iostream>
#include<cstring>
int main()
{
int k;
char s[25]="elemente";
for(k=strlen(s)-1; k>=0; k--)

{
if(s[k]==s[0])
{
s[k+1]=’\0’;
cout<<s<<" ";
}
}// for i
return 0;
}

Problema 1

#include<iostream>
void Putere(int n, int & x, int & p)

{
//cout<<"n = "<<n<<endl;
long long xp; // xp=xˆp
// n=xˆp x=minim
for(x=2; x<=n; x++)
{
xp=1LL*x;
for(p=1; xp<n; p++)
{
//cout<<x<<"ˆ"<<p<<" = "<<xp<<endl;
//getchar();
xp=xp*x;
}
if(xp==n) return;
}
return;
}
int main()
{
int n, x, p;
//cin>>n;// n=16
n=16;
Putere(n,x,p);
cout<<n<<" = "<<x<<"ˆ"<<p<<endl<<endl;
//cin>>n; // n=216
n=216;
Putere(n,x,p);
//cin>>n; // n=12
n=12;
Putere(n,x,p);
return 0;
}
Problema 2

#include<iostream>
#include<cstring>
#include<iomanip>
int a[21][21];
int n;
void afisa()
{
cout<<"--> afisa()"<<endl;
{
{
cout<<setw(3)<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
//getchar();
}
void calcul()
{
cout<<"--> calcul()"<<endl;
// sub diagonnala secundara

for(int i=2; i<=n; i++) // pe diagonala secundara i+j=n+1
{
for(int j=n+1-i+1; j<=n;j++)
{
a[i][j]=-1;
}
}
afisa();
// deasupra diagonnalei secundare (inclusiv ea)

for(int i=2; i<=n; i++) // pe diagonala secundara i+j=n+1
{
for(int j=1; j <= n+1-i;j++)
{
a[i][j]=(a[i-1][j]+a[i-1][j+1])%100;
}
}
afisa();
}// calcul()
int main()
{
cin>>n; // 5 90 10 4 27 30
cout<<"n = "<<n<<endl;

{
cin>>a[1][j]; // 5 90 10 4 27 30
cout<<a[1][j]<<" ";
}
cout<<endl<<endl;
calcul();
return 0;
}
/*
intrare: 5 90 10 4 27 30
iesire:
--> calcul()
--> afisa()
90 10 4 27 30
0 0 0 0 -1
0 0 0 -1 -1
0 0 -1 -1 -1
0 -1 -1 -1 -1
--> afisa()
90 10 4 27 30
0 14 31 57 -1
14 45 88 -1 -1
59 33 -1 -1 -1
92 -1 -1 -1 -1
Process returned 0 (0x0) execution time : 8.254 s

Press any key to continue.
*/
Problema 3

#include<iostream>
#include<fstream>
#include<iomanip>
ifstream fin("bac0.txt");
//ifstream fin("bac1.txt");
//ifstream fin("bac2.txt");
int pas;
int valminc; // valoarea minimacurenta

int valmaxc; // valoarea maximacurenta
int pmin=0; // >=2

int pmax=0; // >=pmin
int main()
{
fin>>valc;
pas=1;
valmaxc=valc;
valminc=valc;
cout<<" "<<setw(3)<<pas<<": "<<setw(3)<<valc

<<" valminc = "<<setw(3)<<valminc
<<" valmaxc = "<<setw(3)<<valmaxc
<<endl;
CAPITOLUL 29. BAC 2023 29.4. SESIUNEA IUNIE-IULIE 246
while(fin>>valc)
{
pas++;
if(valc < valminc) // s-a schimbat min?

{
valminc=valc;
cout<<" * ";
}
else
if(valc > valmaxc) // s-a schimbat max?
{
valmaxc=valc;
cout<<" ** ";
}
else // nu s-a schimbat nimic; apare noul p
{
cout<<" ";
if(pmin==0)
pmin=pas, pmax=pas;
else
pmax=pas;
}
cout<<setw(3)<<pas<<": "<<setw(3)<<valc
<<" valminc = "<<setw(3)<<valminc
<<" valmaxc = "<<setw(3)<<valmaxc
<<endl;
}
if(pmin==0)
cout<<"nu exista"<<endl;
else
cout<<pmin<<" "<<pmax<<endl;
return 0;
}
/*
1: 2 valminc = 2 valmaxc = 2
** 2: 7 valminc = 2 valmaxc = 7
* 3: 1 valminc = 1 valmaxc = 7
* 8: -3 valminc = -3 valmaxc = 10
9: -2 valminc = -3 valmaxc = 10
** 10: 13 valminc = -3 valmaxc = 13
Process returned 0 (0x0) execution time : 0.044 s

*/
29.4 Sesiunea iunie-iulie

29.4.1 Subiectul I
Problema 1
Problema 2

#include<iostream>
void f(int n)
{
if(n != 0) f(n/2);
cout<< n%2;
}
int main()
{
f(23);
return 0;
}
/*
010111
*/
Problema 3
Problema 4
Problema 5

Problema 1

#include<iostream>
int main()
{
int x, p, m, c;
cin>>x; // 6907512, 987, 210

p=1;
m=-1;
while(p <= x)
{
c=(x/p)%10;
cout<<"x = "<<x<<" p = "<<p<<" c = "<<c<<endl;
if(c>m)
{
m=c;
p=p*10;
}
else
{
x=(x/(p*10))*p + x%10;
} // sf if
} // sf while
if(m >= 0)
{
cout<<x;
}
else
{
cout<<"nul";
}// sf if
return 0;
}
/*
6907512
x = 6907512 p = 1 c = 2
x = 6907512 p = 10 c = 1
x = 690752 p = 10 c = 5
x = 690752 p = 100 c = 7
x = 690752 p = 1000 c = 0
x = 69002 p = 1000 c = 9
x = 69002 p = 10000 c = 6
2
*/
/*
987
x = 987 p = 1 c = 7
x = 987 p = 10 c = 8
x = 987 p = 100 c = 9
987
*/
/*
210
x = 210 p = 1 c = 0
x = 210 p = 10 c = 1
x = 210 p = 100 c = 2
210
*/
Problema 2
Problema 3

#include<iostream>
#include<cstring>
struct substructura
{
int nrFire;
int pretFir;
};
struct lalea
{
char denumire[20];
substructura stoc;
};
int main()
{
lalea f[10];
strcpy(f[0].denumire,"nume lalea");
f[0].stoc.nrFire=3;
f[0].stoc.pretFir=7;
cout<<"pret = "
<<"f[0].stoc.nrFire*f[0].stoc.pretFir = "
<<f[0].stoc.nrFire<<" * "<<f[0].stoc.pretFir
<<" = "<<f[0].stoc.nrFire*f[0].stoc.pretFir<<endl;
return 0;
}

Problema 1

#include<iostream>
#include<iomanip>
int abundent(int n)
{
long long Sk; // suma divizorilor lui k
double rapSk; // Sk/k

double maxrapSk=1.0; // max Sk
for(int k=2; k<=n; k++)

{
Sk=1LL;
for(int d=2; d<=k; d++)
{
if(k%d == 0) Sk=Sk+d;
}
rapSk=1.0*Sk/k;
cout<<"S("<<k<<") = "<<Sk<<" rapSk = "<<rapSk<<endl;
if(rapSk > maxrapSk) maxrapSk=rapSk;

}
cout<<"maxrapSk = "<<maxrapSk<<" rapSk = "<<rapSk<<endl;
if(rapSk < maxrapSk) return 0;

else return 1;
}
int main()
{
int n;
cin>>n;
cout<<abundent(n)<<endl;
return 0;
}
/*
6
S(2) = 3 rapSk = 1.5
S(3) = 4 rapSk = 1.33333
S(4) = 7 rapSk = 1.75
S(5) = 6 rapSk = 1.2
S(6) = 12 rapSk = 2
maxrapSk = 2 rapSk = 2
1
*/
Problema 2

#include<iostream>
#include<fstream>
ifstream fin("2023bac-s2-III-2.txt");// pentru testare !!!
int ns, np;

int a[1001][1001];
void afisa()
{
for(int i=1; i<=ns; i++)
{
for(int j=1; j<=np; j++) cout<<a[i][j]<<" ";
cout<<endl;
}
cout<<endl;
return;
}
int main()
{
int jmax, valjmax;
fin>>ns>>np;
cout<<"ns = "<<ns<<" np = "<<np<<endl;

for(int j=1; j<=np; j++) fin>>a[i][j];
afisa();

{
jmax=1;
valjmax=a[i][1];
for(int j=2; j<=np; j++)
{
if(a[i][j] > valjmax)
{
valjmax=a[i][j];
jmax=j;
}
}
cout<<i<<":"<<jmax<<" ";
}
cout<<endl;
return 0;
}
Problema 3

#include<iostream>
#include<fstream>
ifstream fin("2023bac-s2-III-3.txt");
// nr de 2,3,4 cifre
int frp[101]; // frecventa prefixelor

int frs[101]; // frecventa sufijelor
int prefix;
int sufix;
//int pas;
int raspuns=0;
int main()
{
//pas=0;
while(fin>>valc)
{
//pas++;
//cout<<pas<<": "<<valc<<endl;
if(valc < 99) continue; // numai nr de 3, 4 cifre conteaza !
sufix=valc%100;
if(valc > 999) // are 4 cifre?

{
prefix=valc/100;
}
else // aici are 3 cifre
{
prefix=valc/10;
}
frp[prefix]++;
frs[sufix]++;
}
for(int i=10; i<=99; i++)

{
if(frp[i]*frs[i] != 0) // niciunul nu este zero!
if(frp[i]==frs[i]) raspuns++;
}
cout<<raspuns<<endl;
return 0;
}

29.5.1 Subiectul I
Problema 1
Problema 2

#include<iostream>
int f(int x, int y)

{
int z;
if(y==0) return 1;
z=f(x,y/2);
if(y%2 != 0) return z*z*x;
return z*z;
}
int main()
{
cout<<f(3,2);
return 0;
}
/*
9
*/
Problema 3
Problema 4
Problema 5

Problema 1

#include<iostream>
#include<cstring>
int main()
{
int n, x, a, b, c, p;
cin>>n;
x=0;
while(n>0)
{
cin>>a>>b;
c=a; // copie a lui a

p=1;
while(a>9)
{
a=a/10;
p=p*10;
} // sf while
a=a*p+b;
if(a != c)
{
x=x+1;
} // sf if
cout<<"n = "<<n
<<"a = "<<a<<" b = "<<b
<<" c = "<<c<<" p = "<<p
<<" x = "<<x<<endl;
n=n-1;
} // sf while
cout<<x<<endl;
return 0;
}
//*
3 746 82 3067 67 78 178
n = 3 a = 782 b = 82 c = 746 p = 100 x = 1
n = 2 a = 3067 b = 67 c = 3067 p = 1000 x = 1
n = 1 a = 248 b = 178 c = 78 p = 10 x = 2
2
*/
Problema 2
Problema 3

#include<iostream>
#include<cstring>
struct produs
{
char denumire[20];
int pret;
} p;
char a;
int main()
{
strcpy(p.denumire,"Masina de tocat");
p.pret=101;
cout<<p.denumire<<" "<<p.pret<<endl;
if(p.pret < 100)

a=p.denumire[0];
else
a=’*’;
cout<<"a = "<<a<<endl<<endl;
p.pret=97;
cout<<p.denumire<<" "<<p.pret<<endl;
if(p.pret < 100)

a=p.denumire[0];
else
a=’*’;
cout<<"a = "<<a<<endl<<endl;
return 0;
}

Problema 1

#include<iostream>
#include<iomanip>
void DNPI(int n)
{
bool esteprim;
cout<<1<<" "; // este primul !
for(int i=9; i<=n/2; i=i+2) // verific daca i este divizor ok

{
if(n%i != 0) continue; // i nu este divizor !
//aici i este divizor
esteprim=true;
for(int d=3; d*d<=i; d=d+2)

{
if(i%d == 0)
{
esteprim=false;
}
if(esteprim==false) break;
}// sf for d
if(esteprim==true)
{
//cout<<i<<" este prim!"<<endl;
}
else // nu este prim
{
cout<<i<<" ";
}
}// sf for i
return;
}
int main()
{
int n; // 90
cin>>n;
DNPI(n);
return 0;
}
Problema 2

#include<iostream>
#include<fstream>
#include<iomanip>
ifstream fin("2023bac-s3-III-2.txt");// pentru testare acasa !!!
int m, n; // linii, coloane
int a[21][21];
int s, smax;
void afisa()
{
for(int i=1; i<=m; i++)
{
{
cout<<setw(3)<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
return;
}
int main()
{
int jmax, valjmax;
fin>>m>>n;
//cout<<"m = "<<m<<" n = "<<n<<endl;

{
{
fin>>a[i][j];
}
}
//afisa();
smax=0;
for(int i=1; i<=m-1; i++)

{
jmax=1;
valjmax=a[i][1];
for(int j=1; j<=n-1; j++)

{
s=a[i][j]+a[i][j+1]+a[i+1][j]+a[i+1][j+1];
if(s>smax) smax=s;
}
}
cout<<smax<<endl;
return 0;
}
Problema 3

#include<iostream>
#include<fstream>
int m, n;
int valc; // valoarea citita/curenta
int valmin;
int rezultat=0; // era initializat automat oricum!
int fra[100]; // frecventa in sirul a

int frb[100]; // frecventa in sirul b
int main()
{
fin>>m>>n;
//cout<<"m = "<<m<<" n = "<<n<<endl;

{
fin>>valc;
fra[valc]++;
}

{
fin>>valc;
frb[valc]++;
}
for(int i=0; i<=99; i++)

{
valmin=fra[i];
if(frb[i] < valmin) valmin=frb[i];
rezultat=rezultat+valmin;
}
cout<<rezultat<<endl;
return 0;
}
Capitolul 30
BAC 2022

30.1.1 Subiectul I
Problema 1
x " , 3 30,
Expresia din enunţ x<=3 || x>30 <
a. !(x<3) && x<30 x>=3 && x<30 x " 3, 30

b. !(x>=3 && x<=30) x $ 3 ¶ ¶ x % 30 x " , 3 < 30,
c. !(x<3 || x<=30) x>=3 && x>30 x " 30,
d. !(x>3) || !(x<=30) x <= 3 || x > 30 x " , 3 < 30, ,

deci răspunsul corect este d.
Problema 2
Figura 30.1: 2022bac-s0-I-2
Listing 30.1.1: 2021bac-s1-I-2.cpp

#include<iostream>
int f(int st, int dr, int v[])

{
//cout<<"--> f("<<st<<","<<dr<<",v)\n";
if(st==dr)
{
if(v[st]==st)
261
{
//cout<<"<-- f("<<st<<","<<dr<<",v) "<<1<<"\n\n";
return 1;
}
else
{
//cout<<"<-- f("<<st<<","<<dr<<",v) "<<0<<"\n\n";
return 0;
}
}
else
{
int rez1=f(st, (st+dr)/2,v);
int rez2=f(1+(st+dr)/2,dr,v);
int rez12=rez1+rez2;
//cout<<"<-- f("<<st<<","<<dr<<",v) "<<rez12<<"\n\n";
return rez12;
}
}
int main()
{
int x[]={7, 1, 2, 5, 4};
int rez=f(0,4,x);
cout<<"rez = "<<rez;
return 0;
}
Problema 3
Din restricţiile problemei rezultă că avem de-a face cu ”un contor” cu patru poziţii:
lider: valori permise: 1, 3, 6
secund: valori permise: 1, 2, 6
vice-skip valori permise: 4, 5
skip: valori permise: 4, 5
Figura 30.2: 2022bac-s0-I-3-rd
Pe ultimele două poziţii pot fi numai Razvan şi Stefan (codificaţi 4 şi 5). Din primele şase
exemple date deducem că, pe ultima poziţie, după Razvan urmează Stefan deci ... soluţia are
pe ultima poziţie ”Stefan”; astfel, avem de ales ı̂ntre a. şi c.
Trebuie să determinăm ce se află pe primele două poziţii (este un ”contor” cu două poziţii
numai!) Pe prima poziţie: după 1 urmează 2, după 2 urmează 6, după 6 urmează 1. Pe a doua
poziţie: după 1 urmează 3, după 3 urmează 6, după 6 urmează 1. Să lăsăm ”rotiţele”’ contorului
să se ı̂nvârtă şi ... să fim atenţi la ”ce urmează după 3 6.
Problema 4
Accesul la elementele unei structuri se face ”din exterior către interior”, aşa că ... variantele ı̂n
care apar sublinieri cu culoarea roşie sunt ... greşite!
Problema 5
”Subgraf” ı̂nseamnă că putem elimina noduri (cu toate muchiile lor!). Asta ı̂nseamnă că ... rămâne
tot un graf complet.

Problema 1
II-1a:
Figura 30.5: 2022bac-s0-II-1a-rd
Procedeul şterge câte o cifră din y, de la dreapta spre stânga, pı̂nă ajunge la o cifră cu aceeaşi
paritate ca a lui x (sau până la y=0, dacă o astfel de cifră nu există ı̂n y). Dacă ce a rămas coincide
cu x, contorizează acel număr y (deci x trebuie să fie prefix pentru y şi cifrele care urmează să fie
pare/impare dacă x este impar/par.
Listing 30.1.2: 2022bac-s0-II-1a.cpp

#include<iostream>
int main()
{
int n, x;
int nr, i, y;
cin>>n; cin>>x;
nr=0; i=1;
while(i<=n)
{
cin>>y;
while(y != 0 && y%2 != x%2)
y=y/10;
if(y==x) nr=nr+1;
i=i+1;
}
cout<<nr;
return 0;
}
/*
intrare: 6 16 4273 1679 3165 16 200 167
iesire: 3
*/
II-1b:
Dacă primele două numere sunt, ı̂n această ordine, 2 şi 22: urmează două numere.
Dacă ı̂n urma executării algoritmului se afişează 2: ambele numere citite au prefix 22 şi sunt
urmate de cifre impare.
În intervalul [1000, 10000] astfel de numere sunt: 2211, 2213, 2215, 2217, 2219, 2231, 2233,
2235, ..., 2299.
Listing 30.1.3: 2022bac-s0-II-1-b.cpp

#include<iostream>
int main()
{
int n, x;
int nr, i, y;
cin>>n; cin>>x;
nr=0;
i=1;
while(i<=n)
{
cin>>y;
while(y != 0 && y%2 != x%2)
{
y=y/10;
}
if(y==x) nr=nr+1;
i=i+1;
}
cout<<nr;
return 0;
}
/*
2 22 2213 2257
*/
II-1c: Este deja scris!

II-1d:
Figura 30.6: 2022bac-s0-II-1c-rd
Listing 30.1.4: 2022bac-s0-II-1-d.cpp

#include<iostream>
int main()
{
int n;
int x;
int nr;
int i;
int y;
cin>>n;
cin>>x;
nr=0;
//i=1; // initializarea
//while(i<=n) // testarea
for(i=1; i<=n; i++)
{
cin>>y;
while(y != 0 && y%2 != x%2)
{
y=y/10;
}
if(y==x) nr=nr+1;
//i=i+1; // incrementarea
}
cout<<nr;
return 0;
}
/*
6 16 4273 1679 3165 16 200 167
*/
Problema 2
tata[5]=0 deci nodul 5 este rădăcina arborelui.
Fii nodului 5 sunt cei pentru care tata[?]=5. Aceştia sunt 2, 3, 9 şi ı̂i aşezăm pe nivelul 1.
Mai departe ...
Figura 30.7: 2022bac-s0-II-2-rd
Problema 3
a[i][j] este notaţia folosită pentru elementele matricei.
Pentru a avea elemente ”sus” şi ”jos” (la N şi la S) ... i=0;
Pentru a avea elemente ”la stânga” şi ”la dreapta” (la V şi la E) ... j=1,...13;
Pentru a verifica dacă ı̂n cele 4 poziţii N, V, S, E sunt ”valori egale” ... alegem o poziţie (de
exemplu N) şi verificăm dacă valoarea din fiecare poziţie rămasă (V, S, E) este egaă cu valoarea
din poziţia aleasă (N).

Problema 1

#include<iostream>
#include<fstream>
#include<cstring>
void rest(int x, int y, int n, int & k)

{
k=0;
for(int i=n; i>=1; i--)
{
if(i%x==2 && i%y==2)
{
k=i;
break;
}
}
int main()
{
int x=10;
int y=101;
int n=3000;
int rez;
rest(x,y,n,rez);
cout<<"rez = "<<rez;
return 0;
}
Problema 2

#include<iostream>
#include<fstream>
#include<cstring>
char text[251];
char prenume[250];
char nume[250];
char x[250];
char * pch;
int main()
{
cin.get(text,250);
cin.get(); // citeste <Enter>
cin>>x;
//cout<<"text = "<<text<<"\n";
//cout<<"x = "<<x<<"\n\n";
pch=strtok(text," ");
while(pch != NULL)
{
strcpy(prenume,pch);
//cout<<"prenume = "<<prenume<<" "<<strlen(prenume)<<"\n";
pch=strtok(NULL,";");
strcpy(nume,pch);
//cout<<"nume = "<<nume<<" "<<strlen(nume)<<"\n\n";
if(strcmp(prenume,x)==0)
{
//cout<<nume<<" ***\n";
cout<<nume<<" ";
}
pch=strtok(NULL," ");
}
return 0;
}
/*
DAN MARIS; DANILA PREPELEAC; DAN POPA; EDANA DAN;
DAN
text = DAN MARIS; DANILA PREPELEAC; DAN POPA; EDANA DAN;
x = DAN
prenume = DAN 3
nume = MARIS 5
MARIS ***
prenume = DANILA 6
nume = PREPELEAC 9
prenume = DAN 3
nume = POPA 4
POPA ***
prenume = EDANA 5
nume = DAN 3
*/
Problema 3
Numărul 3-urilor din R2 (primul nivel din figură!) este n/3 (”culege” câte un 3 din 3, 6, 9, 12, 15,
18, 21, 24, 27, 30, ...).
Numărul 3-urilor din R3 (al doilea nivel din figură!) este n/9 (”culege” câte un 3 din 9, 18,
27, ...).
Numărul 3-urilor din R4 (nu apare ı̂n figură!) este n/27 (”culege” câte un 3 din 27*1, 27*2,
...).
La fel pentru 5.
45 conţine doi de 3 şi un 5. Dacă ştim câţi de 3 şi câţi de 5 avem la dispoziţie ... este uşor de
calculat câţi de 45 putem construi!
Figura 30.9: 2022bac-s0-III-3-rd
Trebuie să fim atenţi la faptul că factorialul dă nişte numere foarte mari care nu ”ı̂ncap” ı̂n
int sau long long.
Listing 30.1.7: 2022bac-s0-III-3-v0.cpp

#include<iostream>
#include<fstream>
#include<cstring>
#include<iomanip>
#include <climits>
ofstream fout("bac.txt");
int main()
{
int n;
int nf; // n!
int i;
int p, p45; // p45=45ˆp
long long nfLL; // n! long long
cin>>n;
cout<<"n = "<<n<<"\n";
nf=1;
nfLL=1LL;
for(i=2; i<=n; i++)
{
nf=nf*i;
nfLL=nfLL*i;
cout<<setw(2)<<i<<"! : "<<setw(12)<<nf<<setw(22)<<nfLL<<"\n";
}
cout<<"\n";
cout<<"sizeof(int) = "<<sizeof(int)<<"\n";
cout<<"INT_MIN = "<<INT_MIN<<"\n";
cout<<"INT_MAX = "<<INT_MAX<<"\n\n";
cout<<"sizeof(long) = "<<sizeof(long)<<"\n";
cout<<"LONG_MIN = "<<LONG_MIN<<"\n";
cout<<"LONG_MAX = "<<LONG_MAX<<"\n\n";
cout<<"sizeof(long long) = "<<sizeof(long long)<<"\n";

cout<<"LLONG_MIN = "<<LLONG_MIN<<"\n";
cout<<"LLONG_MAX = "<<LLONG_MAX<<"\n";
return 0;
}
/*
21
n = 21
2! : 2 2
3! : 6 6
4! : 24 24
5! : 120 120
6! : 720 720
7! : 5040 5040
8! : 40320 40320
9! : 362880 362880
10! : 3628800 3628800
11! : 39916800 39916800
12! : 479001600 479001600
13! : 1932053504 6227020800
14! : 1278945280 87178291200
15! : 2004310016 1307674368000
16! : 2004189184 20922789888000
17! : -288522240 355687428096000
18! : -898433024 6402373705728000
19! : 109641728 121645100408832000
20! : -2102132736 2432902008176640000
21! : -1195114496 -4249290049419214848
sizeof(int) = 4
INT_MIN = -2147483648
INT_MAX = 2147483647
sizeof(long) = 4
LONG_MIN = -2147483648
LONG_MAX = 2147483647
sizeof(long long) = 8
LLONG_MIN = -9223372036854775808
LLONG_MAX = 9223372036854775807
*/
De ce 17!, pe int, iese negativ?

De ce 21!, pe long long, iese negativ?
De ce 13! = 1,932,053,504 iar 14! = 1,278,945,280 care are o valoare mai mică deşi 14! = 13! *14?
Pentru că ı̂n stânga, pe bitul de semn, ”pică” 1.
29
Şi pentru că se depăşeste capacitatea de ı̂nregistrare!
#include<iostream>
#include<fstream>
#include<cstring>
int main()
{
int n;
int i;
29
https://en.wikipedia.org/wiki/Integer_(computer_science)
int p;
int p45; // p45=45ˆp
long long nfLL; // n! "n factorial long long"
//cin>>n;
n=14;
cout<<"n = "<<n<<"\n";
nfLL=1LL;
for(i=2; i<=n; i++)
{
nfLL=nfLL*i;
}
cout<<"nfLL = "<<nfLL<<"\n";
p=0;
p45=1;
while(nfLL%p45==0)
{
cout<<"p = "<<p<<" 45ˆp = "<<p45<<" nfLL % p45 = "<<(nfLL % p45)<<"\n";
p++;
p45=p45*45;
}
cout<<"\np = "<<p<<" 45ˆp = "<<p45<<" nfLL % p45 = "<<(nfLL % p45)<<"\n";
fout<<(p-1);
return 0;
}
/*
n = 14
nfLL = 87178291200
p = 0 45ˆp = 1 nfLL%p45 = 0
p = 1 45ˆp = 45 nfLL%p45 = 0
p = 2 45ˆp = 2025 nfLL%p45 = 0
p = 3 45ˆp = 91125 nfLL%p45 = 6075
*/

#include<iostream> // determina cati 3 si cati 5 sunt in i = 1, ..., n
#include<fstream>
#include<cstring>
#include<iomanip>
#include <climits>
int main()
{
int n;
int i;
int ii; // copie de lucru a lui i
int nr3=0;
int nr5=0; // sigur nr5 <= nr3 ...
int p;
//cin>>n;
n=14;
cout<<"n = "<<n<<"\n";
for(i=3; i<=n; i++)

{
cout<<i<<" : ";
ii=i;
while(ii%3==0)
{
nr3++;
ii=ii/3;
cout<<"3 ";
}
while(ii%5==0)
{
nr5++;
ii=ii/5;
cout<<"5 ";
}
cout<<"\n";
}
cout<<"nr3 = "<<nr3<<"\n";
cout<<"nr5 = "<<nr5<<"\n";
p=nr5;
while(p > 2*nr3) p--;
cout<<"p = "<<p;
fout<<p;
fout.close();
return 0;
}
/*
n = 14
3 : 3
4 :
5 : 5
6 : 3
7 :
8 :
9 : 3 3
10 : 5
11 :
12 : 3
13 :
14 :
nr3 = 5
nr5 = 2
p = 2
*/

#include<iostream> // calcul direct pentru nr3 si nr5
#include<fstream>
#include<cstring>
int main()
{
int n;
int i;
int ii; // copie de lucru a lui i
int nr3; // numarul 3-urilor care apar in n!

int nr5; // numarul 5-urilor care apar in n! ... sigur nr5 <= nr3 ...
int p3; // vp3 = 3ˆp3 <= n si este cel mai mare

int p5; // vp5 = 5ˆp5 <= n si este cel mai mare
int vp3;
int vp5;
int p; // raspunsul
//cin>>n;
n=14;
cout<<"n = "<<n<<"\n";
p3=0;
vp3=1;
while(vp3*3 <= n)
{
p3++;
vp3=vp3*3;
}
p5=0;
vp5=1;
while(vp5*5 <= n)
{
p5++;
vp5=vp5*5;
}
cout<<"p3 = "<<p3<<"\n";
cout<<"p5 = "<<p5<<"\n";
nr3=0;
vp3=3;
for(int k=1; k<=p3; k++) // 3, 3*3, 3*3*3, ...
{
nr3=nr3+(n/vp3);
vp3=vp3*3;
}
nr5=0;
vp5=5;
for(int k=1; k<=p3; k++) // 5, 5*5, 5*5*5, ...
{
nr5=nr5+(n/vp5);
vp5=vp5*5;
}
cout<<"nr3 = "<<nr3<<"\n";
cout<<"nr5 = "<<nr5<<"\n";
p=nr5;
while(p > 2*nr3) p--;
cout<<"p = "<<p;
fout<<p;
fout.close();
return 0;
}
/*
n = 14
p3 = 2
p5 = 1
nr3 = 5
nr5 = 2
p = 2
*/


Varianta 4
Filieră teoretică, profil real, specializare matematic-informatic ...
30.2.1 Subiectul I
(20 de puncte)
Problema 1
a. 4044/4/2 = 1011/2 = 505
b. 4044/(4*2) = 4044/8 = 505
c. 1011*1+1 = 1011+1 = 1012
d. 1011*(1+1) = 1011*2 = 2022
Problema 2
f(n,p) = f(x,3) = f(120234,3) = f(12023,2) int f(int n,int p)
= f(1202,1) = f(120,0) = 1200+2 = 1202 { if(n==0) return 0;
f(n,p) = f(x,3) = f(122023,3) = f(12202,2) else if(p==0) return n*10+2;
= f(1220,1) = f(122,0) = 1220+2 = 1222 else return f(n/10,p-1);
}
f(n,p) = f(x,3) = f(202345,3) = f(20234,2)
= f(2023,1) = f(202,0) = 2020+2 = 2022
Nu are rost să calculăm mai departe!

#include<iostream>
int f(int n,int p)

{
if(n==0) return 0;
else if(p==0) return n*10+2;
else return f(n/10,p-1);
}
int main()
{
int xa=120234;
int xb=122023;
int xc=202345;
int xd=220223;
cout<<"f("<<xa<<",3) = "<<f(xa,3)<<"\n";
cout<<"f("<<xb<<",3) = "<<f(xb,3)<<"\n";
cout<<"f("<<xc<<",3) = "<<f(xc,3)<<"\n";
cout<<"f("<<xd<<",3) = "<<f(xd,3)<<"\n";
return 0;
}
/*
f(120234,3) = 1202
f(122023,3) = 1222
f(202345,3) = 2022
f(220223,3) = 2202
*/
Problema 3
Este mai bine să lucrăm cu cifrele 1, 2, 3, 4, şi 5.
1: pentru Dokker (negru)

2: pentru Duster (negru)
3: pentru Lodgy (gri)
4: pentru Logan (alb)
5: pentru Sandero (rou)
Figura 30.10: 2022bac-s1-I-3
Când contează ordinea obiectelor, ne gândim la generarea aranjamentelor! Practic aici

este vorba despre generarea aranjamentelor de 5 luate câte 3, dar cu unele restricţii (notate cu R):
R1: 1 şi 2 nu pot fi ı̂mpreună
R2: 5 nu poate fi pe primul loc
R3: 4 nu poate fi ı̂naintea lui 1 şi nici ı̂naintea lui 2
Dacă am stabilit cifra de pe prima poziţie vom obţine 12 variante aşa că ı̂n total vom avea
3
12*5 = 60 variante. Este ok pentru că A5 5 4 3 60.
Un număr cu fix trei cifre este cu atât mai mare cu cât primele cifre sunt mai mari, deci 543
este cel mai mare număr. Înaintea lui este 542 dar ... 4 nu are voie ı̂naintea lui 2. Acestea fiind
spuse şi cum figura asociată este sugestivă, este clar că soluţia este 435, deci ”a)”.
Problema 4

#include<iostream>
#include<cstring>
int main()
{
char s[50];
char d[50];
strcpy(s,"info@rocnee.eu"); cout<<"s = "<<s<<"\n";

s[strlen(s)-3]=’\0’; cout<<"s = "<<s<<"\n";
cout<<"strchr(s,’@’)+1 = "<<strchr(s,’@’)+1<<"\n";
strcpy(d,strchr(s,’@’)+1); cout<<"s = "<<s<<"\n";
cout<<"d = "<<d<<"\n";
return 0;
}
/*
s = info@rocnee.eu
s = info@rocnee
strchr(s,’@’)+1 = rocnee
s = info@rocnee
d = rocnee
*/
Figura 30.11: 2022bac-s1-I-4
Problema 5
Figura 30.12: 2022bac-s1-I-5

Problema 1
1a.
Figura 30.13: 2022bac-s1-II-1a

1b.
Figura 30.14: 2022bac-s1-II-1b
Cu un pic de atenţie se poate observa că cele două numere nu trebuie să se descompună ı̂n
factori primi! Restricţia este să nu se dividă cu 2, 3, 5 sau 7. Cu cine s-ar mai putea divide? Cu
11 dar ... asta ar ı̂nsemna un număr ' 121 ... care are mai mult de două cifre!
În concluzie (ab) şi (bc) trebuie să fie numere prime!
1c.
Listing 30.2.3: 2022bac-s1-II-1c.cpp

#include<iostream>
void calcul(int n)
{
int x;
int p;
do
{
x=n%100;
if(x>1)
{
p=(x%2)*(x%3)*(x%5)*(x%7);
if(p != 0) cout<<x<<" ";
}
n=n/10;
} while(n>=10);
}
int main()
{
int n;
cin>>n; // n=1237518 113 117 ... 897 973
calcul(n);
return 0;
}
1d.
Figura 30.15: 2022bac-s1-II-1d

Problema 2
Figura 30.16: 2022bac-s1-II-2
Problema 3

Problema 1

#include<iostream> // cout
#include<cmath> // sqrt
void patrate(int n, int &x, int &y) // cu sqrt din cmath

{
int n2; // n2=sqrt(n)
n2=sqrt(n);
if(n2*n2 != n) // n nu este patratul unui numar

{
x=0;
y=0;
return;
}
// aici n = patratul lui n2
x=2;
while(n2%x != 0)
{
x++;
}
// aici caut x = divizor al lui n2

if(n2*n2 != n) // n nu este patratul unui numar
{
x=0;
y=0;
return;
}
y=n2/x;
if(x<y) // n nu este patratul unui numar

{
return;
}
else // aici x=y si trebuia x<y
{
x=0;
y=0;
return;
}
}
void patrate2(int n, int &x, int &y) // fara sqrt din cmath
{
x=2;
while(x*x*(x+1)*(x+1) <= n) // x+1 pentru cea mai mica valoare permisa pentru y
{
if(n%(x*x) == 0)
{
int ny=n/(x*x); // yn = ce a ramas din n pentru y
//verific daca ny este patratul vreunui numar

y=x+1; // conditia era: x < y ./.. !!!
while(y*y<ny)
{
y++;
}
if(y*y == ny) // ny este patratul lui y

{
return; // am solutia !
}
else// aici caut alt x
{
x=x+1;
continue;
}
}
else // aici caut alt x
{
x=x+1;
continue;
}
}
// aici nu exista x
x=0;
y=0;
return;
}
int main()
{
int x, y;
//int n=400;
//int n=24;
//int n=16;
int n=2*2*2*2*2*2;
//patrate(n,x,y);
patrate2(n,x,y);
cout<<"n = "<<n<<" --> x = "<<x<<" y = "<<y<<endl;
return 0;
}
Problema 2

#include<fstream> // fin, fout
#include<iomanip> // setw(3) ... afisare matrice ok
int n;
int a[101][101];
ifstream fin("2022bac-s1-III-2.in");
ofstream fout("2022bac-s1-III-2.out");
void afisareal() // matricea reala (initiala)

{
int i,j;
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
return;
}
void afisafinal() // matricea finala

{
int i,j;
for(i=1; i<=n; i++)
{
for(j=1; j<=n-1; j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
return;
}
void reada()
{
int i,j;
fin>>n;
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
fin>>a[i][j];
}
return;
}
void calcul()
{
int i,j;
for(i=1; i<=n-1; i++)
//for(i=1; i<=n; i++)
{
for(j=i+1; j<=n; j++)
//for(j=1; j<=n; j++)
{
//if(j>i)
{
a[i][j-1]=a[i][j];
}
}
}
return;
}
int main()
{
reada();
afisareal();
calcul();
afisafinal();
return 0;
}
/*
20 30 80 52
71 93 64 51
62 81 55 49
90 65 32 22
30 80 52
71 64 51
62 81 49
90 65 32
*/
Problema 3

int n;
int a[101][101];
void calcul()
{
int lg; // lungimea curenta
int lgmax; // lungimea maxima
int xn1; // x[n-1]
int xn; // x[n]
fin>>xn1; // citesc prima valoare ca sa am valoare x[n-1] can citesc x[n]
lg=1;
lgmax=1; // deocamdata am citit numai un element
while(fin>>xn) // cat tim am avut ce sa citesc si sa pun in xn=x[n]

{
if(xn%2 == xn1%2) // au aceeasi paritate
{
lg=lg+1; // se lungeste secventa curenta
}
else // s-a schimbat secventa
{
if(lgmax < lg) // lungimea curenta este mai mare decat max pana aici?
{
lgmax=lg; // am avut secventa mai lunga
}
lg=1; // noua valoare incepe alta secventa

xn1=xn; // prima valoare din noua secventa este deja citita
}
}
// Atentie la ultima secventa ! ... trebuie testat daca este bmai lunga
if(lgmax < lg) // lungimea curenta este mai mare decat max pana aici?
{
lgmax=lg; // am avut secventa mai lunga
cout<<lgmax;
fout<<lgmax;
fout.close(); // este ok si fara asta!
return;
}
int main()
{
calcul();
return 0;
}
/*
1 2 2 3 4 4 4 4 6 6 6 6 6 6 7 7 7 8 8 8 8 8 8 8 8
rezultat = 10
*/


30.3.1 Subiectul I
Problema 1
22/20*20/2 = 1*20/2 = 20/2 = 10
Problema 2
Figura 30.18: 2022bac-s2-I-2
Problema 3
1: pentru tenis
2: pentru fotbal
3: pentru volei
4: pentru handbal
5: pentru baschet
Figura 30.19: 2022bac-s2-I-3

Când nu contează ordinea obiectelor, impunem ordinea crescătoare şi ne gândim la generarea
combinărilor! Figura este sugestivă! Cine ştie că după 24 urmează 245 şi apoi 34 ... rezolvă
această problemă ı̂n câteva secunde! Deci ... trebuie să ştim ... generarea combinărilor!
Problema 4
Figura 30.20: 2022bac-s2-I-4
Problema 5
Figura 30.21: 2022bac-s2-I-5a
Figura 30.22: 2022bac-s2-I-5b


Problema 1
Figura 30.24: 2022bac-s2-II-1b

#include<iostream>
// in pseudocod ... while: "instructiune repetitiva cu test initial"

void calcul(int n)
{
int i=2;
int k=0;
while(n>=i)
{
while(n%i == 0) // scoate factorul prim din n (ce a mai ramas din el!)
{
k=k+1;
n=n/i;
}
if(i==2) // trece pe secventa numerelor impare

{
i=i+1;
}
else // trece la urmatorul numar impar
{
i=i+2;
}
}
cout<<k;
}
int main()
{
int n;
// n = 11 13 17 19 23 29 31 37 41 43 47
// 53 59 61 67 71 73 79 83 89 97
cin>>n;
calcul(n);
return 0;
}
Problema 2
Listing 30.3.2: 2022bac-s2-II-2.cpp

#include<iostream>
int f(int a, int b) // f(2022,x)

{
if(a<=b) return a;
return f(a-1, b+1); // scade 2022 si creste x

}
int main()
{
// 2000 <= x <= 2025
// f(2022,x) = 2022
int x;
int rez;
for(x=2000; x<=2025; x++)

{
rez=f(2022,x);
cout<<"f(2022,"<<x<<") = "<<rez<<endl;
}
return 0;
}
/*
f(2022,2018) = 2020
f(2022,2019) = 2020
f(2022,2020) = 2021
f(2022,2021) = 2021
f(2022,2022) = 2022
f(2022,2023) = 2022
f(2022,2024) = 2022
f(2022,2025) = 2022
*/
Problema 3

#include<iostream>
#include<cstring>
int main()
{
char s[51];
char id[51];
strcpy(id,"");
cout<<"id = "<<id<<"\n";
cout<<"s = "<<s<<"\n\n";
strcpy(s,"Ana Popescu");
cout<<"id = "<<id<<"\n";
cout<<"s = "<<s<<"\n\n";
strcpy(id,strchr(s,’ ’)+1);
cout<<"id = "<<id<<"\n";
cout<<"s = "<<s<<"\n\n";
strcpy(strchr(id,’\0’),"2022");
cout<<"id = "<<id<<"\n";
cout<<"s = "<<s<<"\n\n";
return 0;
}

Problema 1
//#include<cmath> // sqrt
#include<iomanip> // setw
// ----------------------------------------------------
void secventa1(int &n) // fara vector, caut 22 de la dreapta spre stanga

{
int p10=1;
int cp10; // cifra (nn/p10)%10
int cp10s; // cifra din "stanga" cifrei cp10, adica cifra (nn/(10*p10))%10
while(p10<=n)
{
//getchar();
cp10=(n/p10)%10;
cp10s=((n/(10*p10))%10);
//cout<<"n = "<<n<<" p10="<<p10<<" : "

// <<"cp10 = "<<cp10<<" cp10s = "<<cp10s<<endl;
if(cp10==2)
{
if(cp10s==2)
{
n=n-2*p10;
p10=p10*10;
}
else
{
p10=p10*10;
}
}//if(cp10==2)
else// cp10 != 2
{
p10=p10*10;
}
//p10=p10*10; // se putea pune o singura data aici!
}//while
return;
}// secventa1(int &n)
// ----------------------------------------------------
void secventa2(int &n) // caut 22 de la stanga spre dreapta

{
int c1c2; // doua cifre consecutive din n
int nn=n; // copie a lui n;
int p10=1; // 10ˆk
while(nn>0)
{
p10=p10*10;
nn=nn/10;
}
cout<<"p10 = "<<setw(11)<<p10; getchar();
p10=p10/10;
cout<<"n = "<<setw(11)<<n; getchar();
while(p10>1) //
{
c1c2=(n/(p10/10))%100;
cout<<"n = "<<setw(11)<<n<<" p10 = "<<p10<<" c1c2 = " <<c1c2<<endl;

getchar();
if(c1c2 == 22)//
{ // schimb 2 in 0 (prin scadere ... n = n - 2*p10/10)
cout<<"scad din n = "<<n<<" pe 2*p10 = "<<(2*(p10/10))<<endl;
n=n-2*(p10/10);
p10=p10/10;
}
else
{
p10=p10/10;
}
}
return;
}
// ----------------------------------------------------
void secventa3(int &n) // caut 2 de la dreapta spre stanga

{
int p10=1;
int cp10; // cifra (nn/p10)%10
int cp10s; // cifra din "stanga" cifrei cp10, adica cifra (nn/(10*p10))%10
while(p10<=n)
{
//getchar();
cp10=(n/p10)%10;
cp10s=((n/(10*p10))%10);
cout<<"n = "<<n<<" p10="<<p10<<" : "

<<"cp10 = "<<cp10<<" cp10s = "<<cp10s<<endl;
if(cp10==2)
{
if(cp10s==2)
{
n=n-2*p10;
p10=p10*10;
}
else
{
p10=p10*10;
}
}//if(cp10==2)
else// cp10 != 2
{
p10=p10*10;
}
//p10=p10*10; // se putea pune o singura data aici!
}//while
return;
}
// ----------------------------------------------------
void secventa4(int &n) // caut 2 de la stanga spre dreapta

{
int c1,c2; //doua cifre alaturate ... c1 c2 ...
int p10=1; // 10ˆk
while(nn>0)
{
p10=p10*10;
nn=nn/10;
}
p10=p10/10;

cout<<"n = "<<setw(11)<<n; getchar();
while(p10>1) //
{
c1=(n/p10)%10;
c2=(n/(p10/10))%10;
cout<<"n = "<<setw(11)<<n<<endl;
cout<<"p10 = "<<setw(11)<<p10<<" c1c2 = " <<c1<<c2<<endl;
getchar();
if((c1*10+c2) == 22)//
{ // schimb 2 in 0 (prin scadere ... n = n - 2*p10/10)
cout<<"scad din n = "<<n<<" pe 2*p10 = "<<(2*(p10/10))<<endl;
n=n-2*(p10/10);
p10=p10/10;
}
else
{
p10=p10/10;
}
}
return;
}
// ----------------------------------------------------
void secventa5(int &n) // cu vectorul cifrelor

{
int v[10]; // vectorul cifrelor lui n
int k; // pozitia cifrei curente in vector (si in n)
k=-1; // pozictie inainte de cifra unitatilor lui n original
while(n>0) // construiesc vectorul cifrelor

{
if(n%100==22) // plasez 20
{
//cout<<"n="<<n<<"\n";
v[k+1]=0;
v[k+2]=2;
k=k+2;
n=n/100;
}
else // plasez numai ultima cifra din n
{
//cout<<"n="<<n<<"\n";
v[k+1]=n%10;
k=k+1;
n=n/10;
}
}
//cout<<"* n = "<<n<<"\n";
//cout<<"* k = "<<k<<"\n";
// reconstruiesc n
int nrcn=k;
n=0;
for(k=nrcn; k>=0; k--)
{
n=n*10+v[k];
}
return;
}
// ----------------------------------------------------
int main()
{
int n=202233228;// n=...c... dar ccc NU !!!
//secventa1(n);
//secventa2(n);
secventa3(n);
//secventa4(n);
//secventa5(n);
return 0;
}
Problema 2

int m, n;
int a[102][102]; // matrice bordata cu zero ... !!!
int b[102][102]; // pentru afisare finala
void afisa()
{
int i,j;
for(i=1; i<=m; i++)
{
for(j=1; j<=n; j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
cout<<endl;
return;
}
void afisb()
{
cout<<"\nObs: pozitiile cu 0 sunt nemodificate!:\n";
int i,j;
for(i=1; i<=m; i++)

{
for(j=1; j<=n; j++)
cout<<b[i][j]<<" ";
cout<<endl;
}
cout<<endl;
return;
}
void reada()
{
int i,j;
fin>>m>>n;
for(i=1; i<=m; i++) for(j=1; j<=n; j++) fin>>a[i][j];

return;
}
void calcul()
{
int i,j;
int minv; // min vecini
int totalnisip=0;
// bordez matricea
for(i=0; i<=m+1; i++) // bordez coleanele 0 si n+1
{
a[i][0]=11; a[i][n+1]=11;
}
for(j=0; j<=n+1; j++) // bordez liniile 0 si m+1

{
a[0][j]=11; a[m+1][j]=11;
}
for(i=1; i<=m; i++)

{
for(j=1; j<=n; j++)
{
// calculez minv
minv=11; // initializare cu valoare mai mare decat oricare inaltime
if(a[i-1][j]<minv) minv=a[i-1][j]; // N
if(a[i][j-1]<minv) minv=a[i][j-1]; // V
if(a[i][j+1]<minv) minv=a[i][j+1]; // E
if(a[i+1][j]<minv) minv=a[i+1][j]; // S
//cout<<"("<<i<<","<<j<<") minv = "<<minv<<endl;

if(a[i][j] < minv)
{
//cout<<"("<<i<<","<<j<<") pozitie innisipata\n";
totalnisip=totalnisip+minv-a[i][j];
b[i][j]=minv;
}
}
}
cout<<totalnisip<<"\n";
return;
}
int main()
{
reada();
afisa();
calcul();
afisb();
return 0;
}
/*
5 3 4 6
7 5 9 3
6 8 3 9
4 5 2 3
3 1 4 4
Obs: pozitiile cu 0 sunt nemodificate!:

0 4 0 0
0 0 0 6
0 0 0 0
0 0 3 0
0 3 0 0
*/
Problema 3

void calcul()
{
int nrvd; // nr valori distincte
int xn1; // x[n-1]
int xn; // x[n]
int x, y; // x < y
fin>>x;
fin>>y;
//cout<<"x="<<x<<" y = "<<y<<"\n";
fin>>xn1; // citesc prima valoare ca sa am valoare x[n-1] can citesc x[n]
//cout<<"xn1 = "<<xn1<<endl;
if(xn1 > y) // toate sunt mai mari

{
cout<<0;
return;
}
if(xn1 >= x) // xn1 <= y

nrvd=1;
else
nrvd=0;
// citesc urmatoarele numere
while(fin>>xn) // cat tim am avut ce sa citesc si sa pun in xn=x[n]

{
//cout<<"xn = "<<xn<<endl;
if(xn<x) // xn este in stanga intervalului [x,y]

{
xn1=xn;
continue;
}
if(xn>y) break; // xn este in dreapta intervalului [x,y]
if(xn > xn1) // valoare noua distincta

{
nrvd++;
//cout<<" nrvd "<<nrvd<<" este "<<xn<<endl;
}
xn1=xn; // actuializez x[n-1] pentru a citi x[n]
}
//cout<<endl;
cout<<nrvd;
return;
}
int main()
{
calcul();
return 0;
}


30.4.1 Subiectul I
Problema 1
Expresia: x>=3 && x<10
a. !(x<3 && x>=10) x>=3 ¶¶ x$10
b.
!(x<3 ¶¶ x % =10 x>=3 && x<10
c. x<3 && !(x>=10) x<3 && x<10
d. !(x<3) ¶¶ x%=10 x>=3 ¶¶ x%=10
Problema 2
Figura 30.27: 2022bac-s3-I-2
Listing 30.4.1: 2022bac-s3-I-2

#include<iostream>
int f(int x, int y) /// Atentie! ... pentru orice numar PRIM
{
cout<<"x = "<<x<<" y = "<<y<<" y*y = "<<y*y<<endl;
if(x!=2 && x%2==0) return 0; // 0 pentru orice numar PAR (fara 2)
if(y*y > x) return 1; // x a fost depasit de y*y --> x=PRIM
if(x%y == 0) return 0; // x se imparte la y --> nu este PRIM
return f(x,y+2); /// a) verifica mai departe 5, 7, 9, 11, 13, 15, ...
//return f(x,y-2); /// b)
//return f(x,y*2); /// c)
//return f(x,y/2); /// d)
}
int main()
{ int n=997; // [2, 10.000] 997=PRIM
int rez=f(n,3); // verifica 2 si nr par; apoi cauta d=3, 5, 7, 9,
cout<<"rez = "<<rez<<endl;
return 0;
}
/*
x = 997 y = 3 y*y = 9
x = 997 y = 5 y*y = 25
x = 997 y = 7 y*y = 49
x = 997 y = 9 y*y = 81
x = 997 y = 11 y*y = 121
x = 997 y = 13 y*y = 169
x = 997 y = 15 y*y = 225
x = 997 y = 17 y*y = 289
x = 997 y = 19 y*y = 361
x = 997 y = 21 y*y = 441
x = 997 y = 23 y*y = 529
x = 997 y = 25 y*y = 625
x = 997 y = 27 y*y = 729
x = 997 y = 29 y*y = 841
x = 997 y = 31 y*y = 961
x = 997 y = 33 y*y = 1089
rez = 1
*/
Problema 3
1: pentru măr
2: pentru gutuie
3: pentru prună
4: pentru caisă
5: pentru piersică
Figura 30.28: 2022bac-s3-I-3
combinărilor!
Figura este sugestivă! Cine ştie că după 234 urmează 235 şi apoi 245 şi apoi 345, ... rezolvă
această problemă ı̂n câteva secunde! Deci ... trebuie să ştim ... generarea combinărilor!
Problema 4
Pe diagonala secundară i j 99, deci 20 j 99 şi de aici rezultă j 79.
Problema 5
Figura 30.29: 2022bac-s3-I-5


Problema 1
1a.
Observaţie: n ”coboară” către m până când ajunge la o valoare care are un divizor propriu
comun cu m (ı̂n cel mai ”rău” caz ajunge la m).
1b. n poate fi 10, 11, 12, 13 şi 14 (şi coboară până la 10).
1c.
fcmmdc(int x, int y) este funcţia pentru determinare cmmdc prin scăderi succesive.

#include<iostream>
int fcmmdc(int x, int y)

{
cout<<"--> fcmmdc\n";
while(x != y)
{
cout<<"x = "<<x<<" y = "<<y<<endl;
if(x>y) x=x-y;
else
//if(x<y)
y=y-x;
cout<<"x = "<<x<<" y = "<<y<<endl<<endl;
//getchar();
}
return x;
}
int main()
{
int m, n; // 21 47 ... la 47 21 ciclu infinit ... !!!
int x, y;
//cin>>m>>n; // 5 2 --> ciclu dar ... m < n ... restrictie!

m=21;
n=47;
x=1;
while(x==1)
//while(x==1 && n>0) // asa nu mai trebuia m < n
{
x=m;
y=n;
n=n-1; // se tot micsoreaza ... !!!
//cout<<"*** x = "<<x<<" y = "<<y<<" n = "<<n<<endl;

//getchar();
while(x != y) // x=47 y=0 --> ciclu infinit

{
//cout<<" x = "<<x<<" y = "<<y<<endl;
//getchar();
if(x>y)
{
x=x-y;
}
else
{
if(y>x)
y=y-x;
}
//cout<<" x = "<<x<<" y = "<<y<<endl<<endl;
//getchar();
}
}
cout<<n+1;
cout<<endl<<endl;
int a=2*2*3;
int b=2*3*3; //
int rez=fcmmdc(a,b);
cout<<"fcmmdc("<<a<<","<<b<<") = "<<rez<<endl;
return 0;
}
/*
45
--> fcmmdc
x = 12 y = 18
x = 12 y = 6
x = 12 y = 6
x = 6 y = 6
fcmmdc(12,18) = 6
*/
1d.

Problema 2
Problema 3

#include<iostream>
struct meteo
{
int an, temperatura;
} x;
int main()
{
x.an=2023;
//x.temperatura=12;
//x.temperatura=9;
//x.temperatura=10;
x.temperatura=11;
if(x.temperatura > 11) cout<<"CALDUROS";

else
if(x.temperatura < 10) cout<<"RACOROS";
else cout<<"NORMAL";
return 0;
}

Problema 1

void schimb1(int &n, int x, int p)

{
int k=0; // pozitia in n

int p10k=1; // 10ˆk
n=0; // in n construiesc rezultatul

while(nn>0) // are macar 2 cifre
{
if(k == p) // inlocuiesc cu x
{
n=n+x*p10k; // pun x in fata lui n

}
else
{
n=n+(nn%10)*p10k; // pun (nn%10) in fata lui n
}
nn=nn/10; // sterg ultima cifra

p10k=p10k*10; // pregatesc noul 10ˆk
k++; // maresc pozitia
}
return;
}
void schimb2(int &n, int x, int p) // cu vectorul cifrelor

{
int v[10]; // vectorul cifrelor lui n
int k; // pozitia cifrei curente in vector (si in n)
k=0; // pozictie inainte de cifra unitatilor lui n original
while(n>0) // construiesc vectorul cifrelor

{
v[k]=n%10;
n=n/10;
k++;
}
int nrcn=k;
cout<<"nrcn = "<<nrcn<<"\n";
v[p]=x; // schimb cifra de pe pozitia p cu cifra x
n=0; // reconstruiesc n
for(k=nrcn-1; k>=0; k--)
{
n=n*10+v[k];
}
return;
}
int main()
{
int n=12587;// n=...c... dar ccc NU !!!
int x=6;
int p=3;
cout<<"n = "<<n<<" x = "<<x<<" p = "<<p<<endl;
schimb1(n,x,p);
//schimb2(n,x,p);
return 0;
}
Problema 2

#include<cstring> // strlen
char cuvant[52]; // cuvantul
int n; // strlen(cuvant)
void calcul()
{
char ck; // cuvant[k]
char c; // caracter din alfabet
int k; // pozitia in cuvant
for(k=0; k<=n-1; k++)

{
//cout<<k<<" : "<<cuvant[k]<<endl;
ck=cuvant[k];
if(ck==’a’ || ck==’e’ || ck==’i’ || ck==’o’ || ck==’u’)
continue; // iau alta litera
// aici ck = consoana ... determin prima vocala spre stanga

for(c=ck; c>=’a’; c--)
{
if(c==’a’ || c==’e’ || c==’i’ || c==’o’ || c==’u’)
{
cuvant[k]=c;
break; // opresc cautarea vocalei
}
}
}
return; // nu este obligatoriu! ... oricum "pleca" ...
}
int main()
{
cin>>cuvant;
//cout<<"cuvant = "<<cuvant<<endl;
n=strlen(cuvant);
//cout<<"n = "<<n<<endl;
calcul();
//cout<<"cuvant = "<<cuvant<<endl;
cout<<cuvant<<endl;
return 0;
}
/*
rame --> oaie,
sport --> ooooo
*/
Problema 3

#include<fstream> // cout
ifstream fin("2022bac-s3-III-3-bac.txt");
ofstream fout();
int main()
{
int xk; // x[k]
int xk1; // x[k-1]
int n; // numarul elementelor din sirul initial
int lg; // lungimea curenta a subsirului

int lgmax; // lungimea maxima a subsirului
int nrmax; // numarul subsirurilor de lungime maxima
fin>>xk1; // sirul contine cel putin doua numere
lg=1; // deja am citit un numar din ... prima secventa

lgmax=1; // deocamdata ... !!!
n=1; // nu este necesar ... doar de curiozitate acasa ... !!!
nrmax=1; // x[1] este un prim posibil subsir de lungime maxima
while(fin>>xk) // citesc x[k]

{
n++; // am mai preluat un numar
if(xk1%2 == xk%2) // au aceeasi paritate

{
lg++;
xk1=xk; // ca sa se vada clar ce fac in acest caz !
}
else // NU AU aceeasi paritate (subsirul este terminat in x[k-1]
{
if(lg > lgmax) // primul subsir de lungime maxima
{
lgmax=lg;
nrmax=1; // este primul de lungime maxima
}
else
if(lg < lgmax) // nu este interesant acest subsuir
{
// nu fac nimic
}
else // aici lg = lgmax
{
nrmax++; // se mareste numarul subsirurilor de lungime maxima
}
lg=1; // xk este primul din alt sir

xk1=xk; // ca sa se vada clar ce fac in acest caz !
}
}
// fara ultima secventa

//cout<<"lgmax = "<<lgmax<<" nrmax = "<<nrmax<<endl;
// Atentie: de verificat separat ULTIAMA secventa ... !!!

//cout<<"\n\nultima secventa ... !!!:\n";
if(lg > lgmax) // primul subsir de lungime maxima
{
lgmax=lg;
nrmax=1; // este primul de lungime maxima
lg=1; // xk este primul din alt sir
}
else
if(lg < lgmax) // nu este interesant acest subsuir
{
// nu fac nimic
}
else // aici lg = lgmax
{
nrmax++; // se mareste numarul subsirurilor de lungime maxima
}
// cu ultima secventa
//cout<<"lgmax = "<<lgmax<<" nrmax = "<<nrmax<<endl;
cout<<nrmax<<" "<<lgmax;
return 0;
}
/*
2 3 5 1 7 9 8 4 4 11 15 17 21 11 6 11 15 17 21 11 6 5 2 6 4 0 16
1 2 6 7 9 10 14 15 16 20 21 22 23 27
4 5
*/

Capitolul 31
BAC 2021

31.1.1 Subiectul I
Problema 1
Dacă 2021 este divizor al lui x atunci x 2021y unde y " N.
Evaluăm expresiile din cele patru cazuri:
a. x/(x/2021) = x/y = 2021
b. x/(x%2021) = x/0 = ! (nu se fac ı̂mpărţiri prin zero!)
c. x%(x/2021) = x%y = 0
d. x%(x%2021) = x%0 = ! (nu se fac ı̂mpărţiri prin zero!)
Răspunsul corect este: c.
Problema 2
Regulile de generare sunt:

1. se folosesc numai cifrele 0, 1, 2 ı̂n această ordine.
2. se incearcă ’lungirea’ secvenţei.
2a. dacă se poate lungi secvenţa, se completează cu 0 noua poziţie; apoi 2.
2b. dacă nu se poate lungi secvenţa, 3.
3. se ı̂ncearcă plasarea următoarei valori pe poziţia curentă
3a. dacă se poate, se plasează următoarea valoare pe poziţia curentă; apoi 2.
3b. daca nu se poate, 4.
4. se caută spre stânga prima poziţie pe care se poate plasa următoarea valoare
4a. daca există o astfel de poziţie, se pune acolo valoarea următoare; apoi 2.
4b. daca nu există o astfel de poziţie ı̂nseamnă că s-a terminat generarea!
302
Problema 3

#include<iostream>
#include<cstring>
struct masina
{
char model[51];
int an;
} x[10], y;
int main()
{
cout<<" sizeof(y) = "<<sizeof(y)<<"\n";
cout<<"sizeof(y.model) = "<<sizeof(y.model)<<"\n";
cout<<" sizeof(y.an) = "<<sizeof(y.an)<<"\n\n";
cout<<" &x[0] = "<<&x[0]<<"\n";

cout<<" &x[1] = "<<&x[1]<<"\n";
cout<<" ......................\n";
cout<<" &x[9] = "<<&x[9]<<"\n";
cout<<" &y = "<<&y<<"\n\n";
cout<<"&x[1].model = "<<&x[1].model<<"\n";
cout<<" &x[1].an = "<<&x[1].an<<"\n\n";
y.an=2022;
//y.model="model de subiect de bac";
strcpy(y.model,"model de subiect de bac");
//a.
x[1]=y; // se copiaza continutul lui y in x[1]
cout<<" &x[1] = "<<&x[1]<<"\n";
cout<<"x[1].an : "<<x[1].an<<"\n";
cout<<"x[1].model : "<<x[1].model<<"\n\n";
//b.
//x.an[1]=y.an; // err!!!
x[1].an=y.an;
//c.
//x[1].an.masina=y.an.masina; // err!!!
x[1].an=y.an;
//d.
//model.x[1]=model.y; // err!!!
//x[1].model=y.model; // err!
strcpy(x[1].model,y.model);
return 0;
}
/*
sizeof(y) = 56
sizeof(y.model) = 51
sizeof(y.an) = 4
&x[0] = 0x7ff62bda90a0
&x[1] = 0x7ff62bda90d8
......................
&x[9] = 0x7ff62bda9298
&y = 0x7ff62bda92e0
&x[1].model = 0x7ff62bda90d8
&x[1].an = 0x7ff62bda910c
&x[1] = 0x7ff62bda90d8
x[1].an : 2022
x[1].model : model de subiect de bac
*/
a. x[1]=y; (este corect; vezi R32 ı̂n codul sursă)

b. x.an[1]=y.an; (corect ar fi fost x[1].an=y.an; vezi R41)
c. x[1].an .masina=y.an .masina; ( masina este numele structurii de date şi nu are ce căuta ı̂n
numele câmpurilor structurii! corect ar fi x[1].an=y.an; ca ı̂n R45)
d. model.x[1]= model.y; (accesul se face din exterior către interior, ı̂n structură, deci de la
variabilă către câmp adică ... de la x[1] către model[]; ”corect” ar fi fost o atribuire de forma
x[1].model=y.model; (vezi R49) dar ... la şiruri de caractere atribuirea se face, cu ajutorul funcţiei
strcpy, astfel: strcpy(x[1].model,y.model); (vezi R50)).
Structura de date numită ”masina” (R6) are 56 de octeti (R55) formati din 51 de octeti (R56)
pentru câmpul ”model” (R8) şi 4 octeti (R57) pentru câmpul ”an” (R9). Octetul care ”lipseşte”
aici ... se foloseşte pentru aliniere la adrese multiplu de 2, ı̂n memorie.
Adresele sunt afişate ı̂n baza 16.
ı̂n baza 16 ı̂n baza 10

&x[1] = 0x7ff62bda90d8 140695274426584
&x[0] = 0x7ff62bda90a0 140695274426528
diferenta = 38 56
Tabelul 31.1: 2021bac-s1-I-3-t1
x[0], x[1], ..., x[9] sunt ”alăturate” dar ...
ı̂n baza 16 ı̂n baza 10

&y = 0x7ff62bda92e0 140695274427104
&x[9] = 0x7ff62bda9298 140695274427032
diferenta = 48 72
Tabelul 31.2: 2021bac-s1-I-3-t2
Între vectorul x şi variabila y există un spatiu de 16 octeţi!
Problema 4
k 1 2 3 4 5 6 7 8 9 10 11
t[k] 9 3 4 6 4 8 6 0 4 4 4
Tabelul 31.3: 2021bac-s1-I-4
Răspunsul corect este c) (nodul 4 are cinci fii).
Problema 5
n n1
Graful complet cu n noduri are Kn 2
muchii.
Cum ţinem minte această formulă?
Din fiecare nod putem duce câte o muchie către fiecare
vecin, deci putem duce n 1 muchii. Sunt n noduri, deci
putem duce n n 1 muchii ı̂n total. Dar ... fiecare muchie
i, j este numărată de două ori: o dată când ”am fost” ı̂n
nodul i şi a doua oară când ”am fost” ı̂n nodul j. Împărţim la
2 numărul total de muchii numărate şi ... totul s-a corectat!

Putem rezolva ecuaţia Kn 210 dar ... vom face câteva

”ı̂ncercări” rapide:
109
K10 2
45 muchii (prea puţin!).
2019
K20 2
190 muchii (ı̂ncă prea puţin!).
2120
K21 2
21 10 210 muchii (exact!).
Răspunsul corect este d (21 de muchii).

Problema 1
II-1-a:
Observaţia evidentă este: câte numere impare sunt ı̂ntre m şi n (inclusiv m şi n dacă sunt
impare!) atâtea simboluri * se vor afişa!

#include<iostream>
int main()
{
int m, n;
// a)
m=2; n=9; // se citesc !!! --> ****
int nas=0; // nas = nr aparitii steluta
// n=mare, m=mic ... !!!

if(m>n) {int aux; aux=m; m=n; n=aux;}
if(m%2 == 0) m=m+1; // m = impar ... !!!
while(m<=n)
{
m=m+2; // m merge numai pe numere impare
cout<<’*’; nas++;
}
cout<<"\n";
cout<<"nas = "<<nas<<"\n";
return 0;
}
/*
****
nas = 4
*/
II-1-b: Spre stânga şi spre dreapta lui 79 se determină al 40-lea număr impar (incluzând pe 79).
Acestea sunt: 1 şi 157. Se pot alege şi numerele pare 0 şi 158 pentru că ele nu elimină şi nici nu
adaugă alte numere impare dar ... 0 trebuie eliminat pentru că numerele trebuie să fie ”nenule”
(aşa scrie ı̂n enunţ!).
Listing 31.1.3: 2021bac-s1-II-1b.cpp

#include<iostream>
int main()
{
int m, n;
// a)
//m=2; n=9; // se citesc !!! --> ****
int nas=0; // nas = nr afisari steluta
// b1)
//n=79; m=0;
// n=79; m=1;
// b2)
//n=79; m=157;
n=79; m=158;
// n=mare, m=mic ... !!!

if(m%2 == 0) m=m+1; // m = impar ... !!!
while(m<=n)
{
cout<<’*’; nas++;
}
cout<<"\n";
return 0;
}
/*
****************************************
nas = 40
*/
II-1-c: Programele sunt deja scrise aici!
II-1-d:
Figura 31.4: 2021-mai-II-1d
Listing 31.1.4: 2021bac-s1-II-1d.cpp

#include<iostream>
int main()
{
int m, n;
// a)
m=2; n=9; // se citesc !!! --> ****
int nas=0; // nas = nr aparitii steluta
// n=mare, m=mic ... !!!

if(m%2 == 0) m=m+1; // m = impar ... !!!
// ATENTIE la PRIMA iteratie ... !!!

//while(m<=n)
if(m<=n) // daca se face prima iteratie ... !!!
do
{
cout<<’*’; nas++; // actiunea la inceput ...
} while(m<=n); // "cat timp" ... in C++
// } while( !(m<=n) ); // "pana cand" ... in pseudocod !!! atentie ... !!!
cout<<"\n";
return 0;
}
/*
****
nas = 4
*/
Problema 2
Funcţia este:
int f(int x) { if (x<=4) return x; else return x-f(x-2); }
f(2) = 2;
f(21) = 21 - f(19) = 21 - [19 - f(17)] = 21 - 19 + f(17) = 21 - 19 + [17 - f(15)] = 21 - 19 + 17 -
f(15) = 21 - 19 + 17 - 15 + f(13) = 21 - 19 + 17 - 15 + 13 - f(11) = 21 - 19 + 17 - 15 + 13 - 11 +
f(9) = 21 - 19 + 17 - 15 + 13 - 11 + 9 - f(7) = 21 - 19 + 17 - 15 + 13 - 11 + 9 - 7 + f(5) = 21 -
19 + 17 - 15 + 13 - 11 + 9 - 7 + 5 - f(3) = 21 - 19 + 17 - 15 + 13 - 11 + 9 - 7 + 5 - 3 = 2*5 = 10
Problema 3
Instrucţiunea strcpy(x,"bac2021"); ı̂ncarcă vectorul x cu textul ”bac2021” (fără ghilimele!).

Instrucţiunea cout<<x+3<<endl; determină afişarea textului de la x[3] până la ’¯0’ şi

trecerea pe rândul următor.
Instrucţiunea
for(i=0;i<strlen(x);i++) if(strchr("0123456789",x[i])==0) cout<<x[i]<<’!’;

realizează parcurgerea şirului de caractere x; dacă x[i] nu este cifră atunci se afişează pe ecran
caracterul respectiv urmat de ’ !’.

#include<iostream>
#include<cstring>
char x[101];
int main()
{
strcpy(x,"bac2021");
cout<<x+3<<endl;
for(int i=0;i<strlen(x);i++)
if( strchr("0123456789",x[i]) == 0 )
//if( strchr("0123456789",x[i]) == NULL )
cout<<x[i]<<’!’;
return 0;
}
/*
2021
b!a!c!
*/

Problema 1

#include<iostream>
void imog(int x, int y, int & rez)

{
cout<<"--> imog : "<<x<<" "<<y<<" "<<rez<<"\n";
int xi=0; // x numai cu cifre impare
int yio=0; // y numai cu cifre impare, oglindite
int p10;
p10=1; // pentru a obtine in ordine cifrele

while(x != 0)
{
if((x%10)%2 != 0)
{
xi=xi+(x%10)*p10;
x=x/10;
p10=p10*10;
}
else
{
x=x/10;
}
}
cout<<"xi = "<<xi<<"\n";
// se obtin cifrele oglindite

while(y != 0)
{
if((y%10)%2 != 0)
{
yio=yio*10+(y%10);
y=y/10;
}
else
{
y=y/10;
}
}
cout<<"yio = "<<yio<<"\n";
if(xi == yio)
rez=1;
else
rez=0;
}
int main()
{
int x=523;
int y=84356;
//int x=523;
//int y=84536;
int rez;
imog(x,y,rez);
cout<<"rez = "<<rez<<"\n";
return 0;
}
/*
--> imog : 523 84356 32759
xi = 53
yio = 53
rez = 1
*/
Problema 2
Evident, este o problemă banală!

#include<iostream>
int n, k;
int a[21][21];
void afisa()
{
cout<<"\n";

{
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
}
int main()
{
int i, j, aux;
cin>>n>>k;
for(i=1; i<=n; i++)

for(j=1; j<=n; j++)
cin>>a[i][j];
afisa();
for(i=1; i<k; i++) // permut a[i][k] cu a[k][i]

{
aux=a[i][k];
a[i][k]=a[k][i];
a[k][i]=aux;
}
afisa();
return 0;
}
/*
5
4
2 4 3 5 6
8 0 9 8 7
2 6 9 0 5
6 1 3 6 9
7 3 9 4 2
2 4 3 6 6
8 0 9 1 7
2 6 9 3 5
5 8 0 6 9
7 3 9 4 2
*/
Problema 3
O primă rezolvare constă ı̂n determinarea expresiei şirului.
Acest lucru se poate realiza (cu puţin noroc!) scriind relaţia de recurenţă pentru primele şi
ultimele câteva valori ale lui n (ca ı̂n figura următoare).
Figura 31.6: 2021bac-s1-III-3
2
Merită verificat dacă şirul are o expresie de forma f n an bn c. Constantele a, b, c se
determină rezolvând sistemul liniar de ecuaţii:

~
f 0 a0b0c

f 1 a1b1c

f 2 a4b4c

calculând primii termeni ai şirului cu ajutorul relaţiei de recurenţă şi ı̂nlocuind ı̂n sistem valorile
f 0, f 1, f 2 (sau folosind alţi termeni ai şirului!).

#include<iostream> // f_0=1
#include<fstream> // f_n = f_{n-1} + 2*n
int main()
int x, y; // x < y pe pozitii consecutive in sirul f_n
int n;
cin>>x>>y;
//cout<<"x = "<<x<<" y = "<<y<<"\n";
n=(y-x)/2; // f[n]=y; f[n-1]=x; f[n]=f[n-1]+2*n --> y=x+2n;
for(int k=n; k>=0; k--)

{
fout << (k*k+k+1) << " ";
cout << (k*k+k+1) << " ";
}
fout.close();
return 0;
}
/*
21 31
*/
O a doua rezolvare este posibilă calculând ”ı̂napoi” termenii şirului. Ştim că f n 31 şi
termenul anterior este f n 1 f n 2n. Pare că nu ştim cât este n dar ... el se poate
determina folosind cei doi termeni consecutivi din şir: 21 şi 31. Următorul program foloseşte
această idee.

#include<iostream> // f_0=1
#include<fstream> // f_n = f_{n-1} + 2*n
int main()
{
int x, y; // x < y pe pozitii consecutive in sirul f_n
int n;
cin>>x>>y;
//cout<<"x = "<<x<<" y = "<<y<<"\n";
n=(y-x)/2; // f[n]=y; f[n-1]=x; f[n]=f[n-1]+2*n -->

// y=x+2n; --> x = y-2n
fout<<y<<" "<<x; // x < y

cout<<y<<" "<<x;
while(n>1)
{
y=x;
n--; // descrescator ... !!!
x=y-2*n;
fout<<" "<<x;
cout<<" "<<x;
}
fout.close();
return 0;
}
/*
21 31
*/


31.2.1 Subiectul I
Problema 1
Verificăm cele 4 situaţii posibile (pe nişte valori simple/mici): par-par, par-impar, impar-par,
impar-impar.
La par-par trebuie să fie 1.
Mai mult, numai la par-par trebuie să fie 1.

#include<iostream>
int main()
{
int x, y;
int xp=2, xi=1, yp=4, yi=3;
bool a, b, c, d;
cout<<"a:\n";
x=xp; y=yp;
a=(x%2==0 && (y+1)%2!=0); cout<<x<<" "<<y<<" : "<<a<<"\n";
x=xp; y=yi;
a=(x%2==0 && (y+1)%2!=0); cout<<x<<" "<<y<<" : "<<a<<"\n";
x=xi; y=yp;
a=(x%2==0 && (y+1)%2!=0); cout<<x<<" "<<y<<" : "<<a<<"\n";
x=xi; y=yi;
a=(x%2==0 && (y+1)%2!=0); cout<<x<<" "<<y<<" : "<<a<<"\n\n";
cout<<"b:\n";
x=xp; y=yp;
b=((x-y)/2==0); cout<<x<<" "<<y<<" : "<<b<<"\n";
x=xp; y=yi;
b=((x-y)/2==0); cout<<x<<" "<<y<<" : "<<b<<"\n";
x=xi; y=yp;
b=((x-y)/2==0); cout<<x<<" "<<y<<" : "<<b<<"\n";
x=xi; y=yi;
b=((x-y)/2==0); cout<<x<<" "<<y<<" : "<<b<<"\n\n";
cout<<"c:\n";
x=xp; y=yp;
c=((x+y)%2==0 && (x-y)%2==0); cout<<x<<" "<<y<<" : "<<c<<"\n";
x=xp; y=yi;
c=((x+y)%2==0 && (x-y)%2==0); cout<<x<<" "<<y<<" : "<<c<<"\n";
x=xi; y=yp;
c=((x+y)%2==0 && (x-y)%2==0); cout<<x<<" "<<y<<" : "<<c<<"\n";
x=xi; y=yi;
c=((x+y)%2==0 && (x-y)%2==0); cout<<x<<" "<<y<<" : "<<c<<"\n\n";
cout<<"a:\n";
x=xp; y=yp;
d=(x%2==y%2); cout<<x<<" "<<y<<" : "<<d<<"\n";
x=xp; y=yi;
d=(x%2==y%2); cout<<x<<" "<<y<<" : "<<d<<"\n";
x=xi; y=yp;
d=(x%2==y%2); cout<<x<<" "<<y<<" : "<<d<<"\n";
x=xi; y=yi;
d=(x%2==y%2); cout<<x<<" "<<y<<" : "<<d<<"\n";
return 0;
}
/*
a:
2 4 : 1
2 3 : 0
1 4 : 0
1 3 : 0
b:
2 4 : 0
2 3 : 1
1 4 : 0
1 3 : 0
c:
2 4 : 1
2 3 : 0
1 4 : 0
1 3 : 1
a:
2 4 : 1
2 3 : 0
1 4 : 0
1 3 : 1
*/
Problema 2
Un desen al apelurilor (ca ı̂n figură!) este util!
Figura 31.8: 2021bac-s2-I-2-rd-1

Se poate utiliza şi numai un ”simplu” calcul, ca ı̂n figura următoare:
Figura 31.9: 2021bac-s2-I-2-rd-2

#include<iostream>
#include<fstream>
int f(int n,int c)

{
int vret; // valoare returnata
cout<<" --> f("<<n<<","<<c<<")"<<"\n";
if(n==0)
{ vret=0;
cout<<" vret = "<<vret<<" <-- f("<<n<<","<<c<<")"<<"\n";
return vret;
}
else
if(n%10==c)
{ vret=f(n/10,c);
return vret;
}
else
{ vret=n%10+10*f(n/10,c);
return vret;
}
}
int main()
{
int n=2021; // a)
int c=0;
int rez=f(n,c); cout<<"rez = "<<rez<<"\n";
return 0;
}
/*
--> f(2021,0)
--> f(202,0)
--> f(20,0)
--> f(2,0)
--> f(0,0)
vret = 0 <-- f(0,0)
vret = 2 <-- f(2,0)
vret = 2 <-- f(20,0)
vret = 22 <-- f(202,0)
vret = 221 <-- f(2021,0)
rez = 221
*/
Problema 3
Diagonala secundară are suma indicilor elementelor constantă ...
Figura 31.10: 2021bac-s2-I-3
Problema 4
Graful este:
Figura 31.11: 2021bac-s2-I-4
Problema 5
Arborele este:
Figura 31.12: 2021bac-s2-I-5


Problema 1
Rularea pseudocodului pentru 8 şi 5:
Listing 31.2.3: 2021bac-s2-II-1ab.cpp

#include<iostream>
int main()
{
int x, y;
// a)
x=8; y=5; // se citesc !!!
// b1)
//x=10; y=6;
// b2)
//x=10; y=15;
if(x>y) {int aux; aux=x; x=y; y=aux;}
int nr=1;
for(int i=y; i >= x; i=i-1)

{
cout<<"1";
if(nr >= x)
cout<<"2";
nr=nr*3;
cout<<"1";
}
return 0;
}
/*
a: 1111121121
b1: 1111121121121
b2: 111111121121121
*/
Dacă 10 este ”mare”:
Figura 31.14: 2021bac-s2-II-1b x este mare!
Dacă 10 este ”mic”:
Figura 31.15: 2021bac-s2-II-1b x este mic!

#include<iostream>
int main()
{
int x, y;
cin>>x;
cin>>y;
int nr=1;
for(int i=y; i >= x; i=i-1)

{
cout<<"1";
if(nr >= x) cout<<"2";
nr=nr*3;
cout<<"1";
}
return 0;
}
Figura 31.16: 2021-iunie-II-1d
Listing 31.2.5: 2021bac-s2-II-1d-v1.cpp

#include<iostream>
int main()
{
int x, y;
cin>>x;
cin>>y;

int nr=1;
//for(int i=y; i >= x; i=i-1)

int i=y;
while(i >= x)
{
cout<<"1";
nr=nr*3;
cout<<"1";
i=i-1;
}
return 0;
}
Listing 31.2.6: 2021bac-s2-II-1d-v2.cpp

#include<iostream>
int main()
{
int x, y;
cin>>x;
cin>>y;

int nr=1;
//for(int i=y; i >= x; i=i-1)
int i=y;
//while(i >= x)
do
{
cout<<"1";
nr=nr*3;
cout<<"1";
i=i-1;
} while(i >= x); // la PSEUDOCOD: do{...} pana cand !(i >= x);
return 0;
}
/*
5
8
*/
Problema 2
Codificarea cu numere este utilă!
Problema 3
Variabilele f şi fs ı̂n memorie:


Problema 1

#include<iostream>
void divPrim(int n, int & s) // 360=2ˆ3 3 ˆ2 5 ˆ1, deci s=2+5),

{
int d; // divizor 2ˆ3=8 ... d=2 si ed=3
int ed; // exponent divizor
s=0; // suma divizorilor cu ed = impar
d=2;
ed=0; // initial ...

while(n%d == 0) {ed++; n=n/d;} // scot 2-urile din n ... !!!
if(ed % 2 == 1) s=s+d;
if(n==1) return; // n a fost numai o putere a lui 2
// scot 3, 5, 7, 9 ???
// incerc 9 dar ... sigur nu merge pentru ca am scos 3-urile ... !!!
//======================================================================
d=3;
while(d*d <= n) // divizorii mai mici decat d au fost deja scosi ... !!!
{
ed=0; // initial ...
while(n%d == 0) {ed++; n=n/d;} // scot d-urile din n ... !!!
if(ed % 2 == 1) s=s+d;
d=d+2; // ... !!!!

}
//=====================================================================
// ramane n=1 sau

// n=un numar prim ... cel mai mare ... la puterea 1 numai ... !!!
if(n>1) // a ramas un factor prim (la puterea 1) in n ... ???
s=s+n;
return;
}
int main()
{
int n, s;
n=360;
//n=2*3*3*13;
//n=2*3*3*13*13*13;
divPrim(n,s);
cout<<"s = "<<s<<"\n";
return 0;
}
Problema 2

#include<iostream>
#include <string>
int main()
{
int n, k;
cin>>n>>k;
int ncok=0; // nr cuvinte cu ultima litera = vocala

string s[21];
char esteok[21];
int lgs; // lungime string

{
cin>>s[i];
lgs=s[i].size();
esteok[i]=0;
if((s[i][lgs-1]==’a’)||
(s[i][lgs-1]==’e’)||
(s[i][lgs-1]==’i’)||
(s[i][lgs-1]==’o’)||
(s[i][lgs-1]==’u’))
ncok++, esteok[i]=1;
if(ncok < k)
cout<<"nu exista";
else
{
int i=0; // parcurg din nou cuvintele sa afisez primele k ok ...
while(k>0)
{
i++;
if(esteok[i]==1) { cout<<s[i]<<"\n"; k--;}
}
}
return 0;
}
/*
5 2
norii
cumulus
pluteau
pe
cer
norii
pluteau
*/
Problema 3

#include<iostream>
#include<fstream>
//ifstream fin("2021-iunie-bac.txt");
ifstream fin("bac.txt");
int x;
int ncx; // numarul cifrelor lui x
int x10; // 10ˆncx ... nrc%x1 = prefixul cu ncx cifre al lui nrc
int nrc; // numar curent citit

int nr1, nr2; // numere consecutive in sir
int nr1s, nr2s; // numere consecutive solutie
int main()
{
fin>>x;
// ------------------------------------------------------------
// determin nr cifre x ... nu era nevoie ... [100,999] --> 1000
ncx=0;
int xx=x; // copie de lucru a lui x
while(xx != 0)
{
ncx++;
xx=xx/10;
}
//cout<<"ncx = "<<ncx<<"\n";
x10=1;
for(int i=1; i<=ncx; i++) x10=x10*10;
//cout<<"x10 = "<<x10<<"\n\n";
// ------------------------------------------------------------
nr1=-1;
nr2=-2;
nr1s=-1;
nr2s=-2;
// optimizarea = o singura parcurgere a sirului de date

while(fin>>nrc) // asa este OK ... !!!
{
nr1=nr2;
nr2=nrc;
if(((nr1%x10)==x) &&
((nr2%x10)==x))
nr1s=nr1, nr2s=nr2;
}
if(nr1s>0)
cout<<nr1s<<" "<<nr2s<<"\n";
else
cout<<"nu exista";
fin.close();
return 0;
}
/*
210
3445 210 893210 1245 1210 3210 15210 67120 20210 12
3210 15210
*/


31.3.1 Subiectul I
Problema 1
Liniarizarea fracţiilor:
Figura 31.19: 2021bac-s3-I-1a-rd
Este evident răspunsul corect este

d. ((x+y)/5+(x-y)/2)/(x+2)
Problema 2
Calcul:
Figura 31.20: 2021bac-s3-I-2
Problema 3
Construcţia soluţiei:
Figura 31.21: 2021bac-s3-I-3
Problema 4
Reprezentări diverse pentru arbore dar ... acelaşi rezultat:
Figura 31.22: 2021bac-s3-I-4
Problema 5
Calcul ı̂n matricea de adiacenţă:
Figura 31.23: 2021bac-s3-I-5

Problema 1
O reprezentare a execuţiei pseudocodului:

#include<iostream>
int main()
{
int n=15;
int x=3;
int y=4;
int ok=0;

{
if((i%x==0 && i%y!=0) || // multiplu de x dar nu de y
(i%x!=0 && i%y==0)) // multiplu de y dar nu de x
{
cout<<i<<" ";
ok=1;
}
}
if(ok==0) cout<<0;
return 0;
}

#include<iostream>
int main()
{
int n=15;
int x=5;
int y=5; // x = y ...
int ok=0;

{
{
cout<<i<<" ";
ok=1;
}
}
// [(x*y’)+(x’*y)]’=(x’+y)*(x+y’) = x’x+x’y’+yx+yy’=x’y’+yx
if(ok==0) //toate i-urile sunt ... multiplu de ambele sau de niciunul !!!
cout<<0;
return 0;
}
Figura 31.25: 2021-aug-II-1d

#include<iostream>
int main()
{
int n=15;
int x=3;
int y=4;
int ok=0;
//for(int i=1; i<=n; i++)

int i=1; // initializare
while(i<=n) // test de continuare
{
{
cout<<i<<" ";
ok=1;
}
i++; // incrementare
}
if(ok==0) cout<<0;
return 0;
}
Problema 2
Reprezentarea execuţiei pseudocodului:

#include<iostream>
#include<cstring>

char s[21];
char aux;
int main()
{
int i,j;
strcpy(s,"ROMANIA");
//cout<<"s : "<<s<<"\n";
//cout<<"strlen(s) : "<<strlen(s)<<"\n";
i=strlen(s)-1;
for(j=3;j>=0;j--)
{
aux=s[i]; s[i]=s[i-j]; s[i-j]=aux;
i=i-j;
}
cout<<s;
return 0;
}
/*
ARMONIA
*/
Problema 3
Figura 31.27: 2021aug-s3-II-3

#include<iostream> // char int long float
#include<cstring>
struct date
{
char CNP[14];
int anNastere;
};
struct angajat
{ struct date dp;
int venit;
} a[30];
int main()
{
char str[] = "*************";
//strcpy(a[1].dp.CNP,str);
strcpy(a[0].dp.CNP,"*************");
// ---------------------------------
a[0].dp.anNastere=2000;
a[0].venit=4000;
// ---------------------------------
cout<<"CNP : "<<a[0].dp.CNP<<"\n";
cout<<"anNastere : "<<a[0].dp.anNastere<<"\n";
cout<<"venit : "<<a[0].venit<<"\n";
return 0;
}
/*
CNP : *************
anNastere : 2000
venit : 4000
*/

Problema 1

#include<iostream>
void cuburi(int n)
{
while(n>0) { cout<< (n*n*n)<<" "; n--; }
}
int main()
{
int n=5; cuburi(n); return 0;
}

#include<iostream>
void cuburi(int n)
{
for(i=n; i>=1; i--) cout<< (i*i*i) <<" ";
}
int main()
{
int n=5; cuburi(n); return 0;
}
Problema 2

#include<iostream>
#include<iomanip>
int k, n;
int a[101][101];
void afisa()
{
cout<<"\n";
{
for(int j=1; j<=n; j++) { cout<<setw(3)<<a[i][j]<<" "; }
cout<<"\n";
}
cout<<"\n";
}
int main()
{
cin>>k>>n;
//for(int i=1; i<=n; i++) a[i][i]=k*i;
// L2-L1=L3-L2=L4-L3=2=3-1=k-1
afisa();

//a[i][j]=k*i-(i-1)+j-1;
//a[i][j]=k*i+(j-i);
a[i][j]=(k-1)*i + j;
// a[i][j] = x*i+j + y ... x=? ... y=?
afisa(); // i=1 j=1 a[1][1]=x*1+1+y k = x+1+y

// i=2 j=2 a[2][2]=x*2+2+y 2k = 2x+2+y
// ec2-ec1: k = x+1 ==> x = k-1; ==> y = k-x-1 = k-k+1-1=0
return 0;
}
/*
3 4
3 4 5 6
5 6 7 8
7 8 9 10
9 10 11 12
*/
Problema 3
Frecvenţele asociate celor două şiruri de numere:
Figura 31.28: 2021bac-s3-III-3r


#include<iostream> // neoptimizat ... !!!
#include<fstream>
ifstream fin("2021-aug-bac.txt");
const int MAX_N = 1e5 + 1;
int main()
{
int A[100001]; // memorie = 2*10ˆ5 int = 200.000 int
int B[MAX_N];
//int B[1e5 + 1]; // err : 1e5 + 1
int na, nb;

int x, y; // nu le folosesc
int nrpa; // nr perechi asemenea
int a12; // ultimele 2 cifre din A[ia]

int b12; // ultimele 2 cifre din B[ib]
int b21; // ultimele 2 cifre din B[ib] permutate
fin>>na>>nb;
for(int i=1; i<=na; i++) fin>>A[i];
for(int i=1; i<=nb; i++) fin>>B[i];
cout<<"na = "<<na<<" nb = "<<nb<<"\n";

for(int i=1; i<=na; i++) cout<<A[i]<<" "; cout<<"\n";
for(int i=1; i<=nb; i++) cout<<B[i]<<" "; cout<<"\n\n";
nrpa=0;
for(int ia=1; ia<=na; ia++)
{
a12=A[ia]%100;
for(int ib=1; ib<=nb; ib++) // calcul = na*nb = 10ˆ5*10ˆ5 = 10ˆ10
{
b12=B[ib]%100;
b21=(b12%10)*10 + b12/10;
if(a12==b12 || a12==b21)
{
nrpa++;
cout<<nrpa<<" : "<<A[ia]<<" "<<B[ib]<<"\n";
}
}
}
cout<<nrpa;
return 0;
}
/*
na = 9 nb = 7
112 20 42 112 5013 824 10012 55 155
402 1024 321 521 57 6542 255
1 : 112 321
2 : 112 521
3 : 20 402
4 : 42 1024
5 : 42 6542
6 : 112 321
7 : 112 521
8 : 824 1024
9 : 824 6542
10 : 10012 321
11 : 10012 521
12 : 55 255
13 : 155 255
13
*/

#include<iostream> // optimizat ... micsorez timpul ... !!!
#include<fstream>
//const int MAX_N = 1e5 + 1;
int f2a[100]; // frecventa ultimelor 2 cifre 00, 01, ..., 99 din A[];
int f2b[100]; // frecventa ultimelor 2 cifre 00, 01, ..., 99 din B[];
int main()
{
//int A[100001];
//int B[MAX_N];
//int B[1e5 + 1]; // err : 1e5 + 1
int na, nb;

int x, y; // elemente din A, respectiv B
int c1; // cifra zecilor

int c2; // cifra unitatilor
int c12, c21; // nr cu cele 2 cifre (si inversate)
fin>>na>>nb;
cout<<"na = "<<na<<" nb = "<<nb<<"\n";
for(int ia=1; ia<=na; ia++) // calcul = na = 100.000 max

{
fin>>x;
cout<<x<<" ";
c12=x%100; c1=c12/10; c2=c12%10; c21=c2*10+c1;
if(c12 < c21) f2a[c12]++; else f2a[c21]++; // 73 --> 37
}
cout<<"\n";
for(int ib=1; ib<=nb; ib++) // calcul = nb = 100.000 max

{
fin>>y;
cout<<y<<" ";
c12=y%100; c1=c12/10; c2=c12%10; c21=c2*10+c1;
if(c12 < c21) f2b[c12]++; else f2b[c21]++; // 73 --> 37
}
cout<<"\n\n";
nrpa=0;
for(int i=0; i<=99; i++) // calcul = 100
{
if(f2a[i]==0 || f2b[i]==0) continue;
cout<<i<<" : "<<f2a[i]<<" "<<f2b[i]<<"\n";

nrpa=nrpa+f2a[i]*f2b[i];
}
cout<<nrpa;
return 0;
}
/*
na = 9 nb = 7
112 20 42 112 5013 824 10012 55 155
402 1024 321 521 57 6542 255
2 : 1 1
12 : 3 2
24 : 2 2
55 : 2 1
13
*/

#include<iostream> // optimizat ... un singur vector de frecvente
#include<fstream>
//const int MAX_N = 1e5 + 1;
int f2a[100]; // frecventa ultimelor 2 cifre 00, 01, ..., 99 din A[];
int main()
{
//int A[100001];
//int B[MAX_N];
//int B[1e5 + 1]; // err : 1e5 + 1
int na, nb;

int x, y; // elemente din A, respectiv B
int c1; // cifra zecilor

int c2; // cifra unitatilor
int c12, c21; // nr cu cele 2 cifre (si inversate)
fin>>na>>nb;
cout<<"na = "<<na<<" nb = "<<nb<<"\n";
for(int ia=1; ia<=na; ia++) // calcul = na = 100.000 max

{ fin>>x;
cout<<x<<" ";
c12=x%100; c1=c12/10; c2=c12%10; c21=c2*10+c1; // cifrele invers

if(c1 < c2) f2a[c12]++; else f2a[c21]++; // 73 --> 37
}
cout<<"\n";
nrpa=0;
for(int ib=1; ib<=nb; ib++) // calcul = nb = 100.000 max
{
fin>>y;
cout<<y<<"\t";
c12=y%100; c1=c12/10; c2=c12%10; c21=c2*10+c1;

if(c2 < c1) c12=c21; // cel mai mic ...
nrpa+=f2a[c12];
cout<<ib<<" : "<<f2a[c12]<<" --> "<<nrpa<<"\n";
}
cout<<"\n";
cout<<nrpa;
return 0;
}
/*
na = 9 nb = 7
112 20 42 112 5013 824 10012 55 155
402 1 : 1 --> 1
1024 2 : 2 --> 3
321 3 : 3 --> 6
521 4 : 3 --> 9
57 5 : 0 --> 9
6542 6 : 2 --> 11
255 7 : 2 --> 13
13
*/

Capitolul 32
BAC 2020

32.1.1 Subiectul I
Problema 1
5.0©2 2.5 pentru că 5.0 este un număr real şi ı̂mpărţirea se face ı̂n mulţimea numerelor reale.
Rezultatul este 3 2.5 2 7.5
Dacă ar fi fost 5©2 atunci 5©2 2 pentru că 5 este un număr ı̂ntreg şi ı̂mpărţirea s-ar fi făcut
ı̂n mulţimea numerelor ı̂ntregi (operatorul aritmetic © dă câtul ı̂mpărţirii iar operatorul aritmetic
% dă restul ı̂mpărţirii).
Problema 2
Notăm v 0 a, v 1 b, v 2 c şi v 3 d. Trebuie să determinăm valorile a, b, c, d.
O primă observaţie utilă este că afişarea din funcţia f se face ”după” apelul recursiv, deci pe
traseul de ”ı̂ntoarcere” (al apelurilor recursive).
Prima afisare se face la momentul ”s5”, a doua la momentul ”s6”, ... aşa că pe ecran vor
apărea valorile: d 1 c b a. De aici rezultă că trebuie să avem d 1 2, c 0, b 2 şi a 0.
A doua observaţie: se poate ı̂ncepe cu ”rularea” funcţiei f (ca ı̂n figură) pentru a), apoi pentru
b) şi gata! (se obţine deja rezultatul).
334
”Confirmarea” se poate obţine folosind următorul program:

#include<iostream>
void f(int i, int v[4])

{
if(i>=3) v[i]=v[i]+1;
else f(i+1,v);
cout<<v[i];
}
int main()
{
// a)
//int v[]={-1,1,0,2};
// b)
int v[]={0,2,0,1};
// c)
//int v[]={1,-1,0,1};
// d
//int v[]={2,0,1,0};
f(0,v);
return 0;
}
Problema 3
Am notat prin s1, s2, s3 şi s4 cele patru sume care trebuie să respecte condiţia de a fi
un şir strict descrescător. În desen am renunţat uneori la un zero pentru a uşura un pic scrierea
configuraţiilor de numere!
Sunt câteva observaţii care se pot face!

s1 nu poate ı̂ncepe cu valoarea 6 (sau 60 dacă nu renunţ la acel ”zero”) pentru că prima
sumă posibilă ar fi ı̂n acest caz 6+5+4+3=18 şi mai mult de atât nu se poate obţine (sau mai
mult de 180 dacă nu renunţam la acel zero!).
Prima configuraţie posibilă (de ı̂ncercat!) este 7 6 5 4 care conduce la o sumă = 22 dar aceasta
se poate micşora ca să ajungă la 20 (sau 200 dacă ...).
O configuraţie care ı̂ncepe cu 7 5 nu conduce la o configuraţie validă pentru că 7+5+4+3 =
19 şi această sumă nu se mai poate mări.
Notez s12 s1 s2 şi s34 s3 s4.
Ce urmează după configuraţia 80 60 40 20 (sau 8 6 4 2 dacă folosesc o notaţie ”simplificată”)?
s12 80 60 140 şi s34 40 20 60. Evident 60 se poate scrie ca 50+10 deci 80 60 50
10 este a cincea configuraţie.
Ce urmează după 80 60 50 10? În s23 60 nu mai putem construi altă configuraţie, aşa că
trebuie să ”mărim” configuraţie din s12. Ce urmează după configuraţia 80 60?
Urmează 80 70 iar pentru această configuraţie s12 80 70 150 iar s34 200 150 50.
50 se poate realiza cu 30+20 sau 40+10 iar cea mai ”mică” configuraţie este 30 20.
În concluzie, a şasea configuraţie este: c) 80 70 30 20.
Problema 4
tata[6]=0 deci nodul 6 este rădă cina arborelui.
tata[3]=tata[7]=6 ı̂nseamnă că 3 şi 6 sunt ”fiii” lui 6.
La fel se completează nivelurile următoare!
Problema 5
Din ciclul [1,2,3,4,1] se poate elimina oricare muchie.


Problema 1
Figura 32.5: 2020bac-s1-II-1a-rd

#include<iostream>
int main()
{
int a=240107; // 1 1 1 0 0 corespunde cifrelor
//int a=283157; // 0, 2, 4, 6, 8 daca au fost gasite
int c, b, x;
c=0; // cifra c este 0 la inceput

do
{
b=a; // copie a lui a
x=0;
do
{
if(b%10 == c) x=1;
b=b/10;
} while( !((b==0)||(x==1)) ); // daca a gasit cifra c sau a parcurs toate
cifrele ... se opreste
cout<<x<<’ ’;
c=c+2; // cifra devine 2, apoi 4, apoi 6, ... deci cauta cifrele pare
} while( !(c>9) );
return 0;
}

#include<iostream>
int main()
{
//int a=20468;
int a=86420;
int c, b, x;
c=0; // cifra c este 0 la inceput

do
{
b=a; // copie a lui a
x=0;
do
{
if(b%10 == c) x=1;
b=b/10;
} while( !((b==0)||(x==1)) ); // daca a gasit cifra c sau a parcurs
cout<<x<<’ ’; // toate cifrele ... se opreste
c=c+2; // cifra devine 2, apoi 4, apoi 6, ... deci cauta cifrele pare
} while( !(c>9) );
return 0;
}
Figura 32.6: 2020-mai-II-1d
Problema 2
Structura ı̂nregistrării:
Declarărea variabilei ı̂n afara definirii structuri:
Listing 32.1.4: 2020bac-s1-II-2-v1a.cpp

#include<iostream>
int main()
{
//------------ structuri separate -----------------

struct xyz
{
int interna;
int externa;
};
struct calculator
{
char monitor;
struct xyz memorie;
};
struct calculator c;
c.monitor=’M’;
c.memorie.interna=123456;
c.memorie.externa=654321;
cout<<"monitor : "<<c.monitor<<"\n";
cout<<"memorie.interna : "<<c.memorie.interna<<"\n";
cout<<"memorie.externa : "<<c.memorie.externa<<"\n";
return 0;
}

#include<iostream>
int main()
{
//------------ structura interna cu nume -----------------
struct calculator
{
char monitor;
struct xyz
{
int interna;
int externa;
} memorie;
};
c.monitor=’M’;
return 0;
}

#include<iostream>
int main()
{
//------------ structura interna fara nume -----------------
struct calculator
{
char monitor;
struct /* "anonymous struct" */ /* No name */
{
int interna;
int externa;
} memorie;
};
c.monitor=’M’;
return 0;
}
Declarărea variabilei la momentul definirii structuri:
Listing 32.1.7: 2020bac-s1-II-2-v1b.cpp

#include<iostream>
int main()
{
struct xyz
{
int interna;
int externa;
};
struct calculator
{
char monitor;
struct xyz memorie;
} c;
//struct calculator c;
c.monitor=’M’;
return 0;
}

#include<iostream>
int main()
{
struct xyz
{
int interna;
int externa;
};
struct calculator
{
char monitor;
struct xyz memorie;
} c;
c.monitor=’M’;
return 0;
}

#include<iostream>
int main()
{
//------------ structura interna fara nume -----------------
struct calculator
{
char monitor;
struct /* "anonymous struct" */ /* No name */
{
int interna;
int externa;
} memorie;
} c;
c.monitor=’M’;
return 0;
}
Problema 3

#include<iostream>
#include<cstring>
const int n=9;
char a[n][n];
//char a[n+1][n+1];
void afisa()
{
int i,j;
for(i=0; i<n; i++)

{
for(j=0; j<n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
int i,j;
for(i=0; i<n; i++)

for(j=0; j<n; j++)
if(j>8-i && j<i)
a[i][j]=’1’; // in loc de < ca sa se vada mai bine
else
a[i][j]=’0’; // in loc de > ca sa se vada mai bine
afisa();
return 0;
}

Problema 1
Listing 32.1.11: 2020-mai-III-1.cpp

#include<iostream>
int suma(int a, int b)

{
int s=0;
int d;
int minab;
minab=a;
if(b<minab) minab=b;
for(d=1; d<=minab; d++)

{
if((a%d == 0) && (b%d == 0))
s=s+d;
}
return s;
}
int main()
{
int a=20;
int b=12;
int rez=suma(a,b);
return 0;
}
Problema 2
Soluţia 1: Citirea textului caracter cu caracter şi prelucrarea caracterelor.
Listing 32.1.12: 2020-mai-III-2-v1.cpp

#include<iostream> // "il transforma in memorie ..."
#include<cstring>
char t[101];
int n; // lungimea textului
int main()
{
int i, i1, i2;
char primalitera;
char c;
i=0;
while((char)(c=getchar()) != ’\n’) // citire caractere pana la <Enter>
{
t[i]=c;
i++;
}
n=strlen(t);
i1=0;
i2=0;
while(i1<n)
{
while(t[i2]>=’a’ && t[i2]<=’z’) i2++; // i2 este plasat pe spatiu
if((i2-1)-(i1-1) < 3) // nu are cel putin 3 litere ...

{
i1=i2+1;
i2++; // se muta de pa spatiu spre dreapta ...
continue; // reia bucla while(i1<ns)
}
// cuvantul dintre i1 .. i2-1 are cel putin 3 litere

// prima litera ajunge ultima ...
primalitera=t[i1];
for(i=i1; i<=i2-2; i++)
t[i]=t[i+1];
t[i2-1]=primalitera;
i1=i2+1;
i2++; // se muta de pe spatiu spre dreapta ...
}
cout<<t;
return 0;
}
/*
un palc mic de scolarite ilumina sala
*/
Soluţia 2: Citirea directă a liniei de text şi prelucrarea caracterelor.

#include<iostream> // "il transforma in memorie ..."
#include<cstring>
char t[101];
int main()
{
int i, i1, i2;
char primalitera;
cin.get(t,101); // citire line

n=strlen(t);
i1=0;
i2=0;
while(i1<n)
{
while(t[i2]>=’a’ && t[i2]<=’z’) i2++; // i2 este plasat pe spatiu
if((i2-1)-(i1-1) < 3) // nu are cel putin 3 litere ...
{
i1=i2+1;
continue; // reia bucla while(i1<ns)
}
// cuvantul dintre i1 .. i2-1 are cel putin 3 litere

// prima litera ajunge ultima ...
primalitera=t[i1];
for(i=i1; i<=i2-2; i++)
t[i]=t[i+1];
t[i2-1]=primalitera;
i1=i2+1;
}
cout<<t;
return 0;
}
/*
*/
Soluţia 3: Citirea directă a liniei de text şi prelucrarea cuvintelor cu strtok.

#include<iostream> // "il transforma in memorie ..." ... in alta variabila ...
#include<cstring>
char t[101]; // text

char s[101]; // solutie
char x[101]; // cuvant

int nx; // lungimea lui x
int main()
{
cin.get(t,101);
n=strlen(t);
char * pch;
pch=strtok(t," ");
while(pch != NULL)
{
strcpy(x,pch);
nx=strlen(x);
if(nx>=3)
{
char x0=x[0];
strcpy(x,x+1);
x[nx-1]=x0;
}
strcat(x," ");
strcat(s,x);
}
s[n]=’\0’; // pus ’\0’ peste spatiul de la sfarsit
cout<<s;
return 0;
}
/*
*/
Problema 3

#include<iostream>
#include<fstream>
ifstream fin("2020-mai-bac.txt");
int f[1001]; // vector de frecvente; valori: 1..1000
int main()
{
int x;
int nv=0;
int nrfimp; // numar frecvente impare
fin>>x;
while(!fin.eof())
{
f[x]++;
nv++;
fin>>x;
}
/*
while(fin>>x) // este ok si asa
{
cout<<nv<<" : "<<x<<"\n";
f[x]++;
nv++;
}
*/
nrfimp=0;
for(int i=1; i<=1000; i++)
if(f[i]%2 == 1) nrfimp++;
if((nv%2 == 0 && nrfimp == 0) ||

(nv%2 == 1 && nrfimp == 1))
cout<<"DA";
else
cout<<"NU";
return 0;
}


32.2.1 Subiectul I
Problema 1
1000 & x & 2000 1000 999 & x 999 & 2000 999 1&x 999 & 1001 x 999%1000 "
r0, 1, ..., 999x şi pentru x 1999 se obţine 0.
Problema 2
Problema 3

Problema 4
Problema 5

Problema 1
Listing 32.2.1: 2020-iunie-II-1a.cpp

#include<iostream>
int main()
{
int n;
int m, i, x;
cin>>n; //cout<<"n = "<<n<<"\n";

for(i=1; i<=n; i++)
{
cin>>x; //cout<<"\nx = "<<x<<"\n";
while((x%10) > (x/10)%10)
{ //cout<<(x%10)<<" > "<< (x/10)%10 << " x = "<< x<< "\n";
x=x/10;
}
m=m+x;
//cout<<"\nm = "<<m<<"\n";
}
if(m>0) cout<<m;
else cout<<"niciunul";
return 0;
}
/*
5 127 2019 1005 7 1900
*/
Listing 32.2.2: 2020-iunie-II-1b.cpp

#include<iostream>
int main()
{
int n;
int m, i, x;
cin>>n;
//cout<<"n = "<<n<<"\n";
for(i=1; i<=n; i++)

{
cin>>x;
//cout<<"\nx = "<<x<<"\n";
while((x%10) > (x/10)%10)

{
//cout<<(x%10)<<" > "<< (x/10)%10 << " x = "<< x<< "\n";
x=x/10;
}
m=m+x;
//cout<<"\nm = "<<m<<"\n";
}
if(m>0)
cout<<m;
else
cout<<"niciunul";
return 0;
}
/*
2 1234 2345
*/
Figura 32.14: 2020-iunie-II-1d

Problema 2
Listing 32.2.3: 2020-iunie-II-2.cpp

#include<iostream>
#include<cstring>
struct cc // centrul cercului

{
double x;
double y;
};
struct figura
{
struct cc centru;
double raza;
};
int main()
{
struct figura c;
c.centru.x = 1.1; c.centru.y = 2.2; c.raza = 3.3;

cout<<"x = "<<c.centru.x<<"\n";
cout<<"y = "<<c.centru.y<<"\n";
cout<<"raza = "<<c.raza<<"\n";
return 0;
}
Problema 3

Listing 32.2.4: 2020-iunie-II-3.cpp

#include<iostream>
#include<cstring>
const int n=7;

char m[n][n];
void afism()
{
int i,j;
for(i=0; i<=n-1; i++)
{
for(j=0; j<=n-1; j++)
cout<<m[i][j]<<" ";
cout<<"\n";
}
cout<<"\n";
}
int main()
{
int i,j;
for(i=0; i<=n-1; i++)

for(j=0; j<=n-1; j++)
m[i][j]=’*’;
afism();
for(i=0; i<n; i++)

for(j=0; j<n; j++)
if(j<i) // inainte de diagonala principala
m[i][j]=’+’;
else m[i][j]=’a’+j-i;
afism();
return 0;
}

Problema 1
Listing 32.2.5: 2020-iunie-III-1.cpp

#include<iostream>
int multiplu(int n) //
{
int m=1; // m*n = multiplu de n
while(sqrt(m*n)*sqrt(m*n) != m*n) // verificare de "patrat"
{
m++;
}
return m*n;
}
int multiplu2(int n)
{
int mn=n; // la inceput sunt egale
// ------------------------------
int d=2;
int nd; // de cate ori apare d in n
nd=0;
while(n%d == 0)
{
nd++;
n=n/d;
//cout<<d<<" ";
}
if(nd%2==1)
{
mn=mn*d; // d sa apara de un numar par de ori
//cout<<"("<<d<<") ";
}
// ------------------------
d=3;
while(d*d <= n) // while(n>1)
{
//cout<<"\nincerc ... "<<d<<"\n";
nd=0;
// scot d din factorii lui n
while(n%d == 0)
{
nd++;
n=n/d;
//cout<<d<<" ";
}
if(nd%2 == 1)
{
mn=mn*d; // d sa apara de un numar par de ori
//cout<<"("<<d<<") ";
}
d=d+2; // d=3, 5, 7, ... parele s-au scos cu d=2
}
// ------------------------
//cout<<"\nA ramas n = "<<n<<"\n";
if(n>1) // NU daca am folosit while(n>1)
{
mn=mn*n; //cout<<"("<<n<<") ";
}
//cout<<"\n";
return mn;
}
int main()
{
int n;
n=72;
//n=144;
//n=2*2*3*5*5*7;
int rez=multiplu2(n);
cout<<rez<<"\n";
return 0;
}
Problema 2
Listing 32.2.6: 2020-iunie-III-2.cpp

#include<iostream>
#include<cstring>
char text[101];
char p1=’<’;
char p2=’>’;
char spatiu=’ ’;
int citat; // = 1 daca sunt in zona de citat, 0 altfel
int main()
{
int i, n;
cin.get(text,100);
n=strlen(text);
//cout<<text<<" : "<<n<<"\n";
citat=0;
for(i=0; i<=n-1; i++)
{
//cout<<i<<" : "<<text[i]<<" : ";
if(text[i]==p1) // atentie la = si ==
{
citat=1;
//cout<<" p1 ";
}
else
if(text[i]==p2)
{
citat=0;
//cout<<" p2 ";
}
else
if(text[i]==spatiu)
{
//cout<<" spatiu ";
}
else // este litera
if(citat==1)
{
//cout<<" litera in citat ";
text[i]=text[i]-(’a’-’A’);
}
else
{
//cout<<" litera in text ";
}
//cout<<text[i]<<"\n";
}
cout<<text<<"\n";
return 0;
}
/*
mai bine sa fii un <om de valoare> decat un <om de succes>
*/
Problema 3
Listing 32.2.7: 2020-iun-III-3-v1.cpp

#include<iostream> // atentie la "diferenta intre cei doi vecini ... "
#include<fstream>
const int MAX_N = 1e6+1;
int v[MAX_N];
ifstream fin("2020-iun-bac.txt");
int main()
{
int x;
int nv=0; // nr de valori din fisier (numere naturale: 0, 1, 2, ...)
int varfmax;
int difvec; // diferenta intre vecini
int difmin; // diferenta minima
while(fin>>x)
{
cout<<nv<<" : "<<x<<"\n";
v[nv]=x;
nv++;
}
cout<<"nv = "<<nv<<"\n";
varfmax=-1; // nu exista o astfel de valoare in fisier

for(int i=1; i<=nv-2; i++) // v[0] v[1] v[2] ... v[n-3] v[n-2] v[n-1]
{
if(v[i]<=v[i-1]) continue;
if(v[i]<-v[i+1]) continue;
if(varfmax==-1) // a aparut primul varf
{
varfmax=v[i];
difvec=v[i+1]-v[i-1];
if(difvec>0)
difmin=difvec;
else
difmin=-difvec;
continue; // ia alt element
}
// aici se ajunge la varful 2, 3, ...

difvec=v[i+1]-v[i-1];
if(difvec<0) difvec=-difvec; // diferenta absoluta
if(difvec>difmin) continue; // diferenta este mai mare
if(difvec<difmin) // defirenta este mai mica

{
varfmax=i;
difmin=difvec;
continue; // merc la valoarea urmatoare
}
// aici se ajunge daca difvec = difmin ... se alege varful maxim

if(v[i]>varfmax) varfmax=v[i];
}
if(varfmax>0)
cout<<varfmax;
else
cout<<"nu exista";
return 0;
}
Listing 32.2.8: 2020-iun-III-3-v2.cpp

#include<iostream> // atentie la "diferenta intre cei doi vecini ... "
#include<fstream> // optimizare ca spatiu: variabile v1, v2, v3 in loc de vector
ifstream fin("2020-iun-bac.txt");
int main()
{
int x;
int nv=0; // nr de valori din fisier (numere naturale: 0, 1, 2, ...)
int varfmax;
int difvec; // diferenta intre vecini
int difmin; // diferenta minima
int gasitvarf; // 0:nu este gasit; 1:este gasit
int v1, v2, v3;
if(fin>>x) // citesc primul numar: v1

{
v1=x;
}
else
{
cout<<"nu exista";
return 0;
}
if(fin>>x) // citesc al doilea numar: v2

{
v2=x;
}
else
{
cout<<"nu exista";
return 0;
}
// caut primul varf v2 in secventa: v1 v2 v3

gasitvarf=0;
while(gasitvarf==0 && (fin>>x))
{
v3=x;
if(v1<v2 && v2>v3) // primul varf

{
difvec=v3-v1;
if(difvec<0) difvec=-difvec; // valoare absoluta (pozitiva)
varfmax=v2;
gasitvarf=1;
}
else
{
v1=v2;
v2=v3;
}
}
if(gasitvarf==1)
{
}
else
{
cout<<"nu exista";
return 0;
}
// caut pana la sfarsitul fisierului alte varfuri (unul deja exista)

while(fin>>x)
{
v1=v2;
v2=v3;
v3=x;
if(v1<v2 && v2>v3) // daca v2 este varf

{
difvec=v3-v1;
if(difvec<0) difvec=-difvec; // valoare absoluta (pozitiva)
// v2 este varf mai bun ?

if(difvec<difmin)
{
varfmax=v2;
difmin=difvec;
}
else
if(difvec==difmin && v2>varfmax)
{
varfmax=v2;
}
}
// merg mai departe in sir

}
cout<<varfmax;
return 0;
}


32.3.1 Subiectul I
Problema 1
x%2000 " r0, 1, ..., 1999x aşa că ... răspunsul corect este 1999.
Problema 2
Listing 32.3.1: 2020-august-I-2.cpp

#include<iostream>
void f(int x)
{
cout<<"*";
if(x>5) f((x+1)/2);
}
int main()
{
cout<<"f(30): "; f(30); cout<<"\n";
cout<<"f(21): "; f(21); cout<<"\n";
cout<<"f(17): "; f(17); cout<<"\n";
cout<<"f(8): "; f(8); cout<<"\n";
return 0;
}
/*
f(30): ****
f(21): ****
f(17): ***
f(8): **
*/
Problema 3
Problema 4
Problema 5


Problema 1
Listing 32.3.2: 2020-august-II-1a.cpp

#include<iostream>
int main()
{
int n;
int m;
int c;
cin>>n;
do
{
c=n%10;
n=n/10;
if(c<5)
m=m-2*c;
else
m=m+c;
} while( !(n==0) );
if(m==0)
cout<<"DA";
else
cout<<m<<"NU";
return 0;
}
/*
247388
*/
Listing 32.3.3: 2020-august-II-1b.cpp

#include<iostream>
int main()
{
int n;
int m;
int c;
cin>>n;
do
{
c=n%10;
n=n/10;
if(c<5)
m=m-2*c;
else
m=m+c;
} while( !(n==0) );
if(m==0)
cout<<"DA";
else
cout<<m<<"NU";
return 0;
}
/*
247388
*/
Figura 32.22: 2020-aug-II-1d
Listing 32.3.4: 2020-august-II-1d.cpp

#include<iostream>
int main()
{
int n;
int m;
int c;
cin>>n;
while( !(n==0) )
{
c=n%10;
n=n/10;
if(c<5)
m=m-2*c; // scad din m dublul cifrelor mici (<5)
else
m=m+c; // adaug in m cifrele mari (>= 5)
}
if(m==0) // suma cifrelor ’mari’ egala cu dublul sumei cifrelor ’mici’

cout<<"DA";
else
cout<<m<<"NU";
return 0;
}
/*
126
381
*/
Problema 2
Listing 32.3.5: 2020-august-II-2-v1.cpp

#include<iostream>
struct procesor
{
char producator;
int frecventa;
double pret;
} ;
int main()
{
struct procesor p[20];
p[0].producator=’X’;
p[0].frecventa=2200;
p[0].pret=1234.567;
cout<<"producator : "<<p[0].producator<<"\n";
cout<<"frecventa : "<<p[0].frecventa<<"\n";
cout<<"pret : "<<p[0].pret<<"\n";
return 0;
}

#include<iostream>
struct procesor
{
char producator;
int frecventa;
double pret;
} p[20];
int main()
{
//struct procesor p[20];
p[0].pret=1234.567;
return 0;
}

#include<iostream>
struct
{
char producator;
int frecventa;
double pret;
} p[20];
int main()
{
//struct procesor p[20];
p[0].pret=1234.567;
return 0;
}
Problema 3
Listing 32.3.8: 2020-august-II-3.cpp

#include<iostream>
int m=6; // nr linii

int n=4; // nr. coloane
int a[6][4] =
{
{2, 3, 4, 5},
{8, 7, 8, 5},
{1, 3, 5, 7},
{3, 0, 2, 9},
{3, 5, 1, 6},
{7, 3, 0, 2},
};
void afisa()
{
int i, j;
for(i=0; i<m; i++)

{
for(j=0; j<n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
int i, k;
afisa();
// -------------------------------------------------
// bubble sort
for(i=0; i<=m-2; i++) // compar a[i][2] cu a[j][2], i<j<=m-1
{
if(a[i][2]%2==1) continue; // nu este par ... !!!
for(k=i+1; k<=m-1; k++)

{
if(a[k][2]%2==1) continue; // nu este par ... !!!
if(a[i][2] > a[k][2]) // interschimbare (a[i] sa fie cel mai mic)

{
int aux;
aux=a[i][2];
a[i][2]=a[k][2];
a[k][2]=aux;
}
}
}
// -------------------------------------------------
afisa();
return 0;
}

Problema 1
Listing 32.3.9: 2020-august-III-1.cpp

#include<iostream>
int kpn(int a, int b, int k)

{
int sdi; // suma divizorilor lui i
int nrp=0; // numarul p-numerelor gasite
for(int i=a; i<=b; i++)

{
sdi=0; // i se divide prin 1
for(int d=1; d<=i; d++) // d=divizor
{
if(i%d == 0) sdi=sdi+d;
}
if((i%2) == (sdi%2)) nrp++;

if(nrp==k) { return i; }
}
return -1;
int main()
{
int a, b, k;
int rez;
a=27; b=50; k=3;
rez=kpn(a,b,k);
return 0;
}
Problema 2
Figura 32.24: 2020bac-s3-III-2-rd
Listing 32.3.10: 2020-august-III-2 v1.cpp

#include<iostream>
#include<cstring>
char s[101];
int n; // lungimea sirului
int nc; // nr cuvinte in oglinda
int nlcc; // nr litere cuvant curent
int i1, i2; // pozitii inceput si sfarsit cuvant curent
void calcul() // cuvant curent i1..i2

{
int i;
nlcc=i2-(i1-1);
if(nlcc%2==0) return; // nr par de litere
// verific daca este palindrom

int pal=1; // 1 = este palindrom; 0 = nu este palindrom
for(i=0; i<=nlcc/2; i++)

{
if(s[i1+i] != s[i2-i])
{
pal=0;
break;
}
}
if(pal==1) return; // este palindrom
nc++; // maresc numarul cuvintelor in oglinda
char aux; // interschimb literele

{
aux=s[i1+i];
s[i1+i]=s[i2-i];
s[i2-i]=aux;
}
}
int main()
{
cin.get(s,100);
n=strlen(s);
//cout<<s<<" : "<<n<<"\n";
i1=0;
for(int i=0; i<=n-1; i++)
{
if(i==n-1) // s-a terminat ultimul cuvant
{
i2=n-1;
calcul();
}
else
if(s[i]>=’a’ && s[i]<=’z’)
{
// nimic
}
else // este spatiu ... s-a terminat cuvantul curent
if(s[i]==’ ’)
{
i2=i-1; // cuvant: i1 .. i2
calcul();
i1=i2+2; // inceputul altui cuvant
}
else
{
cout<<"EROARE date !!!";
return 1;
}
}
if(nc>0)
cout<<s<<"\n";
else
cout<<"nu exista";
return 0;
}
/*
era o selectie reper de desene animate prezenta
reper pentru desene

*/
Listing 32.3.11: 2020-august-III-2 v2.cpp

#include<iostream>
#include<cstring>
char s[101];
char sol[101];
char x[101];
int pozx; // pozitia lui x in s
int n; // lungimea sirului

int nc; // nr cuvinte in oglinda
void calcul() // cuvant curent i1..i2

{
int nlcc; // nr litere cuvant curent
int i1, i2; // pozitii inceput si sfarsit cuvant curent

int i;
nlcc=strlen(x);
i1=0; // prima pozitie in x

i2=nlcc-1; // ultima pozitie in x
if(nlcc%2==0) // nr par de litere

{
//cout<<x<<" ";
strcat(sol,x); strcat(sol," ");
return;
}
// verific daca este palindrom
int pal=1; // 1 = este palindrom; 0 = nu este palindrom

{
if(x[i1+i] != x[i2-i])
{
pal=0;
break;
}
}
if(pal==1) // este palindrom

{
//cout<<x<<" ";
return;
}
nc++; // maresc numarul cuvintelor in oglinda

char aux; // interschimb literele

{
aux=x[i1+i];
x[i1+i]=x[i2-i];
x[i2-i]=aux;
}
//cout<<x<<" ";
return;
}
int main()
{
cin.get(s,100);
n=strlen(s);
//cout<<s<<" : "<<n<<"\n";
char * pch; // pointer la char
pch = strtok (s," "); // prima citire
while (pch != NULL)

{
strcpy(x,pch);
pozx=pch-s;
//cout<<x<<" : "<<pozx<<"\n";
calcul();

}
if(nc>0)
{
sol[strlen(sol)-1]=’\0’; // sterg ultimul spatiu ...
cout<<sol<<"\n";
}
else
{
cout<<"nu exista";
}
return 0;
}
/*
era o selectie reper de desene animate prezenta
reper pentru desene

*/
Problema 3
Listing 32.3.12: 2020-august-III-3.cpp

#include<iostream>
#include<fstream>
int main()
{
int x;
int vmax=9; // initializare cu valmin-1
int vmin=100; // initializare cu valmaxx+1
while(fin>>x)
{
if(x>9 && x<100)
{
if(x<vmin) vmin=x;
if(x>vmax) vmax=x;
}
cout<<"x = "<<x<<" vmin = "<<vmin<<" vmax = "<<vmax<<"\n";
}
if(vmax>9)
cout<<vmin-1<<" "<<vmax+1;
else
cout<<"nu exista";
return 0;
}

Capitolul 33
BAC 2019

Varianta 1
33.1.1 Subiectul I
Problema 1
Expresia dată: E = (x<3) && (y>=5)
a. !((x<3) || (y>=5)) = !(x<3) && !(y>=5) = (x>=3) && (y<5)
b. !(x>=3) && (y<5) = (x<3) && (y<5)
c. !(!(x<3) || !(y>=5)) = (x<3) && (y>=5) = E
d. !((x>=3) && (y<5)) = !(x>=3) || !(y<5)) = (x<3) || (y>=5)
Problema 2
Se ı̂nţelege clar că m şi n sunt cele două numere iar d este divizor. Apelul f(x,y,x) arată că se
transmit cele două numere x şi y iar pe post de divizor de inceput se transmite unul dintre numere,
de exemplu x.
Apelurile f(m+1,n+1,d) şi f(m-1,n-1,d) se pot elimina din analiza noastră pentru că schimbă
numerele m şi n. Rămâne să analizăm apelurile f(m,n,d+1) şi f(m,n,d-1).
Este clar că nu trebuie mărit divizorul deja ı̂ncercat, deci apelul cu d+1 este eliminat.
Dacă x=9 şi y=6 atunci apelurile sunt: f(9,6,9) = f(9,6,8) = f(9,6,7) = f(9,6,6) = f(9,6,5) =
f(9,6,4) = f(9,6,3) = 3;
Listing 33.1.1: 2019-s1-I-2.cpp

#include<iostream>
void f(int m, int n, int d)

{
if(n%d==0 && m%d==0)
cout<<d;
//else f(m,n,d+1);
else f(m,n,d-1);
//else f(m+1,n+1,d);
//else f(m-1,n-1,d);
}
int main()
{
int x, y, z;
x=12;
y=18;
f(x,y,x);
return 0;
}
366
Problema 3
Ca să fie mai ”uşor” sunt utile codificări cu cifre sau litere.
Problema 4
Problema 5


Problema 1
Listing 33.1.2: 2019-mai-II-1a.cpp

#include<iostream>
int main()
{
int n, k, p, i, x;
//cin>>n>>k;
n=10; // numerele 1..n
k=3; // factorul k
p=0;
i=1;
while(i <= n)// numerele 1..n
{
x=i; // copie a lui i
while(x%k == 0) // x se divide prin k
{
x=x/k; // scot factorul k din x
p=p+1;
}
cout<<"i = "<<i<<" : "<<k<<"ˆ"<<p<<"\n";
i=i+1;
}
cout<<p;
return 0;
}
Problema 2
Listing 33.1.3: 2019-mai-II-2.cpp

#include<iostream>
struct tdata
{
int zi,luna;
} d;
struct eveniment
{
int nr;
struct tdata dev;
} e;
int main()
{
struct tdata d1, d2, d3, d4, d;
e.dev.zi=22;
e.dev.luna=6;
e.nr=33;
d1.zi=21;
d1.luna=6;
d2.zi=22;
d2.luna=5;
d3.zi=22;
d3.luna=7;
d4.zi=23;
d4.luna=6;
// luna mai mica sau

// lunile sunt egale dar ziua este mai mica
// ((d.luna<e.dev.luna) || ((d.luna==e.dev.luna) && (d.zi<e.dev.zi)))
d=d1;
cout<<((d.luna<e.dev.luna) || ((d.luna==e.dev.luna) && (d.zi<e.dev.zi)))<<"\n";
d=d2;
cout<<((d.luna<e.dev.luna)||((d.luna==e.dev.luna) && (d.zi<e.dev.zi)))<<"\n";
d=d3;
d=d4;
return 0;
}
Problema 3
Listing 33.1.4: 2019-mai-II-3.cpp

#include<iostream>
int a[6][6]; // este initializat automat cu 0
int main()
{
int i,j;
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
//if(i==j) a[i][j]=5-i;
//else
if(j<i)
a[i][j]=a[j][j];
//a[i][j]=5-j; // sub diagonala principala este cu inegalitate stricta
else a[i][j]=5-i; // deasupra diagonalei principale
for(i=1; i<=5; i++)

{
for(j=1; j<=5; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}

Problema 1

#include<iostream>
int Egal(int n)
{
int pci; // prima cifra impara
while(n%2 == 0) n=n/10; // elimin cifrele pare de la sfarsit
pci=n%10; // preiau prima cifra impara

n=n/10; // elimin cifra din n
while(n != 0)
{
if((n%2 == 1) && (n%10 != pci)) // cifra impara diferita
return 0;
n=n/10;
}
return 1;
}
int main()
{
int n;
n=7727470;
//n=7921470;
int rez=Egal(n);
return 0;
}
Problema 2
Listing 33.1.6: 2019-mai-III-2-vector-de-cuvinte.cpp

#include<iostream>
#include<cstring>
char t[51][101]; // vector de cuvinte

char cuvant[99];
int nc=0; // nr cuvinte
int n;
int nca=0; // nr cuvinte afisate
int main()
{
while(cin>>cuvant)
{
++nc;
cout<<nc<<" : "<<cuvant<<" : "<<"\n";
if(cuvant[0]>=’0’ && cuvant[0]<=’9’)

break;
strcpy(t[nc],cuvant); // t[nc]=cuvant;
}
n=atoi(cuvant);
cout<<"cuvant = "<<cuvant<<" \n";
nc=nc-1;

{
if(strlen(t[i])==n)
{
nca++;
cout<<t[i]<<"\n";
}
}
if(nca==0)
cout<<"nu exista";
return 0;
}
/*
Fat Frumos este cel mai viteaz 6
Fat Frumos este cel mai viteaz

7
7 Fat Frumos este cel mai viteaz

*/
Problema 3

#include<iostream>
#include<fstream>
int f[10001];
int main()
{
int n; // n <= 10.000 ... 10.000*100 = 1.000.000 = int ok
int x, y, z; // x,y,z < 100
cin>>n; // n <= 10ˆ4

cin>>x>>y>>z;
cout<<"n = "<<n<<" x = "<<x<<" y = "<<y<<" z = "<<z<<"\n";
f[1]=x;
f[2]=y;
f[3]=z;

f[i] = f[i-1] + f[i-2] - f[i-3]; // atentie la ... MINUS ...

{
fout<<f[i]<<" ";
cout<<f[i]<<" ";
}
fout.close();
return 0;
}
/*
10
1 2 4
*/

#include<iostream>
#include<fstream>
int main()
{
int n; // n <= 10.000 ... 10.000*100 = 1.000.000 = int ok
int x, y, z; // x,y,z < 100
int fi;
cin>>n; // n <= 10ˆ4

cin>>x>>y>>z;
cout<<"n = "<<n<<" x = "<<x<<" y = "<<y<<" z = "<<z<<"\n";

{
if(i%2==1)
{
fi = z + ((i+1)/2 - 2) * (z-x);
}
else
{
fi = z+y-x + (i/2 - 2) * (z-x);
}
fout<<fi<<" ";
cout<<fi<<" ";
}
fout.close();
return 0;
}
/*
10
1 2 4
*/

#include<iostream>
#include<fstream>
int main()
{
int n; // n <= 10.000 ... 10.000*100 = 1.000.000 = int ok
int x, y, z; // x,y,z < 100
int fi, fi1, fi2, fi3; // f_i = f_{i-1} + f_{i-2} - f_{i-3}
// f_{i-3} = f_{i-2}+f_{i-1}-f_i
cin>>n; // n <= 10ˆ4
cin>>x>>y>>z;
//cout<<"n = "<<n<<" x = "<<x<<" y = "<<y<<" z = "<<z<<"\n\n";
fi3=x; // x, y, z, fi=calcul
fi2=y; // fi3, fi2, fi1, fi=calcul
fi1=z;
int nc=3;
// merg spre dreapta ... ca sa ajung la 14

while(nc<n) // calculez pe urmatorul ... fi3, fi2, fi1, fi
{// fi3, fi2, fi1, fi=calcul
nc++;
fi=fi1+fi2-fi3;
//cout<<"nc = "<<nc<<" : "<<fi3<<" "<<fi2<<" "<<fi1<<" "<<fi<<"\n";
// pregatesc pentru urmatorul calcul

fi3=fi2;
fi2=fi1;
fi1=fi;
}
fi=fi1;
fi1=fi2;
fi2=fi3;
//fi3=...calcul...!!!
//cout<<fi<<" ";
//cout<<fi1<<" ";
//cout<<fi2<<" ";
fout<<fi<<" ";
fout<<fi1<<" ";
fout<<fi2<<" ";
nc=n-3; // cate mai sunt de scris

while(nc>0)
{
fi3=fi2+fi1-fi;
//cout<<fi3<<" ";
fout<<fi3<<" ";
nc--;

fi=fi1;
fi1=fi2;
fi2=fi3;
// fi3=calcul ...
}
fout.close();
return 0;
}
/*
10
1 2 4
*/

#include<iostream> // dus-intors
#include<fstream>
int main()
{
int n; // n = 1, 2, 3, 4, ..., 10 000
int x, y, z; // x,y,z < 100
int fi, fi1, fi2, fi3; // f_i = f_{i-1} + f_{i-2} - f_{i-3}
// f_{i-3} = f_{i-2}+f_{i-1}-f_i
cin>>n; // n <= 10ˆ4
cin>>x>>y>>z;
if(n==1)
{
fout<<x;
fout.close();
return 0;
}
if(n==2)
{
fout<<y<<" "<<x;
fout.close();
return 0;
}
if(n==3)
{
fout<<z<<" "<<y<<" "<<x;
fout.close();
return 0;
}
fi3=x; // x, y, z, fi=calcul
fi2=y; // fi3, fi2, fi1, fi=calcul
fi1=z;
fi=fi1+fi2-fi3;
int nc=4; // nc = indice element calculat deja
// merg spre dreapta ...

while(nc<n) // calculez pe urmatorul ... fi3, fi2, fi1 --> fi

{
fi3=fi2;
fi2=fi1;
fi1=fi;
// calcul element nou fi

nc++;
fi=fi1+fi2-fi3;
fout<<fi<<" ";
fout<<fi1<<" ";
fout<<fi2<<" ";
fi3=fi2+fi1-fi;
fout<<fi3<<" ";
nc=n-3; // nc = indice element calculat si afisat deja
// merg spre stanga ...

while(nc > 1) // calculez pe urmatorul ... fi3 <-- fi2, fi1, fi
{
fi=fi1;
fi1=fi2;
fi2=fi3;
// calcul element nou fi3

nc--;
fi3=fi2+fi1-fi;
fout<<fi3<<" ";
}
fout.close();
return 0;
}
/*
10
1 2 4
*/


33.2.1 Subiectul I
Problema 1
Expresia logică (x/2+x%y-x/y == 0) are valoarea de adevăr 1 ı̂n (x, y) dacă şi numai dacă
funcţia f(x,y) = x/2 + x%y - x/y are valoarea 0 ı̂n (x,y).
a. x=4 şi y=2: E(x,y) = 4/2+4%2-4/2 = 2+0-2 = 0
b. x=6 şi y=3: E(x,y)=6/2+6%3-6/3 = 3+0-2 = 1
c. x=8 şi y=4: E(x,y) = 8/2+8%4-8/4 = 4+0-2 = 2
d. x=10 şi y=0: E(x,y) = 10/2+10%0 ... ??? ı̂mpărţirea prin 0 nu este permisă!
Listing 33.2.1: 2019-iunie-I-1.cpp

#include<iostream>
int f(int x, int y)

{
cout<<"f("<<x<<","<<y<<") = ";
cout<<x/2<<"+"<<x%y<<"-"<<x/y;
int rez=x/2+x%y-x/y;
cout<<" = "<<rez<<" --> E = "<<(rez==0)<<endl;
return rez;
}
int main()
{
cout<<"a: "; f(4,2);
cout<<"b: "; f(6,3);
cout<<"c: "; f(8,4);
cout<<"d: "; f(10,0);
return 0;
}
/*
a: f(4,2) = 2+0-2 = 0 --> E = 1
b: f(6,3) = 3+0-2 = 1 --> E = 0
c: f(8,4) = 4+0-2 = 2 --> E = 0
d: f(10,0) = 5+
Process returned -1073741676 (0xC0000094) execution time : 1.523 s
Press any key to continue.
*/
Problema 2
Figura 33.4: 2019-s2-I-2-rec

#include<iostream>
int f(int n)
{
if (n<=2) return n;
if (n%2==1) return f(n-2)-f(n-1);
return f(n-1)-f(n-2);
int main()
{
int rez=f(6);
return 0;
}
/*
rez = 5
*/
Problema 3

#include<iostream>
#include<cstring>
int main()
{
//char x[]="i"; // este ok pentru a) dar nu si pentru b), c), d)
char xv=’i’;
char xc=’k’;
//a.
//cout<<"a: "<<(strcmp(x,"aeiou")==0)<<"\n";
// strcmp: Compares two null-terminated byte strings lexicographically.
// Returns: -1, 0, 1 ... <, =, > ...
//b. //
//cout<<"b: xv -->"<<(strchr("aeiou",xv))<<"\n";
//cout<<"b: xc -->"<<(strchr("aeiou",xc))<<"\n\n";
// Returns a pointer to the first occurrence of character
//c.
cout<<"c: "<<xv<<" --> "<<(’a’<=xv && xv<=’u’)<<"\n";
cout<<"c: "<<xc<<" --> "<<(’a’<=xc && xc<=’u’)<<"\n\n";
//d ... eroare ... se scrie xv==’a’ ... nu xv==a ...

//cout<<"d: "<<xv<<" --> "<<(int)(xv==a || xv==e || xv==i || xv==o || xv==u)<<"\n";
//cout<<"d: "<<xc<<" --> "<<(int)(xc==a || xc==e || xc==i || xc==o || xc==u)<<"\n\n
";
//b.
cout<<"b: "<<xv<<" --> "<<(strchr("aeiou",xv))<<"\n";
cout<<"b: "<<xc<<" --> "<<(strchr("aeiou",xc))<<"\n\n";
// Returns a pointer to the first occurrence of character
return 0;
}
/*
c: i --> 1
c: k --> 1
b: i --> iou
b: k -->
*/
Problema 4
Figura 33.6: bac2019-s2-I-4-backtracking
Primul număr este 5432 iar ultimul număr este 1234 (penultimul număr este 1235).
Plecand de la primul număr (şi mai departe pentru orice număr curent deja construit)
următorul număr se obţine astfel:
cifrele numărului curent se parcurg de la dreapta spre stânga;
se ı̂nlocuieşte cifra, de pe poziţia la care am ajuns, cu cea mai mare cifră mai mică decât ea
şi care nu este deja ı̂n stânga poziţiei curente; dacă există o astfel de cifră, se completează
poziţiile din dreapta poziţiei curente cu cele mai mari cifre posibile şi se scrie numărul astfel
obţinut.
dacă acest lucru nu este posibil ... se caută spre stânga prima poziţie ı̂n care se poate pune
o cifră mai mică ı̂n condiţiile menţionate deja şi completarea poziţiilor din dreapta se face
la fel ...
dacă nici acest lucru nu este posibil, ı̂nseamnă că am terminat de scris toate numerele!
Problema 5


Problema 1

#include<iostream>
int main()
{
int m, n, p, q;
int s1, s2, s;
//cin>>m<<n<<p<<q;
m=4; n=3; p=11; q=25; // p <= q
//m=4; n=3; p=13; q=23; // p <= q
s1=0;
s2=0;
while(p<=q) // p creste pana la q

{
// nr numerelor din [p,q] care se impart prin m sau n sau prin ambele
if(p%m==0 || p%n==0) s1=s1+1;
// nr numerelor din [p,q] care se impart prin m si n

if(p%m==0 && p%n==0) s2=s2+1;
cout<<"p = "<<p<<" : "<<" s1 = "<<s1<<" s2 = "<<s2<<"\n";
p=p+1;
}
// nr numerelor din [p,q] care se impart numai prin m sau numai prin n
s=s1-2*s2;
cout<<s;
return 0;
}

#include<iostream>
int main()
{
int m, n, p, q;
int s1, s2, s;
//cin>>m<<n<<p<<q;
//m=3; n=5; p=1; q=25; // p <= q

//m=3; n=5; p=1; q=26; // p <= q
//m=3; n=5; p=1; q=30; // p <= q
m=3; n=5; p=1; q=31; // p <= q
//m=3; n=5; p=1; q=32; // p <= q
s1=0;
s2=0;
while(p<=q) // p creste pana la q

{
if(p%m==0 || p%n==0) s1=s1+1;
// nr numerelor din [p,q] care se impart prin m si n

if(p%m==0 && p%n==0) s2=s2+1;
//cout<<"p = "<<p<<" : "<<" s1 = "<<s1<<" s2 = "<<s2<<"\n";
p=p+1;
}
// nr numerelor din [p,q] care se impart prin numai prin m sau numai prin n
s=s1-2*s2;
cout<<s;
return 0;
}

#include<iostream>
int main()
{
int m, n, p, q;
int s1, s2, s;
//cin>>m<<n<<p<<q;
//m=3; n=5; p=1; q=25; // p <= q
m=3; n=5; p=1; q=26; // p <= q
s1=0;
s2=0;
for( ; p<=q; p++)

//while(p<=q) // p creste pana la q
{
if(p%m==0 || p%n==0) s1=s1+1;
;// nr numerelor din [p,q] care se impart prin m si n

if(p%m==0 && p%n==0) s2=s2+1;

//cout<<"p = "<<p<<" : "<<" s1 = "<<s1<<" s2 = "<<s2<<"\n";
//p=p+1; // ATENTIE: de scos incrementarea de aici ... !!!
}
// nr numerelor din [p,q] care se impart prin numai prin m sau numai prin n
s=s1-2*s2;
cout<<s;
return 0;
}
Problema 2
Problema 3

#include<iostream>
struct punct
{
float x,y;
};
struct cerc
{
struct punct centru;
float raza;
} fig;
int main()
{
struct cerc fig2; // se poate declara si asa
fig.centru.x=0.0;
fig.centru.y=0.0;
fig.raza=1.0;
cout<<"fig:\n";
cout<<"x = "<<fig.centru.x<<"\n";
cout<<"y = "<<fig.centru.y<<"\n";
cout<<"r = "<<fig.raza<<"\n\n";
cout<<"fig2:\n";
cout<<"x = "<<fig2.centru.x<<"\n";
cout<<"y = "<<fig2.centru.y<<"\n";
cout<<"r = "<<fig2.raza<<"\n\n";
cout<<"fig2 dupa fig2=fig;\n";

fig2=fig;
cout<<"x = "<<fig2.centru.x<<"\n";
cout<<"y = "<<fig2.centru.y<<"\n";
cout<<"r = "<<fig2.raza<<"\n";
return 0;
}
/*
fig:
x = 0
y = 0
r = 1
fig2 inainte de initializare:

x = 4.59037e-41
y = 0
r = 0
fig2 dupa fig2=fig;

x = 0
y = 0
r = 1
*/

Problema 1

#include<iostream>
/*
daca n=235690, atunci, dupa apel, n=224680,
daca n= 15690, atunci, dupa apel, n= 4680.
*/
void Impare(int & n)

{
int nn; // n cu cifrele inversate si modificate
int nc=n; // copie a lui n
nn=0;
while(n != 0) // zero la sfarsitul numarului se PIERDE !!!
{
nn=nn*10+(n%10);
//cout<<" nn = "<<nn<<"\n";
n=n/10;
if(nn%2 == 1) nn=nn-1; // cifra impara este modificata
//cout<<" nn = "<<nn<<"\n";
}
//cout<<"nn = "<<nn<<"\n";
while(nn != 0) // intorc cifrele lui nn

{
n=n*10+(nn%10);
nn=nn/10;
}
// zerourile de la sfarsit ... trebuie puse acum !!!

while(nc%10==0 && nc>0)
{
n=n*10;
nc=nc/10;
}
}
int main()
{
int n;
//n=235690;
n=15690;
cout<<"n = "<<n<<"\n";
Impare(n);
cout<<"n = "<<n<<"\n";
return 0;
}

#include<iostream>
/*
daca n=235690, atunci, dupa apel, n=224680,
daca n= 15690, atunci, dupa apel, n= 4680.
*/
void Impare(int & n)

{
int nn; // copie a lui n
int p10; // puterile lui 10
nn=n;
p10=1;
while(nn != 0)
{
if(nn%2 == 1) n=n-p10; // cifra impara este modificata
nn=nn/10;
p10=p10*10;
}
}
int main()
{
int n;
//n=235690;
n=15690;
cout<<"n = "<<n<<"\n";
Impare(n);
cout<<"n = "<<n<<"\n";
return 0;
}
Problema 2
Listing 33.2.10: 2019bac-s2-III-2 .cpp

#include<iostream>
int m, n;
int simetric; // 1 = este simetrica; 0 = nu este simetrica
int a[22][22]; // folosesc indici de la 1
int main()
{
cin>>m>>n;

{
{
cin>>a[i][j];
}
}
simetric=1;
for(int i=1; i<=m && simetric==1; i++)
{
for(int j=1; j<=n/2; j++)// pana la jumatate
{
if(a[i][j] != a[i][n-j+1])
{
simetric=0;
break;
}
}
}
if(simetric == 1)
cout<<"DA";
else
cout<<"NU";
return 0;
}
/*
4 5
1 2 4 2 1
3 5 5 5 3
2 4 1 4 2
1 1 1 1 1
*/
Problema 3
În versiunea v1 este alocat spaţiu pentru şirul de numere. Pentru că numerele sunt din intervalul
3
0, 10 tipul folosit este short int. Cu int s-ar fi depăşit spaţiul de memorie (cel puţin pentru
mine!).

#include<iostream>
#include<fstream>
const int max_N=1e6+1;
short int v[max_N];
int main()
{
int n=0;
short int x;
short int vmaxant; // valoare maxima anterioara pozitiei curente
int pozuv; // pozitia ultimului varf
while(fin>>x)
{
n++;
v[n]=x;
}
for(int i=1; i<=n; i++) cout<<v[i]<<" ";
cout<<"\n";
cout<<v[1]<<" ";
vmaxant=v[1];
pozuv=1;

{
if(v[i] > vmaxant ||

v[i]==vmaxant && pozuv==i-1)
{
cout<<v[i]<<" ";
vmaxant=v[i];
pozuv=i;
}
}
return 0;
}
/*
7 9 10 10 10 30
*/
În versiunea v2 nu este alocat spaţiu pentru şirul de numere ci, pe măsură ce se citessc aceste
numere, se actualizează informaţiile de care avem nevoie!

#include<iostream>
#include<fstream>
int main()
{
int n=0;
int x;
int vmaxant; // valoare maxima anterioara pozitiei curente
fin>>x;
cout<<x<<" ";
vmaxant=x;
pozuv=1;
while(fin>>x)
{
n++;
if(x > vmaxant ||
x==vmaxant && pozuv == n-1)
{
cout<<x<<" ";
vmaxant=x;
pozuv=n;
}
}
return 0;
}
/*
7 9 10 10 10 30
*/
În versiunea v3 nu este alocat spaţiu pentru şirul de numere ci, pe măsură ce se citessc aceste
numere, se actualizează informaţiile de care avem nevoie!

#include<iostream>
#include<fstream>
int main()
{
int x; // nr citit din fisier
int pozx; // pozitia lui x in fisier
int valuv; // valoarea ultimului varf

fin>>x;
pozx=1;
cout<<x<<" ";
valuv=x;
pozuv=1;
while(fin>>x) // citire pana la sfarsitul fisierului

{
pozx++;
if(x > valuv) // x este varf nou
{
cout<<x<<" ";
valuv=x;
pozuv=pozx;
continue;
}
if(x == valuv) // daca x este egal cu ultimul varf

{
if(pozuv == pozx-1) // daca vecinul lui x este varf
{
cout<<x<<" ";
pozuv=pozx;
}
continue;
}
}
return 0;
}
/*
7 9 10 10 10 30
*/
Pentru fişierul de test, cele 3 versiuni dau rezultate corecte!

Rezistă toate aceste versiuni şi la alte fişiere de test?

33.3.1 Subiectul I
Problema 1

#include<iostream>
int main()
{
cout<<"a. ’m’ < ’n’: ---> "<<(’m’ < ’n’)<<endl;
cout<<"b. ’m’ == ’M’: ---> "<<(’m’ == ’M’)<<endl;
cout<<"c. ’M’ == ’m’+’N’-’n’: ---> "<<(’M’ == ’m’+’N’-’n’)<<endl;
cout<<"d. ’N’ == ’M’+1: ---> "<<(’N’ == ’M’+1)<<endl;
return 0;
}
a. ’m’ < ’n’: ---> 1 (true) pentru că m este ı̂nainte de n ı̂n alfabet şi tot aşa sunt
şi ı̂n tabela de coduri ASCII.
b. ’m’ == ’M’: ---> 0 (false) pentru că au coduri diferite ı̂n tabela de coduri ASCII.
c. ’M’ == ’m’+’N’-’n’ ---> 1 (true) pentru că ’m’-’M’ == ’n’-’N’ = de-
plasarea care trebuie făcută pentru a trece de la literele mari la literele mici (literele mari
sunt ı̂naintea literelor mici ı̂n tabela de coduri ASCII ... dar asta nu contează aici!).
d. ’N’ == ’M’+1: ---> 1 (true) pentru că N urmează imediat după M ı̂n alfabet şi
tot aşa sunt şi ı̂n tabela de coduri ASCII.
Problema 2
Figura 33.11: 2019bac-s3-I-2

#include<iostream>
void f(int i, int j)

{
cout<<i<<" ";
if(i!=j)
{ if(i<j){ i=i+j; j=i-j; i=i-j; }

f(i-j,j);
}
}
int main()
{
f(75,30);
return 0;
}
/*
75 45 15 15
*/
Problema 3
Figura 33.12: ***
Problema 4
Figura 33.13: 2019bac-s3-I-4

Problema 5
Figura 33.14: 2019bac-s3-I-5

Problema 1
Figura 33.15: 2019bac-s3-II-1a1

#include<iostream>
int main()
{
int n, m, x, cp;
//cin<<n;
n=27102;
//cout<<"n = "<<n<<"\n";
m=0;
x=1; // cifre de la 1 la 9
while(x<=9)
{
cp=n; // copia lui n
while(cp != 0)
{
if(cp%10==x) m=m*10+x;// pune cifrele mici spre stanga
cp=cp/10;
}
x=x+1; // mareste cifra
}
cout<<m;
return 0;
}
/*
1227
*/

#include<iostream>
int main()
{
int n, m, x, cp;
//cin<<n; // 10..9999
//n=11;
//n=101;
//n=110;
n=1001;
//n=1010;
//n=1100;
cout<<"n = "<<n<<"\n";
m=0;
while(x<=9)
{
while(cp != 0)
{
cp=cp/10;
}
x=x+1; // mareste cifra
}
cout<<m;
return 0;
}

#include<iostream>
int main()
{
int n, m, x, cp;
//cin<<n; // 10..9999
//n=11;
//n=101;
//n=110;
n=1001;
//n=1010;
//n=1100;
cout<<"n = "<<n<<"\n";
m=0;
for( ; x<=9; x++)
//while(x<=9)
{

while(cp != 0)
{
cp=cp/10;
}
//x=x+1; // ATENTIE: de eliminat incrementarea de aici ... !!!
}
cout<<m;
return 0;
}
Problema 2

#include<iostream>
#include<cstring>
int main()
{
char a[20];
char b[20]="centaur"; // --> a=aur ... sufix_3(b)

//char b[20]="au"; // --> a=nedeterminat
int lgb=strlen(b);
cout<<"strlen(b) = "<<strlen(b)<<’\n’;
if(lgb<3)
strcpy(a,"nedeterminat");
else
strcpy(a,b+lgb-3);
cout<<"--------------\n";
cout<<"1 : "<<b+lgb+2<<"\n";
cout<<"2 : "<<b+lgb+1<<"\n";
cout<<"3 : "<<b+lgb-0<<"\n";
cout<<"4 : "<<b+lgb-1<<"\n";
cout<<"5 : "<<b+lgb-2<<"\n";
cout<<"6 : "<<b+lgb-3<<"\n";
cout<<"7 : "<<b+lgb-4<<"\n";
cout<<"8 : "<<b+lgb-5<<"\n";
cout<<"9 : "<<b+lgb-6<<"\n";
cout<<"10 : "<<b+lgb-7<<"\n";
cout<<"11 : "<<b+lgb-8<<"\n";
cout<<"--------------\n";
cout<<"a: "<<a<<"\n";
return 0;
}
/*
strlen(b) = 7
--------------
1 :
2 :
3 :
4 : r
5 : ur
6 : aur
7 : taur
8 : ntaur
9 : entaur
10 : centaur
11 :
--------------
a: aur
*/
Problema 3

#include<iostream>
struct punct
{
int x,y;
} p;
struct cerc
{
struct punct centru;
float raza;
} c;
int main()
{
p.x=1;
p.y=2;
c.centru.x=1;
c.centru.y=2;
//c.centru.y=12;
if((c.centru.x == p.x) && (c.centru.y == p.y))

cout<<"coincid";
else
cout<<"diferite";
return 0;
}

Problema 1

#include<iostream>
int MaxImp(int a, int b)

{
int i; // numar din intervalul [a,b]
int d; // divizor
int p; // produsul divizorilor
int imax; // cel mai mare i cu proprietatea ceruta
imax=0; // initializare in afara intervalului

for(i=a; i<=b; i++) // for(i=b; i>=a; i--) // primul este solutie
{
p=1;
for(d=1; d<=i; d=d+2)
{
if(i%d == 0) p=p*d;
}
if(p>i) imax=i; // return i;
return imax; // return 0;

}
int main()
{
int a, b;
a=14;
b=19;
int rez;
rez=MaxImp(a,b);
return 0;
}
Problema 2

#include<iostream>
int a[21][21]; // indici de la 1
int n;
int main()
{
int i, j, m, val;
int ok;
int mok; // m-ul ok
cin>>n;
for(i=1; i<=n; i++)

for(j=1; j<=n; j++)
cin>>a[i][j];
val=a[1][1];
mok=1;
for(m=2; m<=n; m++) // m = dimensiune patrat ok
{
// verific linia si coloana pozitiei a[m][m]
ok=1; // 1=este ok... 0=nu este ok

for(j=1; j<=m; j++) // verific linia m
if(a[m][j] != val) ok=0;
if(ok==0) break; // intrerup for m
for(i=1; i<=m; i++) // verific coloana m

if(a[i][m] != val) ok=0;
if(ok==0) break; // intrerup for m
mok=m; // este ok patratul de dimensiune m

}
cout<<mok;
return 0;
}
/*
5
2 2 2 2 2
2 2 2 2 8
2 2 2 2 2
2 1 2 8 7
3 5 2 1 2
*/
Problema 3
Varianta v1 se poate folosi aici dar ... ea este utilă atunci când şirul de numere naturale ar fi fost
9
din intervalul 0, 10 (de exemplu!).
În loc de int v[max_N]; se poate folosi aici short int v[max_N];, pentru economie de
memorie, când numerele sunt din intervalul 0, 32 10 (este o aproximaţie pentru 2 1 2
3 15 15
32 1024 32 1000).
5 10
2 2

#include<iostream>
#include<fstream>
#include<algorithm> // pentru sort
int n=0;
%short int v[max_N]; // cate 2 octeti (in loc de 4 octeti pentru "int")
short int v[max_N];
void afisv()
{
for(int k=0; k<n; k++)
{
cout<<v[k]<<" ";
}
cout<<endl;
}
bool fcmp_cresc(int x, int y) // sort crescator

{
if(x < y) return true;
return false;
}
bool fcmp_descresc(int x, int y) // sort descrescator

{
if(x > y) return true;
return false;
}
int main()
{
int x;
int i1; // parcurg de la stanga spre dreapta

int i2; // parcurg de la dreapta spre stanga
short int aux;
while(fin>>x)
{
v[n]=x;
n++;
}
cout<<"v: "; afisv();
// trebuie: plasat imparele la inceput, parele la sfarsit

// i1=0 si i2=n-1 ...
// si interschimbate valorile cand nu sunt ok
// sortat partea stanga
// sortat partea dreapta
i1=0;
i2=n-1;
while(i1<i2)
{
while(i1<i2 && v[i1]%2==1) // parcurg numerele impare
i1++; // la final v[i2]=par
while(i1<=i2 && v[i2]%2==0) // parcurg numerele pare

i2--; // la final v[i2]=impar
// aici trebuie interschimbate ... daca i1 < i2

if(i1<i2)
{
//cout<<"v[i1] = "<<v[i1]<<" <---> "<<"v[i2] = "<<v[i2]<<endl;
aux=v[i1];
v[i1]=v[i2];
v[i2]=aux;
//afisv();
}
}
cout<<"impar ... par: "; afisv();
//cout<<"la iesirea din while ... i1="<<i1<<" i2 = "<<i2<<endl;
// interschimb i1 cu i2 astfel incat

// i1 = ultimul indice pentru impare
// i2 = primul indice pentru pare
aux=i1;
i1=i2;
i2=aux;
//cout<<"dupa interschimbare ... i1="<<i1<<" i2 = "<<i2<<endl;
int st=0;
int dr=i1;
// sortez stanga (nr impare)

//cout<<"sortez stanga ..."<<endl;
sort(v + st, v + dr+1, fcmp_cresc);
cout<<"sortat stanga: "; afisv();
// sortez dreapta (nr pare)

//cout<<"sortez dreapta ..."<<endl;
st=i2;
dr=n-1;
sort(v + i2, v + dr+1, fcmp_cresc);
cout<<"sortat dreapta: "; afisv();
return 0;
}
/*
Exemplu:
daca fisierul contine numerele 12 2 3 1 2 5
se afiseaza pe ecran: 1 3 5 2 2 12
*/
Când numerele sunt dintr-un interval mic de valori (de exemplu cifre, care sunt ı̂n intervalul
3
0, 9, sau ca aici ... ı̂n intervalul 0, 10 ) trebuie să ne gândim (ı̂n primul rând, neapărat! )
să utilizăm un vector de frecvenţă (un vector v unde v k n ı̂nseamnă că numărul k a apărut
de n ori). Aceasta este ideea folosită ı̂n v2.

#include<iostream> // valori mici ... intre [0, 1000] ==> frecvente ...
#include<fstream>
int fr[1001]; // vector de frecvente

int main()
{
int n=0;
int x;
while(fin>>x)
{
fr[x]++;
n++;
}
for(int i=1; i<=999; i=i+2)

{
for(int k=1; k<=fr[i]; k++)
{
cout<<i<<" ";
}
}
for(int i=0; i<=1000; i=i+2)

{
for(int k=1; k<=fr[i]; k++)
{
cout<<i<<" ";
}
}
return 0;
}

Capitolul 34
BAC 2018

Varianta 9
Filieră teoretică, ***
34.1.1 Subiectul I
***
Problema 1
Expresia dată: x $ 3 ¶¶ x % 10 x " , 3 < 10,
a. ! x $ 3 && x $ 10 ! x $ 3 ¶¶ ! x $ 10 x % 3 ¶¶ x % 10 x " 3,

b. x % 3 && ! x % 10 x % 3 && x $ 10 x " 3, 10
c. ! x $ 3 ¶¶ x $ 10 ! x $ 3 && ! x $ 10 x % 3 && x % 10 x " 10,
d. ! x % 3 ¶¶ ! x $ 10 x $ 3 ¶¶ x % 10 x " , 3 < 10,
Problema 2
396
Listing 34.1.1: 2018bac-s1-I-2b.cpp

#include<iostream>
int main()
{
int n,a, nr, i, c, b;
cin>>n>>a;
cout<<"n = "<<n<<" a = "<<a<<"\n";
nr=0;
i=1;
while(i<=n)//4 2
{
cout<<"\ni = "<<i<<"\n";
cin>>b;
cout<<"b = "<<b<<"\n";
c=0;
while(b%2 == 0) // cat timp b este par
{
b=b/2; // scot 2-ul din b
c=c+1; // c = cate 2-uri s-au scos din b
}
cout<<"c = "<<c<<"\n";
if(c==a) // daca s-au scos "a" 2-uri din b
nr=nr+1;
i=i+1;
}
cout<<nr;
return 0;
}
/*
4 2 12 20 28 36
*/
Listing 34.1.2: 2018bac-s1-I-2c.cpp

#include<iostream>
int main()
{
int n,a, nr, i, c, b;
cin>>n>>a;
cout<<"n = "<<n<<" a = "<<a<<"\n";
nr=0;
i=1; // initializarea pentru for o las aici
//while(i<=n)
for( ; i<=n; )
{
cout<<"\ni = "<<i<<"\n";
cin>>b;
cout<<"b = "<<b<<"\n";
c=0;
while(b%2 == 0) // cat timp b este par
{
b=b/2; // scot 2-ul din b
c=c+1; // c = cate 2-uri s-au scos din b
}
cout<<"c = "<<c<<"\n";
if(c==a) // daca s-au scos "a" 2-uri din b
nr=nr+1;
i=i+1; // incrementarea pentru for o las aici ... !!!

cout<<nr;
return 0;
}
/*
4 2 12 20 28 36
*/
Figura 34.2: 2018bac-s1-I-2d

Problema 1
Problema 2

Problema 3

#include<iostream>
struct divizor
{
int nr, mic; // campul nr din variabila d
} d1, d2, d3; // variabila d
void sol(struct divizor d)

{
cout<<d.nr<<" "<<d.mic<<" : ";
if(d.nr==d.mic) cout<<"prim"<<"\n";
else
if(d.nr==d.mic*d.mic) cout<<"patrat"<<"\n";
else
{
int nrr=d.nr/d.mic; // scot divizorul d.mic
int dmare; // poate fi nr=d.mic * d.mic * ... *d.mic, --> dmare=d.mic
// scot divizorul d.mic daca apare de mai multe ori

while(nrr%d.mic == 0) nrr=nrr/d.mic;
if(nrr==1) // d.nr = nr=d.mic * d.mic * ... *d.mic

{
cout<<d.mic<<" "<<d.mic<<"\n";
}
else // caut dmare ... aici sigur este impar !!! ...
// 2-urile s-au scos toate (daca au fost)!!!
{
if(d.mic==2)
dmare=3;
else // daca d.mic a fost 3 atunci urmatorul este 5 de incercat
dmare=d.mic+2;
// ramane nrr==1 sau un alt produs de numere prime

while(nrr%dmare==0) nrr=nrr/dmare;
while(nrr>1)
{
dmare=dmare+2; // maresc dmare
while(nrr%dmare==0) nrr=nrr/dmare; // scot dmare din nrr
}
cout<<d.mic<<" "<<dmare<<"\n";
}
}
}
int main()
{
d1.nr=12;
d1.mic=2; // 2 6
d2.nr=9;
d2.mic=3; // patrat
d3.nr=5;
d3.mic=5; // prim
sol(d1);
sol(d2);
sol(d3);
return 0;
}
Problema 4

#include<iostream> // ca 2018-mai ... !!! ... dar nu ’identic’ ...
int a[10][10]; // este initializat automat cu 0
int main()
{
int i,j;
for(i=1;i<=9;i++)
for(j=1;j<=9;j++)
//if(i==j) a[i][j]=5-i;
//else
if(j <= i)// sub diagonala principala ... inegalitate stricta
a[i][j]=j;
else
a[i][j]=i; // deasupra diagonalei principale
for(i=1; i<=9; i++)

{
for(j=1; j<=9; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
Problema 5

#include<iostream> // TEMA: de facut ... ALTFEL ... ala cu while ... :-)
#include<fstream>
#include<cstring>
#include <cstdio> // getchar();
char s[101];
int main()
{
cin.get(s,102); // TEMA: ... cu while(cin>>cuvant){ ... }
//cout<<"s = "<<s<<"\n";
int i, n;
int pozc; // pozitie inceput nr curent
int pozm; // pozitie nr care incepe cu cifra cea mai mare
n=strlen(s);
//cout<<"n = "<<n<<"\n";
pozm=-1; // daca ramana asa inseamna ca nu au fost cifre ...

i=0; // pozitie in sirul s[]
// for(i=0; i<=n-1; i++) { ... break; ...}

while(i<=n-1)// sunt pe o pozitie in s[] ...
{
//getchar(); // la i=31 ????
while(
(i<=n-1) &&
!(s[i]>=’0’ && s[i]<=’9’) // s[i] nu este cifra
)
i=i+1;
//cout<<"i = "<<i<<"\n";
//getchar();
//i == n sau s[i]=cifra
if(i<=n-1) // s[i]=cifra
{
pozc=i; // pozitie curenta pentru un numar
if(pozm == -1)
pozm=pozc;
else
if(s[pozm]<s[pozc])
pozm=pozc;
// parcurg cifrele consecutive
while(s[i]>=’0’ && s[i]<=’9’) i++;
}
}
i=pozm;
if(pozm == -1)
cout<<"nu exista";
else
while((s[i]>=’0’ && s[i]<=’9’))
{
cout<<s[i];
i++;
}
return 0;
}
/*
am 190 de nuci si 70 de castane
am 190 de nuci si 70 de castane 888
am niste de nuci si niste de castane
9 am 190 de nuci si 70 de castane

*/

Problema 1
Listing 34.1.6: 2018bac-s1-III-1-rec.cpp

#include<iostream>
int f1 (int x, int y)

{
if(x%2!=0 || y%2!=0) return 1;
else return 2*f1(x/2,y/2);
}

{
if (x==y) return x;
else
if(x>y) return f2(x-y,y);
else return f2(x, y-x);
}
int main()
{
cout<<"a) " << f1(30,50) << "\n";
cout<<"b) " << f2(30,50) << "\n\n";
cout<<"c) " << f1(30/2,50) << "\n";

cout<<"d) " << f2(30/2,50) << "\n";
return 0;
}
Problema 2
Este mai bine să lucrăm cu cifrele 1, 2, 3, şi 4.
1: pentru fondante
2: pentru caramele
3: pentru dropsuri
4: pentru acadele
combinărilor!
Figura este sugestivă! Cine ştie că după 13 urmează 134 şi apoi 14 şi apoi 23 ... rezolvă această
problemă ı̂n câteva secunde! Deci ... trebuie să ştim ... generarea combinărilor!
Problema 3

#include<iostream>
int echilibrat(int n)
{
int spp; // suma pozitiilor pare
int spi; // suma pozitiilor impare
int poz; // pozitia
int rez;
spp=0;
spi=0;
poz=0;
while(n != 0)
{
if(poz%2 == 0)
{
spp=spp+(n%10);
}
else
{
spi=spi+(n%10);
}
n=n/10;
poz=poz+1;
if((spp%2==0) && (spi%2 == 1))

rez=1;
else
rez=0;
return rez;
}
int main()
{
int n;
n=25163912;
//n=11211;
int rez;
rez=echilibrat(n);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
ifstream fin("2018bac-s1-bac.txt");
// pa[i]=k; prima aparitie a cifrei i este pe pozitia k ... initializat zero

int pa[10];
// ua[i]=k; ultima aparitie a cifrei i este pe pozitia k ... initializat zero

int ua[10];
int main()
{
int n=0;
int x;
int lgmax;
while(fin>>x)
{
n++;
ua[x]=n;
if(pa[x]==0) pa[x]=n;
}
lgmax=0;
for(int i=0; i<= 9; i++)
if(pa[i]>0)
{
if(ua[i]-pa[i]+1 > lgmax)
lgmax=ua[i]-pa[i]+1;
}
cout<<lgmax<<"\n";
for(int i=0; i<= 9; i++)
if(pa[i]>0)
{
if(ua[i]-pa[i]+1 == lgmax)
cout<<i<<" ";
}
fin.close();
return 0;
}


34.2.1 Subiectul I
Problema 1
Expresia dată: ! x%y! 0 ¶¶ y $ 2 este echivalentă cu
! x%y! 0 && ! y $ 2
x%y 0 && y % 2
x multiplu de y && y % 2
a. x%y y%x && y % 1 ... ne mai gândim ... mai târziu ... !!!
b. x y %y 0 ¶¶ y % 1 x%y 0 ¶¶ y % 1
c. x©y y x && y % 2 x multiplu de y && y % 2 ... deci ... gata!
(o singură variantă este corectă şi varianta asta este 100% corectă! )
d. x%y 0¶¶y %2
Problema 2
Figura 34.7: 2018bac-s2-I-2a1

Listing 34.2.1: 2018bac-s2-I-2a.cpp

#include<iostream>
int main()
{
int n, s, x, i;
cin>>n;
//cout<<"n="<<n<<"\n";
if(n<0) n=-n;
s=0;
do
{
//cout<<"n = "<<n<<" : ";
x=n%10; // x=ultima cifra a lui n
for(i=1; i<=x; i++)
{
s=s+x;
//cout<<" "<<s<<" ";
}
//cout<<"s = "<<s<<"\n";
n=n/10;
} while( !(n==0) );
cout<<s;
return 0;
}
/*
2018 --> 69
*/

#include<iostream>
int main()
{
int n, s, x, i;
cin>>n; // [10, ..., 1000]

// suma patratelor cifrelor numarului, de 2-3 cifre, sa fie egala cu 100
// patratele sunt: 1 4 9 16 25 36 49 64 81
// 36+64=100 --> cifre 6 si 8 si 0 in orice combinatie ... !!!
cout<<"n="<<n<<"\n";
if(n<0) n=-n;
s=0;
do
{
cout<<"n = "<<n<<" : ";
for(i=1; i<=x; i++)
{
s=s+x;
//cout<<" "<<s<<" ";
}
cout<<"s = "<<s<<"\n";
n=n/10;
} while( !(n==0) );
cout<<s;
return 0;
}
/*
68, 86, 608, 806, 680, 860
*/

#include<iostream>
int main()
{
int n, s, x, i;
cin>>n; // [10, ..., 1000]

// suma patratelor cifrelor numarului, de 2-3 cifre, sa fie egala cu 100
// patratele sunt: 1 4 9 16 25 36 49 64 81
// 36+64=100 --> cifre 6 si 8 si 0 in orice combinatie ... !!!
cout<<"n="<<n<<"\n";
if(n<0) n=-n;
s=0;
do
{
cout<<"n = "<<n<<" : ";
//for(i=1; i<=x; i++)

//{
// s=s+x;
//cout<<" "<<s<<" ";
//}
s=s+x*x;
cout<<"s = "<<s<<"\n";
n=n/10;
} while( !(n==0) );
cout<<s;
return 0;
}
/*
2018 --> 69
*/


Problema 1

#include<iostream>
struct medicament
{
float pret;
struct
{
int cod, doza;
} substanta;
} m[20];
int main()
{
//a.
//m[0].cod.substanta=123;
//cout<<m[0].substanta.cod<<endl;
//b.
m[0].substanta.cod=123;
cout<<m[0].substanta.cod<<endl;
//c.
//m.cod.substanta[0]=123;
//d.
//m.substanta.cod[0]=123;
return 0;
}
Problema 2

Problema 3
Problema 4
Figura 34.12: 2018bac-s2-II-4-v1

Figura 34.13: 2018bac-s2-II-4-v2

#include<iostream> // sun 4 zone (N,S,E,V) + diagonalele
#include <iomanip> // setw(2)
int a[9][9]; // initializat cu 0 ...
void afisa()
{
int i,j;
for(i=0; i<=8; i++)
{
for(j=0; j<=8; j++)
{
//cout<<a[i][j]<<" "; // a=global ... se vede si aici ...
cout<<setw(2)<<a[i][j]<<" "; // a=global ... se vede si aici ...
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
int i,j;
for(i=0; i<=8; i++)

for(j=0; j<=8; j++)
a[i][j]=-1; // a global ... se vede si aici
for(i=0;i<9;i++) // linia i incepe cu valoarea i

for(j=0;j<9;j++) // coloana j din linia i este ... circular --> modulo ...
//if((j==i) || (j==8-i)) // diagonale
// a[i][j]=0;
// else
if((j==i) ) // diagonala principala
a[i][j]=0;
else
if( (j==8-i)) // diagonala secundara
a[i][j]=0;
else
if((j >= i+1) && (j <= 8-i-1)) // N == NE && NV - nord !!!
// incepe cu valoarea: i+minj si creste pe masura ce creste j
a[i][j]=i+j;
else
if((8-i+1 <= j) && (j <= i-1)) // S == SE && SV - sud !!!
// incepe cu valoarea: 1 si creste cu +1 cand creste j ...
a[i][j]=1+j-8+i-1;
else
if((j >= i+1) && (8-i+1 <= j)) // E == NE && SE
// este cu 1 mai mult decat elementul de deasupra lui ...
a[i][j]=1+a[i-1][j];
else
if((j <= 8-i-1) && (j <= i-1)) // V == NV && SV
// incepe cu valoarea: i si creste cu +1 pe masura ce creste j
a[i][j]=i+j;
afisa();
return 0;
}

#include<iostream> // ... !!! ... :-) ... !!!
int a[9][9]; // initializat cu 0 ...
void afisa()
{
int i,j;
for(i=0; i<=8; i++)
{
for(j=0; j<=8; j++)
{
//cout<<a[i][j]<<" "; // a=global ... se vede si aici ...
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
int i,j;
for(i=0; i<=8; i++)

for(j=0; j<=8; j++)
a[i][j]=-1;
for(i=0;i<9;i++)
for(j=0;j<9;j++)
if((i==j) || (i+j==8))
a[i][j]=0;
else
if(i+j < 8)
a[i][j]=i+j;
else // i+j >= 8 prinde si situatia i+j==8 dar ... nu-i bai!
a[i][j]=i+j-8;
afisa();
return 0;
}
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
char s[101], c[101], sc[101];
int ns, nc, nsc;
int main()
{
cin.get(s,101);
cin.get();
cin.get(c,101);
ns=strlen(s);
nc=strlen(c);
//cout<<"s = "<<s<<"\n";
//cout<<"c = "<<c<<"\n";
if(ns != nc)
{
cout<<"cod incorect";
return 0;
}
sc[0]=s[0];
nsc=1; // lungimea sirului construit
for(int i=1; i<=ns-1; i++)
{
if(c[i]%2==1)
{
//cout<<c[i]<<" impar ... !!!\n";
sc[nsc]=s[i];
nsc++;
}
else // inserare in fata
{
nsc++;
for(int j=nsc-1; j>=1; j--)
{
sc[j]=sc[j-1];
}
sc[0]=s[i];
}
}
cout<<sc;
return 0;
}
/*
etalon
025843
*/

Problema 1
Este mai bine să lucrăm cu cifrele 1, 2, 3, 4 şi 5.
Când contează ordinea obiectelor ne gândim la generarea aranjamentelor! În figură am notat
(pentru o ı̂nţelegere ... consider un exemplu) prin 4 12{45} 2, 3 pe rândul 5 coloanele G, H, I
4: ”numărul curent” ı̂n reprezentarea mea (cred că este uşor de ı̂nţeles!)
12{45}: variantele 1245, 1254
2, 3: nr. curent 2 pentru 1245 şi nr. curent 3 pentru 1254
După 2154 urmează 23 şi nu trebuia neapărat acest desen!
Problema 2


#include<iostream>
void f(char ch, int x)

{
cout<<ch;
if(x==0)
cout<<’*’;
else
if(ch==’a’) // a, b, c, d, e ... !!!
cout<<x; // si se intoarce ... !!!
else
f(ch-1,x-1); // micsoreaza litera si x-ul ... !!!
}
int main()
{
f(’e’,0); cout<<" : "<<0<<"\n";
f(’e’,1); cout<<" : "<<1<<"\n";
f(’e’,2); cout<<" : "<<2<<"\n";
f(’e’,3); cout<<" : "<<3<<"\n";
f(’e’,4); cout<<" : "<<4<<"\n";
f(’e’,5); cout<<" : "<<5<<"\n";
f(’e’,6); cout<<" : "<<6<<"\n";
f(’e’,7); cout<<" : "<<7<<"\n";
f(’e’,8); cout<<" : "<<8<<"\n";
f(’e’,9); cout<<" : "<<9<<"\n";
f(’e’,10); cout<<" : "<<10<<"\n";
f(’e’,11); cout<<" : "<<11<<"\n";
f(’e’,12); cout<<" : "<<12<<"\n";
return 0;
}
Problema 3

#include<iostream>
int resturi(int n, int x, int y, int r)

{
int i; // numar din [1,n]
int nrv; // nr de valori cerut
nrv=0;
for(i=1; i<=n; i++)
{
if((i%x == r) && (i%y == r)) nrv=nrv+1;
}
return nrv;
}
int main()
{
int n, x, y, r;
n=200;
x=5;
y=14;
r=2;
int rez;
rez=resturi(n,x,y,r);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
ifstream fin("2018bac-s2-bac.txt");
int main()
{
int x;
int lgc; // lungime curenta
int lgmax; // lungime maxima
int x1, x2, x3; // trei numere consecutive
fin >> x1;

fin >> x2;
fin >> x3;
while(x1==x2 || x2==x3)
{
cout<<x1<< " "<<x2<<" "<<x3<<" lgc = "<<lgc<<" lgmax = "<<lgmax<<"\n";
fin>>x;
x1=x2;
x2=x3;
x3=x;
}
lgc=3;
lgmax=3;
cout<<x1<< " "<<x2<<" "<<x3<<" lgc = "<<lgc<<" lgmax = "<<lgmax<<"\n\n";
cout<<"\n************\n";
while(fin >> x)
{
if(x != x3)
{
lgc++;
if(lgc > lgmax) lgmax=lgc;
}
else
{
lgc=1;
}
x1=x2;
x2=x3;
x3=x;
cout<<x1<< " "<<x2<<" "<<x3<<" lgc = "<<lgc<<" lgmax = "<<lgmax<<"\n";
}
cout<<lgmax;
return 0;
}


34.3.1 Subiectul I
Problema 1
Figura 34.16: 2018bac-s3-I-1
Problema 2

#include<iostream>
int main()
{
int n, m, p, x, c;
//cin>>n; // 10523 --> 55533

n=10523;
cout<<"n = "<<n<<"\n"; // 10523
m=0;
p=1;
x=0;
if(n<0) n=-n;
do
{
cout<<"n = "<<n<<" ";
c=n%10; // ultima cifra a lui n
n=n/10;
if(c>m) m=c; // m=cifra mare !!!
x=m*p+x; // pune cifra m in fata numarului x

cout<<" x = "<<x<<"\n";
p=p*10; // puterile lui 10
} while( !(n==0) );
cout<<x;
return 0;
}

#include<iostream>
int main()
{
int n, m, p, x, c;
//cin>>n; // 10523 --> 55533

//n=10523;
// --> 722
//n=702;
//n=712;
//n=722;
n=-702;
cout<<"n = "<<n<<"\n";
m=0;
p=1;
x=0;
if(n<0) n=-n;
do
{
cout<<"n = "<<n<<" ";

n=n/10;

cout<<" x = "<<x<<"\n";
} while( !(n==0) );
cout<<x;
return 0;
}

#include<iostream>
int main()
{
int n, m, p, x, c;
//cin>>n; // 10523 --> 55533

//n=10523;
// --> 722
//n=702;
//n=712;
//n=722;
n=-702;
cout<<"n = "<<n<<"\n";
m=0;
p=1;
x=0;
if(n<0) n=-n;
while( !(n==0) )
//do
{
cout<<"n = "<<n<<" ";
n=n/10;

cout<<" x = "<<x<<"\n";
} //while( !(n==0) );
cout<<x;
return 0;
}
Figura 34.18: 2018bac-s3-I-2c


Problema 1

#include<iostream>
#include<cstring>
int main()
{
cout<<"strlen(\"2018\") = "<<strlen("2018")<<"\n";
return 0;
}
Problema 2
Problema 3

#include<iostream>
int main()
{
struct impartire
{
int cat;
int rest;
} rezultat;
int x;
//x=10;
x=0;
if(x != 0)
{
rezultat.cat=2018/x;
rezultat.rest=2018%x;
}
else
cout<<"impartire nepermisa";
return 0;
}
Problema 4
Problema 5
Listing 34.3.6: ***.cpp

#include<iostream>
#include<fstream>
#include<cstring>
#include<cmath>
int n;
int a[100][100];
int x[100];
int main()
{
int i, j;
cin>>n; // 4
for(i=0; i<=n-1; i++) // 7 2 5 3

cin>>x[i];
for(i=0; i<=n-1; i++)

for(j=0; j<=n-1; j++)
if(j%2==1)
a[i][j]=x[i];
else
a[i][j]=x[n-i-1];
for(i=0; i<n; i++)

{
for(j=0; j<n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}

Problema 1

#include<iostream>
void f(int n)
{
cout<<n%2;
if(n>=3) f(n-3);
}
int main()
{
f(7);
return 0;
}
Problema 2
Este mai bine să lucrăm cu cifrele 1, 2, 3, 4 şi 5.
1: pentru stilou
2: pentru pana
3: pentru toc
4: pentru creion
5: pentru pensula
Când contează ordinea obiectelor şi trebuie să le folosim pe toate, ne gândim la generarea
permutărilor!
Observaţii:
4 nu poate fi ultimul pentru ca ı̂naintea lui ar fi toate cifrele, deci şi 1 şi 2
4 nu poate fi nici penultimul pentru că cel puţin unul dintre cifrele 1 şi 2 ar fi ı̂n faţa lui
Deci 4 trebuie să fie pe primele trei poziţii (şi ı̂n stânga lui să nu fie nici 1 nici 2)!
Notaţia {3,5} 4 {12} {3,5} semnifică faptul că ı̂n stânga lui 4 pot fi numai cifrele 3 sau 5
(sau amândouă, sau niciuna dintre ele) iar ı̂n dreapta lui 4 sunt obligatoriu 1 şi 2 dar ... pot fi şi
3 şi 5 ı̂nsă nu in mod obligatoriu!
Sunt cinci grupuri de variante, notate ı̂n figură A, B, C, D şi E.
Poziţiile 6 şi 7 sunt respectiv ultima variantă din A şi prima variantă din B.
Varianta cu numărul 6 este 34521, adică (toc, creion, pensula, pana, stilou) iar varianta cu
numărul 7 este 35412 adică (toc, pensula, creion, stilou, pana).
Problema 3

#include<iostream>
int interval(int n)
{
int x; // n < x = in dreapta unui numar prim
int esteprim=0; // 0 = NU ... nu este prim
int d; // divizor
int rez; // rezultat
x=n;
if(x%2 == 0) x=x+1; // x = par si >3 --> sigur nu nu este prim

while(esteprim==0) // verific daca x = prim

{
cout<<"x = "<<x<<" : ";
esteprim=1;
// d=3; daca folosesc while(...)
for(d=3; d*d <=x; d=d+2) // while(d*d <= x)
{
if(x%d == 0)
{
cout<<" d = "<<d<<" ";
esteprim=0;
break;
}
// while ... d=d+2;
}
cout<<"\n";
x=x+2; // merg numai pe numere impare ...
}
rez=x-1; // crescusa deja cu +2 ...

return rez;
}
int main()
{
int n;
n=8; // 8 9 10 11 12=rez ... 11=prim ... rez=prim+1
//n=121; // este prim ???
int rez;
rez=interval(n);
return 0;
}
Problema 4


#include<iostream>
#include<fstream>
#include<cmath>
// f1=0; f2=3;
// f_n = 2 f_{n-1} - f_{n-2} + 2 <==>
// x_n = f_n-f_{n-1}; x_{n-1}=f_{n-1}-f_{n-2}
// f_n-f_{n-1} = f_{n-1}-f_{n-2} + 2 <==>

// x_n = x_{n-1} + 2 ... ==> f[n]=n*n-1
int main()
{
int x, y, n;
cin>>x>>y;
n=sqrt(y+1);
cout<<"n = "<<n<<"\n";

cout<<(i*i-1)<<" ";
return 0;
}
/*
48 63
*/

#include<iostream> // f1=0; f2=3; f_n = 2 f_{n-1} - f_{n-2} + 2
// f[n] = 2 f[n-1] - f[n-2] + 2
#include<fstream> // f[n-2]=2 f[n-1] - f[n] + 2
#include<cmath>
int main()
{
int x, y, n;
cin>>x>>y;
int fn, fn1, fn2;
cout<<y<<" "<<x<<" ";
fn=y; // 3 ... <-- fn2, fn1, fn ... calculat spre stanga

fn1=x; // 0
fn2=2*fn1-fn+2;
while(fn>3)
{
cout<<fn2<<" ";
fn=fn1;
fn1=fn2;
fn2=2*fn1-fn+2;
}
return 0;
}
/*
48 63
*/

Capitolul 35
BAC 2017

Varianta 3
35.1.1 Subiectul I
Problema 1

#include<iostream>
int main()
{
int x1=1;
int x2=12;
int x3=123;
int x4=1234;
int x;
x=x1;
cout<<"x = "<<x1<<endl;
cout<<"a. x/1000==0 && x/100!=0 --> "
<<(x/1000==0 && x/100!=0)<<endl;
cout<<"b. x/1000==0 || x/100!=0 --> "
<<(x/1000==0 || x/100!=0)<<endl;
cout<<"c. x%1000==0 && x%100!=0 --> "
<<(x%1000==0 && x%100!=0)<<endl;
cout<<"d. x%1000==0 || x%100!=0 --> "
<<(x%1000==0 || x%100!=0)<<endl;
cout<<endl;
x=x2;
cout<<"a. x/1000==0 && x/100!=0 --> "
<<(x/1000==0 && x/100!=0)<<endl;
cout<<"b. x/1000==0 || x/100!=0 --> "
<<(x/1000==0 || x/100!=0)<<endl;
cout<<"c. x%1000==0 && x%100!=0 --> "
<<(x%1000==0 && x%100!=0)<<endl;
cout<<"d. x%1000==0 || x%100!=0 --> "
<<(x%1000==0 || x%100!=0)<<endl;
cout<<endl;
x=x3;
cout<<"a. x/1000==0 && x/100!=0 --> "
<<(x/1000==0 && x/100!=0)<<endl;
cout<<"b. x/1000==0 || x/100!=0 --> "
<<(x/1000==0 || x/100!=0)<<endl;
cout<<"c. x%1000==0 && x%100!=0 --> "
427
<<(x%1000==0 && x%100!=0)<<endl;

cout<<"d. x%1000==0 || x%100!=0 --> "
<<(x%1000==0 || x%100!=0)<<endl;
cout<<endl;
x=x4;
cout<<"a. x/1000==0 && x/100!=0 --> "
<<(x/1000==0 && x/100!=0)<<endl;
cout<<"b. x/1000==0 || x/100!=0 --> "
<<(x/1000==0 || x/100!=0)<<endl;
cout<<"c. x%1000==0 && x%100!=0 --> "
<<(x%1000==0 && x%100!=0)<<endl;
cout<<"d. x%1000==0 || x%100!=0 --> "
<<(x%1000==0 || x%100!=0)<<endl;
cout<<endl;
return 0;
}
/*
x = 1
a. x/1000==0 && x/100!=0 --> 0
b. x/1000==0 || x/100!=0 --> 1
c. x%1000==0 && x%100!=0 --> 0
d. x%1000==0 || x%100!=0 --> 1
x = 12
a. x/1000==0 && x/100!=0 --> 0
b. x/1000==0 || x/100!=0 --> 1
c. x%1000==0 && x%100!=0 --> 0
d. x%1000==0 || x%100!=0 --> 1
x = 123
a. x/1000==0 && x/100!=0 --> 1
b. x/1000==0 || x/100!=0 --> 1
c. x%1000==0 && x%100!=0 --> 0
d. x%1000==0 || x%100!=0 --> 1
x = 1234
a. x/1000==0 && x/100!=0 --> 0
b. x/1000==0 || x/100!=0 --> 1
c. x%1000==0 && x%100!=0 --> 0
d. x%1000==0 || x%100!=0 --> 1
*/
Trebuie să vedem care variantă are 1 pentru x=123 şi 0 pentru toate celelalte!
Prima variantă pe care o verifică este a. care are 1 pentru x=123 şi 0 pentru x=1, 0 pentru
x=12, 0 pentru x=1234.
Deci, a. este ok ... şi nu mai are rost să ”pierdem timpul” cu alte verificări!
Dar ... ı̂n examen nu avem calculator!

Verificăm două situaţii: ”x are 3 cifre” si ”x nu are trei cifre”.
Pentru ”x are trei cifre” (de exemplu x=123):
a. 123/1000==0 && 123/100!=0 0==0 && 1 != 0 1 && 1 1
b. 123/1000==0 ¶¶ 123/100 != 0 0==0 ¶¶ 1 != 0 1 ¶¶ 1 1
c. 123%1000==0 && 123%100 != 0 123==0 && 23 != 0 0 && 1 0
d. 123%1000==0 ¶¶ 123%100!=0 123==0 ¶¶ 23 != 0 0 ¶¶ 1 1
Căutăm soluţia ı̂ntre variantele care au dat 1, adică variantele a., b., şi d.. Varianta care are
zero (fals!) pentru x=1 sau x=12 sau x=1234 este soluţie (dacă este singura cu 0; dacă sunt mai
multe cu 0, le eliminăm pe cele cu 1 şi verificăm, pe cele rămase, cu un alt x).
Prima variantă pe care trebuie să o verificăm este varianta a.. (ea ı̂ndeplineşte condiţia că are
valoarea 1 pentru numere cu trei cifre dar ... să vedem dacă ”ea şi numai ea”!).
Pentru ”x are patru cifre” (de exemplu x=1234):
a. 1234/1000==0 && 1234/100!=0 1==0 && 12 != 0 0 && 1 0
b. 1234/1000==0 ¶¶ 1234/100 != 0 1==0 ¶¶ 12 != 0 0 ¶¶ 1 1
d. 1234%1000==0 ¶¶ 1234%100!=0 234==0 ¶¶ 34 != 0 0 ¶¶ 1 1
A rămas numai varianta a..

Problema 2

#include<iostream>
int main()
{
int a, b, x, s, c;
//cin>>a>>b; // a,b in [2,...,9]

/*
2 --> 2 3 --> 3 4 --> 2 5 --> 5
6 --> 2 7 --> 7 8 --> 2 9 --> 3
*/
//a=2; b=4; //a=4; b=2;
//a=4; b=5; //a=5; b=4;
//a=5; b=6; //a=6; b=5;
a=7; b=4;
if(a>b) {x=a; a=b; b=x;}
//cout<<"a = "<<a<<" b = "<<b<<"\n\n";
s=0;
for(x=a; x<=b; x++)
{
//cout<<"x = "<<x<<" : ";
c=2;
while(x%c > 0) // cat timp x nu se imparte la "c", il maresc pe "c"
{
c=c+1;
} // "c" va fi primul divizor al lui x (dar nu 1)
s=s+c; // s este suma acestor divizori mici ...

//cout<<"c = "<<c<<" s = "<<s<<"\n\n";
}
cout<<s;
return 0;
}
/*
16
*/


#include<iostream>
int main()
{
int a, b, x, s, c;
//cin>>a>>b; // a,b in [2,...,9]

/*
2 --> 2 3 --> 3 4 --> 2 5 --> 5
6 --> 2 7 --> 7 8 --> 2 9 --> 3
*/
//a=2; b=4; //a=4; b=2;

//a=4; b=5; //a=5; b=4;
//a=5; b=6; //a=6; b=5;
a=7; b=4;

cout<<"a = "<<a<<" b = "<<b<<"\n\n";
s=0;
for(x=a; x<=b; x++)
{
cout<<"x = "<<x<<" : ";
c=2;
while(x%c > 0) // cat timp x nu se imparte la "c", il maresc pe "c"
{
c=c+1;
} // "c" va fi primul divizor al lui x (dar nu 1)
s=s+c; // s este suma acestor divizori mici ...

cout<<"c = "<<c<<" s = "<<s<<"\n\n";
}
cout<<s;
return 0;
}
/*
a = 4 b = 7
x = 4 : c = 2 s = 2
x = 5 : c = 5 s = 7
x = 6 : c = 2 s = 9
x = 7 : c = 7 s = 16
16
*/

#include<iostream>
int main()
{
int a, b, x, s, c;
//cin>>a>>b; // a,b in [2,...,9]
a=7; b=4;

cout<<"a = "<<a<<" b = "<<b<<"\n\n";
s=0;
for(x=a; x<=b; x++)
{
cout<<"x = "<<x<<" : ";
//c=2;
//while(x%c > 0)
c=1; // atentie la initializare ... !!!
do
{
c=c+1;
}
while(x%c > 0);
s=s+c;
cout<<"c = "<<c<<" s = "<<s<<"\n\n";
}
cout<<s;
return 0;
}
/*
a = 4 b = 7
x = 4 : c = 2 s = 2
x = 5 : c = 5 s = 7
x = 6 : c = 2 s = 9
x = 7 : c = 7 s = 16
16
*/

Problema 1

Problema 2
Problema 3

#include<iostream>
int main()
{
struct poligon // eticheta structurii
{
int numar; // camp in structura ... [3,100) ...
struct // struct anonim ... !!!
{
float x; // camp in structura ...
float y; // camp in structura ...
} varf[100]; // [3,100) ...
};
struct poligon p;
p.numar=12;
p.varf[0].x=3.4;
p.varf[0].y=5.67;
cout<<"p.numar = "<<p.numar<<"\n";
cout<<"p.varf[0].x = "<<p.varf[0].x<<"\n";
cout<<"p.varf[0].y = "<<p.varf[0].y<<"\n";
return 0;
}
Problema 4

#include<iostream> // ca 2018 iunie ... sun 4 zone (N,S,E,V) + diagonalele
char a[9][9]; // initializat cu ??? ... aici
void afisa()
{
int i,j;
for(i=0; i<=8; i++)
{
for(j=0; j<=8; j++)
{
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
int i,j;
for(i=0; i<=8; i++)

for(j=0; j<=8; j++)
a[i][j]=’*’; // a global ... se vede si aici
for(i=0;i<9;i++) // linia i incepe cu valoarea i

for(j=0;j<9;j++) // coloana j din linia i este ...
if((j >= i+1) && (j <= 8-i-1)) // N == NE && NV - nord !!!
a[i][j]=’a’;
else
a[i][j]=’b’;
afisa();
return 0;
}
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
char s[101];
char x[101];
char DO[]="DO";
char RE[]="RE";
char MI[]="MI";
char FA[]="FA";
char SOL[]="SOL";
char LA[]="LA";
char SI[]="SI";
int main()
{
cin.get(s,101);
cout<<"s = "<<s<<"\n";
if(
strstr(s,DO)==NULL &&
strstr(s,RE)==NULL &&
strstr(s,MI)==NULL &&
strstr(s,FA)==NULL &&
strstr(s,SOL)==NULL &&
strstr(s,LA)==NULL &&
strstr(s,SI)==NULL
)
{
cout<<"nu exista";
return 0;
}
char * pch;
pch=strtok(s," ");
while(pch != NULL)
{
strcpy(x,pch);
if(
strstr(x,DO)!=NULL ||
strstr(x,RE)!=NULL ||
strstr(x,MI)!=NULL ||
strstr(x,FA)!=NULL ||
strstr(x,SOL)!=NULL ||
strstr(x,LA)!=NULL ||
strstr(x,SI)!=NULL
)
cout<<x<<"\n";

}
return 0;
}
/*
REMI DOMINO SI KHANHOO SUNT DENUMIRI DE JOCURI CE AU ASPECTE SIMILARE
s = REMI DOMINO SI KHANHOO SUNT DENUMIRI DE JOCURI CE AU ASPECTE SIMILARE
REMI
DOMINO
SI
DENUMIRI
SIMILARE
*/

Problema 1
Problema 2

#include<iostream>
void f(int n)
{
//cout << "\n" << "--> f(" << n << ")" << "\n";
int i;
if(n>0)
{
for(i=1;i<=n;i++) cout<<i;
f(n-1);
//cout<<n*n<<"\n";;
}
//cout<<"<-- f("<<n<<")"<<"\n";
}
int main()
{
f(4);
return 0;
}
/*
1234123121
*/
Problema 3

#include<iostream>
void identice(int a, int b)

{
cout<<"a = "<<a<<" b = "<<b<<"\n";
int nrv=0;
for(int i=a; i<=b; i++)

{
// i are toate cifrele egale ?
int c=i%10;
int ii=i;
while(ii>0 && ii%10 == c)

{
ii=ii/10;
}
if(ii>0)
{
// ...
}
else
{
cout<<i<<" ";
nrv++;
}
}
if(nrv==0) cout<<"nu exista";
}
int main()
{
int a, b;
a=700;
//a=1450;
b=1500;
//b=78987;
identice(a,b);
return 0;
}
/*
a = 700 b = 1500
777 888 999 1111
*/

#include<iostream>
void identice(int a, int b)

{
cout<<"a = "<<a<<" b = "<<b<<"\n";
int aa=a; // copie a lui a;

int bb=b; // copie a lui b;
int nca; // nr cifre a

int ncb; // nr cifre b
int nr; // numar cerut in enunt, de afisat

int nrv; // numar variante scrise
nca=0;
while(aa != 0)
{
nca=nca+1;
aa=aa/10;
}
//cout<<"nca = "<<nca<<"\n";
ncb=0;
while(bb != 0)
{
ncb=ncb+1;
bb=bb/10;
}
//cout<<"ncb = "<<ncb<<"\n";
int p10;
nrv=0;
for(int nc=nca; nc<=ncb; nc++) // lungimea numarului nr
{
for(int c=1; c<=9; c++) // cifre nr=ccccc
{
p10=nc;
nr=c;
while(p10 > 1)
{
nr=nr*10+c;
p10=p10-1;
}
if(nr >= a && nr <= b)

{
cout<<nr<<" ";
nrv=nrv+1;
}
}
}
if(nrv == 0)
cout<<"nu exista";
}
int main()
{
int a, b;
a=700;
b=1500;
identice(a,b);
return 0;
}
/*
a = 700 b = 1500
777 888 999 1111
*/
Problema 4

#include<iostream> // n si m pot avea valoarea 1 ... !!!
#include<fstream> // sirurile sunt strict crescatoare ... !!!
#include<iomanip>
ifstream fin("2017-mai-bac2.in");
const int max_N = 1e6+1;
int A[max_N]; // risipa de memorie ... !!!

int B[max_N];
int m, n;
void afisv(int v[], int nv)

{
cout<<"--> afisv : ";
for(int i=1; i<=nv; i++)

cout<<setw(3)<<v[i]<<" ";
cout<<"\n";
}
int main()
{
fin>>m>>n;
cout<<"m = "<<m<<" n = "<<n<<"\n";
for(int i=1; i<=m; i++) fin>>A[i];

cout<<"A: "; afisv(A,m);
for(int i=1; i<=n; i++) fin>>B[i];

cout<<"B: "; afisv(B,n);
int a1=A[1];
int am=A[m];
if(am < B[1])

{
cout<<1; // inserez pe prima pozitie, inainte de B
return 0;
}
if(a1 > B[n])

{
cout<<(n+1); // inserez dupa ultima pozitie, dupa B
return 0;
}
int k; // pozitia de inserare

k=0; // nu este inca inserat !
for(int i=1; i<=n-1; i++)
{
if(a1 > B[i] && am < B[i+1])
{
k=i+1;
break;
}
}
if(k>0)
cout<<k;
else
cout<<"imposibil";
return 0;
}

#include<iostream> // n si m pot avea valoarea 1 ... !!!
#include<fstream> // sirurile sunt strict crescatoare ... !!!
#include<iomanip>
ifstream fin("2017-mai-bac2.in");
int m, n;
int a; // elemente din A
int b1, b2; // elemente consecutive din B
int a1, am; // elemente din minA si maxA
int main()
{
int i;
fin>>m>>n; // cout<<"m = "<<m<<" n = "<<n<<"\n";
fin>>a;
a1=a;
am=a;
for(i=2; i<=m; i++) fin>>am; // ultimul ramane cel mai mare ... !!!
//cout<<"minA = "<<a1<<" maxA = "<<am<<"\n";
int k; // pozitia de inserare
fin>>b1; // citesc primul numar din B

//cout<<"b1 = "<<b1<<"\n";
if(am < b1)

{
cout<<1; // inserez pe prima pozitie
return 0;
}
if(am == b1)
{
cout<<"imposibil"; // ...
return 0;
}
k=0; // nu este inca inserat !

for(i=2; i<=n; i++)
{
fin>>b2;
if(b1 >= am) break;
//cout<<i<<" : "<<b1<<" ... "<<b2<<"\n";

if(a1 > b1 && am < b2) // [b1 .. b2]
{
k=i;
break;
}
else
{
b1=b2; // [b1, ...] b1 si b2 raman egala daca nu se citesta iar ... !!!
}
}
if(k==0) // nu s-a gasit b >= minA

{
if(am>b2)
cout<<(n+1); // // inserez dupa ultima pozitie, dupa B
else
cout<<"imposibil";
}
else
{
cout<<k;
}
return 0;
}


Varianta 4
35.2.1 Subiectul I
Problema 1
Indicaţi o expresie C/C++ care are valoarea 1 dacă şi numai dacă numărul natural memorat ı̂n
variabila ı̂ntreagă x are exact o cifră.
a. x%10==x b. x/10==x c. x%10==x/10 d. (x%10)/10==x
Fie x=3;
a. 3%10 == 3 este ’adevărat’

b. 3/1 == 3 este ’fals’
c. 3%10 == 3/10 este ’fals’ ( 3 este diferit de 0)
d. (3%10)/10 == 3 este ’fals’ ( 3/10 este diferit de 3)
Am avut noroc! O singură variantă este adevărată (expresia are valoarea 1).
Problema 2

#include<iostream>
int main()
{
int n, i, j;
//cin>>n;
n=3;
for(i=1; i<=n; i++)

{
for(j=1; j<=n; j++)
{
if((i==j)||(i+j==n+1))
cout<<’#’;
else
cout<<j;
}
}
return 0;
}

#include<iostream>
int main()
{
int n, i, j;
int nrdiez=0;
//cin>>n;
n=50;
for(i=1; i<=n; i++)

{
for(j=1; j<=n; j++)
{
if((i==j)||(i+j==n+1))
cout<<’#’, nrdiez=nrdiez+1;
else
cout<<j;
}
}
cout<<"\n";
cout<<"nrdiez = "<<nrdiez<<"\n";
return 0;
}

#include<iostream>
int main()
{
int n, i, j;
int nrdiez=0;
//cin>>n;
n=50;
//for(i=1; i<=n; i++)

i=1; // initializarea ...
while(i<=n) // conditia de test ...
{
for(j=1; j<=n; j++)
{
if((i==j)||(i+j==n+1))
cout<<’#’, nrdiez=nrdiez+1;
else
cout<<j;
}
i=i+1; // incrementarea ...
}
cout<<"\n";
cout<<"nrdiez = "<<nrdiez<<"\n";
return 0;
}

Problema 1

#include<iostream>
#include<cstring>
#include<iomanip> // setw(3)
int main()
{
cout<<strstr("veni,vidi,vici","vi");
return 0;
}
/*
vidi,vici
*/
Problema 2
Problema 3

#include<iostream>
#include<cstring>
struct elev
{
char nume[30];
int media1, media2;
} x;
int main()
{
//x.nume="Popescu";
strcpy(x.nume,"Popescu");
x.media1=9;
x.media2=10;
cout<<x.nume[0]<<"\n";
cout<<(float)(x.media1+x.media2)/2.0<<"\n"; // ok
cout<<((float)x.media1+x.media2)/2<<"\n"; // ok
cout<<(x.media1+x.media2)/2.0<<"\n"; // ok
cout<<(x.media1+x.media2)/2<<"\n"; // ??????????????
return 0;
}
/*
P
9.5
9.5
9.5
9
*/
Problema 4
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
int n, m; // n=linii m=coloane
int a[51][51];
int main()
{
int i, j;
int anm;
cin>>n>>m;
for(i=1; i<=n; i++)

for(j=1; j<=m; j++)
cin>>a[i][j];
anm=a[n][m];
// modific in memorie tabloul dat

for(i=1; i<=n; i++)
for(j=1; j<=m; j++)
if(i==1 || i==n || j==1 || j==m)
a[i][j]=anm;
// afisez pe ecran tabloul modificat

for(i=1; i<=n; i++)
{
for(j=1; j<=m; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
intrare:
5 4
0 5 2 11
3 2 10 2
7 3 1 4
4 5 0 12
8 13 7 5
iesire:
5 5 5 5
5 2 10 5
5 3 1 5
5 5 0 5
5 5 5 5
*/

Problema 1

Problema 2
Problema 3

#include<iostream>
void duplicare(int & n)

{
//cout<<"n = "<<n<<"\n";
int nn=n; // copie a lui n
int ncn; // nr cifre n
int p10; // puteri ale lui 10;
int c; // cifra
ncn=0;
while(nn != 0)
{
ncn=ncn+1;
nn=nn/10;
}
//cout<<"ncn = "<<ncn<<"\n";
p10=1; // o folosesc ca sa determin cifra din stanga

for(int i=2; i<=ncn; i++) p10=p10*10;
//cout<<"p10 = "<<p10<<"\n";
nn=n; // copie a lui n

n=0;
for(int i=1; i<=ncn; i++) // parcurg cifrele lui n
{
c=(nn/p10)%10;
n=n*10+c;
if(c%2 == 0)
n=n*10+c/2;
p10=p10/10;
//cout<<"n = "<<n<<"\n";
}
int main()
{
int n;
n=2380;
//n=35;
cout<<"n = "<<n<<"\n";
duplicare(n);
cout<<"n = "<<n<<"\n";
return 0;
}
/*
n = 2380
n = 2138400
*/

#include<iostream>
void duplicare(int & n)//de la dreapta la stanga ... !!!

{
int nr0fin; // 0-urile de la sfarsit ajung in fata lui ni ... si dispar!
int ni; // inverssul lui n;
//cout<<"duplicare: n = "<<n<<endl;
nr0fin=0;
while(n%10 == 0) // 0-urile de la sfarsitul lui n
{
nr0fin++;
n=n/10;
}
ni=0;
while(n>0) // inversarea cifrelor lui n cu cifre pare injumatatite
{
if(n%2 == 0)
{
ni=ni*10+(n%10)/2;
ni=ni*10+(n%10);
n=n/10;
}
else
{
ni=ni*10+(n%10);
n=n/10;
}
}
cout<<"ni = "<<ni<<endl;
n=0; // era deja 0 din calcul ... dar ... ca sa fie clar!
while(ni>0) // inversarea cifrelor lui ni
{
n=n*10+(ni%10);
ni=ni/10;
}
while(nr0fin>0) // pun zerourile de la sfarsitul lui n

{
n=n*100; // cate doua 0-uri
nr0fin=nr0fin-1;
}
}
int main()
{
int n;
n=2380;
//n=35;
cout<<"n = "<<n<<"\n";
duplicare(n);
cout<<"n = "<<n<<"\n";
return 0;
}
/*
n = 2380
n = 2138400
*/
Problema 4

#include<iostream> // cu vector ... nu este optim !
#include<fstream>
ifstream fin("2017bac-s2-bac1.txt");
//ifstream fin("2017bac-s2-bac2.txt");
int s[max_N]; // sir de numere

int n; // nr elementelor din sir
int nrs; // nr secvente de lg max

int lgmax; // lg maxima
int lgc; // lg curenta
int i1, i2; // capetele secventei
int ok; // ok=1 daca sunt in secventa para (pentru afisare ...)
int main()
{
int x;
n=0;
while(fin>>x)
{
n++;
s[n]=x;
}
for(int i=1; i<=n; i++) cout<<s[i]<<" ";
cout<<"\n\n";
i1=i2=lgc=0;
if(s[1]%2==0)
{
i1=1;
i2=1;
lgc=1;
ok=1;
//cout<<s[1]<<" ";
}

{
if(s[i]%2==0) // incepe secventa para sau se lungeste o secventa para
{
if(s[i-1]%2==0) // se lungeste secventa para
{
i2++;
lgc++;
//cout<<s[i]<<" ";
}
else // incepe o secventa para
{
i1=i;
i2=i;
lgc=1;
ok=1;
//cout<<s[i]<<" ";
}
}
else // s[i]%2 == 1 incepe sau se lungeste o secventa impara
{
if(s[i-1]%2==0) // incepe o secventa impara (s-a terminat una para)
{
//cout<<" lgc = "<<lgc<<" "; // s-a terminat o secventa para
if(lgc > lgmax) // lg mai mare ...
{
lgmax=lgc;
nrs=1;
}
else
if(lgc == lgmax) // lgc egala cu cea maxima
{
nrs++;
}
else // lgc < lgmax
{
// ... nimic
}
lgc=0;
i1=i2=0; // in asteptarea unei secvente pare
//cout<<"lgmax = "<<lgmax<<" nrs = "<<nrs<<"\n";

}
else // s[i-1]%2==1; se lungeste o secventa impara
{
// ... nimic
}
}
}
//cout<<"\n\n";
//cout<<"pentru ultima secventa ramasa: lgc = "<<lgc<<" ";
{
lgmax=lgc;
}
else
{
nrs++;
}
else // lgc < lgmax
{
// ... nimic
}
cout<<"lgmax = "<<lgmax<<" nrs = "<<nrs<<"\n";
cout<<"\n";
cout<<nrs;
return 0;
}

#include<iostream> // fara vector ...
#include<fstream>
ifstream fin("2017bac-s2-bac1.txt");
//ifstream fin("2017bac-s2-bac2.txt");
// sunt automat initializate cu zero

int nrs; // nr secvente de lg max
int lgmax; // lg maxima
int lgc; // lg curenta
int v1, v2; // doua valori consecutive: v1, v2
int ok; // ok=1 daca sunt in secventa para (pentru afisare ...)
int main()
{
int x; // valoarea curenta citita
fin>>x;
v1=x; // valoarea anterior citita
v2=x; // valoarea curenta citita
if(x%2==0)
{
lgc=1;
ok=1;
cout<<x<<" ";
}
while(fin >> x)
{
v1=v2;
v2=x; // deplasare spre dreapta in sir
if(v2%2==0) // incepe sau se lungeste o secventa para

{
if(v1%2==0) // se lungeste secventa para
{
lgc++;
cout<<v2<<" ";
}
else // incepe o secventa para
{
lgc=1;
ok=1;
cout<<v2<<" ";
}
}
else // v2%2 == 1 incepe sau se lungeste o secventa para
{
if(v1%2==0) // incepe o secventa impara (s-a terminat una para)
{
cout<<"\t\t lgc = "<<lgc<<" "; // s-a terminat secventa para
{
lgmax=lgc;
if(lgc >= 2) // cel putin doua in secventa
nrs=1;
}
else
{
if(lgc >= 2)// cel putin doua in secventa
nrs++;
}
else // lgc < lgmax
{
// ... nimic
}
lgc=0;

}
else // v1%2==1; se lungeste o secventa impara
{
// ... nimic
}
}
}
cout<<"\n\n";
cout<<"la sfarsit (pentru ultima secventa ramasa): lgc = "<<lgc<<" ";
{
lgmax=lgc;
if(lgc >= 2) // cel putin doua in secventa
nrs=1;
}
else
{
nrs++;
}
else // lgc < lgmax
{
// ... nimic
}
cout<<"\n";
cout<<nrs;
return 0;
}


Varianta 7
35.3.1 Subiectul I
Problema 1
3+7/4+3 = 3 + 1 + 3 + 7
7/4 are ca rezultat 1 pentru că ı̂mpărţirea intre două numere ı̂ntregi dă ca rezultat ”câtul”
acele ı̂mpărţiri!
Problema 2

#include<iostream>
int main()
{
int n, k, i, x, y;
cin>>n;
//cout<<"n = "<<n<<"\n";
k=0;
i=1;
while(i<=n)
{
cin>>x;
//cout<<"x = "<<x<<" : ";
y=2;
while((x>1) && (x%y != 0))
{
y=y+1; // y se duce la primul divizor > 1 al lui x
}
//cout<<" y = "<<y;
if(k < x/y) k=x/y; // k este cel mai mare divizor ...
//cout<<" x/y = "<<x/y<<" k = "<<k<<"\n";
i=i+1;
}
cout<<k;
return 0;
}
/*
intrare: 4 5 24 3 45
iesire: 15
*/

#include<iostream>
int main()
{
int n, k, i, x, y;
cin>>n;
//cout<<"n = "<<n<<"\n";
k=0;
i=1;
while(i<=n)
{
cin>>x;
//cout<<"x = "<<x<<" : ";
y=2;
while((x>1) && (x%y != 0))
{
}
//cout<<" y = "<<y;
//cout<<" x/y = "<<x/y<<" k = "<<k<<"\n";
i=i+1;
}
cout<<k;
return 0;
}
/*
3 5 7 11 ... numere prime ...
3 13 17 19
*/

#include<iostream>
int main()
{
int n, k, i, x, y;
cin>>n;
//cout<<"n = "<<n<<"\n";
k=0;
i=1;
//while(i<=n)
for( ; i<=n; ) // initializarea este deja ...
{
cin>>x;
//cout<<"x = "<<x<<" : ";
y=2;
while((x>1) && (x%y != 0))
{
}
//cout<<" y = "<<y;
//cout<<" x/y = "<<x/y<<" k = "<<k<<"\n";
i=i+1; // asta este si incrementarea pentru for

}
cout<<k;
return 0;
}
/*
3 1 3 5 ... numere prime ...
*/

Problema 1

#include<iostream>
#include<cstring>
int main()
{
struct interval
{
float s,d;
} v[20];
v[0].s=1.2;
v[0].d=11.22;
cout<<"["<<v[0].s<<","<<v[0].d<<"]\n";
return 0;
}
Problema 2
Problema 3
Problema 4

#include<iostream>
#include<cstring>
#include<iomanip>
#include<fstream>
ifstream fin("2017bac-s3-II-4-bac.txt");
int main()
{
int i, n;
char s[21];
n=0;
for(i=1;i<=11;i++)
{
cout<<i<<" : "; //cout<<i<<" : ";
fin>>s;
//getchar();
if((strstr(s,"are") != NULL) && (strlen(strstr(s,"are"))==3))

{
cout<<s<<" : "<<strstr(s,"are")
<<" ( "<<strlen(s)<<" --> "<<strlen(strstr(s,"are"))<<" )";

n++;
}
cout<<"\n";
}
return 0;
}
/*
la
proiectare
se
are
in
vedere
evitarea
deformatiilor
areolare
si
liniare
*/
Problema 5

#include<iostream> // cu vector ajutator
#include<fstream>
#include<cstring>
int n; // numar par

float a[52][51];
float x[51]; // vectorul mediilor
int main()
{
int i, j;
cin>>n;
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
cin>>a[i][j];
// calculez mediile
for(j=1; j<=n; j++)
{
x[j]=0;
for(i=1; i<=n; i++) x[j]=x[j]+a[i][j]; // suma
x[j]=x[j]/n; // media
}
cout<<"\n\n";
// deplasez liniile din jumatatea inferioara, in jos 1 linie

for(i=n+1; i>=n/2+1; i--)
for(j=1; j<=n; j++)
a[i][j]=a[i-1][j];
// plasez linia mediilor pe linia n/2 + 1

for(j=1; j<=n; j++)
a[n/2+1][j]=x[j];
// afisez matricea
for(i=1; i<=n+1; i++)
{
for(j=1; j<=n; j++)
{
cout<<setw(6)<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
4
1.5 0.75 3 1.2
2.75 1.25 2.25 1.5
4.5 1.15 3 4.5
0.25 0.85 1.75 3
*/

#include<iostream> // fara vector ajutator
#include<fstream>
#include<cstring>
int n; // numar par

float a[52][51];
int main()
{
int i, j;
cin>>n;
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
cin>>a[i][j];
// deplasez liniile din jumatatea inferioara, in jos 1 linie

for(i=n+1; i>=n/2+1; i--)
for(j=1; j<=n; j++)
a[i][j]=a[i-1][j];
// plasez linia mediilor pe linia n/2 + 1 (dupa ce o calculez ... :-)

for(j=1; j<=n; j++)
{
float sj=0;
for(i=1; i<=n+1; i++)

if(i != n/2+1)
sj=sj+a[i][j];
a[n/2+1][j]=sj/n;
}
// afisez matricea
for(i=1; i<=n+1; i++)
{
for(j=1; j<=n; j++)
{
cout<<setw(6)<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*4
1.5 0.75 3 1.2
2.75 1.25 2.25 1.5
4.5 1.15 3 4.5
0.25 0.85 1.75 3
*/

Problema 1

#include<iostream>
int f(int n)
{
if (n!=0)
return (n%2)*(n%10)+f(n/10);
return 0;
}
int main()
{
int rez;
rez=f(1234);
return 0;
}

Problema 2
Problema 3

#include<iostream>
void triplete(int a, int b, int c)

{
int x, y, z;
int nrv=0; // numar variante
for(x=a; x<=b; x++)

{
for(y=x; y<=b; y++)
{
for(z=y; z<=b; z++)
{
if(x+y+z == c)
{
cout<<"{"<<x<<","<<y<<","<<z<<"}";
nrv=nrv+1;
}
}
}
}
if(nrv == 0) cout<<"nu exista";
}
int main()
{
int a, b, c;
a=2; b=4; c=8;
//a=5; b=8; c=8;
triplete(a,b,c);
return 0;
}

#include<iostream>
void triplete(int a, int b, int c)

{
int x, y, z;
int nrv=0; // numar variante
for(x=a; x<=b; x++)

{
if(x>c) break;
for(y=x; y<=b; y++)

{
if(x+y > c) break;
for(z=y; z<=b; z++)

{
if(x+y+z > c) break;
if(x+y+z == c)
{
cout<<"{"<<x<<","<<y<<","<<z<<"}";
nrv=nrv+1;
}
}
}
}
if(nrv == 0) cout<<"nu exista";
}
int main()
{
int a, b, c;
a=2; b=4; c=8;
//a=5; b=8; c=8;
triplete(a,b,c);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
ifstream fin("2017bac-s3-III-4-vac.txt");
int fr[1001]; // vector de frecvente ... initializat cu zero
int main()
{
int r=-1; // ratia
int x; // valoare din fisier

while(fin>>x)
{
fr[x]++;
}
for(int i=0; i<=1000; i++)
if(fr[i]>0)
cout<<i<<" : "<<fr[i]<<"\n";
int v1, v2; // valori consecutive din vectorul de frecventa

v1=0;
while(v1<=1000 )
{
if(fr[v1]>0) break;
v1++;
}
cout<<v1<<" "<<fr[v1]<<"\n";
v2=v1+1;
while(v2<=1000 )
{
if(fr[v2]>0) break;
v2++;
}
cout<<v2<<" "<<fr[v2]<<"\n";
r=v2-v1;
v1=v2;
v2=v2+1;
while(v2<=1000)
{
if(fr[v2]==0)
{
v2++;
continue;
}
// aici fr[v2]>0
if(v2-v1 == r) // este ok in progresie
{
v1=v2;
v2=v1+1;
}
else // nu este in progresie
{
r=-1;
break;
}
}
cout<<"Solutia: \n";
if(r>0)
cout<<r;
else
cout<<"nu exista";
return 0;
}

Capitolul 36
BAC 2016

Varianta *
36.1.1 Subiectul I
Problema 1
Numerele fiind strict pozitive, putem să facem ı̂mpărţiri!
a. x*y%y*z && x*z%y*z
x%z && x%y
b. x*z%x*y && y*z%y*x
z%y && z%x
c. y*z%x*z && y*x%z*x
y%x && y%z
d. y*z%y*x && y*z%z*x
z%x && y%x
Problema 2
Listing 36.1.1: 2016bac-s1-I-2a-cu-functie.cpp

#include<iostream>
int f(int n)
{
int k, m;
k=1;
m=1;
while(n>9) // n are 2 cifre cel putin
{
//cout<<"\n";
//cout<<"n = "<<n<<" k = "<<k<<" : ";
if(n%10 == (n/10)%10) // daca ultimele 2 cifre sunt egale
{
k=k+1;
//cout<<"k = "<<k<<" m = "<<m;
if(k>m)
{
m=k; // cea mai lunga secventa de cifre egale
}
}
else
{
k=1;
}
//cout<<" * m = "<<m<<" k = "<<k<<"\n";
n=n/10;
}
return m;
}
461
int main()
{
int n;
int rez;
n=81112337;
rez=f(n);
return 0;
}
Listing 36.1.2: 2016bac-s1-I-2b-cu-functie.cpp

#include<iostream>
int f(int n)
{
int k, m;
k=1;
m=1;
while(n>9) // n are 2 cifre cel putin
{
//cout<<"\n";
//cout<<"n = "<<n<<" k = "<<k<<" : ";
{
k=k+1;
//cout<<"k = "<<k<<" m = "<<m;
if(k>m)
{
}
}
else
{
k=1;
}
//cout<<" * m = "<<m<<" k = "<<k<<"\n";
n=n/10;
}
return m;
}
int main()
{
int n;
int rez;
int nrv4=0;
for(n=10000; n<=19999; n++)

{
rez=f(n);
if(rez==4)
{
nrv4++;
cout<<nrv4<<" : "<<n<<endl;
}
}
return 0;
}
Listing 36.1.3: 2016bac-s1-I-2c-do-cu-functie.cpp

#include<iostream>

int f(int n)
{
int k, m;
k=1;
m=1;
//while(n>9) // n are 2 cifre cel putin
if(n>9) // pentru primul pas ... !!!
do
{
//cout<<"\n";
//cout<<"n = "<<n<<" k = "<<k<<" : ";
{
k=k+1;
//cout<<"k = "<<k<<" m = "<<m;
if(k>m)
{
}
}
else
{
k=1;
}
//cout<<" * m = "<<m<<" k = "<<k<<"\n";
n=n/10;
} while(n>9);
return m;
}
int main()
{
int n;
int rez;
n=81112337;
rez=f(n);
return 0;
}
Listing 36.1.4: 2016bac-s1-I-2c-for-cu-functie.cpp

#include<iostream>
int f(int n)
{
int k, m;
k=1;
m=1;
//while(n>9) // n are 2 cifre cel putin
for( ; n>9; )
{
//cout<<"\n";
//cout<<"n = "<<n<<" k = "<<k<<" : ";
{
k=k+1;
//cout<<"k = "<<k<<" m = "<<m;
if(k>m)
{
}
}
else
{
k=1;
}
//cout<<" * m = "<<m<<" k = "<<k<<"\n";
n=n/10; // se poate pune in for la al treilea argument!
}
return m;
}
int main()
{
int n;
int rez;
n=81112337;
rez=f(n);
return 0;
}

Problema 1
Primul element de pe linia i este m[i][0].
Ultimul element de pe coloana j este m[4][j].
Problema 2

Problema 3
Problema 4

#include<iostream>
struct parcare
{
int nrLocuriInchiriate;
int pretOra;
} p[20];
int main()
{
int i, s;
for(i=0; i<20; i++)

{
p[i].nrLocuriInchiriate=10;
p[i].pretOra=1;
}
s=0;
for(i=0; i<20; i++)
s=s+p[i].nrLocuriInchiriate*p[i].pretOra;
cout<<s<<"\n";
return 0;
}
Problema 5

#include<iostream>
//#include<fstream>
#include<cstring>
int n, k;
char v[21][21]; // vector de cuvinte

char cuvant[21]; // cuvant curent
char sir[21*21]; // sirul construit in memorie
int main()
{
int i, j;
cin>>n;
cout<<"n = "<<n<<"\n";
for(i=1; i<=n; i++)

{
cin>>cuvant;
strcpy(v[i],cuvant);
}
cin>>k;
cout<<"k = "<<k<<"\n";
cout<<"\n";
for(i=1; i<=n; i++)
{
cout<<i<<" : "<<v[i]<<"\n";
}
cout<<"\n";
// construiesc in memorie sirul cu cuvintele de lungime k

for(i=1; i<=n; i++)
{
if(strlen(v[i])==k)
{
strcat(sir,v[i]);
strcat(sir," ");
}
}
cout<<"sir = "<<sir<<"\n";
// adaug in sir cuvintele de lungime diferita de k

for(i=1; i<=n; i++)
{
if(strlen(v[i])!=k)
{
strcat(sir,v[i]);
strcat(sir," ");
}
}
cout<<"sir = "<<sir<<" : "<<strlen(sir)<<"\n";
// "sterg" ultimul spatiu din sir

sir[strlen(sir)-1]=’\0’;
cout<<"sir = "<<sir<<" : "<<strlen(sir)<<"\n";
// final
cout<<"sir = "<<sir<<"\n";
return 0;
}
/*
5
am
un
cires
de
mai
2
*/

Problema 1

#include<iostream>
void f(int n, int p)// reprezentarea lui n ca suma de puteri ale lui 2 ...
{
if(n>0)
{
if(n%2==1)
cout<<p<<" ";
f(n/2, p*2);
}
}
int main() // x=? maxim, a.i. sa se afiseze numerele 2 4 16

{
for(int x=20; x<=25;x++)
{
cout<<x<<" : ";
f(x,1);
cout<<"\n";
}
return 0;
}
Problema 2
Problema 3

#include<iostream>
int minDivPrim(int n)
{
cout<<"n = "<<n<<"\n";
int nrmin; // numarul cerut ... are factorii primi la puterea 1
int d; // divizor ... factor prim
nrmin=1;
d=2;
if(n%d == 0)
{
nrmin=nrmin*d;
while(n%d == 0) // scot 2-urile din n
n=n/d;
cout<<"d = "<<d<<" nrmin = "<<nrmin<<"\n";
}
d=3;
while(d*d<=n) // optimizare ...
{
if(n%d ==0)
{
nrmin=nrmin*d; // scot d-urile din n
while(n%d == 0)
n=n/d;
cout<<"d = "<<d<<" nrmin = "<<nrmin<<"\n";
}
d=d+2; // trec la 5, 7, ...

}
cout<<"n = "<<n<<" ... la sfarsit !!!\n";
if(n != 1) // a ramas ultimul factor prim la puterea 1 (optimizare ...!!!)

nrmin=nrmin*n;
return nrmin;
}
int main()
{
int n;
n=75;
//n=7;
//n=2*2*3*5*5*5*7;
int rez;
rez=minDivPrim(n);
return 0;
}
Problema 4

#include<iostream> // f1=1; f2=-1; f_n = 1-2*f_{n-1}-f_{n-2}:
#include<fstream> // 1, -1, 2, -2, 3, -3, 4, -4, ...
/*
k = impar : f(k) = (k+1)/2
k = par : f(k) = - k/2
*/
int main()
{
int n;
cin>>n;

{
if(i%2 == 1)
fout<<(i+1)/2<<" ";
else
fout<<-i/2<<" ";
}
return 0;
}

#include<iostream> // f1=1; f2=-1; f_n = 1-2*f_{n-1}-f_{n-2}:
#include<fstream> // 1, -1, 2, -2, 3, -3, 4, -4, ...
int main()
{
int n;
cin>>n;
int fn2, fn1, fn;
// fn2 fn1 fn *=?=calcu

// fn2 fn1 --> fn
fn2=1; // n=1
fn1=-1; // n=2
fn=1-2*fn1-fn2; // n=3;
cout<<1<<" : "<<fn2<<"\n";
cout<<2<<" : "<<fn1<<"\n";
cout<<3<<" : "<<fn<<"\n";
// ... fn2 fn1 fn ... -->

// fn2 fn1 fn=calcul
{
fn2=fn1;
fn1=fn;
fn=1-2*fn1-fn2;
//cout<<i<<" : "<<fn<<"\n";
}
//cout<<fn2<<" "<<fn1<<" "<<fn<<"\n";
fout<<fn<<" "<<fn1<<" "<<fn2;

// fn=1-2*fn1-fn2;
// fn2=1-2*fn1-fn;
// <-- calcul=f[n-2], f[n-1], f[n] ...

for(int i=n-3; i>=1; i--)
{
fn=fn1;
fn1=fn2;
fn2=1-2*fn1-fn;
fout<<" "<<fn2;
}
return 0;
}


36.2.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg. Indicaţi o expresie C/C++ care are valoarea 1 dacă şi numai dacă
valoarea variabilei x are exact trei cifre.
a. x%1000==0 || x%100!=0
b. x/1000==0 || x/100!=0
c. x%1000==0 && x%100!=0
d. x/1000==0 && x/100!=0
a. x%1000==0 || x%100!=0 pentru x=10000 ar trebui să dea 0 (pentru că nu are 3 cifre)
dar valoarea este 10000%1000==0 || 10000%100!=0
0==0 || 0!=0 1 || 0
1
b. x/1000==0 || x/100!=0 pentru x=10000 ar trebui să dea 0 (pentru că nu are 3 cifre)
dar valoarea este 10000/1000==0 || 10000/100!=0
10==0 || 10!=0 0 ||
1 1
c. x%1000==0 && x%100!=0 pentru x=100 ar trebui să dea 1 (pentru că are 3 cifre) dar
valoarea este 100%1000==0 && 100%100!=0
100==0 && 0!=0 0 && 1 0
Ştim că o variantă este sigur soluţie aşa că ... putem să nu mai ”perdem timpul” cu verificarea
cazului d. x/1000==0 && x/100!=0 pentru că sigur el este soluţia!
Problema 2


#include<iostream>

/*
m creste pana la multiplu de x
n descreste pana la multiplu de x
se afiseaza m si n
sunt egale daca exista un singur multiplu de x intre ele, la inceput!
*/
int main()
{
int m, n, x, p; // m < n ... x nu se schimba !
//cin>>m>>n>>x; pastrez m=11 si n=30 (? = multiplu de x intre ele)

m=11;
n=30;
x=31;
// x=8 --> 16 si 24; x=9 --> 18 si 24; x=10 --> 10 si 20; x=11 --> 11 si 22
// x=15 --> 15 si 30; x=16 --> 16 si 32 ??? de la 16 "in sus este ok
cout<<"m = "<<m<<" n = "<<n<<" x = "<<x<<"\n\n";
p=0;
//while(m<n && p==0)

while((m<n) && (p==0))
{
cout<<" m = "<<m<<" n = "<<n<<" x = "<<x<<" p = "<<p<<"\n";
//if(m%x==0 && n%x==0)

if((m%x == 0) && (n%x == 0))
{
//cout<<" 1. m = "<<m<<" n = "<<n<<" x = "<<x<<" p = "<<p<<"\n";
p=x; // p = divizor_comun(m,n)
}
else
{
//cout<<" 2. m = "<<m<<" n = "<<n<<" x = "<<x<<" p = "<<p<<"\n";
if(m%x==0) // m era mic ... daca m se divide cu x
{
n=n-1; // n descreste !
}
else // m nu se divide cu x
{
m=m+1; // m creste !
}
} // if ... else
} // while
cout<<m<<’ ’<<n<<’\n’;
return 0;
}
/*
11 30 17 --> 17 17
*/

#include<iostream>
int main()
{
int m, n, x, p;
//cin>>m>>n>>x;
m=11;
n=30;
x=17;
cout<<"m = "<<m<<" n = "<<n<<" x = "<<x<<"\n\n";
p=0;
//while((m<n) && (p==0))

for( ; (m<n) && (p==0) ; )
{
if((m%x == 0) && (n%x == 0))
{
p=x;
}
else
{
if(m%x==0)
{
n=n-1;
}
else
{
m=m+1; // m era mic !
}
} // if ... else
} // while
cout<<m<<’ ’<<n<<’\n’;
return 0;
}
/*
11 30 17 ... !!!
*/

Problema 1

#include<iostream>
#include<cstring>
struct masina
{
int an_fabricatie;
char marca[20];
} m;
int main()
{
m.an_fabricatie=1949;
//m.marca="Dacia";
strcpy(m.marca,"Dacia");
cout<<"m.an_fabricatie = "<<m.an_fabricatie<<"\n";
cout<<"m.marca = "<<m.marca<<"\n";
return 0;
}
Problema 2
Problema 3
Problema 4

#include<iostream>
#include<cstring>

int main()
{
char s1[21];
char s2[21];
strcpy(s1,"informatica");
cout<<strlen(s1);
strcpy(s2,"mate"); // s2="mate"
strcat(s2,strstr(s1,"ma")); // concateneaza s2 cu "matica"
cout<<s2;
return 0;
}
/*
11matematica
*/
Problema 5

#include<iostream>
#include<iomanip>
int n;
int a[101][101];
int main()
{
int i, j;
cin>>n;
// prima coloana
for(i=1; i<=n; i++)
a[i][1]=i;
// ultima linie
for(j=2; j<=n; j++) // prima pozitie are deja valoarea n
a[n][j]=n;
// restul pozitiilor
for(i=n-1; i>=1; i--)
for(j=2; j<=n; j++)
a[i][j]=a[i][j-1]+a[i+1][j-1];
// afisare
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
cout<<setw(2)<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
intrare: 4
iesire:
1 3 8 20
2 5 12 23
3 7 11 15
4 4 4 4
*/

Problema 1

#include<iostream>
void f(int n)
{
if (n!=0)
{
cout<<n;
f(n/10);
}
}
int main()
{
f(2016);
return 0;
}
/*
2016201202
*/
Problema 2
Problema 3

#include<iostream>
int cifreImpare(int n)
{
int nn=n; // n original
int nr=0;
while(n>0)
{
if(n%2 == 0)
nr=nr*10+(n%10);
n=n/10;
}
n=nr;
nr=0;
while(n>0) // rasturnare simpla ...
{
nr=nr*10+(n%10);
n=n/10;
}
if(nr==0 || nr==nn) nr=-1;
return nr;
}
int main()
{
int n;
n=23541;
//n=28;
int rez=cifreImpare(n);
return 0;
}

#include<iostream>
int cifreImpare(int n)
{
int p10; // puteri ale lui 10
int nci; // nr de cifre impare
int ncn; // nr cifrelor lui n
ncn=0;
nci=0;
while(nn != 0)
{
if(nn%2 == 1) nci=nci+1;
ncn=ncn+1;
p10=p10*10;
nn=nn/10;
}
if(nci==0 || nci==ncn) // nu exista cifre impare

return -1; // sau toate sunt impare
p10=1; // folosit pentru a obtine cifra din stanga lui n

for(int i=1; i<=ncn-1; i++)
p10=p10*10;
nn=0; // in nn construiesc solutia

while(p10 != 0)
{
if((n/p10)%2 == 0)
{
nn=nn*10+(n/p10)%10;
}
p10=p10/10;
}
return nn;
}
int main()
{
int n;
n=23541;
//n=28;
int rez=cifreImpare(n);
return 0;
}
Problema 4

#include<iostream> // numere ordonate crescator ... !!!
#include<fstream>
ifstream fin("2016bac-s2-III-4-numere.in");
int n;
int main()
{
fin>>n;
//cout<<"n = "<<n<<"\n";
int x; // valoare citita din fisier

int v1, v2; //doua valori consecutive din fisier
fin>>x;
v1=x;
for(int i=1; i<=v1-1; i++) // primele numere
cout<<i<<" ";
while(fin>>x)
{
v2=x;
for(int i=v1+1; i<=v2-1; i++) // v1+1 .. v2-1
cout<<i<<" ";
v1=v2;
}
for(int i=v2+1; i<=n; i++) // ultimele numere

cout<<i<<" ";
return 0;
}
/*
intrare:
10
3 4 4 8
iesire: 1 2 5 6 7 9 10
*/


36.3.1 Subiectul I
Problema 1
!(x>0 && y>0) !(x>0) || !(y>0) x<=0 || y<=0)
Este clar că vom urmări numai variantele cu | | (sau) deci numai a. şi c.
Soluţia esyte a.
Problema 2

#include<iostream>
int main()
{
int n, p, m, i;
//cin>>n;
n=12;
p=0;
for(i=1; i<=n; i++)
{
m=i; // m este copie a lui i
while(m%2==0)// scoate 2-urile dim m
{
m=m/2;
}
if(m==1) // i a fost putere a lui 2

{
p=i; // p ramane cel mai mare i care este putere de 2
}
}
cout<<p;
return 0;
}
/*
*/

#include<iostream>
int main()
{
int n, p, m, i;
//cin>>n;
n=31; // 16 si 31
p=0;
for(i=1; i<=n; i++)
{
{
m=m/2;
}

{
}
}
cout<<p;
return 0;
}
Orice număr natural din intervalul [16,31] dă ca rezultat 16.

#include<iostream>
int main()
{
int n, p, m, i;
//cin>>n;
n=31; // 16 si 31
p=0;
//for(i=1; i<=n; i++)

i=1; // initializarea ... n nenul --> se executa cel putin o data !!!
do
{
{
m=m/2;
}

{
}
i=i+1; // incrementarea
} while( (i<=n) ); // la pseudocod: pana cand ( !(i<=n) );
cout<<p;
return 0;
}

Problema 1

#include<iostream>
int main()
{
struct fractie
{
int x,y;
} f;
f.x=2;
f.y=3;
// a.
//if((int x).f==(int y).f) cout<<"x/y == 1 \n";
//else cout << "x/y = " << (float)f.x/f.y <<"\n";
// b.
//if(x.f.fractie==y.f.fractie) cout<<"x/y == 1 \n";
// c.
if(f.x == f.y) cout<<"x/y == 1 \n";
else cout << "x/y = " << (float)f.x/f.y <<"\n";
// d.
//if(x.y==y.x) cout<<"x/y == 1 \n";
return 0;
}
Problema 2
Problema 3

#include<iostream>
#include<cstring>
#include<iomanip> // cout<<setw(3);
#include<fstream> // ifstream("bac.txt");
int main()
{
char s1[21];
char s2[21];
strcpy(s1,"bacalaureat"); // bacal aureat ... de la s1+5 ...

cout<<strlen(s1); // 11
strcpy(s2,s1+5); // s2="aureat"
s2[3]=’\0’; // s2="aur"
cout<<s2;
return 0;
}
Problema 4
Problema 5

#include<iostream>
int n, m, x;
int a[101][101];
int main()
{
int i, j;
int ok; // ok=1 --> DA ok=0 --> NU
cin>>n; // nr linii
cin>>m; // nr coloane
for(i=1; i<=n; i++)

for(j=1; j<=m; j++)
cin>>a[i][j];
cin>>x;
ok=0; // initializare
for(j=1; j<=m; j++) // verific prima linie
if(a[1][j]==x)
{
ok=1;
break;
}
if(ok==0)
for(j=1; j<=m; j++) // verific ultima linie
if(a[n][j]==x)
{
ok=1;
break;
}
if(ok==0)
for(i=2; i<=n-1; i++) // verific prima coloana
if(a[i][1]==x)
{
ok=1;
break;
}
if(ok==0)
for(i=2; i<=n-1; i++) // verific ultima coloana
if(a[i][m]==x)
{
ok=1;
break;
}
if(ok==1)
cout<<"DA";
else
cout<<"NU";
return 0;
}
/*
intrare:
4 5
12 5 12 11 4
3 20 10 20 12
4 5 30 12 6
8 13 7 12 14
12
iesire: DA
*/

Problema 1

#include<iostream>
int f1(int n)
{
if(n==0) return 1;
else
return n*f1(n-1);
}
int f2(int n)
{
if(n!=1) return n*f2(n-1);
else return 0;
}
int main()
{
int rez1=f1(5);
int rez2=f2(5);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 120
rez2 = 0
*/
Problema 2
Problema 3

#include<iostream>
void duplicare(int n, int & d)

{
//cout<<"n = "<<n<<"\n";
int ncn;
int ncp; // nr cifre pare
int nn; // copie a lui n
int p10; // puteri ale lui 10

int c; // cifra
nn=n;
ncn=0;
while(nn != 0)
{
if(nn%2==0) ncp=ncp+1;
ncn=ncn+1;
nn=nn/10;
}
//cout<<"ncn = "<<ncn<<"\n";
//cout<<"ncp = "<<ncp<<"\n";
if(ncp==0)
{
d=-1;
return;
}
p10=1;
for(int i=1; i<=ncn-1; i++)// ca sa obtin cifra din stanga
p10=p10*10;
//cout<<"p10 = "<<p10<<"\n";
d=0; // aici construiesc solutia

while(p10 != 0)
{
c=(n/p10)%10;
d=d*10+c;
if(c%2==0) d=d*10+c;
p10=p10/10;
}
return;
}
int main()
{
int n;
int d;
n=2380;
cout<<"d = "<<d<<endl;
duplicare(n,d);
cout<<"d = "<<d<<endl;
return 0;
}
/*
intrare: 2380
iesire: 2238800
*/
Problema 4

#include<iostream> // numere distincte
#include<fstream>
int main()
{
int nri;
nri=0;
while(fin>>x) // citesc pana gasesc 3 nr impare
{
if(x%2==1) nri++;
if(nri==3) break;
}
if(nri<3)
{
cout<<"Nu exista";
return 0;
}
int xparmax1=-1;
int xparmax2=-1;
while(fin>>x)
{
if(x%2==1) break; // este al patrulea nr impar
// aici x=par
if(xparmax1 < 0) // apare primul nr par
xparmax1=x;
else
if(xparmax2 < 0) // apare al doilea nr par (nr sunt distincte)
{
xparmax2 = x;
if(xparmax1 > xparmax2)
{
xparmax2=xparmax1;
xparmax1=x;
}
}
else // aa aparut alt nr par x: xparmax1 ... xparmax2 ...
{ // unde este plasat x ?
if(x > xparmax2) // xparmax1 ... xparmax2 ... x
{
xparmax1=xparmax2;
xparmax2=x;
}
else
if(x > xparmax1) // xparmax1 ... x ... xparmax2
{
xparmax1=x;
}
}
}
if(xparmax1 < 0 || xparmax2 < 0)

cout<<"Nu exista";
else
cout<<xparmax1<<" "<<xparmax2;
return 0;
}

Capitolul 37
BAC 2015

Varianta *
37.1.1 Subiectul I
***
Problema 1
4+5%7*2 = 4+(5%7)*2 = 4+5*2=14
Înmulţirile şi ı̂mpărţirile au priorităţi egale şi se execută de la stânga spre dreapta.
Operatorul aritmetic % reprezintă o ı̂mpărţire şi dă ca rezultat numai restul ı̂mpărţirii!
Problema 2

#include<iostream>
int main()
{
int m, n, x, y, z, nr;
m=997;
n=1005;
nr=0;
for(x=m; x<=n; x++)
{
cout<<"x = "<<x<<" : ";
y=0;
z=x; // z = copie a lui x
do
{
y=y*10+z%10;// inverseaza cifrele lui z
z=z/10;
} while( !(z==0) );
cout<<" y = "<<y; cout<<" x = "<<x;
if(x==y)
{
nr=nr+1;
}
cout<<"\n";
}
cout<<nr;
return 0;
}
489

#include<iostream>
int main()
{
//cin>>m>>n; // m <= n
m=54321;
//n=54345; // n=max a.i. nr=0 la final
n=54344; // n=max a.i. nr=0 la final
nr=0;
for(x=m; x<=n; x++)
{
//cout<<"x = "<<x<<" : ";
y=0;
do
{
z=z/10;
} while( !(z==0) );
//cout<<" y = "<<y;
//cout<<" x = "<<x;
if(x==y)
{
nr=nr+1;
}
//cout<<"\n";
}
cout<<nr;
return 0;
}

#include<iostream>
int main()
{
//cin>>m>>n; // m <= n
m=54321;
//n=54345; // n=max a.i. nr=0 la final
n=54344; // n=max a.i. nr=0 la final
nr=0;
//for(x=m; x<=n; x++)

x=m; // initializarea
while(x<=n) // conditia de testare (finalizare!)
{
y=0;
do
{
z=z/10;
} while( !(z==0) );
if(x==y)
{
nr=nr+1;
}
x++; // incrementarea
}
cout<<nr;
return 0;
}

Problema 1
Accesul &in structură se face ”din exterior către interior”! Valabile sunt numai A.x, A.y, B.x şi
B.y.
Problema 2
Problema 3
Problema 4

#include<iostream>
int a[6][6];
int i, j;
void afisa()
{
for(i=1; i<=5; i++)
{
for(j=1; j<=5; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
afisa();
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
a[i][j]=(1+i+j)%2;
afisa();
return 0;
}
Problema 5

#include<iostream>
#include<cstring>
char text[101];
char acronim[11];
int main()
{
int ntext; // lungime text
int na; // lungime acronim
cin.get(text,100);
ntext=strlen(text);
//cout<<"text = "<<text<<" : "<<ntext<<"\n";
na=0;
for(int i=0; i<ntext; i++)
{
if((i==0 && text[i]>=’A’ && text[i]<=’Z’)||
(text[i]>=’A’ && text[i]<=’Z’ &&
!(text[i-1]>=’A’ && text[i-1]<=’Z’)))
{
acronim[na]=text[i];
//cout<<"acronim["<<na<<"] = "<<acronim[na]<<"\n";
na++;
}
}
acronim[na]=’\0’;
cout<<acronim;
return 0;
}
/*
intrare: Universitatea de Arte Plastice BUCURESTI
iesire: UAPB
*/

Problema 1
Problema 2
Figura 37.6: 2015bac-s1-III-2-fig1

Figura 37.7: 2015bac-s1-III-2-fig2

#include<iostream>
void F(long a, int b)

{
if(a*b!=0)
if(a%2==0)
{
cout<<a%10;
F(a/10,b-1);
}
else
{
F(a/10,b+1);
cout<<a%10;
}
}
int main()
{
cout<<"F(154678,5) : "; F(154678,5); cout<<"\n";
cout<<"F(154678,4) : "; F(154678,4); cout<<"\n";
cout<<"F(154678,3) : "; F(154678,3); cout<<"\n";
cout<<"F(154678,2) : "; F(154678,2); cout<<"\n";
cout<<"F(154678,1) : "; F(154678,1); cout<<"\n";
return 0;
}
/*
F(154678,5) : 864157
F(154678,4) : 864157
F(154678,3) : 864157
F(154678,2) : 8647
F(154678,1) : 8
*/
Problema 3

#include<iostream>
int DivImpar(int a, int b)

{
int d=1; // divizorul comun impar
int minab; // min(a,b);
int maxd; // valoarea maxima pentru d
int dsol; // solutia
while(a%2 == 0) a=a/2; // scot 2-urile din a

while(b%2 == 0) b=b/2; // scot 2-urile din b
if(a<=b)
minab=a;
else
minab=b;
if((a%minab==0) && (b%minab==0)) // cel mic il divide pe cel mare

return minab; // ... sau sunt egale
maxd=minab/3; // d=impar ... 3=div_mic ... minab/3=div_mare
for(d=1; d<=maxd; d=d+2) // preia pe 1 ca divizor

{
if((a%d ==0 ) && (b%d == 0))
dsol=d;
}
return dsol;
}
int main()
{
int a, b;
int rez;
a=30;
b=60;
//a=5;
//b=3;
rez=DivImpar(a,b);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
ifstream fin("2015bac-s1-III-4-date1.in");
//ifstream fin("2015bac-s1-III-4-date2.in");
int main()
{
int x; // citit din fisier
int ok=1;
int unrp=-2; // ultimul nr par
int unri=-1; // ultimul nr impar
while(fin>>x)
{
//cout<<"x = "<<x<<"\n";
cout<<x<<" ";
if(x%2 == 0) // x = par
{
//cout<<" par...\n";
if(unrp<0) // este primul nr par
unrp=x;
else
{
if(unrp <= x) // este in secventa crescatoare
unrp=x;
else
{
ok=0; // nu este ok ... parele nu sunt sir crescator
break;
}
}
}
else // // x = impar
{
//cout<<" impar...\n";
if(unri<0) // este primul nr impar
unri=x;
else
{
if(unri >= x) // este in secventa descrescatoare
unri=x;
else
{
ok=0; // nu este ok ... imparele nu sunt sir descrescator
break;
}
}
}
//cout<<"unrp = "<<unrp<<" unri = "<<unri<<"\n";
}
cout<<"\n";
if(ok==1)
cout<<"DA";
else
cout<<"NU";
return 0;
}

#include<iostream>
#include<fstream>
ifstream fin("2015bac-s1-III-4-date1.in");
//ifstream fin("2015bac-s1-III-4-date2.in");
int main()
{
int x; // citit din fisier
int ok=123;
int kk=1e9+7;
//cout<<"kk = "<<kk<<"\n";
int unrp=-2; // ultimul nr par

int unri=1e9+1; // ultimul nr impar
while(fin>>x)
{
cout<<x<<" ";
if(x%2 == 0) // x = par
{
{
if(unrp <= x) // este in secventa crescatoare
unrp=x;
else
{
ok=789; // nu este ok ... parele nu sunt sir crescator
break;
}
}
}
else // // x = impar
{
{
if(unri >= x) // este in secventa descrescatoare
unri=x;
else
{
ok=321; // nu este ok ... imparele nu sunt sir descrescator
break;
}
}
}
//cout<<"unrp = "<<unrp<<" unri = "<<unri<<"\n";
}
cout<<"\n";
if(ok==123)
cout<<"DA";
else
cout<<"NU";
return 0;
}


37.2.1 Subiectul I
Problema 1
Variabila ntreag x memoreaz un numr natural cu cel puin patru cifre nenule distincte. Expresia
C/C++ a crei valoare este egal cu cifra sutelor acestui numr este:
a. x/100
b. x%100
c. (x/10)%10
d. (x/100)%10
Să luăm x=12345 şi să vedem ce valori apar &in fiecare caz.
a. 12345/100 = 123
b. 12345%100 =45
c. (12345/10)%10 = 1234%10 = 4
d. (12345/100)%10 = 123%10 = 3
Soluţia este d.
Problema 2

#include<iostream>

int main()
{
int n, k, pm, i, x, p;
//cin>>n>>k;
n=7;
k=2; // k > 1
pm=0;
i=1;
while(i<=n)
{
cout<<"i = "<<i<<" : ";
x=i; // x = copie a lui i
p=0;
while(x%k==0)
{
x=x/k; // scoate k-ul din factorii lui x
p=p+1; // puterea la care apare k in i
cout<<k<<" ";
}
cout<<"\n";
if(p>pm)
{
pm=p;// puterea p cea mai mare
}
i=i+1;
}
cout<<pm;
return 0;
}

#include<iostream>
int main()
{
//cin>>n>>k;
//n=125;
//n=625;
n=624;
k=5; // k > 1
pm=0;
i=1;
while(i<=n)
{
cout<<"i = "<<i<<" : ";
p=0;
while(x%k==0)
{
cout<<k<<" ";
}
cout<<"\n";
if(p>pm)
{
}
i=i+1;
}
cout<<pm;
return 0;
}

#include<iostream>
int main()
{
//cin>>n>>k;
//n=125;
//n=625;
n=624;
k=5; // k > 1
pm=0;
i=1;
//while(i<=n)
for( ; i<=n; ) // initializarea si incrementarea sunt deja ... !!!
{
//cout<<"i = "<<i<<" : ";
p=0;
while(x%k==0)
{
//cout<<k<<" ";
}
//cout<<"\n";
if(p>pm)
{
}
i=i+1;
}
cout<<pm;
return 0;
}

Problema 1
Oricum ı̂n toate variantele apare factorul de multiplicare corect! Problema este numai despre
corectitudinea sintaxei de acces la pret.

#include<iostream>
#include<cstring>

struct carte
{
char titlu[21];
float pret;
} c;
int main()
{
strcpy(c.titlu,"carte_titlul");
c.pret=2.5;
cout << "c.pret = " << c.pret << "\n";

cout << "c.pret*3/2 = " << c.pret*3/2 << "\n";
return 0;
}
Problema 2
Problema 3

Problema 4

#include<iostream>
#include<cstring>
char a[21]; // a = prefix a lui b ... : b = a*** (a urmat de alte caractere...)

char b[21];
int main()
{
strcpy(b,"aurari");
cout<<"b = "<<b<<"\n";
strcpy(a,b);
cout<<"a = "<<a<<"\n";
a[strlen(a)/2]=’\0’;
cout<<"a = "<<a<<"\n";
cout<<"strlen(a) = "<<strlen(a)<<"\n";
//cout<<"a.strlen() = "<<a.strlen()<<"\n"; // daca ... string a="***";

//cout<<"a.size() = "<<a.size()<<"\n"; // daca ... string a="***";
return 0;
}
Problema 5

#include<iostream>
int n;
int a[21][21];
int main()
{
int i, j;
cin>>n;
for(j=0; j<=n-1; j++) // circular --> e mai bine 0..n-1

cin>>a[0][j];
for(i=1; i<=n-1; i++)

for(j=0; j<=n-1; j++)
//a[i][j]=a[i-1][(j-1)%n]; // pentru -1 ... ???
a[i][j]=a[i-1][(n+j-1)%n]; // pentru -1 ... ok
for(i=0; i<=n-1; i++)

{
for(j=0; j<=n-1; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
4
1 1 3 2
*/

#include<iostream>
int n;
int a[21][21];
int main()
{
int i, j;
cin>>n;
for(j=1; j<=n; j++) cin>>a[1][j];
//cout<<"\n";
// construire in memorie
for(i=2; i<=n; i++)
for(j=1; j<=n; j++)
if(j==1)
a[i][j]=a[i-1][n];
else
a[i][j]=a[i-1][j-1];
// afisare pe ecran
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
4
1 1 3 2
*/

Problema 1

Problema 2

#include<iostream>
void F(char c)
{
//cout<<"\n";
//cout<<"--> "<<c<<"\n";
if(c >= ’a’)

{
cout<<c;
F(c-1);
}
//cout<<"\n";
//cout<<"<-- "<<c<<"\n";
}
int main()
{
F(’d’);
return 0;
}
Problema 3

#include<iostream>
int Fibo(int n)
{ // 1 1 2 3 5 8 13 21 34 55 89 144 233 ...
// impare sunt 1 1 3 5 13 21
if(n==1 || n==2) return 1;
int fi, fi1, fi2;

int nrimp=2; // pentru 1 1
fi2=1;
fi1=1;
fi=fi1+fi2;
while(nrimp < n)
{
fi2=fi1;
fi1=fi;
fi=fi1+fi2;
if(fi%2==1) nrimp=nrimp+1;
}
return fi;
}
int main()
{
int n;
int rez;
n=6;
rez=Fibo(n);
return 0;
}
Problema 4

#include<iostream> // nr in intervalul 0..100 ==> vector de frecvente(aparitii)
#include<fstream>
int a[101]; // vector de aparitii; initializat automat cu zero

int main()
{
int x;
int i1, i2; // i1 000000 i2 indici ... intre ei sunt zerouri
int zona; // zona=0: sunt in zona cu zerouri in a[]
while(fin>>x)
{
cout<<x<<" ";
a[x]++;
}
cout<<"\n";
zona=1;
for(int i=1; i<=99; i++)
{
if(a[i-1]>0 && a[i] == 0)
{
i1=i; // incepe zona cu zerouri
zona=0;
continue;
}
if(a[i]==0 && a[i+1] > 0)

{
i2=i; // se termina zona cu zerouri
zona=0;
cout<<(i1-1)<<" "<<(i2+1)<<"\n";
continue;
}
}
fin.close();
return 0;
}


37.3.1 Subiectul I
Problema 1
Figura 37.14: 2015bac-s3-I-1
Problema 2

#include<iostream>
int main()
{
int n, k, i, t;
//cin>>n>>k;
//n=7; k=3;
//k=11; n=5; // --> 11 10 9 8 7
k=11; n=93;
// --> 11 10 9 8 7 6 5 4 3 2 1 ... 11 10 9 8 7 6 5 4 3 2 1 11 10 9 8 7
//k=11; n=9; // --> 11 10 9 8 7 6 5 4 3
//k=11; n=10; // --> 11 10 9 8 7 6 5 4 3 2
//k=11; n=11; // --> 11 10 9 8 7 6 5 4 3 2 1
//k=11; n=12; // --> 11 10 9 8 7 6 5 4 3 2 1 11
//k=11; n=13; // --> 11 10 9 8 7 6 5 4 3 2 1 11 10
while(n>=1)
{
//cout<<"\n\nn = "<<n<<" k = "<<k;
if(n>k)
{
i=k; // i = cel mai mic dintre n si k
}
else
{
i=n;
}
//cout<<" i = "<<i<<" = cel mic";
n=n-i; // n se schimba ... k nu se schimba
t=k;
//cout<<" n = n-i = "<<n<<" : \n";
while(i>=1)
{
cout<<t<<’ ’;// k, k-1, k-2, ... se scriu i numere
i=i-1;
t=t-1;
}
}
return 0;
}

#include<iostream>
int main()
{
int n, k, i, t;
//cin>>n>>k
k=11;
n=99;
int nc=n; // copie a lui n
for(nc=1; nc<=99; nc++)

{
n=nc;
cout<<"n = "<<n<<" k = "<<k<<" : ";
while(n>=1)
{
if(n>k)
{
}
else
{
i=n;
}
//cout<<" i = "<<i<<" = cel mic";
t=k;
//cout<<" n = n-i = "<<n<<" : \n";
while(i>=1)
{
cout<<t<<’ ’;// k, k-1, k-2, ... se scriu i numere
i=i-1;
t=t-1;
}
}
cout<<endl;
if(t==7)
{
cout<<"\n*** ultima cifra = 7 ... !!!\n\n";
}
}// for nc
return 0;
}

#include<iostream>
int main()
{
int n, k, i, t;
//cin>>n>>k;
//n=5;
n=93;
k=11;
cout<<"n = "<<n<<" k = "<<k<<":\n";

while(n>=1)
{
if(n>k)
{
}
else
{
i=n;
}
//cout<<" i = "<<i<<" = cel mic";
t=k;
//cout<<" n = n-i = "<<n<<" : \n";
//while(i>=1)
// la pseudocod trebuie "repeta ... pana cand" (C/C++: do ... while)
for( ; i>=1; )
{
cout<<t<<’ ’;
i=i-1;
t=t-1;
}
}
return 0;
}


Problema 1

#include<iostream>
struct complex
{
float re;
float im;
} z;
int main()
{
z.re=3.0;
z.im=4.0;
cout<<"z.re = "<<z.re<<"\n";
cout<<"z.im = "<<z.im<<"\n";
cout << "patratul modulului = " << z.re*z.re+z.im*z.im << "\n";
return 0;
}
Problema 2
Problema 3

Problema 4
Listing 37.3.5: 2015bac-s3-II-4v1.cpp

#include<iostream>
int a[6][6];
int i, j;
void afisa()
{
for(i=1; i<=5; i++)
{
for(j=1; j<=5; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
afisa();
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
a[i][j]=5*(i-1)+j; // liniarizarea matricei ... !!!
afisa();
return 0;
}
Listing 37.3.6: 2015bac-s3-II-4v2-setw(2).cpp

#include<iostream>
#include<iomanip> // aici chiar SE FOLOSESTE ... !!!
int a[6][6];
int i, j;
void afisa()
{
for(i=1; i<=5; i++)
{
for(j=1; j<=5; j++)
{
cout<<setw(2)<<a[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
afisa();
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
a[i][j]=5*(i-1)+j; // liniarizarea matricei ... !!!
afisa();
return 0;
}
Problema 5

#include<iostream>
//#include<fstream>
#include<cstring>
char c[101]; // cuvant
int main()
{
int n; // lungime cuvant
int ok; // DA: ok=1 ... NU ok=0
cin>>c;
n=strlen(c);
//cout<<"c = "<<c<<" : "<<n<<"\n";
ok=1;
for(int i=0; i<n; i++)
if(c[i]==’a’ || c[i]==’e’ || c[i]==’o’ || c[i]==’u’)
{
ok=0;
//cout<<i<<" : "<<c[i]<<"\n";
break;
}
if(ok==1)
cout<<"DA";
else
cout<<"NU";
return 0;
}
/*
inscriptibil
inestimabil
*/

Problema 1

Problema 2

#include<iostream>
void F (int n, int d)

{
cout<<"--> F(" << n << "," << d << ")\n";
if(d<n/2) F(n, d+1);
if(n%d==0) // dupa apelul recursiv ... !!!
cout<<d<<’ ’; // afiseaza la intoarcere ... descrescator ... !!!
}
int main()
{
//F(2015,1); cout<<"\n"; // 403 155 65 31 13 5 1
//F(2015,2); cout<<"\n"; // 403 155 65 31 13 5
//cout<<"\n\n";
F(12,1);
cout<<"\n\n";
F(12,2);
return 0;
}
Problema 3

#include<iostream>
int NrPrime(int n)
{
int ncp=0;
int c;
while(n != 0)
{
c=n%10;
if(c==2 || c==3 || c==5 || c==7) ncp=ncp+1;
n=n/10;
}
return ncp;
}
int main()
{
int n;
int rez;
n=1233405;
rez=NrPrime(n);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
int n;
int main()
{
int x; // nr din fisier
int s1p; // suma nr pare din prima jumatate
int s1i; // suma nr impare din prima jumatate
int s2p; // suma nr pare din a doua jumatate
int s2i; // suma nr impare din a doua jumatate
fin>>n;
cout<<"n = "<<n<<"\n";
s1p=s2p=s1i=s2i=0;
for(int i=1; i<=n; i++) // prima jumatate a numerelor

{
fin>>x;
cout<<x<<" ";
if(x%2==0)
s1p=s1p+x;
else
s1i=s1i+x;
}
cout<<" ";
for(int i=n+1; i<=2*n; i++) // a doua jumatate a numerelor
{
fin>>x;
cout<<x<<" ";
if(x%2==0)
s2p=s2p+x;
else
s2i=s2i+x;
}
cout<<"\n\n";
cout<<"s1p = "<<s1p<<"\n"; cout<<"s1i = "<<s1i<<"\n";

cout<<"s2p = "<<s2p<<"\n"; cout<<"s2i = "<<s2i<<"\n\n";
cout<<(s1p*s2i+s1i*s2p);
return 0;
}
/* intrare: 1 2 0 0 5 4 2 3 1 0
iesire: 44 */

Capitolul 38
BAC 2014

Varianta *
38.1.1 Subiectul I
***
Problema 1
Variabila x este de tip ı̂ntreg şi poate memora un număr natural cu cel mult două cifre. Valoarea
maximă pe care o poate avea expresia x%7 este: 6 pentru că resturile ı̂mpărţirii prin 7 pot fi
numai 0, 1, 2, 3, 4, 5 şi 6.
Problema 2
515

#include<iostream>
int main()
{
int n, x, a, b, c;
n=0;
do
{
cin>>x;
cout<<"x = "<<x<<"\n";;
a=0;
b=1;
do
{
c=a+b; // sir Fibonacci
//cout<<"a="<<a<<" b="<<b<<" c="<<c<<"\n";
a=b;
b=c;
} while( !(c>=x) );
if(x==c)// daca x este numar Fibonacci

{
n=n+1;
}
} while( !(x==0) );
cout<<n;
return 0;
}

#include<iostream> // atentie: 3 numere + al patrulea = 0
int main()
{
int n, x, a, b, c;
n=0;
do
{
cin>>x; // 4, 6, 7, 9
cout<<"x = "<<x<<"\n";;
a=0;
b=1;
do
{
//cout<<"a="<<a<<" b="<<b<<" c="<<c<<"\n";
a=b;
b=c;
} while( !(c>=x) );

{
n=n+1;
}
} while( !(x==0) );
cout<<n;
return 0;
}
/*
10 8 11 1 21 0
0 1 3 5 8 11 13 21 ... Fibo
9 4 6 0 --> 0
9 7 6 0 --> 0
*/

int main()
{
int n, x, a, b, c;
n=0;
//do
x=1; // initializare ... ca sa faca prima citire ...
while( !(x==0) )
{
cin>>x;
//cout<<"x = "<<x<<"\n";;
a=0;
b=1;
do
{
//cout<<"a="<<a<<" b="<<b<<" c="<<c<<"\n";
a=b;
b=c;
} while( !(c>=x) );

{
n=n+1;
}
} //while( !(x==0) );
cout<<n;
return 0;
}
/*
10 8 11 1 21 0
0 1 3 5 8 11 13 21 ... Fibo
2 4 6 0
9 7 6 0
*/


Problema 1

#include<iostream>
float A[3][7];
int main()
{
A[1][2]=1.2;
cout<<A[1][2]<<endl;
return 0;
}
Problema 2
Problema 3

Problema 4
Problema 5

#include<iostream>
#include<cstring>
char text[101]; // text

char sol[101]; // solutia
char cuvant[101]; // cuvant
int main()
{
int nt; // lungime text
int nc; // lungime cuvant
int nrc=0; // nr cuvinte schimbate
char * pch;
cin.get(text,100);
nt=strlen(text);
//cout<<"text = "<<text<<" : "<<nt<<"\n";
while(pch != NULL)
{
strcpy(cuvant,pch);
nc=strlen(cuvant);
//cout<<cuvant<<" : "<<strlen(cuvant)<<"\n";
if(nc%2==1 && nc >= 3)

{
nrc++; // nr cuvinte schimbate
for(int i=nc/2; i<=nc-2; i++)
{
cuvant[i]=cuvant[i+1];
}
cuvant[nc-1]=’\0’;
}
//cout<<cuvant<<" : "<<strlen(cuvant)<<"\n";
strcat(sol,cuvant);
strcat(sol," ");
//cout<<"sol = "<<sol<<"\n\n";
}
if(nrc > 0)
cout<<sol;
else
cout<<"nu exista";
return 0;
}
/*
intrare: pictura prin aceea arata o pace profunda
iesire: picura prin acea arta o pace profunda
*/

Problema 1
Problema 2

#include<iostream>
int f(int a, int b)

{
if (a==b) return 0;
if (b/a==0) return a+b;
return f(a+2,b-3); // maresc ’a’ si micsorez ’b’ ...

}
int main()
{
int rez1=f(5,5);
int rez2=f(10,21);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 0
rez2 = 28
*/
Problema 3

#include<iostream>
void perfect(int a, int b) // nr = suma divizorilor

{
int n; // numar in [a, b]
int sd; // suma divizorilor
int d; // divizor si n/d=divizor ... !!! d=n/d !!!
for(n=b; n>=a; n--)

{
//cout<<"n = "<<n<<" : ";
sd=1;
d=2;
while(d*d < n)
{
if(n%d == 0)
{
sd=sd+d+n/d;
//cout<<d<<" "<<(n/d)<<" ";
}
d=d+1;
}
if(d*d==n) // d coincide cu n/d ...

{
sd=sd+d;
//cout<<d<<"\n";
}
if(sd == n)
{
//cout<<n<<" ***\n";
cout<<n<<" ";
}
//cout<<"\n";
}
}
int main() // 28 = 1 + 2 + 4 + 7 + 14 ... (2,14) (4,7) ...

{
int a, b;
a=5;
b=30;
perfect(a,b);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
int main()
{
int val, vallgmax; // valoare din fisier
int lg, lgmax; // lg secventa
int n=0; // n=nr valori citite
lg=0;
lgmax=0;
vallgmax=-1;
fin>>val;
n++;
//cout<<n<<" : "<<val<<"\n";
lg=1;
while(fin>>x)
{
n++;
//cout<<n<<" : "<<x<<"\n";
if(x==val) // se lungeste secventa
{
lg++;
}
else // s-a terminat o secventa si a inceput alta
{
//cout<<"s-a terminat secventa in pozitia "<<(n-1)<<"\n";
if(lg>=lgmax)
{
lgmax=lg;
vallgmax=val;
}
lg=1;
val=x;
//cout<<"incepe secventa pe pozitia "<<n<<"\n";
}
}
//cout<<"\n\n";
//cout<<"vallgmax = "<<vallgmax<<" lgmax = "<<lgmax<<"\n\n";
cout<<lgmax<<"\n";
for(int i=1; i<=lgmax; i++)
cout<<vallgmax<<" ";
return 0;
}


38.2.1 Subiectul I
Problema 1
Valoarea expresiei C/C++ alturate este: 42/10*29/10 = 4*29/10=116/10 = 11
Problema 2

#include<iostream>
int main()
{
int n, d, p;
//cin>>n;
n=2352;
d=2; // d=divizor
while(d<=n)
{
p=0; // puterea la care apare divizorul d
while(n%d == 0)
{
p=p+1;
n=n/d;
}
//if(p>0) cout<<" ("<<d<<"ˆ"<<p<<") ";

if(p%2==0 && p!=0)// putere para (diferita de zero!)
{
cout<<d<<’ ’;
}
d=d+1;
}
cout<<n; // cat a mai ramas din n ...
return 0;
}

#include<iostream>
int main()
{
int n, d, p;
//cin>>n;
//n=2352;
n=25*1;
//n=25*2;
//n=25*3;
d=2; // d=divizor
while(d<=n)
{
while(n%d == 0)
{
p=p+1;
n=n/d;
}
//if(p>0) cout<<" ("<<d<<"ˆ"<<p<<") ";

{
cout<<d<<’ ’;
}
d=d+1;
}
return 0;
}

#include<iostream>
int main()
{
int n, d, p;
//cin>>n;
//n=2352;
//n=25*1;
//n=25*2;
n=25*3;
d=2; // d=divizor
//while(d<=n)
for( ; d<=n; ) // este suficient si corect asa ...
{
while(n%d == 0)
{
p=p+1;
n=n/d;
}
//if(p>0) cout<<" ("<<d<<"ˆ"<<p<<") ";

{
cout<<d<<’ ’;
}
d=d+1;
}
return 0;

Problema 1
Problema 2


#include<iostream>
#include<cstring>
int main()
{
char s[21];
strcpy(s,"1b2d3"); cout<<"1 : "<<s<<"\n";
s[2]=’a’+2; // = ’c’
cout<<"2 : "<<s<<"\n";
strcpy(s,s+1); cout<<"3 : "<<s<<"\n";
strcpy(s+3,s+4); cout<<"4 : "<<s<<"\n";
cout<<s;
return 0;
}
/*
1 : 1b2d3
2 : 1bcd3
3 : bcd3
4 : bcd
bcd
*/
Problema 3

#include<iostream>
#include<cstring>
#include<fstream>
#include<iomanip>
struct timp
{
int minut;
int secunda;
} start,stop;
int main()
{
start.minut=22;
start.secunda=34;
stop.minut=21;
stop.secunda=43;
if( (start.minut < stop.minut) ||

((start.minut == stop.minut ) && (start.secunda < stop.secunda)) )
{
cout<<"acceptat"<<"\n";
cout<<start.minut<<"’"<<start.secunda<<"’’"
<<" < "<<stop.minut<<"’"<<stop.secunda<<"\n";
}
else
{
cout<<"respins"<<"\n";
cout<<start.minut<<"’"<<start.secunda<<"’’"
<<" > "<<stop.minut<<"’"<<stop.secunda<<"\n";
}
return 0;
}
Problema 4
Problema 5

#include<iostream>
//#include<fstream>
//#include<cstring>
int m; // linii
int n; // coloane
int a[51][51];
int main()
{
int i, j;
cin>>m>>n;
for(i=1; i<=m; i++)

for(j=1; j<=n; j++)
cin>>a[i][j];
cout<<"\n";
// elimin penultima linie

for(j=1; j<=n; j++)
a[m-1][j]=a[m][j];
// elimin penultima coloana

for(i=1; i<=m; i++)
a[i][n-1]=a[i][n];
m=m-1;
n=n-1;
// afisej matricea rezultata
for(i=1; i<=m; i++)
{
for(j=1; j<=n; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}

Problema 1
Figura 38.13: 2014bac-s2-III-1-rec

#include<iostream>
int f(int n)
{
if (n<10) return f(n+1)+3;
else
if (n==10) return 7;
else return f(n-2)-1;
}
int main()
{
int rez=f(15);
return 0;
}
/*
7
*/
Problema 2

Problema 3

#include<iostream>
void interval(int n, int & a, int & b) // ( (n-1)! .. (n+1)! )

{
int nf; // nf=n!
nf=1;
nf=nf*i;
a=nf/n + 1;
b=nf*(n+1) - 1;
}
int main()
{
int n, a, b;
n=3;
interval(n,a,b);
cout<<"a = "<<a<<" b = "<<b<<"\n";
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
int fr[100]; // 00 .. 99
int main()
{
int frmax; // frecventa maxima
while(fin>>x)
{
cout<<x<<" ";
while(x>99)
{
fr[x%100]++;
x=x/10;
}
}
cout<<"\n\n";
frmax=0;
for(int i=0; i<=99; i++)
if(fr[i]>frmax)
frmax=fr[i];
//cout<<"frmax = "<<frmax<<"\n";
for(int i=10; i<=99; i++) // exact 2 cifre ...
if(fr[i]==frmax)
cout<<i<<" ";
return 0;
}

#include<iostream>
#include<fstream>
int fr[100]; // 00 .. 99
int main()
{
int frmax; // frecventa maxima
while(fin>>x)
{
cout<<x<<" ";
while(x>99)
{
fr[x%100]++;
x=x/10;
}
}
cout<<"\n\n";
frmax=-123;
for(int i=0; i<=99; i++)
if(fr[i]>frmax)
frmax=fr[i];
cout<<"frmax = "<<frmax<<"\n";
for(int i=0; i<=99; i++) // exact 2 cifre

if(fr[i]==frmax)
if(i>9)
cout<<i<<" ";
else
cout<<0<<"i"<<" ";
return 0;
}


38.3.1 Subiectul I
Problema 1
Valoarea maxim pe care o poate avea expresia C/C++ x%7 este 6 (ı̂mpărţirea prin 7 poate da ca
rest numai 0, 1, 2, 3, 4, 5 sau 6).
Problema 2

#include<iostream>
int main()
{
int n, x, a, b, c;
n=0;
do
{
cin>>x;
cout<<"x = "<<x<<" ";;
a=0;
b=1;
do
{
//cout<<"a="<<a<<" b="<<b<<" c="<<c<<"\n";
a=b;
b=c;
} while( !(c>=x) );

{
n=n+1;
cout<<"este numar Fibonacci";
}
cout<<endl;
} while( !(x==0) );
cout<<n;
return 0;
}

#include<iostream>
int main()
{
int n, x, a, b, c;
n=0;
do
{
cin>>x; // 4 6 7 9 0
cout<<"x = "<<x<<"\n";;
a=0;
b=1;
do
{
//cout<<"a="<<a<<" b="<<b<<" c="<<c<<"\n";
a=b;
b=c;
} while( !(c>=x) );

{
n=n+1;
}
} while( !(x==0) );
cout<<n;
return 0;
}
/*
10 8 11 1 21 0
1 2 3 5 8 13 21 0 ... Fibo
4 6 7 9
*/

int main()
{
int n, x, a, b, c;
n=0;
//do
x=1; // initializare ... ca sa faca prima citire ...
while( !(x==0) )
{
cin>>x;
//cout<<"x = "<<x<<"\n";;
a=0;
b=1;
do
{
//cout<<"a="<<a<<" b="<<b<<" c="<<c<<"\n";
a=b;
b=c;
} while( !(c>=x) );

{
n=n+1;
}
} //while( !(x==0) );
cout<<n;
return 0;
}

Problema 1

Problema 2
Problema 3

Problema 4
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
#include<iomanip>
int m; // linii
int n; // coloane
int a[21][21];
int main()
{
int i, j, k;
cin>>m>>n;
k=0;
for(i=1; i<=m; i++)
for(j=1; j<=n; j++)
{
k=k+2;
if(k%5 == 0) k=k+2;
a[i][j]=k;
}
// afisej matricea rezultata

for(i=1; i<=m; i++)
{
for(j=1; j<=n; j++)
{
cout<<setw(3)<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
intrare: 4 3
*/

Problema 1
Problema 2


#include<iostream>
int f(int a,int b)

{
if (b==0) return a;
else return f(b,a%b);
}
int main()
{
for(int x=1; x<=50; x++)
{
cout<<"f(30,"<<x<<") = "<<f(30,x)<<"\n";
//if(f(30,x)==5) cout<<x<<" ";
}
return 0;
}
Problema 3

#include<iostream>
void triplete(int n) // y(x+z)=n si x<= y-1 < y <y+1 <= z

{
int x, y, z;
int xyz=10;
int nrv=0;
for(x=0; x<=n-2; x++)

{
if(x*x+x*x>n) break;
for(y=x+1; y<=n-1; y++)

{
if(x*y+y*y>n) break;
for(z=y+1; z<=n; z++)

{
if(x*y + y*z > n) break;
if(x*y+y*z == n)
{
nrv++;
cout<<nrv<<" : ";
cout<<"("<<x<<","<<y<<","<<z<<")\n";
}
}
}
}
}
int main()
{
int n;
n=8;
//n=100000;
triplete(n);
return 0;
}
Problema 4

#include<iostream>
#include<fstream>
int fr[10]; // 0..9 frecventa puterilor
int main()
{
int n;
int nrtermeni;
int x; // nr din fisier

int p; // puterea la care apare 10 in x
fin>>n;
//cout<<"n = "<<n<<"\n";
nrtermeni=0;
while(fin>>x)
{
nrtermeni++;
p=0;
cout<<"x = "<<x<<" p = ";
while(x>0)
{
p++;
x=x/10;
}
p=p-1; // p = nr. cifre - 1
cout<<p<<"\n";
fr[p]++;
}
if(nrtermeni < n)
{
cout<<"Nu exista";
return 0;
}
// sunt suficiente numere in fisier

for(int i=0; i<=9; i++)
cout<<fr[i]<<" ";
cout<<"\n\n";
int s=0;
for(int i=0; i<=9; i++)
{
s=s+fr[i];
if(s >=n)
{
p=i;
break;
}
}
cout<<1;
for(int i=1; i<=p; i++) cout<<0;
return 0;
}

Capitolul 39
BAC 2013

Varianta 7
39.1.1 Subiectul I
Problema 1
Indicaţi expresia care are valoarea 1 dacă c si numai dacă numărul natural memorat ı̂n variabila
ı̂ntreagă x are exact două cifre.
a. x/100==0 && x>9 b. x/100==0 || x<100
c. x%100==0 && x<100 d. x%100==0 || x>9
Verificam pentru x=12 (număr cu două cifre).
a. x/100==0 && x>9

12/100==0 && 12>9
0==0 && 12>9
1 && 1 1
b. x/100==0 || x<100
12/100==0 || 12<100
0==0 || 12<100
1 || 1 1
c. x%100==0 && x<100

12%100==0 && 12<100
12==0 && 12<100 0 acest caz este eliminat! (trebuia să dea 1)
0 && 1
d. x%100==0 || x>9
12%100==0 || 12>9
12==0 || 12>9 0 || 1 1
Trebuie să verificăm cazurile care au rămas ”suspecte” (varianta corectă este printre ele!).
Să consideră x=123 (număr care nu are două cifre).
a. x/100==0 && x>9

123/100==0 && 123>9
1==0 && 123>9
0 && 1 0
b. x/100==0 || x<100
123/100==0 || 123<100
1==0 || 123<100
0 || 0 0
539
d. x%100==0 || x>9
123%100==0 || 123>9
23==0 || 123>9
0 || 1 1 acest caz este eliminat! (trebuia să dea 0)
Buuuun! Au rămas numai cazurile a. şi b. Vom verifica şi pentru numere care au mai puţin
de două cifre.
Să consideră x=5 (numă care nu are două cifre).
a. x/100==0 && x>9

5/100==0 && 5>9
0==0 && 5>9
1 && 0 0
b. x/100==0 || x<100
5/100==0 || 5<100
0==0 || 5<100
1 || 0
1 acest caz este eliminat! (trebuia să dea 0)
Deci răspunsul corect este varianta a.
Puteam să ne dăm seama de la ı̂nceput că varianta a. este cea corectă! Să notăm cu nrcx
numărul de cifre pe care le are x;
x/100==0 ı̂nseamnă că x nu are mai mult de două cifre (deci, are o cifă sau două cifre,
nrcx & 2)
x>9 ı̂nseamnă că x nu are mai puţin de două cifre (deci, are două cifre sau mai multe cifre,
nrcx ' 2)
Din cele două inegalităţi rezultă nrcx 2.

Problema 2

#include<iostream>
int main()
{
int a, b, nr, i;
//cin>>a>>b;
a=5;
b=9;
nr=1;
for(i=a; i<=b; i++)
{
cout<<’*’;
if(nr >=a)
{
cout<<’#’;
}
nr=nr*2; // 2*2*2*2*...*2
cout<<’*’;
}
return 0;
}
/*
*******#**#*
*/

#include<iostream>
int main()
{
int a, b, nr, i;
//cin>>a>>b;
a=10;
b=16;
nr=1;
for(i=a; i<=b; i++)
{
cout<<’*’;
if(nr >=a)
cout<<’#’;
nr=nr*2; // 2*2*2*2*...*2
cout<<’*’;
}
return 0;
}
/*
*********#**#**#*
*/

#include<iostream>
int main()
{
int a, b, nr, i;
//cin>>a>>b;
a=10;
b=16;
nr=1;
//for(i=a; i<=b; i++)

i=a; // initializarea
while(i<=b)
{
cout<<’*’;
if(nr >=a)
cout<<’#’;
nr=nr*2; // 2*2*2*2*...*2
cout<<’*’;
i++; // incrementarea
}
return 0;
}
/*
*********#**#**#*
*/

Problema 1
Problema 2
Problema 3

#include<iostream>
#include<cstring>
#include<iomanip> // cout<<setf(3)<< ...;
struct fractie
{
int a, b;
} f, fs;
int main()
{
f.a=5;
f.b=2;
// f.a/f.b + 2/3 = (f.a*3 + f.b*2) / (f.b*3)
fs.a=f.a*3 + f.b*2;
fs.b=f.b*3;
cout<<f.a<<"/"<<f.b<<" + 2/3 = "<<fs.a<<"/"<<fs.b<<"\n";
return 0;
}
Problema 4
Problema 5
Listing 39.1.5: 2013bac-s1-II-5 strtok.cpp

#include<iostream>
#include<fstream>
#include<cstring>
char text[101];
char sol[101];
char * pch;
int main()
{
cin.get(text,100);
//cout<<"text = "<<text<<"\n";
while(pch != NULL)
{
if(strlen(pch) == 3)
strcat(sol,"* ");
else
{
strcat(sol,pch);
strcat(sol," ");
}
}
sol[strlen(sol)-1]=’\0’; // sterg ultimul spatiu
cout<<sol;
return 0;
}
/*
intrare: bun este izvorul ce are apa rece
iesire: * este izvorul ce * * rece
*/

Problema 1

#include<iostream>
int f1(int n)
{
return n*(n+1)/2;
}
int f2 (int n)
{
if(n>0) return n+f2(n-1);
return 0;
}
int main()
{
int rez1=f1(10);
int rez2=f2(10);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 55
rez2 = 55
*/
f2(n) este suma n + (n-1) + + 2 + 1

n n1
iar f1(n) este formula 2
.
Problema 2

Problema 3

#include<iostream>
void sub(int n, int v[], int x)

{
//cout<<"x = "<<x<<"\n";
int i, aux;
int nrx=0; // nr aparitii x
int poz; // pozi\c tia ultimului element mutat
//for(int i=0; i<n; i++)

// cout<<v[i]<<" ";
//cout<<"\n";
poz=n;
for(i=n-1; i>=0; i--)
{
if(v[i]==x) // permut v[poz] cu v[i]
{
nrx++;
}
else
{
poz=poz-1;
v[poz]=v[i];
}
}
for(i=0; i<=poz-1; i++) // plasez x in fata pe nrx pozitii

v[i]=x;
}
int main()
{
int n;
int a[]={2, 1, 0, 1, 7, 0, 1, 4, 5};
int x;
n=9;
x=1;

cout<<a[i]<<" ";
cout<<"\n";
sub(n,a,x);

cout<<a[i]<<" ";
cout<<"\n";
return 0;
}
/*
intrare: 2 1 0 1 7 0 1 4 5
iesire: 1 1 1 2 0 7 0 4 5
*/
Problema 4

#include<iostream>
#include<fstream>
int fr[100]; // 00 .. 99 frecventa nr cu 2 cifre
int main()
{
int minp; // min par
int maxp; // max par
while(fin>>x)
{
if(x%2==1) continue;
// aici x = par
if(x>99) continue;
if(x<10) continue;
fr[x]++;
}
minp=0;
for(int i=10; i<=98; i=i+2)
{
if(fr[i]==0)
{
minp=i;
break;
}
}
maxp=0;
for(int i=98; i>=minp; i=i-2)
{
if(fr[i]==0)
{
maxp=i;
break;
}
}
//cout<<"minp = "<<minp<<" maxp = "<<maxp<<"\n";
if(minp == 0 || maxp == 0 || minp == maxp)

cout<<"Nu exista";
else
cout<<minp<<" "<<maxp;
return 0;
}
/*
intrare: 7 2 40 5 10 15 11 12 18 350
iesire: 14 98
*/


Varianta 2
39.2.1 Subiectul I
Problema 1
Variabila x este de tip n̂treg şi poate memora un număr natural cu cel mult două cifre. Valoarea
maximă pe care o poate avea expresia x%4 este ?
Indiferent de numă rul cifrelor lui x, valoarea maximă este 3 (restul ı̂mpărţirii la 3 poate fi
numai 0, 1, 2 sau 3).
Problema 2

#include<iostream>
int main()
{
int a, b, c, x, y, s;
//cin>>a>>b>>c; // a<=b, 0<- x <= 9
a=19;
b=23;
c=2;
s=0;
for(x=a; x<=b; x++)
{
y=x; // y = copie a lui x
while(y>0)
{
if(y%10==c) // cifra lui y este c

{
s=s+1;
}
y=y/10;
}
}
cout<<s; // cate cifre c se gasesc in numerele a ... b
return 0;
}
/*
5
*/

#include<iostream>
int main()
{
//cin>>a>>b>>c; // a<=b, 0<- x <= 9
a=1;
b=19; // b=19,20 (1,10,11,12,13,14,15,16,17,18,19,20)
c=1;
for(b=a; b<=999; b++)

{
s=0;
for(x=a; x<=b; x++)
{
while(y>0)
{
{
s=s+1;
}
y=y/10;
}
}
if(s==12)
{
cout<<b<<" --> s = "<<s<<endl; // cate cifre c se gasesc in numerele a ... b
}
}
return 0;
}
/*
19 --> s = 12
20 --> s = 12
*/

#include<iostream>
int main()
{
//cin>>a>>b>>c; // a<=b, 0<- x <= 9
a=1;
b=19; // b=19,20 (1,10,11,12,13,14,15,16,17,18,19,20)
c=1;
s=0;
for(x=a; x<=b; x++)
{

if(y>0) // pentru prima iteratie a lui do ... !
//while(y>0)
do
{
{
s=s+1;
}
y=y/10;
} while(y>0); // la pseudocod: !(y>0)
}
cout<<s<<endl;
return 0;
}
/*
12
*/

Problema 1

#include<iostream>
#include<cstring>
int main()
{
cout<<"strlen(\"bine\") = "<<strlen("bine")<<"\n";
return 0;
}
/*
strlen("bine") = 4
*/
Problema 2
Având ı̂n vedere că variantele erau numai 5, 7, 10 şi 15 arce iar varianta din figură are 15 arce ...
se alege varianta d.
O mică observaţie: ”cine intră ı̂n 3 nu mai iese de acolo!”.
Problema 3

#include<iostream>
#include<cstring>
struct numar
{
int v;
char paritate;
} x;
int main()
{
x.v=3;
if(x.v%2 == 0)
x.paritate=’p’;
else
x.paritate=’i’;
cout<<x.v<<" --> "<<x.paritate<<"\n";
return 0;
}
/*
3 --> i
*/
Problema 4
Problema 5

#include<iostream>
int m, n;
int a[51][51];
int main()
{
int i, j, val;
int ok; // ok=1 daca valorile sunt egale pe coloana
cin>>m>>n; // m=linii n=coloane

for(i=1; i<=m; i++)

for(j=1; j<=n; j++)
cin>>a[i][j];
for(j=1; j<=n; j++)

{
val=a[1][j]; // prima valoare pe coloana j
ok=1;
for(i=2; i<=m; i++)
{
if(a[i][j] != val)
ok=0;
}
if(ok ==1) cout<<val<<" ";

}
return 0;
}
/*
intrare:
4 5
2 3 7 5 7
3 3 7 4 7
7 3 7 1 7
8 3 7 6 7
iesire:
3 7 7
*/

#include<iostream>
int m, n;
int a[51][51];
int main()
{
int i, j;
int nr; //
cin>>m>>n; // m=linii n=coloane
for(i=1; i<=m; i++)

for(j=1; j<=n; j++)
cin>>a[i][j];
for(j=1; j<=n; j++)

{
nr=0;
for(i=2; i<=m; i++)
if(a[i][j] == a[1][j])
nr++;
if(nr == m-1) cout<<a[1][j]<<" ";

}
return 0;
}
/*
intrare:
4 5
2 3 7 5 7
3 3 7 4 7
7 3 7 1 7
8 3 7 6 7
iesire:
3 7 7
*/

Problema 1

#include<iostream>

{
return x*y;
}

{
if (y==1) return x;
else return x*f2(x, y-1);
}
int main()
{
int x=2, y=3;
int rez1=f1(x,y);
int rez2=f2(x,y);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 6
rez2 = 8
*/
Problema 2
Problema 3

#include<iostream>
void valuri(int n, int v[])

{
v[2*i]=2*i+1;

v[2*i+1]=2*n-2*i;
int main()
{
int n;
int a[100]={};
n=4;
//for(int i=0; i<2*n; i++)

// cout<<a[i]<<" ";
//cout<<"\n";
valuri(n,a);
for(int i=0; i<2*n; i++)

cout<<a[i]<<" ";
cout<<"\n";
return 0;
}
/*
1 8 3 6 5 4 7 2
*/
Problema 4

#include<iostream>
#include<fstream>
ofstream fout("2013bac-s2-III-4-bac.txt");
int main()
{
int x;
int n;
int doilan;
cin>>x;
cout<<"x = "<<x<<"\n";
n=0;
doilan=1;
while(doilan < x) // primul 2ˆn care depaseste sigur pe x

{
n++;
doilan=doilan*2;
}
cout<<"n = "<<n<<" doilan = "<<doilan<<"\n\n";
if(doilan == x)
{
cout<<doilan<<" "<<doilan-1<<" ";
}
else
{
if(doilan-1 == x)
cout<<doilan-1<<" ";
}
doilan=doilan/2;
while(doilan > 1)
{
cout<<doilan<<" "<<doilan-1<<" ";
doilan=doilan/2;
}
return 0;
}
/*
15
x = 15
n = 4 doilan = 16
15 8 7 4 3 2 1
*/


Varianta 6
39.3.1 Subiectul I
Problema 1
Valoarea expresiei C/C++ 7+5/2 este: 7+2 = 9.
Problema 2

#include<iostream>
int main()
{
int a, b, nr, i, x, c;
//cin>>a>>b;
a=65; b=80; nr=0;
for(i=a; i<=b; i++)
{
c=x%10; // c= ultima cifra a lui x
while(x!=0 && x%10==c)
x=x/10;
if(x==0)// daca i are toate cifrele egale

nr=nr+1;
}
cout<<nr;
return 0;
}
/*
2
*/

#include<iostream>
int main()
{
//cin>>a>>b;
a=1234; // 2222, 3333, 4444, 5555, 6666, 7776-->7777
//b=7776;
for(b=9999; b>=1000; b--)

{
nr=0;
for(i=a; i<=b; i++)
{
while(x!=0 && x%10==c)
x=x/10;

nr=nr+1;
}
if(nr==5)
{
cout<<"b = "<<b<<" --> nr = "<<nr<<endl;
break;
}
} // for b
return 0;
}
/*
b = 7776 --> nr = 5
*/

#include<iostream>
int main()
{
//cin>>a>>b;
a=1234; // 2222, 3333, 4444, 5555, 6666, 7776-->7777
b=7776;
nr=0;
//for(i=a; i<=b; i++)

i=a; // initializarea
do // a<=b --> se executa cel putin o data !
{
while(x!=0 && x%10==c)

x=x/10;

nr=nr+1;
i++; // incrementarea
} while(i<=b); // in pseudocod ... pana cand (i>b)
cout<<nr;
return 0;
}
/*
5
*/

Problema 1
Evident d. a[i][i]
Problema 2

Problema 3
Problema 4

#include<iostream>
struct punct
{
int x,y;
} p;
struct dreptunghi
{
punct A, B; // fara "struct" ...
} d;
int main()
{
bool e;
d.A.x=2; d.A.y=3;
d.B.x=6; d.B.y=1;
p.x=4;
p.y=2; // 1, 3, 5, ...
e=(d.A.x < p.x) && (p.x < d.B.x) && (d.B.y < p.y) && (p.y < d.A.y);
cout<<"e = "<<e<<"\n";
return 0;
}
Problema 5

Problema 1

#include<iostream>
void f (int n)
{
if (n!=0)
{
f(n-1);
cout<<n; // dupa apel ... !!!
}
}
int main()
{
f(3);
return 0;
}
/*
123
*/
Problema 2
Problema 3

#include<iostream>
int sub(int n, int v[], int k)

{
int sumk=0;
int nrsum; // cate numere au participat la suma

{
if(v[i]%2==1)
{
nrsum++;
sumk=sumk+v[i];
}
if(nrsum==k) break;
}
if(nrsum==k) return sumk;

return -1;
}
int main()
{
int k=3;
int v[]={2, 7, 6, 8, 3, 7, 5, 1};
int n=sizeof(v)/sizeof(int);
int rez;
for(int i=0; i<n; i++) cout<<v[i]<<" ";
cout<<endl;
rez=sub(n,v,k);
return 0;
}
/*
2 7 6 8 3 7 5 1
rez = 17
*/
Problema 4

#include<iostream>
#include<fstream>
int main()
{
int x;
int v; // valoare citita din fisier
int vsol; // valoare solutie
fin>>x;
cout<<"sufix = "<<x<<"\n";
//getchar();
int p10=1;
int xx=x; // copie a lui x
while(xx>0)
{
p10=p10*10;
xx=xx/10;
}
//cout<<"p10 = "<<p10<<"\n";
vsol=-1;
while(fin>>v)
{
cout<<v<<" ";
if(v%p10 == x) vsol=v;
}
cout<<"\n\n";
if(vsol<0)
cout<<"Nu exista";
else
cout<<vsol;
fin.close();
return 0;
}
/*
sufix = 12
3445 89312 1245 12 67120 312 1234578
312
*/

Capitolul 40
BAC 2012

Varianta 3
40.1.1 Subiectul I
Problema 1
are exact două cifre, iar cifra unităţilor este nenulă. (4p.)
a. (x/10)*(x%10)!=0 && x/100==0

b. (x/10)*(x%10)!=0 && x%100==0
c. (x/10)+(x%10)!=0 || x/100==0
d. (x/10)+(x%10)!=0 || x%100==0
Testăm pentru x=12 (număr cu două cifre şi cifra unităţilor nenulă.
a. (12/10)*(12%10)!=0 && 12/100==0 --> 1*2!=0 && 0==0 --> 1&&1 --> 1
b. (12/10)*(12%10)!=0 && 12%100==0 --> 0*2!=0 && 12==0 --> 0&&0 --> 0
cazul b. "a picat"! (trebuia s\u a dea 1)
c. (12/10)+(12%10)!=0 || 12/100==0 --> 0+2!=0 || 0==0 --> 1||1 --> 1
d. (12/10)+(12%10)!=0 || 12%100==0 --> 0+2!=0 || 12==0 --> 1||0 --> 1
Testăm pentru x=10 (număr cu două cifre şi cifra unităţilor nulă (trebuie să obţinem 0).
a. (10/10)*(10%10)!=0 && 10/100==0 --> 1*0!=0 && 0==0 --> 0&&1 --> 0
c. (10/10)+(10%10)!=0 || 10/100==0 --> 1+0!=0 || 0==0 --> 1||1 --> 1
cazul c. "a picat"! (trebuia s\u a dea 0)
d. (10/10)+(10%10)!=0 || 10%100==0 --> 1+0!=0 || 10==0 --> 1||0 --> 1
cazul d. "a picat"! (trebuia s\u a dea 0)
A rămas nmumai cazul a.
a. (x/10)*(x%10)!=0 && x/100==0
Puteam să ne dăm seama pentru că:

(x/10) ne ”spune” dacă x are o cifră sau mai multe cifre
(x%10) ne ”spune” dacă x are ultima cifră nenulă sau nulă
(x/100) ne ”spune” dacă x are cel mult două cifre sau nu are cel mult două cifre
563
Problema 2

#include<iostream>
int main()
{
int a, n, s, b, c;
//cin>>a>>n;
a=5;
n=4;
s=0;
for(b=1; b<=n; b++)
{
//cout<<"b = "<<b<<"\n";
c=b; // c = copie a lui b
while(c>0)
{
s=s+a;
//cout<<s<<’ ’;
c=c-1;
}
//cout<<"\n\n";
}
cout<<s;
return 0;
}
/*
50
*/

#include<iostream>
int main()
{
int a, n, s, b, c;
//cin>>a>>n;
a=1;
//n=5;
for(n=1; n<=9; n++)

{
s=0;
for(b=1; b<=n; b++)
{
//cout<<"b = "<<b<<"\n";
while(c>0)
{
s=s+a;
//cout<<s<<’ ’;
c=c-1;
}
//cout<<"\n\n";
}
if(s%2==1)
cout<<n<<" --> "<<s<<"\n";
}
return 0;
}
/*
1 --> 1
2 --> 3
5 --> 15
6 --> 21
9 --> 45
*/

#include<iostream>
int main()
{
int a, n, s, b, c;
//cin>>a>>n;
a=5;
n=4;
s=0;
//for(b=1; b<=n; b++)
b=1; // initializarea
do
{
while(c>0)
{
s=s+a;
c=c-1;
}
b++; // incrementarea
} while(b<=n); // la pseudocod: pana cand b>n;
cout<<s;
return 0;
}

Problema 1
Problema 2
Problema 3

#include<iostream>
//#include<cstring>
//#include<fstream> // ifstream("bac.txt");
//#include<iomanip> // cout<<setf(3)<< ...;
struct punct
{
int x,y;
};
struct segment
{
punct A,B;
} s;
int main()
{
s.A.x=1;
s.A.y=0;
s.B.x=3;
s.B.y=0;
bool e = (s.A.y==0 && s.B.y==0);
cout<<"e = "<<e<<"\n";
return 0;
}
/*
e = 1
*/
Problema 4

#include<iostream>
//#include<cstring>
//#include<fstream> // ifstream("bac.txt");
int i, j;
int A[6][6];
void afisA()
{
for(i=1; i<=5; i++)
{
for(j=1; j<=5; j++)
{
cout<<setw(3)<<A[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
afisA();
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
A[i][j]=2*i+j;
}
afisA();
return 0;
}
/*
3 4 5 6 7
5 6 7 8 9
7 8 9 10 11
9 10 11 12 13
11 12 13 14 15
*/
De unde ideea cu A[i][j]=2*i+j;?

Se poate ”suspecta” că există, pentru A[i][j], o combinaţie liniară ı̂ntre indicii i şi j.
Merită să ı̂ncercăm o expresie de forma A[i][j]= i*x + j*y + z;
Pentru a găsi x, y şi z avem nevoie de 3 ecuaţii; vom alege 3 poziţii din matrice (eu am ales o
poziţie pe diagonala principală, o poziţie deasupra diagonalei principale şi o poziţie sub diagonala
principală).
De exemplu:
A[3][3]=9=3*x+3*y+z (ec1)
A[1][4]=6=1*x+4*y+z (ec2)
A[4][2]=10=4*x+2*y+z (ec3)
Eliminăm z:
(ec1)-(ec2): 2*x-y=3 (ec4)
(ec4)-(ec1): x-y=1 (ec5)
Din (ec5): x=y+1
Înlocuind ı̂n (ec4): 2*(y+1)-y=3 obţinem y=1;
Înlocuind y=1 ı̂n (ec5) obţinem: x=2.
Înlocuind x=2 şi y=1 ı̂n (ec2) obţinem 6=1*2+4*1+z de unde se obţine z=0.
O mică observaţie:
atunci când pe linii valorile sunt consecutive ... aproape sigur vom obţine y=1.
Problema 5

#include<iostream>
#include<cstring>
char cuv1[31];
char cuv2[31];
int n1, n2;
int main()
{
int i1, i2;
int ok; // ok=1 daca se poate transforma
cin.get(cuv1,30);
cin.get(cuv2,30);
//cin>>cuv1; // mai usor asa ... !!! // mama are mere ... alta fraza ... !!!
//cin>>cuv2; // tata e la meci
//cout<<"\n";
n1=strlen(cuv1);
n2=strlen(cuv2);
//cout<<cuv1<<" : "<<n1<<"\n";
//cout<<cuv2<<" : "<<n2<<"\n\n";
if(n2<n1)
{
cout<<"NU";
return 0;
}
i2=0;
for(i1=0; i1<=n1-1; i1++) // parcurg literele lui cuv1
{
ok=1; // presupun ca se poate transforma cuv2 --> cuv1
//cout<<"i1 = "<<i1<<" : caut "<<cuv1[i1]<<" ... ";
// caut prima aparitie a lui cuv1[i] in cuv2[]
while(i2<=n2-1)
{
if(cuv1[i1] != cuv2[i2]) i2++;
else break;
}
//cout<<"i2 = "<<i2<<" : "<<cuv2[i2]<<"\n";
//cout<<"i2 = "<<i2<<" n2-1 = "<<(n2-1)<<"\n";
if(i2 > n2-1)
{
ok=0;
break;
}
}
//cout<<"\n";
if(ok==0) cout<<"NU";
else cout<<"DA";
return 0;
}
/*
calut
bacalaureat
DA
calut
lacatus
NU
*/

Problema 1
Algoritmul de generare a tuturor numerelor naturale de 5 cifre, fiecare număr având toate cifrele
nenule şi distincte, este echivalent cu algoritmul de generare a aranjamentelor (se ţine cont de
ordinea cifrelor: 12345 este cu totul alt număr natural faţă de 54321).
Pentru combinări nu se ţine cont de ordinea cifrelor şi de obicei alegerea este să fie scrise
crescător (ar ı̂nsemna că 12345 este acelaşi lucru cu 54321, dacă nu ţinem cont de ordinea cifrelor!).
Despre permutări nu poate fi vorba pentru că acolo se folosesc toate cifrele nu numai 5 din 9.
Nici despre generartea submulţimilor nu poate fi vorba pentru că acolo apar soluţii cu o cifră,
cu două cifre, ... iar aici este vorba de lungime fixă de 5 cifre.
Problema 2

#include<iostream>
int f(int x)
{
if(x<=0) return 0;
return x+f(x-5);
}
int main()
{
int rez1=f(-6);
int rez2=f(20);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 0
rez2 = 50
*/
Problema 3

#include<iostream>
void subprogram_minus(int & n, int v[])

{
int i, j;
i=0;
while(i<n)
{
if(v[i] != 0) // inserez ... deplasare spre dreapta
{
n=n+1; // adaug o casuta la dreapta vectorului
for(j=n-1; j>i; j--) // copiez ("deplasez")
v[j]=v[j-1];
v[i+1]=-1*v[i]; // in casuta "eliberata" pun ...

i=i+2; // ma plasez dupa "copia" lui v[i]
//for(int k=0; k<n; k++)

// cout<<v[k]<<" ";
//cout<<"\n\n";
}
else
{
i=i+1;
}
}
}
int main()
{
int n;
int a[100]={4, -5, 0, 9, 0};
n=5;
cout<<"*n = "<<n<<"\n";
cout<<a[i]<<" ";
cout<<"\n\n";
subprogram_minus(n,a);
cout<<"**n = "<<n<<"\n";
cout<<a[i]<<" ";
cout<<"\n";
return 0;
}
Problema 4

#include<iostream> // numerele din fisier sunt crescatoare ...
#include<fstream> // indicatie "gresita" in barem ... !!!
ifstream fin("2012bac-s1-III-4-bac1.txt");
//ifstream fin("2012bac-s1-III-4-bac2.txt");
int main()
{
int n;
int v1, v2; // ... v1 < v2 ... in prima jumatate
int v3; // prima valoare din a doua jumatate
int v; // valoare curenta citita din fisier
fin>>n;
//cout<<"n = "<<n<<"\n";
v1=-1;
v2=-1; // neatribuite valori inca
for(int i=1; i<=n/2; i++)

{
fin>>v;
//cout<<v<<" ";
if(v1<0) // daca v1 nu are valoare atribuita

{
v1=v;
continue;
}
if(v==v1) continue; // se prelungeste secventa cu v1
if(v2<0) // daca v2 nu are valoare atribuita

{
v2=v;
continue;
}
if(v2==v) continue; // se prelungeste secventa cu v2
// aici ... v1 .. .< v2 ... < v actualizez v1 si v2

v1=v2;
v2=v;
}
//cout<<"\n";
//cout<<"v1 = "<<v1<<" v2 = "<<v2<<" in prima jumatate\n";
fin>>v3; // prima valoare din a doua jumatate
if(v1==v3)
{
cout<<"Nu exista";
return 0;
}
// aici 0 < v1 < v3

if(v2<0) // v2 nu are incarcata valoare --> valori egale in prima parte a sirului
{
cout<<v1;
return 0;
}
// aici v1 si v2 au valori
if(v2<v3)
cout<<v2;
else // v2=v3 deci mai mic este v1
cout<<v1;
return 0;
}
/*
10
1 3 5 5 5 5 5 5 7 10
v1 v2 v3
6
3 3 3 3 9 15
v1 v2=-1 v3
*/



40.2.1 Subiectul I
Problema 1
Este evident că răspunsul corect este c.
Problema 2

#include<iostream>
int main()
{
int n, m, p;
n=56413; // --> 46402 schimba cifrele impare in cifre pare

m=0;
p=1;
while(n>0)
{
if(n%2!=0)//daca n este impar
{
n=n-1;// il face par ... mai mic cu 1
}
m=m+(n%10)*p; //
n=n/10; // sterge ultima cifra din n
p=p*10; // p se plaseaza pe 1 pozitie spre stanga
}
cout<<m;
return 0;
}
/*
46402
*/

#include<iostream>
int main()
{
int n, m, p;
//n=56413; // --> 46402 schimba cifrele impare in cifre pare
for(int nn=1000; nn<=9999; nn++)

{
n=nn;
//if(n%1000==0) cout<<n<<"\n";
m=0;
p=1;
while(n>0)
{
{
n=n-1;// il face paer ... mai mic cu 1
}
m=m+(n%10)*p; //
}
if(m==40)
cout<<nn<<" : "<<m<<"\n";
}
return 0;
}
/*
1040 : 40
1041 : 40
1050 : 40
1051 : 40
1140 : 40
1141 : 40
1150 : 40
1151 : 40
*/

#include<iostream>
int main()
{
int n, m, p;
n=56413; // --> 46402 schimba cifrele impare in cifre pare

m=0;
p=1;
//while(n>0)
for( ; n>0; ) // initializarea si incrementarea sunt deja
{
{
n=n-1;// il face paer ... mai mic cu 1
}
m=m+(n%10)*p; //
}
cout<<m;
return 0;
}
/*
46402
*/

Problema 1
Problema 2

Problema 3
Problema 4

#include<iostream>
#include<cstring>
int i, j;
int A[6][6];
void afisA()
{
for(i=1; i<=5; i++)
{
for(j=1; j<=5; j++)
{
cout<<setw(3)<<A[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
//afisA();
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
A[i][j]=(i+j)%5;
}
afisA();
return 0;
}
/*
2 3 4 0 1
3 4 0 1 2
4 0 1 2 3
0 1 2 3 4
1 2 3 4 0
*/
O mică observaţie:
când apar linii ”mişcate circular” sigur este vorba de % (modulo).
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
char a[31];
char b[31];
int na, nb;
int main()
{
int n; // n=min(n1,nb)=lungime maxima prefix (sufix)
int k; // lungime prefix (sufix)
int nrsol; // nr solutii
cin.get(a,30);
cin.get(b,30);
na=strlen(a);
nb=strlen(b);
//cout<<"\n";
//cout<<"a = "<<a<<" : "<<na<<"\n";
//cout<<"b = "<<b<<" : "<<nb<<"\n\n";
n=na;
if(nb<n) n=nb;
nrsol=0;
for(k=1; k<=n; k++) // verific daca exista prefix de lungime k
{
//cout<<"k = "<<k<<" : ";
//for(int i=0; i<=k-1; i++) cout<<b[i];
//cout<<" ";
//for(int i=0; i<=k-1; i++) cout<<a[na-k+i];
// verific ...
int ok=1;
for(int i=0; i<=k-1; i++) // i=pozitia in a[]
{
// (k=1 0--na-1) (k=2 0--na-2) (k=3 0--na-3) incepe ...
if(b[0+i] != a[na-k+i])
{
ok=0;
break;
}
}
if(ok==1)
{
nrsol++;
//cout<<" *** ";

for(int i=0; i<=k-1; i++) cout<<b[i];
cout<<" ";
//cout<<" ***";
}
//cout<<"\n";
//if(strstr(b,a+na-k) != NULL) // 41 ... 60

// if(strstr(b,a+na-k) - b == 0)
// cout<<a+na-k<<" ";
}
if(nrsol==0) cout<<"NU EXISTA";
return 0;
}
/*
rebele
elegant --> e ele
strai
rai --> rai
strai
ria --> NU EXISTA
*/

Problema 1
Problema 2

#include<iostream>

void f(int x)
{
cout<<x;
if(x>0)
{
if(x%2==0) cout<<’*’;
f(x/2);
}
return;
}
int main()
{
f(9);
return 0;
}
/*
94*2*10
*/
Problema 3

#include<iostream>
void dublu(int & n, int v[])

{
int i, j;
i=0;
while(i<n)
{
if(v[i] > 0) // inserez ... deplasare spre dreapta
{
v[j]=v[j-1];
v[i+1]=v[i]; // in casuta "eliberata" pun ...


// cout<<v[k]<<" ";
//cout<<"\n\n";
}
else
{
i=i+1;
}
}
}
int main()
{
int n;
int a[100]={4, -5, 0, 9, 9, -2};
n=6;
cout<<"*n = "<<n<<"\n";
cout<<a[i]<<" ";
cout<<"\n\n";
dublu(n,a);
cout<<"**n = "<<n<<"\n";
cout<<a[i]<<" ";
cout<<"\n";
return 0;
}
/*
*n = 6
4 -5 0 9 9 -2
**n = 9
4 4 -5 0 9 9 9 9 -2
*/
Problema 4

#include<iostream>
#include<fstream>
int main()
{
int x; // 1 <= x <=8
int p, nr, u;
cin>>x; // 1 <= x <= 8
for(p=1; p<=9-x; p++) // p=prima cifra a secventei de numere

{
nr=p;
u=p+x; // u = urmatoarea (ultima) cifra din secventa de numere
while(u <= 9)
{
nr=nr*10+u; // nr cu cel putin 2 cifre
cout<<nr<<"\n";
fout<<nr<<"\n";
u=u+x; // cifre in ordine crescatoare
}
}
fout.close();
return 0;
}
/*
3 -->
3
14
147
25
258
36
369
47
58
69
*/


Varianta 4
40.3.1 Subiectul I
Problema 1
Variabila x este de tip ı̂ntreg şi memorează un număr natural. Expresia
alăturată are valoarea 0 dacă şi numai dacă expresia x%5 are valoarea: (4p.)
a. 1 b. 2 c. 3 d. 4
Notam E(x) = ((x%5+1)%5+1)%5

a. Dacă x%5=1 atunci x=M5+1 şi E(1) = ((1+1)%5+1)%5 = (2%5+1)%5 = (2+1)%5 = 3
b. Dacă x%5=2 atunci x=M5+2 şi E(2) = ((2+1)%5+1)%5 = (3%5+1)%5 = (3+1)%5 = 4
c. Dacă x%5=3 atunci x=M5+3 şi E(3) = ((3+1)%5+1)%5 = (4%5+1)%5 = (4+1)%5 = 0
d. Dacă x%5=4 atunci x=M5+4 şi E(4) = ((4+1)%5+1)%5 = (5%5+1)%5 = (0+1)%5 = 1
Problema 2

#include<iostream>
int main()
{
int n, p, s, i, j;
//cin>>n>>p;
n=7;
p=5;
s=0;
for(i=1; i<=n; i++)
{
j=i; // j = copie a lui i
while(j%p != 0) // cat timp j nu este multiplu de p
{ j=j-1; }
s=s+j; // s aduna cel mai mare multiplu de p care este <=i
//cout<<"i = "<<i<<" j="<<j<<" s = "<<s<<"\n";
}
cout<<s;
return 0;
}

#include<iostream>
int main()
{
int n, p, s, i, j;
//cin>>n>>p;
n=7;
p=5;
for(n=1; n<=99; n++)

for(p=1; p<=99; p++)
{
s=0;
for(i=1; i<=n; i++)
{
{
j=j-1;
}
}
if(s==28)
cout<<"n="<<n<<" p="<<p<<" s = "<<s<<"\n";
}
return 0;
}
/*
n=7 p=1 s = 28
n=10 p=7 s = 28
n=15 p=14 s = 28
n=28 p=28 s = 28
*/

#include<iostream>
int main()
{
int n, p, s, i, j;
//cin>>n>>p;
n=7;
p=5;
s=0;
//for(i=1; i<=n; i++)
i=1; // initializarea din for
do
{
{
j=j-1;
}
i=i+1; // incrementarea din for
} while(i<=n); // la pseudocod: pana cand i>n;;
cout<<s;
return 0;
}

Problema 1
Problema 2

Problema 3

#include<iostream>
struct triunghi
{
int a,b,c;
} t1, t2;
int main()
{
t1.a=1;
t1.b=3;
t1.c=3;
t2.a=1;
t2.b=2;
t2.c=2;
bool e = (t1.a+t1.b+t1.c > t2.a+t2.b+t2.c);
cout<<"e = "<<e<<"\n";
return 0;
}
/*
e = 1
*/
Problema 4

#include<iostream>
#include<cstring>
int i;
char s[21]; // un caracter pentru ’\0’
int main()
{
strcpy(s,"elevi");
//cout<<"s = "<<s<<"\n";
for(i=0;i<strlen(s);i++)
{
cout<< s+i<<" ";
}
//cout<<endl;
// in ordine inversa ... !!!
//for(i=0;i<strlen(s);i++)
//{
// cout<< s + (strlen(s)-1) - i<<" ";
//}
return 0;
}
/*
elevi levi evi vi i
i vi evi levi elevi
*/
Problema 5

#include<iostream>
//#include<fstream>
//#include<cstring>
#include<iomanip>
int n;
int a[16][16];
int main()
{
int i, j;
//cin>>n;
n=4;
// prima coloana
for(i=1; i<=n; i++)
a[i][1]=1;
// ultima linie
for(j=2; j<=n; j++) // prima pozitie este deja incarcata
a[n][j]=j;
// celelalte pozitii
for(i=n-1; i>=1; i--)
{
for(j=2; j<=n; j++)
a[i][j]=a[i][j-1]+a[i+1][j];
}
// afisare matrice
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
cout<<setw(2)<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
intrare:
4
iesire:
1 5 15 35
1 4 10 20
1 3 6 10
1 2 3 4
*/

Problema 1
Problema 2

#include<iostream>
int f(int x,int y)

{
if(x*2>y) return x;
return f(x*2,y);
}
int main()
{
int rez1=f(3,4);
int rez2=f(2,20);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 3
rez2 = 16
*/
Problema 3
Figura 40.19: 2012bac-s3-III-3-v1

#include<iostream>
void afisv(int n, int v[])

{
for(int i=1; i<=2*n; i++)
cout<<v[i]<<" ";
cout<<"\n";
}
void zero(int n, int v[])

{
int i; // pozitia de rezolvat
int j; // pozitia cautata si gasita pentru rezolvare
int p; // paritate: 0=par 1=impar
int aux; // pentru interschimbare
i=1;
while(i <= 2*n-1) // i=pozitia de rezolvat
{
if((i%2) == (v[i]%2))
{
i=i+1;
continue; // au aceeasi paritate
}
// i si v[i] au paritati diferite

// caut spre dreapta v[j] cu paritate corecta
// situat pe pozitie incorecta
p=i%2; // paritatea lui i

j=i+1;
// caut o pozitie incorecta ... cu valoare ... !p

while( v[j]%2 == j%2 // pozitie corecta
|| v[j]%2 != p // v[j] are paritate diferita de paritatea lui i
) j++;
// schimb v[i] cu v[j]

//cout<<"schimb v["<<i<<"]="<<v[i]<<" cu v["<<j<<"]="<<v[j]<<"\n";
aux=v[i];
v[i]=v[j];
v[j]=aux;
//afisv(n,v); cout<<"\n";
// ma plasez pe pozitia j+1

i=j+1;
}
}
int main()
{
int n;
int a[100]={-1, 4, 5, 0, 9, 10, 7, 15, 3, 8, 10};// indici de la 1 ...
n=5;
afisv(n,a); cout<<"\n";
zero(n,a);
afisv(n,a);
return 0;
}
/*
4 5 0 9 10 7 15 3 8 10
5 4 9 0 7 10 15 8 3 10
*/
Problema 4

#include<iostream> // vmax > toate celelalte valori (in afara de valmax insusi)2012bac-
s3-III-4
#include<fstream>
ifstream fin("2012bac-s3-III-4-bac1.txt");
//ifstream fin("2012bac-s3-III-4-bac2.txt");
int main()
{
int n;
int vmax; // valoare maxima;

int nrvmax; // nr celor de valoare maxima
fin>>n;
fin>>vmax; // prima valoare, initializez vmax

nrvmax=1;

{
fin>>x;
if(x<vmax) continue;
if(x>vmax) // schimb vmax

{
vmax=x;
nrvmax=1;
continue;
}
// aici x = vmax
nrvmax++;
}
//cout<<"vmax = "<<vmax<<" nrvmax = "<<nrvmax<<"\n";
if(nrvmax < n/2)

cout<<"DA";
else
cout<<"NU";
return 0;
}

Capitolul 41
BAC 2011

Varianta 9
41.1.1 Subiectul I
Problema 1
a. din x>=-3 && x<=-1 && x>=1 && x<=3 rezultă mulţimea vidă
(x nu poate fi ı̂n acelaşi timp x<=-1 && x>=1)
b. !(x<-3 || x>-1) || !(x<1 || x>3) <-->
folosind legile lui De Morgan
(x>=-3 && x<=-1) || (x>=1 && x<=3)
Nu are rost să calculăm mai departe pentru că un singur răspuns este corect!
Problema 2

#include<iostream>
int main()
{
int n, k, t, i;
//cin>>n>>k;
n=5; k=2;
t=0;
while(n>=1)
{
//cout<<"n = "<<n<<" k = "<<k<<"\n";
if(n>k) i=k; else i=n; // i=min(n,k)
t=t+1;
n=n-i; // n se micsoreaza cu i=min(n,k)
//cout<<"n = "<<n<<" k = "<<k<<" i = "<<i<<" t = "<<t<<"\n";
while(i>=1) // i i-1 ... 1
{
cout<<t<<’ ’;
i=i-1;
}
//cout<<"\n\n";
}
return 0;
}
/*
1 1 2 2 3
*/
589

#include<iostream>
int main()
{
int n, k, t, i;
//cin>>n>>k;
k=5;
for(int nn=1; nn<=999; nn++)

{
n=nn;
t=0;
while(n>=1)
{
//cout<<"n = "<<n<<" k = "<<k<<"\n";
if(n>k) // i=min(n,k)
i=k;
else
i=n;
t=t+1;
n=n-i; // n se micsoreaza cu i=min(n,k)
//cout<<"n = "<<n<<" k = "<<k<<" i = "<<i<<" t = "<<t<<"\n";
while(i>=1) // i i-1 ... 1
{
//cout<<t<<’ ’;
i=i-1;
}
}
if(t==7) cout<<nn<<" --> "<<t<<endl;
}
return 0;
}
/*
31 --> 7
32 --> 7
33 --> 7
34 --> 7
35 --> 7
*/
Listing 41.1.3: 2011bac-s1-I-2c-v1.cpp

#include<iostream>
int main()
{
int n, k, t, i;
//cin>>n>>k;
n=15; k=4; // grupe de k ... cat se poate ...
//cout<<"n = "<<n<<" k = "<<k<<endl;
t=0; // valoarea de afisat
for(i=1; i<=n; i++)
{
if(i%k == 1) t=t+1;
cout<<t<<" ";
}
return 0;
}
/*
1 1 1 1 2 2 2 2 3 3 3 3 4 4 4
*/

#include<iostream>
int main()
{
int n, k, t, i;
//cin>>n>>k;
n=15; k=4; // grupe de k ... cat se poate ...
cout<<"n = "<<n<<" k = "<<k<<endl;
for(i=0; i<=n-1; i++) cout<<((i/k)+1)<<’ ’;
return 0;
}
/*
n = 15 k = 4
1 1 1 1 2 2 2 2 3 3 3 3 4 4 4
*/


Problema 1
Problema 2
Problema 3

Problema 4

#include<iostream>
int i, j;
int A[5][5];
void afisA()
{
for(i=0;i<5;i++)
{
for(j=0;j<5;j++) cout<<A[i][j]<<" ";
cout<<"\n";
}
cout<<"\n";
}
int main()
{
afisA();
for(i=0;i<5;i++)
for(j=0;j<5;j++)
A[i][j]=i+j;
afisA();
return 0;
}
/*
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
*/
Problema 5
Listing 41.1.6: 2011bac-s1-II-5-v1 pozitie substring.cpp

#include<iostream>
#include<cstring>
int n;
int nrc; // nr cuvinte solutie
char v[21][21]; // vector de cuvinte

char * pch;
int main()
{
cin>>n;
//cout<<"n = "<<n<<"\n";
cin.get(); // trebuie ... daca urmeaza texte ...

{
cin.get(v[i],20);
}
//cout<<"\n";
//for(int i=1; i<=n; i++)

//{
// cout<<i<<" : "<<v[i]<<"\n";
//}
//cout<<"\n";
nrc=0;

{
pch = strstr(v[i], v[1]);
if(pch != NULL)
{
//cout<<v[1]<<" este in "<<v[i]<<" la pozitia "<<pch-v[i]<<"\n";
if(pch-v[i] == 0) nrc++;
}
else
{
//cout<<v[1]<<" nu este in "<<v[2]<<"\n";
}
}
if(nrc > 0)
cout<<nrc;
else
cout<<"nu exista";
return 0;
}
/*
intrare:
5
bun
buncar
bunici
abundent
bunavoie
iesire:
3
*/

#include<iostream>
#include<cstring>
int n;
int nrc; // nr cuvinte solutie
char c1[21], cc[21];

char * pch;
int main()
{
cin>>n;
cout<<"n = "<<n<<"\n";
cin>>c1;
cout<<"c1 = "<<c1<<"\n";

{
cin>>cc;
pch=strstr(cc,c1);
if(pch != NULL)
if(pch-cc == 0)
nrc++;
}
if(nrc > 0)
cout<<nrc;
return 0;
}

Problema 1

#include<iostream>
int C1 (int a, int b)

{
if(a==b) return a;
else
if(a>b) return C1(a-b,b);
else return C1(a,b-a);
}
int C2 (int a, int b)

{
if(b==0) return a;
else return C2(b,a%b);
}
int main()
{
//int a=2*2*3, b=2*2*3*3;
int a=2*2*3*3, b=2*3*5;
int rez1=C1(a,b);
int rez2=C2(a,b);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 6
rez2 = 6
*/
Problema 2
Problema 3

#include<iostream>
void inserare(int & n, int v[])

{
int i, j;
i=0;
while(i<n)
{
if(v[i]%2 == 0) // inserez ... deplasare spre dreapta
{
v[j]=v[j-1];
v[i+1]=2011; // in casuta "eliberata" pun ...


// cout<<v[k]<<" ";
//cout<<"\n\n";
}
else
{
i=i+1;
}
}
}
int main()
{
int n;
int a[100]={1,4,5,3,82,6,2};
n=7;
cout<<n<<"\n";
cout<<a[i]<<" ";
cout<<"\n\n";
inserare(n,a);
cout<<n<<"\n";
cout<<a[i]<<" ";
cout<<"\n";
return 0;
}
/*
intrare:
7
1 4 5 3 82 6 2
iesire:
11
1 4 2011 5 3 82 2011 6 2011 2 2011
*/
Problema 4

#include<iostream> // crescator c1c2c3c4c5: c1+c2=s1 c4+c5=s2
#include<fstream>
int main()
{
int s1, s2;
int maxc1, maxc4;

int c1, c2, c3, c4, c5;
int nr5; // nr cu 5 cifre
int nrv=0; // nr variante ... !!!
cin>>s1>>s2;
cout<<"s1 = "<<s1<<" s2 = "<<s2<<"\n";
if(s1>9) maxc1=9;
else maxc1=s1;
if(s2>9) maxc4=9;
else maxc4=s2;
for(c1=1; c1<=maxc1; c1++)

{
c2=s1-c1; // c1+c2=s
for(c3=0; c3<=9; c3++) // cifra fara restrictii

{
for(c4=0; c4<=maxc4; c4++)
{
c5=s2-c4; // c4+c5=s2
nr5=c1*10000+c2*1000+c3*100+c4*10+c5;
nrv++; cout<<nrv<<" : "; cout<<nr5<<"\n";

fout<<nr5<<"\n";
}
}
}
fout.close();
return 0;
}


41.2.1 Subiectul I
Problema 1
Analizăm cele patru cazuri:
a. x=1 si y=4.
x+y=5 > 6 ? nu
cout<<3;
b. x=4 si y=1.
x+y=5 > 6 ? nu
cout<<3;
c. x=5 si y=2. d. x=5 si y=3.

x+y=7 > 6 ? da x+y=8 > 6 ? da
x-y=3 < 3 ? nu x-y=2 < 3 ? da
cout<<2; cout<<1;
Problema 2

#include<iostream>
int main()
{
int a=6;
int b=11;
int i, j, s;
i=a;
j=b;
s=0;
while(i <= j)
{
s = s + (i%2)*i + (j%2)*j;
i=i+1;
j=j-1;
}
cout<<s;
return 0;
}
/*
27
*/


#include<iostream>
int main()
{
int a=10;
int b; // 16
int i, j, s;
for(b=a; b<=999; b++)

{
i=a;
j=b;
s=0;
while(i <= j)
{
s = s + (i%2)*i + (j%2)*j;
i=i+1;
j=j-1;
}
if(s==11) cout<<"b = "<<b<<" : s = "<<s<<endl;

}
return 0;
}
/*
b = 11 : s = 11
*/

#include<iostream>
int main()
{
int a=6; // a <= b
int b=11;
int i, j, s;
i=a;
j=b;
s=0;
//while(i <= j)
do // se executa cel putin o data ... !!!
{
s = s + (i%2)*i + (j%2)*j;
i=i+1;
j=j-1;
} while(i <= j);
cout<<s;
return 0;
}
/*
27
*/

#include<iostream>
int main()
{
int a; // a <= b
int b;
//a=6; b=11;
a=6; b=13;
//se aduna numerele impare din intervalul [a,b]

// cel de la mijloc se aduna de doua ori ... !!!
int i, j, s;
if(a%2==0) i=a+1;
else i=a;
if(b%2==0) j=b-1;
else j=b;
// numerele impare din intervalul [7,11] sunt: (7+11) + (9+9)

// daca i si j "se intalnesc" la mijloc ... se aduna de doua ori ... !!!
// numerele impare din intervalul [7,13] sunt: (7+13) + (9+11)
// caz1: 7 9 11 -> mijloc = (7+11)/2=9=impar ... 3 numere impare

// caz2: 7 9 11 13 -> mijloc = (7+13)/2=10= par ... 4 numere impare
// s = media * nr numere impare
// nr numere impare caz1: (11-7)/2+1=4/2+1=3 = nrnri = (j-i)/2+1

// nr numere impare caz2: (13-7)/2+1=6/2+1=4 = nrnri
//nrnri = (j-1)/2+1
// media = (i+j)/2;
s=((i+j)/2)*((j-i)/2+1);
cout<<"i="<<i<<" j="<<j<<" s = "<<s;
return 0;
}
/*
i=7 j=11 s = 27
i=7 j=13 s = 40
*/


Problema 1

#include<iostream>
struct s1
{
int c, d;
};
struct s2
{
int a;
char b;
struct s1 x;
} y;
int main()
{
// a.
y.a=y.b-’a’;
// b.
//y=(1,’a’,2,3); // eroare sintaxa !
y={1,’a’,2,3}; // corect!
// c.
//y.s2.a=34; // eroare sintaxa !
y.a=34; // corect!
// d.
//y(b)=’a’; // eroare sintaxa !
y.b=’a’; // corect!
return 0;
}
Problema 2
Problema 3

#include<iostream>
#include<iomanip>
int a[11][11];
void afisa()
{
for(int i=1; i<=10; i++)
{
for(int j=1; j<=10; j++)
cout<<setw(2)<<a[i][j]<<" ";
cout<<endl;
}
cout<<endl;
return;
}
int main()
{
for(int i=1; i<=10; i++)
for(int j=1; j<=10; j++)
a[i][j]=(i%2)*i+(j%2)*j;
afisa();
int s=0;
for(int i=1; i<=10; i++)
s=s+a[i][11-i];
cout<<"s = "<<s<<endl;
return 0;
}
Elementul A[1][10] este pe diagonala secundară (ı̂n dreapta-sus).

Suma indicilor este 1+10=11.
Toate elementele A[i][j] de pe diagonala secundară au proprietatea i+j=11 (i i 1 şi j j 1,
deci suma rămâne constantă!)
Suma cerută este
s = A[1][10]+A[2][9]+A[3][8]+A[4][7]+A[5][6]+A[6][5]+A[7][4]+A[8][3]+A[9][2]+A[10][1].
(i%2)*i = 0 dacă i este par.
(j%2)*i = 0 dacă j este par.
Deci A[i][j] = (i%2)*i+(j%2)*j = suma indicilor impari!
s = 1+9+3+7+5+5+7+3+9+1 = 10+10+10+10+10 = 50.
Problema 4
Problema 5

#include<iostream>
#include<cstring>
char s[21];
char v[10]={’A’,’E’,’I’,’O’,’U’,’a’,’e’,’i’,’o’,’u’};
int main()
{
int ns;
int nrv=0; // nr vocale distincte gasite in sir
int i;
cin>>s;
//ns=strlen(s);
//cout<<"s = "<<s<<" --> "<<ns<<"\n";
for(i=0; i<=9; i++)

if(strchr(s,v[i])==NULL)
{
cout<<v[i];
nrv++;
}
if(nrv==0)
cout<<"SIRUL VID";
return 0;
}
/*
intrare: fULminAnta
iesire: EIOeou
*/

Problema 1
Problema 2

#include<iostream>
int f(int n)
{
if(n!=0) return n%2+f(n/2);
else return 0;
}
int main()
{
int rez1=f(0);
int rez2=f(14);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
rez1 = 0
rez2 = 3
*/
Problema 3

#include<iostream>
void schimb(int n, int v[], int k)

{
int aux;
aux=v[0];
for(int i=0; i<=k-2; i++)
v[i]=v[i+1];
v[k-1]=aux;
aux=v[n-1];
for(int i=n-1; i>=k+1; i--)
v[i]=v[i-1];
v[k]=aux;
return;
}
int main()
{
int a[]={1,21,9,21,40,3,5};
int n=sizeof(a)/sizeof(int);
int k=3;
// afisare vector
{
cout<<a[i]<<" ";
}
cout<<"\n";
schimb(n,a,k);
// afisare vector
{
cout<<a[i]<<" ";
}
cout<<"\n";
return 0;
}
/*
intrare: 1 21 9 21 40 3 5
iesire: 21 9 1 5 21 40 3
*/
Problema 4

#include<iostream>
#include<fstream>
int main()
{
int ak, ak1; // a[k], a[k-1]
int r; // ratia curenta

int lgc; // lungime curenta secventa
int lgmax=0; // lungime maxima secventa
fin>>ak1; cout<<ak1<<" ";

fin>>ak; cout<<ak<<" ";
r=ak-ak1;
lgc=2;
// pregatesc urmatoarea citire

ak1=ak;
while(fin>>ak)
{
cout<<ak<<" ";
if(ak-ak1==r)
{
lgc++;
}
else// s-a terminat o secventa, incepe alta
{
if(lgc>lgmax) lgmax=lgc;
r=ak-ak1;
lgc=2;
}
ak1=ak;
}
cout<<"\n"; // s-au terminat secventele
if(lgmax<3)
cout<<"NU EXISTA";
else
cout<<lgmax;
return 0;
}
/*
intrare: 3 8 13 18 17 16 2 3 9 4 -1 -6 -11 9
iesire: 5
*/


41.3.1 Subiectul I
Problema 1
Expresia
!(-20>=x) && (x<=-10) || (x>=-5) && !(x>5)
devine (folosind legile De Morgan şi priorităţile operatorilor)
(-20<x) && (x<=-10) || (x>=-5) && (x<=5)
deci răspunsul corect este d.
Problema 2

#include<iostream>
int main()
{
int n, m, x, p, c;
//cin>>n>>m;
n=1034;
m=1234;
//n=3333;
//m=5222;
//cout<<"n = "<<n<<" m = "<<m<<"\n";

if(n<m) // trebuie n=mare si m=mic
{
x=n;
n=m;
m=x;
}
//cout<<"n = "<<n<<" m = "<<m<<"\n\n";
p=1; // ajuta la parcurgerea cifrelor de la dreapta spre stanga

while(m>0)
{
//cout<<"n = "<<n<<" m = "<<m<<"\n";
c=m%10; // c=ultima cifra a lui m
m=m/10; // se sterge ultima cifra din m
n=n-p*c;// se scade m din n ... !!!
p=p*10;
}
cout<<n;
return 0;
}
/*
intrare: 1034 1234
iesire: 200
*/

#include<iostream>
int main()
{
int n, m, x, p, c;
//cin>>n>>m;
n=1034;
m=1234;
//n=3333;
//m=5222;
if(n<m) // trebuie n=mare si m=mic

{
x=n;
n=m;
m=x;
}
for(int mm=10; mm<=99; mm++)

for(int nn=mm; nn<=99; nn++)
{
m=mm;
n=nn;
p=1; // ajuta la parcurgerea cifrelor de la dreapta spre stanga
while(m>0)
{
c=m%10; // c=ultima cifra a lui m
m=m/10; // se sterge ultima cifra din m
n=n-p*c;// se scade m din n ... !!!
p=p*10;
}
if(n==86)
cout<<"("<<mm<<","<<nn<<") ("
<<nn<<","<<mm<<") \n";
}
return 0;
}
/*
(10,96) (96,10)
(11,97) (97,11)
(12,98) (98,12)
(13,99) (99,13)

#include<iostream>
int main()
{
int n, m, x, p, c;
//cin>>n>>m;
n=1034;
m=1234;
//n=3333;
//m=5222;
if(n<m)
cout<<(m-n);
else
cout<<(m-n);
return 0;
}

Problema 1
Problema 2

Problema 3

#include<iostream>
#include<cstring>
struct CARTE
{
float valoare;
int nrPagini;
char titlu[50];
};
int main()
{
CARTE c;
c.valoare=12.3;
c.nrPagini=234;
//c.titlu="Limbajul de programare C++";
strcpy(c.titlu,"Limbajul de programare C++");
cout<<"c.valoare = "<<c.valoare<<"\n";
cout<<"c.nrPagini = "<<c.nrPagini<<"\n";
cout<<"c.titlu = "<<c.titlu<<"\n";
return 0;
}
Problema 4

#include<iostream>
#include<cstring>
char a[101];
int i, k;
int main()
{
k=’a’-’A’; // distanta dintre literele mici si cele MARI
// a(0x61)-A(0x41) = 0x20 = 32 ...
strcpy(a,"bacalaureat");
cout<<a<<"\n";
for(i=0; i<strlen(a); i++)

if(strchr("aeiou",a[i])!=NULL)
a[i]=a[i]-k; // transforma vocalele mici in litere MARI
cout<<a;
return 0;
}
/*
bacalaureat
bAcAlAUrEAt
*/
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
int n, m; // n=linii m=coloane
int a[25][25];
int main()
{
int i, j;
cin>>n>>m;
cout<<"n = "<<n<<" m = "<<m<<"\n";
// ultima linie
for(j=1; j<=m; j++) a[n][j]=1;
// ultima coloana (ultima pozitie era deja 1)

for(i=1; i<=n-1; i++) a[i][m]=1;
// celelalte pozitii
for(i=n-1; i>=1; i--)
for(j=m-1; j>=1; j--)
a[i][j]=(a[i+1][j]+a[i][j+1])%10;
for(i=1; i<=n; i++)

{
for(j=1; j<=m; j++)
{
cout<<a[i][j]<<" ";
}
cout<<"\n";
}
return 0;
}
/*
intrare: 4 5
iesire:
5 0 0 4 1
5 0 6 3 1
5 4 3 2 1
1 1 1 1 1
*/

Problema 1
Problema 2


#include<iostream>
void f (int x)
{
cout<<’*’;
if(x>0)
{
cout<<x;
f(x/100);
cout<<’*’;
}
}
int main()
{
f(12345);
return 0;
}
/*
*12345*123*1****
*/
Problema 3

#include<iostream>
int inter(int na, int nb, int a[], int b[])

{
int n; // nr elem din intersectie
n=0;
for(int i=0; i<na; i++) // caut a[i]
{
for(int j=0; j<nb; j++) // in vectorul b
{
if(a[i]==b[j])
{
n++;
break; // intrerup cautarea ...
}
}
}
return n;
}
int main()
{
int na, nb;
int a[]={35,149,72,3798};
int b[]={72,151,149,9,623};
na=4;
nb=5;
int rez;
rez=inter(na, nb, a, b);
//cout<<"rez = "<<rez<<"\n";
cout<<rez<<"\n";
return 0;
}
/*
2
*/
Problema 4

#include<iostream>
#include<fstream>
int nracz[10];// nracz[i]=k; nr aparitii a cifrei zecilor = "i" este k

int poznr[10];// poznr[i]=k; pozitia ultimului nr cu cifra zecilor= "i" este k
int main()
{
int nrc; // nr curent in sir
int cz; // cifra zecilor numarului curent citit
int vmax; // max in nracz[]
int imax; // poz vmax
nrc=0;
while(fin>>x)
{
nrc++;
cout<<x<<" ";
cz=(x/10)%10;
nracz[cz]++;
poznr[cz]=nrc;
}
cout<<"\n";
vmax=-1;
imax=-1;
for(int i=0; i<=9; i++)
{
if(nracz[i]>vmax)
{
vmax=nracz[i];
imax=i;
}
}
//cout<<"imax = "<<imax<<" vmax = "<<vmax<<"\n";
cout<<poznr[imax];
return 0;
}
/*
intrare: 12 36 265 18 139 19 32 34 112 14 68
iesire: 10
*/

Capitolul 42
BAC 2010

Varianta 1
42.1.1 Subiectul I
Problema 1
a. abs(x)<=5 x " 5, 5
b. (x>-5) && (x<5)
x " 5, 5
c. !(x<-5) || !(x>5)
(x>=-5) || (x<=5)
x " 5, < , 5
x " ,
d. !(x<-5) && (x>5)
(x>=-5) && (x>5)
x " 5,
Problema 2

#include<iostream>
int main()
{
int a, d, ok;
//cin>>a;
a=5789;
d=a%10-(a/10)%10;
a=a/10;
if(d!=0) ok=1;
else ok=0;
//cout<<"a="<<a<<" d="<<d<<" ok="<<ok<<"\n";
while(a>9 && ok==1)// cat timp a = cel putin 2 cifre

{
//cout<<" a="<<a<<" d="<<d<<" ok="<<ok<<"\n";
if((a%10-(a/10)%10)*d <= 0)
ok=0;
a=a/10;
//cout<<" a="<<a<<" d="<<d<<" ok="<<ok<<"\n\n";
}
cout<<ok<<" "<<a;
return 0;
}
/*
intrare: 5789
iesire: 1 5
*/
617

#include<iostream>
int main()
{
int a, d, ok;
//cin>>a;
//a=5789;
//a=9876;
for(int aa=9999; aa>=1000; aa--)

{
a=aa;
d=a%10-(a/10)%10; // cifra unitatilor - cifra zecilor
a=a/10; // se sterge cifra unitatilor
if(d!=0)
ok=1; // cifre diferite
else
ok=0; // cifre egale
//cout<<"a="<<a<<" d="<<d<<" ok="<<ok<<"\n";
while(a>9 && ok==1)// cat timp a = cel putin 2 cifre

{
// cifre diferite si nu s-a schimbat monotonia ...
//cout<<" a="<<a<<" d="<<d<<" ok="<<ok<<"\n";
if((a%10-(a/10)%10)*d <= 0) // cifre egale sau schimbare de monotonie
ok=0;
a=a/10;
//cout<<" a="<<a<<" d="<<d<<" ok="<<ok<<"\n\n";
}
//cout<<ok<<" "<<a<<endl;
//cout<<aa<<" : "<<ok<<" "<<a<<endl;
if(ok==1)
{
cout<<aa<<" : "<<ok<<" "<<a;
break;
}
}// for aa
return 0;
}
/*
9876 : 1 9
*/

#include<iostream>
int main()
{
int a, d, ok;
//cin>>a;
a=5789;
//a=9876;
d=a%10-(a/10)%10;
a=a/10;
if(d!=0)
ok=1;
else
ok=0;
//while(a>9 && ok==1)

if(a>9 && ok==1) // pentru prima iteratie ... !!!
do
{
if((a%10-(a/10)%10)*d <= 0)
ok=0;
a=a/10;
} while(a>9 && ok==1); // pana cand !(a>9 && ok==1) la pseudocod
cout<<ok<<" "<<a;
return 0;
}
/*
1 5
*/

Problema 1
Problema 2
Problema 3

#include<iostream>
struct punct
{
int x, y;
};
struct triunghi
{
struct punct A, B, C;
} t2; // in zona globala este initializat automat cu 0
int main()
{
struct triunghi
{
struct punct A, B, C;
} t; // in functie NU este initializat ... !!!
t.A.x=0;// aceasta este instructiunea ...
// de antrenament ... !!!

cout<<"t.A.x = "<<t.A.x<<"\n";
cout<<"t.A.y = "<<t.A.y<<"\n\n";
cout<<"t.B.x = "<<t.B.x<<"\n";
cout<<"t.B.y = "<<t.B.y<<"\n\n";
cout<<"t.C.x = "<<t.C.x<<"\n";
cout<<"t.C.y = "<<t.C.y<<"\n";
return 0;
}
Problema 4

#include<iostream>
#include<cstring>
int p;
char s[21];
int main()
{
strcpy(s,"estetician");
cout<<"s = "<<s<<"\n";
for (p=0;p<strlen(s);p++)
//if(!(s[p]==’e’ || s[p]==’i’))
if(s[p]!=’e’ && s[p]!=’i’) // din legile lui De Morgan
cout<<s[p];
return 0;
}
/*
intrare: estetician
iesire: sttcan
*/
Problema 5

#include<iostream>
#include<fstream>
int m, n; // m=linii n=coloane
int a[21][21];
int nlc; // numar linii complementare
int npc; // numar pozitii complementare pe linia curenta
int main()
{
int i, j;
cin>>m>>n;
//cout<<"m = "<<m<<" n = "<<n<<"\n";
for(i=1; i<=m; i++)

for(j=1; j<=n; j++)
cin>>a[i][j];
nlc=0;
for(i=1; i<=m-1; i++) // analizez linia i
{
npc=0;
for(j=1; j<=n; j++)
{
if(a[i][j]+a[m][j] == 1)
npc++;
}
if(npc == n)
{
nlc++;
//cout<<"linia "<<i<<"\n";
}
}
cout<<nlc;
return 0;
}
/*
intrare:
5 3
1 0 0
1 0 1
1 0 0
0 0 1
0 1 1
iesire: 2
*/

Problema 1
Cifrele impare sunt: 1, 3, 5, 7, 9.
Generarea tuturor numerelor naturale formate din exact trei cifre presupune folosirea cifrelor
din mulţimea {1, 3, 5, 7, 9}. Soluţiile sunt, de exemplu, ca la un contor de maşină (de la un
moment dat, dupa ce am parcurs deja 110 Km): 111, 112, 113, ..., 912, 913, 914, ..., 997, 998, 999
şi gata!
Este vorba de generarea produsului cartezian.
Problema 2

#include<iostream>
int p(int n)
{
if(n>0 && n%2==0) return 1+p(n/2);

else return 1;
}
int main()
{
int rez1=p(-4);
int rez2=p(4);
cout<<"rez1 = "<<rez1<<"\n";
cout<<"rez2 = "<<rez2<<"\n";
return 0;
}
/*
1
3
*/
Problema 3

#include<iostream>
void afisv(int n, int v[])

{
cout<<v[i]<<" ";
cout<<"\n";
}
void ordonare(int n, int a[])

{
int i, j;
int aux; // pentru interscimbare
for(i=0; i<=n-2; i++) // bubble sort ... par crescator: 0, 1, ..., n-2, n-1
{
if(a[i]%2==1) continue;
// a[i]=par
for(j=i+1; j<=n-1; j++)

{
if(a[j]%2==1) continue;
// a[j]=par
if(a[i] > a[j])

{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
}
}
}
int main()
{
int a[]={1,4,5,3,82,6,2};
int n;
n=7;
afisv(n,a);
ordonare(n,a);
afisv(n,a);
return 0;
}
/*
1 4 5 3 82 6 2
1 2 5 3 4 6 82
*/
Problema 4

#include<iostream>
#include<fstream>
int main()
{
int n;
int s, kf, k;
cin>>n;
//cout<<"n = "<<n<<"\n";
kf=1; // initializat cu 0!=1
s=0;
for(k=1; k<=n; k++)
{
kf=kf*k;
if(n-k+1 < kf) break; // (n-k+1)/kf = 0
s=s+(n-k+1)/kf;
}
//cout<<s;
fout<<s;
return 0;
}
/*
4 --> 5
*/


Varianta 8
42.2.1 Subiectul I
Problema 1
Dacă x, y şi z au valori egale atunci expresia x==y && x==z este adevărată, deci are valoarea 1.
Invers: dacă expresia x==y && x==z area valoarea 1 ı̂nseamnă că afirmaţiile x==y şi x==z sunt
simultan adevărate, adică x, y, şi z au valori identice.
Cazul a. este ok şi cum ştim că numai un răspuns este corect ... alegerea este a.
Problema 2

#include<iostream>
int main()
{
int n, s, i, a, b, j, r;
n=6;
s=0;
for(i=1; i<=n; i++)
{
a=0; b=1; j=1;
while(j<i)
{
r=2*b-a; a=b; b=r; =j+1;
}
s=s+b;
}
cout<<s;
return 0;
}
/* 21 */

#include<iostream>
int main()
{
int n, s, i, a, b, j, r;
//cin>>n;
//n=10;
for(int nn=1; nn<=20;nn++)

{
n=nn;
s=0;
for(i=1; i<=n; i++)
{
//cout<<"i = "<<i<<"\n";
a=0;
b=1;
j=1;
while(j<i)
{
r=2*b-a; //
//cout<<"j="<<j<<" a="<<a<<" b="<<b<<" r="<<r<<"\n";
a=b;
b=r;
j=j+1;
}
//cout<<"\n";
s=s+b;
//cout<<n<<" --> "<<s<<endl;
}
if(s==55)
{
cout<<nn<<" --> "<<s<<endl;
break;
}
}
return 0;
}
/*
10 --> 55
*/

#include<iostream>
int main()
{
int n, s, i;
//cin>>n;
n=10;
s=0;
for(i=1; i<=n; i++)
{
s=s+i;
}
cout<<s;
return 0;
}
/*
55
*/

Problema 1
Problema 2

#include<iostream>
#include<cstring>
int i, j;
char s[21];
int main()
{
strcpy(s,"bacalaureat");
j=strlen(s);
for(i=0;i<3;i++) // i=0, 1, 2
if(s[i]!=s[j-i-1]) // i=0 --> s[0]=primul ... s[j-1]=ultimul
s[i]=s[j-i-1]; // primul devine egal cu ultiml ...
// "bac alaur eat" --> "tae alaur eat"
cout<<s;
return 0;
}
/*
taealaureat
*/
Problema 3
Problema 4

#include<iostream>
#include<cstring>
struct data_n
{
int an, luna, zi;
};
struct elev
{
char nume[20];
data_n d;
} e1, e2;
int main()
{
strcpy(e1.nume,"Popescu");
e1.d.an=2005;
e1.d.luna=7;
e1.d.zi=23;
strcpy(e2.nume,"Ionescu");
e2.d.an=2007;
e2.d.luna=7;
e2.d.zi=23;
cout<<e1.nume<<" "<<e1.d.an<<" "<<e1.d.luna<<" "<<e1.d.zi<<endl;

cout<<e2.nume<<" "<<e2.d.an<<" "<<e2.d.luna<<" "<<e2.d.zi<<endl;
if(e1.d.an < e2.d.an) // varsta mai mare <--> an mai mic ... !!!
cout<<e1.nume;
else
cout<<e2.nume;
return 0;
}
/*
Popescu 2005 7 23
Ionescu 2007 7 23
Popescu
*/
Problema 5

#include<iostream>
#include<fstream>
#include<cstring>
int n;
int a[21][21]; // este initializat cu zero, automat
int main()
{
int i, j;
// sub diagonala principala (j=i):linia i: j=1, ...,, i-1

for(i=2; i<=n; i++)
for(j=1; j<=i-1; j++)
a[i][j]=i-j;
// deasupra diagonalei principale (j=i): linia i: j=i+1, ...,, n

for(i=1; i<=n; i++)
for(j=i+1; j<=n; j++)
a[i][j]=j-i;
for(i=1; i<=n; i++) // afisare matrice

{
for(j=1; j<=n; j++)
cout<<a[i][j]<<" ";
cout<<"\n";
}
return 0;
}
/*
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
*/

Problema 1

Problema 2

#include<iostream>
int f(int a, int b)

{
if(a>=b)
return (a-b)+f(a/b,b);
return 1;
}
int main()
{
int x1, x2;
for(x1=21; x1<=29; x1++)

{
int rez1=f(x1,3);
if(rez1==29)
cout<<"f("<<x1<<",3) = "<<rez1<<"\n";
}
cout<<"\n";
for(x2=21; x2<=29; x2++)

{
int rez2=f(3,x2);
if(rez2==1)
cout<<"f(3,"<<x2<<") = "<<rez2<<"\n";
}
return 0;
}
/*
f(26,3) = 29
f(3,21) = 1
f(3,22) = 1
f(3,23) = 1
f(3,24) = 1
f(3,25) = 1
f(3,26) = 1
f(3,27) = 1
f(3,28) = 1
f(3,29) = 1
*/
Problema 3
Problema 4

#include<iostream> // nr distincte
#include<fstream>
ifstream fin("2010bac-s2-III-4-bac.in");
int main()
{
int n;
int c; // ultima cifra din x;
int nr1; // primul nr din solutie

int nr2; // al doilea nr din solultie ... nr1 <= nr2
fin>>n; //cout<<"n = "<<n<<"\n";
nr1=-1;
nr2=-1; // nu au inca valori din fisier
while(fin>>x)
{
cout<<x<<" ";
c=x%10;
if(c != 5) continue; // nu are ultima cifra = 5

if(nr1<0) // a aparut primul nr ok
{
nr1=x;
continue;
}
if(nr2<0) // a aparut al doilea nr ok

{
nr2=x;
if(x<nr1) // nr1 < nr2

{
nr2=nr1; // nr2 = cel mai mare
nr1=x; // nr1 = cel mai mic

}
continue;
}
// aici a aparut si al treilea ok ...

if(x > nr2) // nr1 .. nr2 .. x
{
nr2=x;
nr1=nr2;
}
else // x < nr2
if(x > nr1) // ... nr1 ... x ... nr2 ...
{
nr1=x;
}
// daca ... x ... nr1 ... nr2 ... nu se schimba nimic
}
cout<<"\n\n";
cout<<nr1<<" "<<nr2;
return 0;
}
/*
97 5 11 1 8 6 85 3 25 15
25 85
*/


Varianta 10
42.3.1 Subiectul I
Problema 1
a. !( (n%2==1) || (n%7!=0) ) !(n%2==1) && !(n%7!=0) (n%2==0) &&
!(n%7!=0) (n%2==0) && (n%7==0) adică x este divizibil cu 2 şi cu 7. Nu are rost să
calculaăm mai departe pentru că numai un răspuns este corect! Deci, alegerea este a.
Problema 2

#include<iostream>
int main()
{
int n, m, c;
n=64598; //cin<<n;
m=0;
do
{
c=n%10; // c = ultima cifra a lui n
n=n/10; // sterg ultima cifra din n
if(c>5)
c=c/2; // injumatatesc cifra c daca este > 5
m=m*10+c; // construiesc numarul, invers, cu noua cifra
} while( !(n==0)); // in pseudocod: pana cand (n==0)

cout<<m;
return 0;
}
/* 44543 */

#include<iostream>
int main()
{
int n, m, c;
//cin<<n;
//n=64598; // --> 44543 ... invers ... parcurgerea cifrelor
for(int nn=100; nn<=999; nn++)

{
n=nn;
m=0;
do
{
if(c>5)
{
}
} while( !(n==0)); // in pseudocod: pana cand (n==0)
if(m==24)
cout<<nn<<" --> "<<m<<"\n";
}
return 0;
}
/*
420 --> 24
820 --> 24
920 --> 24
*/

#include<iostream>
int main()
{
int n, m, c;
//cin<<n;
n=64598; // --> 44543 ... invers ... parcurgerea cifrelor
m=0;
//do
while(n!=0)
{
if(c>5)
{
}
} //while( !(n==0)); // in pseudocod: pana cand (n==0)
cout<<m;
return 0;
}
/*
44543
*/

Problema 1

#include<iostream>
//#include<cstring>
struct cerc
{
float x, y;
float raza;
} FIG;
int main()
{
FIG.x=22.0;
FIG.y=22.0;
bool e1=(FIG.x == FIG.y);
cout<<"e1 = "<<e1<<"\n";
FIG.y=23.0;
bool e2=(FIG.x == FIG.y);
cout<<"e2 = "<<e2<<"\n";
return 0;
}
/*
e1 = 1
e2 = 0
*/
Problema 2
Problema 3

#include<iostream>
int i, j;
int A[5][5];
void afisA()
{
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
cout<<A[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n";
}
int main()
{
//afisA();
for(i=0;i<5;i++)
for(j=0;j<5;j++)
A[i][j]=2*i+j+1;
afisA();
return 0;
}
/*
1 2 3 4 5
3 4 5 6 7
5 6 7 8 9
7 8 9 10 11
9 10 11 12 13
*/
Problema 4
Problema 5
Listing 42.3.6: 2010bac-s3-II-5 strcpy.cpp

#include<iostream>
#include<cstring>
char text[101];
int main()
{
int i, i1, i2;
cin.get(text,100);
i=0;
while(i<strlen(text))
{
while(i<strlen(text) && text[i] != ’.’)
i++;
if(!(i<strlen(text))) break; // ies din while
// caut spre stanga pentru i1

i1=i;
while(text[i1]!=’ ’)
i1--;
// caut spre dreapta

i2=i;
while(i2<strlen(text) && text[i2]!=’ ’)
i2++;
// i1=spatiu ... i2=spatiu (trebuie sa ramana spatiile)

// elimin i1+1 ... i2-1
// mut i2... peste i1...
strcpy(text + i1+1,text + i2); // scrie peste ... !!!
i=i1;
}
cout<<text<<"\n";
return 0;
}
/*
intrare: Reprezentat cu 4 zecimale PI este 3.1415 si e este 2.7182
iesire: Reprezentat cu 4 zecimale PI este si e este
*/

Problema 1

#include<iostream>
int p(int m, int n)

{
if(n==0) return 1;
return 1+p(n, m%n);

}
int main()
{
int rez=p(210,49);
cout<<rez<<"\n";
return 0;
}
/*
4
*/
Problema 2
Figura 42.18: 2010bac-s3-III-2 backtracking

Problema 3
Listing 42.3.8: 2010bac-s3-III-3 v1.cpp

#include<iostream>
void tablou(int n, int k, int a[])

{
int i, j;
for(i=1; i<=n; i++)

for(j=1; j<=k; j++)
a[(i-1)*k+j-1]=i;
}
int main()
{
int n, k;
int a[201];
n=4;
k=3;
tablou(n, k, a);
for(int i=0; i<=n*k-1; i++) cout<<a[i]<<" ";

cout<<"\n";
return 0;
}
/* 1 1 1 2 2 2 3 3 3 4 4 4 */
Listing 42.3.9: 2010bac-s3-III-3 v2.cpp

#include<iostream>
void tablou(int n, int k, int a[])

{
int i, j, poz;
poz=0;
for(i=1; i<=n; i++)
{
for(j=1; j<=k; j++)
{
a[poz]=i;
poz++;
}
}
}
int main()
{
int n, k;
int a[201];
n=4;
k=3;
tablou(n, k, a);
for(int i=0; i<=n*k-1; i++) cout<<a[i]<<" ";

cout<<"\n";
return 0;
}
/* 1 1 1 2 2 2 3 3 3 4 4 4 */
Problema 4

#include<iostream> // nr in ordine crescatoare in fisier
#include<fstream> // cel putin un nr par
int main()
{
int x1, x2; // nr consecutive din fisier
while(fin>>x1) // cel putin un nr din fisier este par!

{
if(x1%2==0) break; // am gasit primul nr par
}
cout<<x1<<" "; // x1 este primul nr par
while(fin>>x2)
{
if (x2%2==0 && x2 != x1) // par si nu prelungeste o secventa para
{
cout<<x2<<" ";
x1=x2; // x1 = ultimul nr par citit pana acum
}
}
fin.close();
return 0;
}
/*
1 1 2 2 2 7 10 10 10 10 24
2 10 24
*/

640
Appendix A
”Instalare” C++
Ca să putem ”lucra” cu C++ avem nevoie de
un compilator pentru C++, şi
un IDE (Integrated Development Enviroment) pentru C++.
A.1 Kit OJI 2017

Poate că cel mai uşor este să se descarce fişierul
http://www.cnlr.ro/resurse/download/Kit_OJI_2017.rar
https://cdn.kilonova.ro/p/WXbRLG/Kit_OJI_2017.rar
http://olimpiada.info/oji2018/Kit_OJI_2017.rar
https://www.liis.ro/Documents/download/Kit_OJI_2017.rar
folosit de către elevi la şcoală şi la olimpiade.
Fişierele din arhivă sunt:
Figura A.1: Fişierele din Kit OJI 2017
Se lansează ı̂n execuţie fişierul OJIkit 2017.exe.
Instalarea este foarte uşoară (este de tipul ”next -> next -> ... -> next”) iar pe in-
ternet sunt multe site-uri de ajutor. De exemplu:
https://www.pbinfo.ro/?pagina=intrebari-afisare&id=26
https://www.youtube.com/watch?v=CLkWRvAwLO8
https://infoas.ro/lectie/112/tutorial-instalare-codeblocks-usor-introducere-in-in
https://www.competentedigitale.ro/c/oji2019/Kit_OJI_2017.rar
Există numeroase alternative la CodeBlocks: Dev-C++, Microsoft Visual Studio, Eclipse,

NetBeans, CodeLite, CLion, KDevelop, etc.
641
APPENDIX A. ”INSTALARE” C++ A.1. KIT OJI 2017 642
Kitul Kit_OJI_2017 se instalează implicit pe C:¯OJI¯

30
t IDE-ul Code::Blocks ,
t compilatorul pentru C: gcc.exe,
31
t compilatorul pentru C++: g++.exe
t make.exe
t gdb.exe
t şi... altele!
La sfârşitul instalării apar pe ecran două link-uri:
Figura A.2: CodeBlocks & C++ Reference
Figura A.3: Ce conţine C:¯ OJI ¯
A.1.1 Code::Blocks
Pentru versiuni mai noi, de Code::Blocks şi compilatoare, se poate accesa site-ul
http://www.codeblocks.org/downloads/binaries
de unde se poate descărca, de exemplu, codeblocks-20.03mingw-setup.exe.
Versiuni mai vechi, dar foarte bune, se pot descărca de la adresa
30
Code::Blocks este un IDE (integrated development environment) pentru C/C++, un fel de Notepad ... mai
sofisticat, cu multe butoane care lansează ı̂n execuţie diverse programe, de exeplu g++.exe
31
g++.exe este compilatorul de C++, programul care va verifica dacă instrucţiunile noastre sunt ok sau nu ...
şi care ne va supăra mereu cu erorile pe care ni le arată ... ... Este “o mică artă” să ı̂nţelegem mesajele de
eroare pe care le vedem pe ecran şi să fim ı̂n stare să “depanăm” programele noastre!
http://www.codeblocks.org/downloads/source/5
Mai precis:
https://sourceforge.net/projects/codeblocks/files/Binaries/20.03/
http://sourceforge.net/projects/codeblocks/files/Binaries/17.12
http://sourceforge.net/projects/codeblocks/files/Binaries/16.01
A.1.2 Folder de lucru
Figura A.4: Folder de lucru
De preferat este să avem cel puţin două partiţii: C:¯, D:¯, ... şi să “lăsăm ı̂n pace” partiţia C:¯
pentru sistemul de operare şi programele instalate!
În figura de mai sus se poate observa că pe D:¯ există un folder de lucru pentru programele ı̂n
C++, folder care se numeşte Programe C++. Aici vom salva toate programele C++ pe care
le vom scrie, eventual organizate pe mai multe subfoldere.
Acum, să intrăm ı̂n folderul Programe C++.
Click-dreapta cu mouse-ul şi selectăm “New % Text document” ca ı̂n figura următoare.
Figura A.5: New % Text document
Figura A.6: Schimbare nume fişier şi nume extensie fişier

Figura A.7: Confirmare schimbare extensie ı̂n .cpp
Figura A.8: Pregătit pentru Code::Blocks
Dacă vom executa două click-uri pe numele fşierului p01.cpp sau un click pentru a marca
fişierul şi apoi un ¡Enter¿, se va declanşa Code::Blocks cu p01.cpp ı̂n fereastra de editare şi, ce
este şi mai important, cu Programe C++ ca folder curent de lucru pentru Code::Blocks.
Adică, aici vor apărea toate fişiere generate de Code::Blocks pentru p01.cpp.
A.1.3 Utilizare Code::Blocks
Figura A.9: Pregătit pentru a scrie cod de program C++ ı̂n Code::Blocks
Figura A.10: Primul cod de program C++ ı̂n Code::Blocks
Figura A.11: Build - compilare

Figura A.12: 0 error(s), 0 warning(s)
Figura A.13: Run - execuţie

Figura A.14: Executat corect: a făcut “nimic”
A.1.4 Setări Code::Blocks

De preferat este să lăsăm setările implicite (sunt stabilite totuşi de nişte specialişti!) dar, dacă
vrem, putem să umblăm şi noi prin setări!
Figura A.15: Settings % Compiler

Figura A.16: Toolchain executables
Figura A.17: Unde sunt acele programe

A.1.5 Multe surse ı̂n Code Blocks

Settings Environment: pe calculatorul meu setările sunt:
Figura A.18: Multe surse ı̂n Code Blocks - setări
Dacă avem fişierele p01.cpp, ..., p05.cpp, ı̂n folderul nostru de lucru, şi facem dublu-click pe
fiecare ... vor apărea toate ...
Figura A.19: Multe surse in Code Blocks - exemple

APPENDIX A. ”INSTALARE” C++ A.2. WINLIBS 651
A.2 winlibs
A.2.1 GCC şi MinGW-w64 pentru Windows
Se descarcă de la
http://winlibs.com/#download-release
unul dintre fişierele:
winlibs-x86_64-posix-seh-gcc-10.2.0-llvm-11.0.0-mingw-w64-8.0.0-r
3.7z dimensiune fişier = 148 MB
winlibs-x86_64-posix-seh-gcc-10.2.0-llvm-11.0.0-mingw-w64-8.0.0-r
3.zip dimensiune fişier = 324 MB
winlibs-x86_64-posix-seh-gcc-10.2.0-mingw-w64-8.0.0-r3.7z dimensiune
fişier = 52.1 MB
winlibs-x86_64-posix-seh-gcc-10.2.0-mingw-w64-8.0.0-r3.zip dimensi-
une fişier = 141 MB
Se dezarhivează şi se mută folderul mingw64 pe C: sau D: sau ...

Eu l-am dezarhivat pe cel mai mic şi l-am pus pe D:
Figura A.20: mingw64 pe D:
A.2.2 PATH
Trebuie pusă ı̂n PATH calea pentru D:\mingw64\bin\. În “Type here to search” scrieţi: path
şi apoi click pe “Edit the system environment variables”, ca ı̂n figura următoare:
Figura A.21: search path
Apare fereastra “System properties”:
Figura A.22: System properties –¿ Advanced
Fereastra este poziţionată pe tab-ul “Advanced”. Se selectează “Environment Variables”.

Figura A.23: Environment Variables
Se selecteaza “Path” şi click pe “Edit”. Apare fereastra “Edit Environment Variables”
Figura A.24: Edit Environment Variables –¿ New
Se selectează “New”, se scrie calea D:¯mingw64¯bin şi se finalizează cu click pe “OK”,

“OK”, ..., “OK” până la sfârşit!
Se verifică calea şi versiunea pentru “gcc”:
C:¯path
C:¯gcc –version (Atentie! sunt 2 caractere - consecutive)

Figura A.25: Calea şi versiunea pentru gcc
Dacă totul este OK atunci se trece la instalarea IDE-ului preferat (Integrated Development
32
Environment ), de exemplu Code::Blocks 20.03 (sau Eclipse, Visual Studio Code, Dev C++,
NetBeans, şi altele).
Observatie: Pentru Windows 11
"Setting the path and variables in Windows 11
In the System > About window,

click the Advanced system settings link
at the bottom of the Device specifications section.
In the System Properties window,

click the Advanced tab,
then click the Environment Variables button
near the bottom of that tab."
A.2.3 CodeBlocks
CodeBlocks se poate descărca de la http://www.codeblocks.org/downloads/26. Sunt
mai multe variante dar eu am descărcat numai codeblocks-20.03-setup.exe care are 35.7 MB.
La instalare am lăsat totul implicit, deci ... Next, Next, ..., Next până la sfârşit!
La prima lansare ı̂n execuţie este necesară setarea locaţiei compilatorului de C++ (gcc-ul pe
care tocmai l-am instalat!).
32
https://en.wikipedia.org/wiki/Integrated_development_environment
https://ro.wikipedia.org/wiki/Mediu_de_dezvoltare
Figura A.26: Settings –¿ Compiler
Figura A.27: Toolchain executables –¿ Auto-detect

Figura A.28: New –¿ Text Document
Figura A.29: New text Document.txt
Figura A.30: Schimbare nume şi extensie

Figura A.31: Moore apps
Figura A.32: Look for another app

Figura A.33: Cale pentru codeblocks.exe
Figura A.34: Selectare codeblocks.exe

Figura A.35: Editare test01.cpp
Figura A.36: Compilare test01

Figura A.37: Mesaje după compilare
Figura A.38: Execuţie test01

Figura A.39: Rezultat execuţie test01
Figura A.40: Fişiere apărute după compilare!
Figura A.41: Creare test02.cpp gol! + ¡dublu click¿ sau ¡Enter¿

Figura A.42: Lista programelor de utilizat
Figura A.43: Selectare Code::Blocks IDE pentru fişierele .cpp
Figura A.44: Editare+Compilare+Execuţie pentru test02

Figura A.45: Selectare tab ce conţine test01.cpp

Appendix B
Exemple pentru rezolvarea

subiectelor de BAC
B.1 Subiectul I
B.1.1 Subiectul I-1
2017 Sesiunea specială din luna mai
Enunţ:
variabila ı̂ntreagă x are exact trei cifre. (4p.)
a. x/1000==0 && x/100!=0 b. x/1000==0 || x/100!=0

c. x%1000==0 && x%100!=0 d. x%1000==0 || x%100!=0
Rezolvare:
Listing B.1.1: 2017bac-s1-I-1.cpp

1 #include<iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int x1=1;
8 int x2=12;
9 int x3=123;
10 int x4=1234;
11
12 int x;
13
14 x=x1;
15 cout<<"x = "<<x1<<endl;
16 cout<<"a. x/1000==0 && x/100!=0 --> "
17 <<(x/1000==0 && x/100!=0)<<endl;
18 cout<<"b. x/1000==0 || x/100!=0 --> "
19 <<(x/1000==0 || x/100!=0)<<endl;
20 cout<<"c. x%1000==0 && x%100!=0 --> "
21 <<(x%1000==0 && x%100!=0)<<endl;
22 cout<<"d. x%1000==0 || x%100!=0 --> "
23 <<(x%1000==0 || x%100!=0)<<endl;
24 cout<<endl;
25
26 x=x2;
27 cout<<"x = "<<x2<<endl;
28 cout<<"a. x/1000==0 && x/100!=0 --> "
29 <<(x/1000==0 && x/100!=0)<<endl;
30 cout<<"b. x/1000==0 || x/100!=0 --> "
31 <<(x/1000==0 || x/100!=0)<<endl;
32 cout<<"c. x%1000==0 && x%100!=0 --> "
664
APPENDIX B. EXEMPLE PENTRU REZOLVAREA SUBIECTELOR DE BAC B.1.
SUBIECTUL I 665
33 <<(x%1000==0 && x%100!=0)<<endl;

34 cout<<"d. x%1000==0 || x%100!=0 --> "
35 <<(x%1000==0 || x%100!=0)<<endl;
36 cout<<endl;
37
38 x=x3;
39 cout<<"x = "<<x3<<endl;
40 cout<<"a. x/1000==0 && x/100!=0 --> "
41 <<(x/1000==0 && x/100!=0)<<endl;
42 cout<<"b. x/1000==0 || x/100!=0 --> "
43 <<(x/1000==0 || x/100!=0)<<endl;
44 cout<<"c. x%1000==0 && x%100!=0 --> "
45 <<(x%1000==0 && x%100!=0)<<endl;
46 cout<<"d. x%1000==0 || x%100!=0 --> "
47 <<(x%1000==0 || x%100!=0)<<endl;
48 cout<<endl;
49
50 x=x4;
51 cout<<"x = "<<x4<<endl;
52 cout<<"a. x/1000==0 && x/100!=0 --> "
53 <<(x/1000==0 && x/100!=0)<<endl;
54 cout<<"b. x/1000==0 || x/100!=0 --> "
55 <<(x/1000==0 || x/100!=0)<<endl;
56 cout<<"c. x%1000==0 && x%100!=0 --> "
57 <<(x%1000==0 && x%100!=0)<<endl;
58 cout<<"d. x%1000==0 || x%100!=0 --> "
59 <<(x%1000==0 || x%100!=0)<<endl;
60 cout<<endl;
61
62 return 0;
63 }
64 /*
65 x = 1
66 a. x/1000==0 && x/100!=0 --> 0
67 b. x/1000==0 || x/100!=0 --> 1
68 c. x%1000==0 && x%100!=0 --> 0
69 d. x%1000==0 || x%100!=0 --> 1
70
71 x = 12
72 a. x/1000==0 && x/100!=0 --> 0
73 b. x/1000==0 || x/100!=0 --> 1
74 c. x%1000==0 && x%100!=0 --> 0
75 d. x%1000==0 || x%100!=0 --> 1
76
77 x = 123
78 a. x/1000==0 && x/100!=0 --> 1
79 b. x/1000==0 || x/100!=0 --> 1
80 c. x%1000==0 && x%100!=0 --> 0
81 d. x%1000==0 || x%100!=0 --> 1
82
83 x = 1234
84 a. x/1000==0 && x/100!=0 --> 0
85 b. x/1000==0 || x/100!=0 --> 1
86 c. x%1000==0 && x%100!=0 --> 0
87 d. x%1000==0 || x%100!=0 --> 1
88 */
Trebuie să vedem care variantă are 1 pentru x=123 şi 0 pentru toate celelalte!
Prima variantă pe care o verifică este a. care are 1 pentru x=123 şi 0 pentru x=1, 0 pentru
x=12, 0 pentru x=1234.
Deci, a. este ok ... şi nu mai are rost să ”pierdem timpul” cu alte verificări!
Dar ... ı̂n examen nu avem calculator!

Verificăm două situaţii: ”x are 3 cifre” si ”x nu are trei cifre”.
Pentru ”x are trei cifre” (de exemplu x=123):
a. 123/1000==0 && 123/100!=0 0==0 && 1 != 0 1 && 1 1
b. 123/1000==0 ¶¶ 123/100 != 0 0==0 ¶¶ 1 != 0 1 ¶¶ 1 1
c. 123%1000==0 && 123%100 != 0 123==0 && 23 != 0 0 && 1 0
d. 123%1000==0 ¶¶ 123%100!=0 123==0 ¶¶ 23 != 0 0 ¶¶ 1 1
Căutăm soluţia ı̂ntre variantele care au dat 1, adică variantele a., b., şi d.. Varianta care are
zero (fals!) pentru x=1 sau x=12 sau x=1234 este soluţie (dacă este singura cu 0; dacă sunt mai
APPENDIX B. EXEMPLE PENTRU REZOLVAREA SUBIECTELOR DE BAC B.1.
SUBIECTUL I 666
multe cu 0, le eliminăm pe cele cu 1 şi verificăm, pe cele rămase, cu un alt x).

Prima variantă pe care trebuie să o verificăm este varianta a.. (ea ı̂ndeplineşte condiţia că are
valoarea 1 pentru numere cu trei cifre dar ... să vedem dacă ”ea şi numai ea”!).
Pentru ”x are patru cifre” (de exemplu x=1234):
a. 1234/1000==0 && 1234/100!=0 1==0 && 12 != 0 0 && 1 0

b. 1234/1000==0 ¶¶ 1234/100 != 0 1==0 ¶¶ 12 != 0 0 ¶¶ 1 1
d. 1234%1000==0 ¶¶ 1234%100!=0 234==0 ¶¶ 34 != 0 0 ¶¶ 1 1
A rămas numai varianta a..

Appendix C
Diagonale ı̂n matrice
C.1 Diagonale ı̂n matrice
Figura C.1: diagonale ı̂n matrice - start = 0
În figura C.1 sunt prezentate diagonale principală şi secundară ı̂mpreună cu zonele din matrice pe
care acestea le separă (indici plecând de la 0).
Figura C.2: diagonale ı̂n matrice - start = 1
În figura C.2 sunt prezentate diagonale principală şi secundară ı̂mpreună cu zonele din matrice
pe care acestea le separă (indici plecând de la 1).
667
APPENDIX C. DIAGONALE ÎN MATRICE C.2. SIMETRIC FAŢĂ DE DIAGONALE 668
C.2 Simetric faţă de diagonale

C.2.1 Simetric faţă de diagonala principală
Figura C.3: simetric faţă de diagonala principală
C.2.2 Simetric faţă de diagonala secundară
Figura C.4: simetric faţă de diagonala secundară

Appendix D
Interclasare
D.1 Interclasarea vectorilor
Figura D.1: Interclasarea vectorilor
În figura D.1 este prezentată interclasarea a doi vectori a1[ ] şi a2[ ] ı̂n vectorul a12[ ].
Vom folosi doi indici i1 (care se ”plimbă” prin vectorul a1[ ]) şi i2 (care se ”plimbă” prin vectorul
a2[ ]). La ”momentul 0” cei doi indici sunt plasaţi pe poziţia 0 (fiecare ı̂n vectorul lui!). Aceşti
doi indici pot fi priviţi ca două persoane (i1 şi i2) care parcurg fiecare câte un şir de cutii (a1[ ] şi
a2[ ]) numerotate cu 0, 1, 2, ... ı̂n care sunt obiecte care au scris preţul lor pe ele. Ambele şiruri de
cutii conţin obiecte cu valori ı̂n ordine crescătoare. Aceste obiecte trebuie mutate ı̂n şirul cutiilor
goale a12[ ] dar trebuie să rămână tot ı̂n ordine crescătoare acolo!
Cele două persoane (i1 şi i2) cunosc ı̂n orice moment care este valoarea din cutia ı̂n faţa
căreia ”aşteaptă” celălalt indice (persoană!). La momentrul 0 ı̂ncepe să ”care obiectele”, pentru
depozitare ı̂n şirul a12[ ], cel care are ı̂n cutia din faţa lui valoarea cea mai mică ... iar dacă au
valori egale ı̂ncepe i1 (sau i2 dacă vrei neapărat! ).

În exemplul nostru ı̂ncepe i1 pentru că el este ı̂n faţa cutiei cu numărul 0 care conţine un
obiect de valoare 2 ... iar celălalt are ı̂n cutia lui (tot cu numărul 0) un obiect cu valoare 4 (mai
mare decât 2). Şi i1 ı̂ncepe să care obiecte! El se opreşte ı̂n dreptul cutiei cu numărul 5 pentru că
aceasta conţine un obiect cu valoare 5 (este o pură ı̂ntâmplare că este tot 5 ...), valoare care este
mai mare decât valoarea pe care o are i2 (i2 este ı̂n aşteptare ı̂n dreptul cutiei cu numărul 0 care
are un obiect cu valoarea 4).
În acest moment i2 ı̂ncepe să care obiecte iar i1 aşteaptă ”cuminte” ı̂n dreptul cutiei cu numărul
5 ... până când i2 va da peste o cutie cu o valoare strict mai mare decât cea a lui i1.
Şi tot aşa ... ! Până sunt cărate toate cutiile!
669
Appendix E
Recursivitate
E.1 Recursivitate numai ”dus”
Listing E.1.1: recursivitate1.cpp

#include<iostream> // doar dus
void f(int n)
{
if(n<=0)
{
return;
}
cout<<n<<"d ";//dus
f(n-1);
return;
}
int main()
{
f(3);
return 0;
}
/*
3d 2d 1d
*/
Figura E.1: Recursivitate numai ”dus”
Pentru a fi pe aceeaşi pagină desenul şi descrierea celor 15 momentelor de timp (ca să se poată
face mai uşor legătura ı̂ntre ele), apare din nou figura E.1 pe pagina următoare!
670
APPENDIX E. RECURSIVITATE E.2. RECURSIVITATE NUMAI ”ÎNTORS” 671
t1: apelul iniţial din main() al funcţiei f şi transmiterea valorii 3, parametrului funţiei f
t2: executarea instrucţiunilor până la apelul recursiv (scrie pe ecran 3)
t3: apelul recursiv al funţiei f şi transmiterea valorii 2, parametrului funţiei f
t4: executarea instrucţiunilor până la apelul recursiv (scrie pe ecran, ı̂n continuare, 2; deci, pe
ecran vom vedea acum 32)
t8: se constată ”terminarea avansării ı̂n adâncime” a recursivităţii
t9: se ı̂ntoarce ı̂n locul din care a fost apelată funţia f
t10: se execută instrucţiunile de după apelul recursiv (aici nu are nimic de executat!)
t15: se ı̂ntoarce ı̂n locul din care a fost apelată funţia f (adică ı̂n main)
Şi tot aşa ... ! până ...
E.2 Recursivitate numai ”ı̂ntors”

#include<iostream> // doar intors
void f(int n)
{
if(n<=0)
{
return;
}
f(n-1);
cout<<n<<"i "; // intors
return;
}
int main()
{
f(3);
return 0;
}
/*
1i 2i 3i
*/
APPENDIX E. RECURSIVITATE E.3. RECURSIVITATE ”DUS ŞI ÎNTORS” 672
E.3 Recursivitate ”dus şi ı̂ntors”

#include<iostream> // dus si intors
void f(int n)
{
if(n<=0)
{
return;
}
cout<<n<<"d "; // dus
f(n-1);
return;
}
int main()
{
f(3);
return 0;
}
/*
3d 2d 1d 1i 2i 3i
*/
E.4 Recursivitate cu mesaj la oprire

#include<iostream> // cu mesaj la oprire
void f(int n)
{
if(n<=0)
{
cout<<n<<"o "; // oprire
return;
}
cout<<n<<"d "; // dus
f(n-1);
return;
}
int main()
{
f(3);
return 0;
}
/*
3d 2d 1d 0m 1i 2i 3i
*/
APPENDIX E. RECURSIVITATE E.4. RECURSIVITATE CU MESAJ LA OPRIRE 673
Figura E.2: Recursivitate dus-intors cu mesaj de oprire
În figura E.2 cele 15 momente de timp sunt:
t1: apelul iniţial din main() al funcţiei f şi transmiterea valorii 3, parametrului funţiei f
t2: executarea instrucţiunilor până la apelul recursiv (scrie pe ecran 3)
t8: se constată ”terminarea avansării ı̂n adâncime” a recursivităţii, dar are de scris 0 pe ecran,
deci ... ı̂n acest moment pe ecran avem scris 3210 si prompterul a rămas, pe egran, imediat
după 0 (adică acolo se va scrie la următoarea comandă de scriere!)

t10: se execută instrucţiunile de după apelul recursiv; aici are de scris valoarea parametrului n
din această instanţă a funcţiei f, adică scrie pe ecran 1 (ı̂n locul ı̂n care rămăsese prompterul
pe ecran, adică după 3210, ceea ce ı̂nseamnă că pe ecran vom avea scris, ı̂n acest moment,
32101
321012
3210123
t15: se ı̂ntoarce ı̂n locul din care a fost apelată funţia f (adică ı̂n main); pe ecran a rămas scris
3210123, care este un palindrom

Index
adrese ı̂n memorie, 304 limbaj natural, 22

algoritm echivalent, 12, 23 LLONG MAX, 269
algoritm eficient, 22, 24 LLONG MIN, 269
algoritm proiectat, 22 LONG MAX, 269
algoritmului proiectat, 24 LONG MIN, 269
arbore, 3, 20, 23, 26
arbore cu rădăcină, 18 memorează, 26
memorie utilizată, 24
ciclu eulerian, 3 memorie utilizata, 22
ciclu hamiltonian, 3 metoda backtracking, 25
cin.get, 344 muchie, 21, 23, 25, 26
CINOR, vi
climits, 269 nivel, 18
cmmdc nivelul 0, 23
scăderi succesive, 296 nod, 21, 25
comonentă tare conexă, 3 nod frunză, 23
componentă conexă, 23
o mică observaţie, 568, 576
definiţia completă a subprogramului, 24
descendent direct, 20, 23 parametrul subprogramului, 26
Descrieţi ı̂n limbaj natural, 24 partea ı̂ntreagă, 12, 21, 23
deytermină ı̂n memporie, 26 prefix, 9, 13
diagonala secundară, 25 program C/C++, 26
pseudocod, 9, 12, 21, 23
fii, 20
fiu, 23 rădăcină, 20, 23, 26
fraţi, 20, 26 restul ı̂mpărţirii, 12, 21, 23
frunză, 18, 20, 23
secvenţă de instrucţiuni, 23, 26
generare, 25 setw, 269
generarea aranjamentelor, 274 sizeof, 269
generarea combinărilor, 283, 295, 403 soluţii distincte, 20
getchar, 343 sortat topologic, 67
graf complet, 21 strchr, 20
graf eulerian, 6, 129, 131 strcpy, 20
graf neorientat, 21, 23, 25 strlen, 20
graf parţial, 3 strtok, 345
structuă repetitivă cu test final, 25
I.d.k.: structură cât timp...execută, 23
I don’t know who the author is., i, v structură repetitivă cu test final, 23
identificatorii utilizaţi, 83 structură repetitivă cu test iniţial, 21
INT MAX, 269 structura pentru...execută, 15
INT MIN, 269 structura repetă...până când, 21
iomanip, 269 structuracât timp...execută, 15, 25
subgraf, 21
justificarea eficienţei, 22 subprogram, 23
lanţ elementar, 18, 23, 25 tablou bidimensional, 24, 25

lexicografic, 26 timp de executare, 22, 24
Liceul Militar Dimitrie Cantemir, vi trage cu tunul, iv
674
INDEX INDEX 675
Universitatea Ovidius, vi vector de taţi, 18, 23

vector de frecvenţă, 152, 394 vectori de frecvenţă, 136
Bibliografie
[1] Aho, A., Hopcroft, J., Ullman, J.D.; Data strutures and algorithms, Addison Wesley, 1983
[2] Andreica M.I.; Elemente de algoritmică - probleme şi soluţii, Cibernetica MC, 2011
[3] Andonie R., Gârbacea I.; Algoritmi fundamentali, o perspectivă C++, Ed. Libris, 1995
[4] Atanasiu, A.; Concursuri de informatică. Editura Petrion, 1995
[5] Bell D., Perr M.; Java for Students, Second Edition, Prentice Hall, 1999
[6] Calude C.; Teoria algoritmilor, Ed. Universităţii Bucureşti, 1987

[7] Cerchez, E., Şerban, M.; Informatică - manual pentru clasa a X-a., Ed. Polirom, 2000
[8] Cerchez, E.; Informatică - Culegere de probleme pentru liceu, Ed. Polirom, 2002
[9] Cerchez, E., Şerban, M.; Programarea ı̂n limbajul C/C++ pentru liceu, Ed. Polirom, 2005
[10] Cori, R.; Lévy, J.J.; Algorithmes et Programmation, Polycopié, version 1.6;
http://w3.edu.polytechnique.fr/informatique/
[11] Cormen, T.H., Leiserson C.E., Rivest, R.L.; Introducere ı̂n Algoritmi, Ed Agora, 2000
[12] Cormen, T.H., Leiserson C.E., Rivest, R.L.; Pseudo-Code Language, 1994
[13] Cristea, V.; Giumale, C.; Kalisz, E.; Paunoiu, Al.; Limbajul C standard, Ed. Teora, Bucureşti,
1992
[14] Erickson J.; Combinatorial Algorithms; http://www.uiuc.edu/˜jeffe/
[15] Flanagan, D.; Java in a Nutshell, O’Reilly, 1997.
[16] Giumale C., Negreanu L., Călinoiu S.; Proiectarea şi analiza algoritmilor. Algoritmi de
sortare, Ed. All, 1997
[17] Halim S., Halim F., Competitive programming, 2013
[18] Knuth, D.E.; Arta programării calculatoarelor, vol. 1: Algoritmi fundamentali, Ed. Teora,
1999.
[19] Knuth, D.E.; Arta programarii calculatoarelor, vol. 2: Algoritmi seminumerici, Ed. Teora,
2000.
[20] Knuth, D.E.; Arta programarii calculatoarelor, vol. 3: Sortare şi căutare, Ed. Teora, 2001.
[21] Knuth, D.E.; The art of computer programming, vol. 4A: Combinatorial algorithms, Part 1,
Addison Wesley, 2011.
[22] Lambert,K. A., Osborne,M.; Java. A Framework for Programming and Problem Solving,
PWS Publishing, 1999
[23] Laaksonen A.; Guide to competitive programming, Springer, 2017
[24] Livovschi, L.; Georgescu H.; Analiza şi sinteza algoritmilor. Ed. Enciclopedică, Bucureşti,
1986.
[25] Niemeyer, P., Peck J.; Exploring Java, O’Reilly, 1997.
676
BIBLIOGRAFIE BIBLIOGRAFIE 677
[26] Odăgescu, I., Smeureanu, I., Ştefănescu, I.; Programarea avansată a calculatoarelor personale,
Ed. Militară, Bucureşti 1993
[27] Odăgescu, I.; Metode şi tehnici de programare, Ed. Computer Lobris Agora, Cluj, 1998
[28] Popescu Anastasiu, D.; Puncte de articulaţie şi punţi ı̂n grafuri, Gazeta de Informatică nr.
5/1993
[29] Răbâea, A.; https://math.univ-ovidius.ro/Doc/Admitere/CentruPregatire
/2007/Info/Lista_probleme_2000-2007.pdf
/2007/Info/Rezolvari_C09.pdf


/2007/Info/Rezolvari_Baraj.pdf
[34] Skiena S.S., Revilla M.A.; Programming challenges - The Programming Contest Training
Manual, Springer, 2003
[35] Tomescu, I.; Probleme de combinatorică şi teoria grafurilor, Editura Didactică şi Pedagogică,
Bucureşti, 1981
[36] Tomescu, I.; Leu, A.; Matematică aplicată ı̂n tehnica de calcul, Editura Didactică şi Peda-
gogică, Bucureşti, 1982
[37] Tudor, S.; Informatică - profilul real intensiv, varianta C++; Editura L&S, Bucureşti, 2004
[38] Tudor, S.; Hutanu, V,; Informatică intensiv; Editura L&S, Bucureşti, 2006
[39] Văduva, C.M.; Programarea in JAVA. Microinformatica, 1999
[40] Vişinescu, R.; Vişinescu, V.; Programare dinamică - teorie şi aplicaţii; GInfo nr. 15/4 2005
[41] Vlada, M.; Conceptul de algoritm - abordare modernă, GInfo, 13/2,3 2003
[42] Vlada, M.; Grafuri neorientate şi aplicaţii. Gazeta de Informatică, 1993
[43] Vlada, M.; Gândirea Algoritmică - O Filosofie Modernă a Matematicii şi Informaticii, CNIV-
2003, Editura Universităţii din Bucureşti, 2003
[44] Weis, M.A.; Data structures and Algorithm Analysis, Ed. The Benjamin/Cummings Pub-
lishing Company. Inc., Redwoods City, California, 1995.
[45] Winston, P.H., Narasimhan, S.; On to JAVA, Addison-Wesley, 1996
[46] Wirth N.; Algorithms + Data Structures = Programs, Prentice Hall, Inc 1976
[47] *** - Gazeta de Informatică, Editura Libris, 1991-2005
[48] *** - https://github.com/DinuCr/CS/blob/master/Info/stuff%20stuff/Re
zolvari_C09.pdf
[49] *** - https://dokumen.tips/documents/rezolvaric09.html
[50] *** - https://www.scribd.com/doc/266218102/Rezolvari-C09
[51] *** - https://www.scribd.com/document/396362669/Rezolvari-C10
[52] *** - https://www.scribd.com/document/344769195/Rezolvari-C11
[53] *** - https://www.scribd.com/document/364077679/Rezolvari-C11-pdf
[54] *** - https://needoc.net/rezolvari-c11-pdf

BIBLIOGRAFIE BIBLIOGRAFIE 678
[55] *** - https://vdocumente.com/algoritmi-i-structuri-de-date.html

[56] *** - https://pdfslide.net/documents/algoritmi-si-structuri-de-dat
e-1-note-de-cuprins-1-oji-2002-clasa-a-ix-a-1-11.html
[57] *** - https://www.infoarena.ro/ciorna
[58] *** - https://infoarena.ro/olimpici

[59] *** - https://www.infogim.ro/
[60] *** - https://www.pbinfo.ro/
[61] *** - http://www.cplusplus.com/

[62] *** - http://www.cplusplus.com/doc/tutorial/operators/
[63] *** - http://www.info1cup.com/
[64] *** - http://www.olimpiada.info/
[65] *** - http://www.usaco.org/

[66] *** - http://algopedia.ro/
[67] *** - http://campion.edu.ro/
[68] *** - http://varena.ro/
[69] *** - http://rmi.lbi.ro/rmi_2019/
[70] *** - https://codeforces.com/
[71] *** - https://cpbook.net/
[72] *** - https://csacademy.com/
[73] *** - https://gazeta.info.ro/revigoram-ginfo/
[74] *** - https://oj.uz/problems/source/22
[75] *** - https://profs.info.uaic.ro/˜infogim/2019/index.html
[76] *** - https://wandbox.org/
[77] *** - https://en.cppreference.com/w/cpp/language/operator_alternative
[78] *** - https://en.cppreference.com/w/cpp/algorithm
[79] *** - https://www.ejoi2019.si/
[80] *** - https://en.wikipedia.org/wiki/Algorithm
[81] *** - https://en.wikipedia.org/wiki/List_of_algorithms
[82] *** - https://en.wikipedia.org/wiki/List_of_data_structures
[83] *** - https://cs.pub.ro/images/NewsLabsImages/Teste-admitere-informa
tica-UPB-2020.pdf
[84] *** - https://www.viitoriolimpici.ro/
[85] *** - https://oni2023.ro/blog/
Lista autorilor
problemelor şi indicaţiilor
Constantin Tudor, vi Ion Văduva, vi

Gheorghe Dodescu, vi
679
What’s the next?
ORNL’s Frontier First to Break the Exaflop Ceiling
H T T P S :// E N . W I K I P E D I A . O R G / W I K I /F R O N T I E R _( S U P E R C O M P U T E R )#/ M E D I A /F I L E :F R O N T I E R _S U P E R C O M P U T E R _(2). J P G
Over time
the following steps
will lead you to the value
you seek for yourself
now!

cls12BAC 2023 9

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

cls12BAC 2023 9

Încărcat de

Drepturi de autor:

Formate disponibile

Informatică

**** 2023 2022 2021 2020

... draft (ciornă) ...

Adrian Răbâea, Ph.D.

https://www.scribd.com/user/552245048/Adi-Rabaea (sprijin financiar![ 19 ])

p : proiecţia canonică (se fac listele) i : injecţia canonică

liste cu elevi f¯ = predau lista şefi de echipe

Figura 2: Un desen ... i ` f¯ ` p f

I would like to dedicate this book ...

a ”to myself” ...

a to people impacted by the book

... restricţiile de memorie, din enunţurile problemelor, par ’ciudate’ acum!).

Adresele acestor cursuri:

Bistriţa, 9th September 2023 Adrian Răbâea

”I want to thank God most of all because

I thank everyone for their support 19

telefon: +40 728 zz ll aa +40 363 xx 25 xx

Studii doctorale ı̂n informatică economică - Diplomă de doctor (1997-2002):

Sanjeev Dhawan, Kulvinder Singh, Adrian Răbâea, Amit Batra;

Sanjeev Dhawan, Kulvinder Singh, Adrian Răbâea, Amit Batra;

E.M. Craciun, A. Răbâea, S. Das;

EM Craciun, A Răbâea, MF Popa, CI Mihailov;

EM Craciun, M Marin, A Răbâea;

T. Sadowski, E. M. Craciun, A. Răbâea, L. Marsavina;

E.M. Craciun, T. Sadowski, A. Răbâea;

E-M Craciun, T. Sadowski, L. Marsavina, A. Răbâea;

 Probleme de informatică date la bacalaureat

Lista tabelelor xxvi

Lista programelor xxvii

12 BAC 2012 102

13 BAC 2011 111

14 BAC 2010 119

16 BAC 2022 139

17 BAC 2021 147

19 BAC 2019 159

20 BAC 2018 164

21 BAC 2017 170

23 BAC 2015 182

24 BAC 2014 188

25 BAC 2013 194

27 BAC 2011 207

28 BAC 2010 214

III Rezolvări detaliate 221

30 BAC 2022 261

31 BAC 2021 302

32 BAC 2020 334

33 BAC 2019 366

34 BAC 2018 396

35 BAC 2017 427

36 BAC 2016 461

37 BAC 2015 489

39 BAC 2013 539

40 BAC 2012 563

41 BAC 2011 589

Appendix A ”Instalare” C++ 641

Appendix B Exemple pentru rezolvarea subiectelor de BAC 664

Appendix C Diagonale ı̂n matrice 667

Appendix D Interclasare 669

Appendix E Recursivitate 670

Lista autorilor 679

1 Descompunerea canonică a lui f . . . . . . . . . . . . . . . . . . . . . . . . . . . . i

30.1 2022bac-s0-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

31.1 2021bac-s1-I-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

Probleme de informatică date la bacalaureat

a. v=lglth; b. v=lg.plt.ph.p; c. v=p(lglth); d. v=p.lgp.ltp.h;

a. 2023/(22) b. 20/223/2 c. (2023)/2 d. (2023)/22

a. 4044/4/2 b. 4044/(42) c. 10111+1 d. 1011*(1+1)

n, prin care primeşte un număr natural (n " 2, 10 );