cls12BAC Vol1 2023 3

Informatică
Bacalaureat
specializarea matematică-informatică
2023-3
PROBLEME DE INFORMATICĂ
date la bacalaureat
la specializarea matematică-informatică
ı̂n
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!
Volumul 1
... draft (ciornă) ...
*** Nobody is perfect ***
Adrian Răbâea, Ph.D.
https://www.scribd.com/user/552245048/Adi-Rabaea
2023-3-12
Dedication
I would like to dedicate this book ...
a ”to myself” ...

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

a to my nephew Adam.
( in ascending order! )
1
https://www.femalefirst.co.uk/books/carol-lynne-fighter-1034048.html
2
https://otiliaromea.bandcamp.com/track/dor-de-el
3
https://en.wikipedia.org/wiki/To_be,_or_not_to_be
4
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!.
5
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
6 7
dificilă! :-) Vezi, de exemplu, IOI2020 şi IOI2019 , IOI2015 .
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
8
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
9
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!).

În perioada 2017-2020 cele mai puternice calculatoare din lume au fost: ı̂n noiembrie 2017
10
ı̂n China, ı̂n noiembrie 2019 ı̂n SUA şi ı̂n iunie 2020 ı̂n Japonia. În iunie 2022 ”Frontier”
5
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’ ...
6
IOI2019 şi IOI2020 au a permis utilizarea limbajelor de programare C++ şi Java
7
IOI2015 a permis utilizarea limbajelor de programare C++, Java, Pascal, Python şi Rubi (...)
8
Vezi cele 5 secunde pentru Timp maxim de executare/test din problema ”avârcolaci” - ONI2014 clasa a 11-a
9
https://en.wikipedia.org/wiki/Computer
10
https://www.top500.org/lists/top500/2022/06/
iii
11
depăşeşte pragul ”exascale”! (1.102 Exaflop/s). ”Peta” a fost depăşit ı̂n 2008, ”tera” ı̂n 1997,
12
”giga” ı̂n 1972. . Pentru ce a fost mai ı̂nainte, vezi https://en.wikipedia.org/wiki/Li
st_of_fastest_computers.
13
O mică observaţie: ı̂n 2017 a fost prima ediţie a olimpiadei EJOI ı̂n Bulgaria şi ... tot
14
ı̂n Bulgaria a fost şi prima ediţie a olimpiadei IOI ı̂n 1989. Dar ... prima ediţie a olimpiadei
15
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 ... !!!
16
”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
Adrese utile (programe şcolare):
http://programe.ise.ro/Portals/1/Curriculum/Progr_Lic/TH/Informatica_teoretic_vocatio
nal_intensiv_clasa%20a%20IX-a.pdf
nal_intensiv_clasa%20a%20X_a.pdf
nal_intensiv_clasa%20a%20XI-a.pdf
Bistriţa, 12th March 2023 Adrian Răbâea

11
https://en.wikipedia.org/wiki/Metric_prefix/
12
https://en.wikipedia.org/wiki/Computer_performance_by_orders_of_magnitude
13
https://ejoi.org/about/
14
https://stats.ioinformatics.org/olympiads/
15
https://en.wikipedia.org/wiki/International_Mathematical_Olympiad
16
https://www.facebook.com/johnwayne/photos/a.156450431041410/2645523435467418/?type=3
”Acknowledgements”
17
”I want to thank God most of all because without God I wouldn’t be able to do any of this.”
Bistriţa, 12th March 2023
Adrian R.
17
I.d.k.: ”I don’t know who the author is.”
v
Despre autor
18
nume: Răbâea Aurel-Adrian, 18.03.1953 - ...
telefon: +40 728 zz ll aa +40 363 xx 25 xx

email: adrian1803@gmail.com
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://stiinte.utcluj.ro/departamente.html
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;
19
Titlul tezei: Algoritmi paraleli şi aplicaţii pe maşini virtual paralele
20
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
21
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̆
22
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-
23
matică, Departamentul de Informatică
24
- (1992-1979) Centrul de Informatică şi organizare CINOR, Bucureşti
25
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)
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
18
https://dmi.cunbm.utcluj.ro/?page_id=2
19
http://opac.biblioteca.ase.ro/opac/bibliographic_view/149021
20
http://www.ionivan.ro/2015-PERSONALITATI/Dodescu.htm
21
http://old.fmi.unibuc.ro/ro/prezentare/promotii/promotia1978informatica_10ani/
22
https://ro.wikipedia.org/wiki/Ion_V%C4%83duva
23
https://fmi.univ-ovidius.ro/
24
https://www.cinor.ro/index.htm
25
https://www.cantemircml.ro/
vi
Cuprins
Prefaţă iii
Cuprins vii
Lista figurilor xii
Lista tabelelor xv
Lista programelor xvi
I Enunţuri 1
1 BAC 2014 2
1.1 Sesiunea specială . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.3 Subiectul al III-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Sesiunea iunie - iulie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Sesiunea de toamnă . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 BAC 2013 10
2.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 BAC 2012 18
3.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
vii
3.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4 BAC 2011 27
4.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5 BAC 2010 35
5.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
II Indicaţii de rezolvare 43
6 BAC 2014 44
6.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7 BAC 2013 50
7.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
7.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8 BAC 2012 56
8.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
8.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9 BAC 2011 63
9.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
9.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
9.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
9.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10 BAC 2010 70
10.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
10.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
III Rezolvări detaliate 77

11 BAC 2014 78
11.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
11.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
11.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
11.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
11.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
11.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
12 BAC 2013 102
12.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
12.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
12.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
12.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
12.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
12.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
13 BAC 2012 126

13.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
13.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
13.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
13.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
13.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
14 BAC 2011 152

14.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
14.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
14.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
14.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
14.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
14.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
15 BAC 2010 180

15.1.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
15.1.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
15.2.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
15.2.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
15.3.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
15.3.2 Subiectul al II-a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Appendix A ”Instalare” C++ 204
A.1 Kit OJI 2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
A.1.1 Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
A.1.2 Folder de lucru . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
A.1.3 Utilizare Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
A.1.4 Setări Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
A.1.5 Multe surse ı̂n Code Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
A.2 winlibs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
A.2.1 GCC şi MinGW-w64 pentru Windows . . . . . . . . . . . . . . . . . . . . . 214
A.2.2 PATH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
A.2.3 CodeBlocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Appendix B Exemple pentru rezolvarea subiectelor de BAC 227

B.1 Subiectul I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
B.1.1 Subiectul I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Index 230
Bibliografie 231
Lista autorilor 234

Lista figurilor
11.1 2014bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
11.2 2014bac-s1-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
11.3 2014bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
11.4 2014bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
11.5 2014bac-s1-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
11.6 2014bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
11.7 2014bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
11.8 2014bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
11.9 2014bac-s2-I-2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
11.102014bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
11.112014bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
11.122014bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
11.132014bac-s2-III-1-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
11.142014bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
11.152014bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
11.162014bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
11.172014bac-s3-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
11.182014bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
11.192014bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
11.202014bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
11.212014bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
11.222014bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
12.1 2013bac-s1-I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

12.2 2013bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
12.3 2013bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
12.4 2013bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
12.5 2013bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
12.6 2013bac-s1-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
12.7 2013bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
12.8 2013bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
12.9 2013bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
12.102013bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
12.112013bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
12.122013bac-s2-III-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
12.132013bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
12.142013bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
12.152013bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
12.162013bac-s3-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.172013bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.182013bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
12.192013bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
13.1 2012bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

13.2 2012bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
13.3 2012bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.4 2012bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.5 2012bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
13.6 2012bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
13.7 2012bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
xii
13.8 2012bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
13.9 2012bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
13.102012bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
13.112012bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
13.122012bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
13.132012bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
13.142012bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
13.152012bac-s3-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
13.162012bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
13.172012bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
13.182012bac-s3-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
13.192012bac-s3-III-3-v1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
14.1 2011bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

14.2 2011bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
14.3 2011bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
14.4 2011bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
14.5 2011bac-s1-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
14.6 2011bac-s1-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
14.7 2011bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
14.8 2011bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
14.9 2011bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
14.102011bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
14.112011bac-s2-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
14.122011bac-s2-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.132011bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
14.142011bac-s2-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
14.152011bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
14.162011bac-s3-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
14.172011bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
14.182011bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
14.192011bac-s3-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
14.202011bac-s3-III-2-v1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
14.212011bac-s3-III-2-v2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
15.1 2010bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

15.2 2010bac-s1-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
15.3 2010bac-s1-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
15.4 2010bac-s1-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
15.5 2010bac-s1-III-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
15.6 2010bac-s2-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
15.7 2010bac-s2-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
15.8 2010bac-s2-II-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
15.9 2010bac-s2-II-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
15.102010bac-s2-III-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
15.112010bac-s2-III-2-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
15.122010bac-s2-III-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
15.132010bac-s3-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
15.142010bac-s3-I-2c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
15.152010bac-s3-II-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
15.162010bac-s3-II-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
15.172010bac-s3-III-1-rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
15.182010bac-s3-III-2 backtracking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
A.1 Fişierele din Kit OJI 2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

A.2 CodeBlocks & C++ Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
A.3 Ce conţine C:¯ OJI ¯ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
A.4 Folder de lucru . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
A.5 New % Text document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
A.6 Schimbare nume fişier şi nume extensie fişier . . . . . . . . . . . . . . . . . . . . . . 207
A.7 Confirmare schimbare extensie ı̂n .cpp . . . . . . . . . . . . . . . . . . . . . . . . . 208
A.8 Pregătit pentru Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
A.9 Pregătit pentru a scrie cod de program C++ ı̂n Code::Blocks . . . . . . . . . . . . 208
A.10 Primul cod de program C++ ı̂n Code::Blocks . . . . . . . . . . . . . . . . . . . . . 209
A.11 Build - compilare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
A.12 0 error(s), 0 warning(s) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
A.13 Run - execuţie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
A.14 Executat corect: a făcut “nimic” . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
A.15 Settings % Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
A.16 Toolchain executables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
A.17 Unde sunt acele programe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
A.18 Multe surse ı̂n Code Blocks - setări . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
A.19 Multe surse in Code Blocks - exemple . . . . . . . . . . . . . . . . . . . . . . . . . 213
A.20 mingw64 pe D: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
A.21 search path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
A.22 System properties –¿ Advanced . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
A.23 Environment Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
A.24 Edit Environment Variables –¿ New . . . . . . . . . . . . . . . . . . . . . . . . . . 216
A.25 Calea şi versiunea pentru gcc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
A.26 Settings –¿ Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
A.27 Toolchain executables –¿ Auto-detect . . . . . . . . . . . . . . . . . . . . . . . . . . 218
A.28 New –¿ Text Document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
A.29 New text Document.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
A.30 Schimbare nume şi extensie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
A.31 Moore apps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
A.32 Look for another app . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
A.33 Cale pentru codeblocks.exe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
A.34 Selectare codeblocks.exe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
A.35 Editare test01.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
A.36 Compilare test01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
A.37 Mesaje după compilare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
A.38 Execuţie test01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
A.39 Rezultat execuţie test01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
A.40 Fişiere apărute după compilare! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
A.41 Creare test02.cpp gol! + ¡dublu click¿ sau ¡Enter¿ . . . . . . . . . . . . . . . . . . 224
A.42 Lista programelor de utilizat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
A.43 Selectare Code::Blocks IDE pentru fişierele .cpp . . . . . . . . . . . . . . . . . . 225
A.44 Editare+Compilare+Execuţie pentru test02 . . . . . . . . . . . . . . . . . . . . . 225
A.45 Selectare tab ce conţine test01.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Lista tabelelor
xv
Lista programelor
11.1.12014bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
11.1.22014bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
11.1.32014bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
11.1.42014bac-s1-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
11.1.52014bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
11.1.62014bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
11.1.72014bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
11.1.82014bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
11.2.12014bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
11.2.22014bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
11.2.32014bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
11.2.42014bac-s2-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
11.2.52014bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
11.2.62014bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
11.2.72014bac-s2-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
11.2.82014bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
11.2.92014bac-s2-III-4-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
11.2.10
2014bac-s2-III-4-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
11.3.12014bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
11.3.22014bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
11.3.32014bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
11.3.42014bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
11.3.52014bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11.3.62014bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11.3.72014bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
12.1.12013bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
12.1.22013bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
12.1.32013bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
12.1.42013bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
12.1.52013bac-s1-II-5 strtok.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
12.1.6***.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
12.1.72013bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
12.1.82013bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
12.2.12013bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
12.2.22013bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
12.2.32013bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
12.2.42013bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
12.2.52013bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
12.2.62013bac-s2-II-5-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
12.2.72013bac-s2-II-5-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
12.2.82013bac-s2-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
12.2.92013bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
12.2.10
2013bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
12.3.12013bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
12.3.22013bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
12.3.32013bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
12.3.42013bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.3.52013bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
12.3.62013bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
xvi
12.3.72013bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
13.1.12012bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
13.1.22012bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
13.1.32012bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
13.1.42012bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.1.52012bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
13.1.62012bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
13.1.72012bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
13.1.82012bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
13.1.92012bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
13.2.12012bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
13.2.22012bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
13.2.32012bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
13.2.42012bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
13.2.52012bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
13.2.62012bac-s2-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
13.2.72012bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
13.2.82012bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
13.3.12012bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
13.3.22012bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
13.3.32012bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
13.3.42012bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
13.3.52012bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
13.3.62012bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
13.3.72012bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
13.3.82012bac-s3-III-3-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
13.3.92012bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
14.1.12011bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
14.1.22011bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
14.1.32011bac-s1-I-2c-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
14.1.42011bac-s1-I-2c-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
14.1.52011bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
14.1.62011bac-s1-II-5-v1 pozitie substring.cpp . . . . . . . . . . . . . . . . . . . . . . . . 156
14.1.72011bac-s1-II-5-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
14.1.82011bac-s1-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
14.1.92011bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
14.1.10
2011bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
14.2.12011bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
14.2.22011bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14.2.32011bac-s2-I-2c-v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14.2.42011bac-s2-I-2c-v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
14.2.52011bac-s2-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
14.2.62011bac-s2-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
14.2.72011bac-s2-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.2.82011bac-s2-III-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
14.2.92011bac-s2-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
14.2.10
2011bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
14.3.12011bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
14.3.22011bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
14.3.32011bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
14.3.42011bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
14.3.52011bac-s3-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
14.3.62011bac-s3-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
14.3.72011bac-s3-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
14.3.82011bac-s3-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
14.3.92011bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
15.1.12010bac-s1-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
15.1.22010bac-s1-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
15.1.32010bac-s1-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
15.1.42010bac-s1-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
15.1.52010bac-s1-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
15.1.62010bac-s1-II-5.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
15.1.72010bac-s1-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
15.1.82010bac-s1-III-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
15.1.92010bac-s1-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
15.2.12010bac-s2-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
15.2.22010bac-s2-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
15.2.32010bac-s2-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
15.2.42010bac-s2-II-2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
15.2.52010bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
15.2.62010bac-s2-II-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
15.2.72010bac-s2-III-2-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
15.2.82010bac-s2-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
15.3.12010bac-s3-I-2a.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
15.3.22010bac-s3-I-2b.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
15.3.32010bac-s3-I-2c.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
15.3.42010bac-s3-II-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
15.3.52010bac-s3-II-3.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
15.3.62010bac-s3-II-5 strcpy.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
15.3.72010bac-s3-III-1-rec.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
15.3.82010bac-s3-III-3 v1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
15.3.92010bac-s3-III-3 v2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
15.3.10
2010bac-s3-III-4.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
B.1.1 2017bac-s1-I-1.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Part I
Enunţuri
1
Capitolul 1
BAC 2014
1.1 Sesiunea specială

Varianta 2
1.1.1 Subiectul I
Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare răspunsului corect.
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
Se consideră algoritmul alăturat, reprezentat ı̂n pseu-
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.
a) Scrieţi numărul afişat dacă se citeşte valoarea 162453. (6p.)
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̆
repetitivă cu test final. (6p.)
d) Scrieţi programul C/C++ corespunzător algoritmului dat.
(10p.)
1.1.2 Subiectul al II-a

Pentru fiecare dintre itemii 1 şi 2 scrieţi pe foaia de examen litera corespunzătoare
răspunsului corect.
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];
2
CAPITOLUL 1. BAC 2014 1.1. SESIUNEA SPECIALĂ 3
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
Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.
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.
Exemplu: pentru textul
pictura prin aceea arata o pace profunda
se afişează
picura prin acea arta o pace profunda (10p)
1.1.3 Subiectul al III-a
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
CAPITOLUL 1. BAC 2014 1.2. SESIUNEA IUNIE - IULIE 4
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.
Scrieţi definiţia completă a subprogramului.
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.
Exemplu: dacă fişierul bac.txt conţine numerele
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
a) Descrieţi ı̂n limbaj natural algoritmul utilizat, justificând eficienţa acestuia. (4p.)
b) Scrieţi programul C/C++ corespunzător algoritmului descris. (6p.)
1.2 Sesiunea iunie - iulie

Varianta 4
1.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.)
c) Scrieţi ı̂n pseudocod un algoritm, echivalent cu cel dat,
ı̂n care să se ı̂nlocuiască prima structură cât timp...execută
cu o structură repetitivă de alt tip. (6p.)
d) Scrieţi programul C/C++ corespunzător algoritmului
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.
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.

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.)
CAPITOLUL 1. BAC 2014 1.3. SESIUNEA DE TOAMNĂ 7
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
prin câte un spaţiu.
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
1.3 Sesiunea de toamnă

Varianta 10
1.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
Se consideră algoritmul alăturat, reprezentat ı̂n pseudocod.
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.)
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 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.
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 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
al timpului de executare.
5
100 100000 1 100000 1000 100 10
atunci pe ecran se afişează valoarea
1000
Capitolul 2
BAC 2013

Varianta 7
2.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̆
repetitivă de alt tip. (6p.)

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]
10
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.
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 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
2.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
Se consideră algoritmul alăturat, reprezentat ı̂n
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
2.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.
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 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
afişează ı̂n urma apelului de mai jos.
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.
al memoriei şi al timpului de executare.
12
3445 89312 1245 12 67120 312 1234578
atunci pe ecran se afişează 312.
Capitolul 3
BAC 2012

Varianta 3
3.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.
a) Scrieţi valoarea afişată dacă se citesc, ı̂n această
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
18
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
3.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
al timpului de executare.

Varianta 4
3.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
fiecare dintre acestea, să se afişeze valoarea 28. (4p.)

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 4
BAC 2011

Varianta 9
4.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
27
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
4.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
4.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 5
BAC 2010

Varianta 1
5.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
35
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
5.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.)
d) Scrieţi programul C/C++ corespunzător algoritmului
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
5.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
43
Capitolul 6
BAC 2014

Varianta 2
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.
a 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.
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.
6.1.1 Subiectul I
1. Răspuns corect: a 4p.

2a. Răspuns corect: 615243 6p.
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.
2.c) Pentru algoritm pseudocod corect 6p. (*) Se acordă numai 2p. dacă algoritmul are o
-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.
-corectitudine globală a algoritmului 1p. Se va puncta orice formă corectă de structură
repetitivă conform cerinţei.
2.d) Pentru program corect 10p. (*) Se acordă numai 2p. dacă doar una dintre
-declarare a tuturor variabilelor 1p. instrucţiunile de decizie este corectă.
-citire date 1p.
-afişare date 1p.
-instrucţiuni de decizie corecte (*) 3p.
-instrucţiune repetitivă corectă 2p.
-atribuiri corecte 1p.
-corectitudine globală a programului 1p.
1. Răspuns corect: d 4p.

2. Răspuns corect: c 4p.
44
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.
5. Pentru program corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect al
-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).
-declarare variabile simple, corectitu-
dine globală a programului 1p.

2. Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare valoare con-
form cerinţei.
f(5,5)=0 şi f(10,21)=28
3. Pentru subprogram corect 10p. (*) Se acordă câte 1p. pentru fiecare aspect
-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.
4a. Pentru răspuns corect 4p. (*) Se acordă punctajul chiar dacă metoda
-coerenţă a explicării metodei (*) 2p. aleasă nu este eficientă.
-explicare a unor elemente de eficienţă 2p
4b. Pentru program corect 6p. (*) 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̆ 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
6.2.1 Subiectul I

2a. Răspuns corect: 2 7 1 6p. Se acordă câte 2p. pentru fiecare valoare
menţionată corect.
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.
-instrucţiune de decizie corectă 2p.
-instrucţiuni repetitive corecte (*) 3p.

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.
-corectitudine globală a secvenţei 1p.
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,
corectitudine globală a programului 1p.
1. Răspuns corect: b 4p.

2. Răspuns corect: 6p. Se acordă câte 2p. pentru fiecare as-
(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).
3. Pentru subprogram corect 10p. (*) Se acordă câte 2p. pentru fiecare aspect al
-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-
etatea cerută (*) 6p.
-declarare a tuturor variabilelor locale,
corectitudine globală a subprogramului 1p.
-descriere coerentă a metodei (*) 2p. aleasă nu este eficientă.
-justificare a unor elemente de eficienţă 2p
ı̂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
6.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
form cerinţei (*) 5p. corectă, dar nu este echivalent cu cel dat.
- corectitudine globală a algoritmului 1p. Se va puncta orice formă corectă de structură
-declarare corectă a tuturor variabilelor 1p. instrucţiuni este corectă.
-citire corectă 1p.
-afişare corectă 1p.

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).
4a. Pentru răspuns corect 4p. (*) Se acordă punctajul chiar dacă algoritmul
-descriere coerentă a algoritmului (*) 2p. ales nu este eficient.
-justificare a unor elemente de eficienţă 2p
ı̂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 7
BAC 2013

Varianta 7
7.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 *.
2.b) Răspuns corect: 16 4p.
-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.

50
3. Pentru rezolvare corectă 6p.

-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
scrisă, conţinut a doua soluţie scrisă, ordinea
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
7.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.
-coerenţă a explicării metodei (*) 2p. aleasă nu este eficientă.
-explicare a unor elemente de eficienţă
conform cerinţei 2p
ı̂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).
-utilizare a unui algoritm eficient (***) 1p. (***) Se acordă punctajul numai pentru un
algoritm liniar (de complexitate O n), care
utilizează eficient memoria.
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
7.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
utilizează eficient memoria.
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 8
BAC 2012

Varianta 3
8.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.

56

-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

8.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
8.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.

2. Pentru răspuns corect 6p. Se acordă câte 3p. pentru fiecare valoare con-
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 9
BAC 2011

Varianta 9
9.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:
63
-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
9.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
menţionată corect.
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.
- operaţii cu fişiere: declarare, pregătire pusă nu prezintă elemente de eficienţă.
ı̂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
9.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.
4a. Pentru răspuns corect 4p. (*) Se acordă punctajul chiar dacă algoritmul
-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 10
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.
a În programele cerute, datele de intrare se consideră corecte, validarea acestora nefiind nece-
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.
10.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
70

- 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̆.
10.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̆.
10.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
77
Capitolul 11
BAC 2014

Varianta *
Filieră teoretică, ***
11.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
Figura 11.1: 2014bac-s3-I-2a
78
Listing 11.1.1: 2014bac-s3-I-2a.cpp

#include<iostream>
using namespace std;
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;
}
Listing 11.1.2: 2014bac-s3-I-2b.cpp

#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
*/
Listing 11.1.3: 2014bac-s3-I-2c.cpp

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
*/
Figura 11.2: 2014bac-s1-I-2d


Problema 1
Listing 11.1.4: 2014bac-s1-II-1.cpp

#include<iostream>
float A[3][7];
int main()
{
A[1][2]=1.2;
cout<<A[1][2]<<endl;
return 0;
}
Problema 2
Figura 11.3: 2014bac-s1-II-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";
pch=strtok(text," ");
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";
pch=strtok(NULL," ");
}
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
Figura 11.6: 2014bac-s1-III-1
Problema 2
Listing 11.1.6: 2014bac-s1-III-2-rec.cpp

#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
Listing 11.1.7: 2014bac-s1-III-3.cpp

#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>
ifstream fin("2014bac-s1-III-4-bac.txt");
int main()
{
int x; // valoare din fisier
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;
}
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).

11.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;
Figura 11.9: 2014bac-s2-I-2d

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 11.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);
cout<<"rez = "<<rez<<"\n";
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;
for(int i=2; i<=n; i++)
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
Listing 11.2.9: 2014bac-s2-III-4-v1.cpp

#include<iostream>
#include<fstream>
ifstream fin("2014bac-s2-III-4.txt");
int fr[100]; // 00 .. 99
int main()
{
int x; // nr citit din fisier
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>
ifstream fin("2014bac-s2-III-4.txt");
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;
}


11.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;
}
Figura 11.16: 2014bac-s3-I-2c

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 12
BAC 2013

Varianta 7
12.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
102
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.
Figura 12.1: 2013bac-s1-I-1
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<fstream> // ifstream("bac.txt");
#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 12.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";
pch=strtok(text," ");
while(pch != NULL)
{
if(strlen(pch) == 3)
strcat(sol,"* ");
else
{
strcat(sol,pch);
strcat(sol," ");
}
pch=strtok(NULL," ");
}
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
Listing 12.1.6: ***.cpp

#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;
for(int i=0; i<n; i++)

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
12.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
Listing 12.2.6: 2013bac-s2-II-5-v1.cpp

#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>
int f1 (int x, int y)

{
return x*y;
}
int f2 (int x, int 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
12.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++)
{
x=i; // x = copie a lui 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);
cout<<"rez = "<<rez<<endl;
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 13
BAC 2012

Varianta 3
13.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
126
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(); // citeste <Enter>
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 x; // valoare din fisier
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
*/



13.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>
ofstream fout("bac.txt");
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
13.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 13.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 14
BAC 2011

Varianta 9
14.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
*/
152

#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 14.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 14.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;
}


14.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
*/


14.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 15
BAC 2010

Varianta 1
15.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
*/
180

#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
15.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
15.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 15.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 15.18: 2010bac-s3-III-2 backtracking

Problema 3
Listing 15.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 15.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
*/

203
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.
204
APPENDIX A. ”INSTALARE” C++ A.1. KIT OJI 2017 205
Kitul Kit_OJI_2017 se instalează implicit pe C:¯OJI¯

26
t IDE-ul Code::Blocks ,
t compilatorul pentru C: gcc.exe,
27
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
26
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
27
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 214
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
28
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!).
28
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̧:
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
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 --> "
227
APPENDIX B. EXEMPLE PENTRU REZOLVAREA SUBIECTELOR DE BAC B.1.
SUBIECTUL I 228
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 229
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..

Index
CINOR, vi o mică observaţie, 131, 139

I.d.k.:
trage cu tunul, iv
I don’t know who the author is., v
Liceul Militar Dimitrie Cantemir, vi Universitatea Ovidius, vi
230
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.
231
BIBLIOGRAFIE BIBLIOGRAFIE 232
[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 233
[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
Lista autorilor
problemelor şi indicaţiilor
Constantin Tudor, vi Ion Văduva, vi

Gheorghe Dodescu, vi
234
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 Vol1 2023 3

Î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 Vol1 2023 3

Încărcat de

Drepturi de autor:

Formate disponibile

Informatică

2014 2013 2012 2011 2010

Adrian Răbâea, Ph.D.

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!).

Bistriţa, 12th March 2023 Adrian Răbâea

Bistriţa, 12th March 2023

telefon: +40 728 zz ll aa +40 363 xx 25 xx

Lista figurilor xii

Lista programelor xvi

III Rezolvări detaliate 77

13 BAC 2012 126

14 BAC 2011 152

15 BAC 2010 180

Appendix B Exemple pentru rezolvarea subiectelor de BAC 227

Lista autorilor 234

12.1 2013bac-s1-I-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

13.1 2012bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

14.1 2011bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

15.1 2010bac-s1-I-2a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

A.1 Fişierele din Kit OJI 2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

1.1 Sesiunea specială

1.1.2 Subiectul al II-a

a. A[3..7] int; b. A[3][7] float;

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

Scrieţi matricea de adiacenţă prin care poate fi reprezentat graful orientat

1.1.3 Subiectul al III-a

Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare răspunsului corect.

Utilizând metoda backtracking, se generează toate posibilităţile de a obţine suma 4 cu numere

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

Se consideră subprogramul f, definit alăturat. Scrieţi valorile

1.2 Sesiunea iunie - iulie

Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare răspunsului corect.

Valoarea expresiei C/C++ alăturate este: (4p.)

1.2.2 Subiectul al II-a

a. 1b438 b. 1bcd8 c. ba2 d. bcd

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

1.2.3 Subiectul al III-a

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

1.3 Sesiunea de toamnă

1.3.2 Subiectul al II-a

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

1.3.3 Subiectul al III-a

Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare

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

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

2.1 Sesiunea specială

a. x/100==0 && x>9 b. x/100==0 || x<100

2.1.2 Subiectul al II-a

a. a[1][3] b. a[15][15] c. a[16][24] d. a[42][59]

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

2.1.3 Subiectul al III-a

Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare răspunsului corect.

a. at\ˆat f1, c\ˆat \c si f2 b. numai f1 c. numai f2 d. nici f1, nici f2

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

 n, prin care primeşte un număr natural (2¡n¡50);

2.2 Sesiunea iunie - iulie

2.2.2 Subiectul al II-a

Scrieţi pe foaia de examen răspunsul pentru fiecare dintre cerinţele următoare.

2.2.3 Subiectul al III-a

Pentru itemul 1, scrieţi pe foaia de examen litera corespunzătoare

n, prin care primeşte un număr natural (2¡n¡50);

v, prin care primeşte un tablou unidimensional cu n elemente,

v, prin care primeşte un tablou unidimensional cu 2 n elemente, numere naturale cu cel