Subiecte Admitere Informatica UBB Cluj 2010-2019

UNIVERSITATEA BABEŞ-BOLYAI CLUJ-NAPOCA
FACULTATEA DE MATEMATICĂ ŞI INFORMATICĂ
EXAMEN DE ADMITERE – 2010

Proba scrisă la INFORMATICĂ
Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu. Timpul efectiv de lucru
este de 3 ore.
Subiectul I (30 puncte)

a) Definiţi noţiunea de tip de dată. Daţi două exemple de tipuri de date şi evidenţiaţi
diferenţele dintre tipurile respective.
b) Formulaţi problema de căutare. Descrieţi în pseudocod doi algoritmi de căutare şi
discutaţi comparativ complexitatea acestora.
c) Ce înţelegeţi prin subprogram definit de utilizator? Precizaţi deosebirea dintre
transmiterea parametrilor prin valoare şi transmiterea lor prin referinţă.
Subiectul II (30 puncte)

Se dă următorul algoritm:
Algoritm Ce_Face; Se cere:
Citeşte n (n>0, natural); a) Ce rezultate se vor afişa dacă la execuţii
S 0; repetate se citesc valorile 1 şi 10?
k 2; b) Scrieţi o secvenţă de instrucţiuni echivalentă
Câttimp k < n execută descrierii date care să utilizeze structura
Dacă n mod k = 0 atunci repetitivă Pentru în locul structurii Câttimp.
S S + k;
SfDacă; c) Daţi o variantă optimizată a algoritmului.
kk+1;
SfCâttimp;
Tipăreşte S;
SfAlgoritm
Subiectul III (30 puncte)
Se citeşte de la tastatură numărul natural n. Se cere să se scrie un program care

construieşte şi tipăreşte o matrice pătratică de ordinul n cu următoarele proprietăţi:
a) Elementele de pe diagonala principală sunt nule.
b) Elementele de pe linia i aflate sub diagonala principală au valoarea i, iar cele de
deasupra diagonalei principale au valoarea k, unde k este al i-lea număr prim.
Se vor folosi subalgoritmi pentru: verificarea dacă un număr este prim, determinarea celui
de-al m-lea număr prim şi tipărirea unei matrice.
Rezolvarea se poate formula în orice limbaj de programare învăţat în liceu.

BAREM de corectare
Oficiu = 10p
Subiectul I = 30p
a) 7p (3p definiţia, 2 x 1p exemplele, 2p diferenţa);

b) 13p (3p problema, 2 x 4p algoritmii, 2p discuţia complexităţii);
c) 10p (4p definiţia subprogramului definit de utilizator, 3p transmiterea prin
valoare, 3p transmiterea prin referinţă).
Subiectul II = 30p
a) 8p (4p pt n=1, 4p pt n=10);

b) 12p;
c) 10p.
Subiectul III = 30 p
Subalgoritmii pentru:
a. Verificarea dacă un număr este prim = 10p;
b. Determinarea celui de-al m-lea număr prim = 10p;
c. Tipărirea matricei = 3p;
Programul pentru rezolvarea problemei = 7p.
Total punctaj = 10p(oficiu) + 30p(subiectul I) + 30p(subiectul II) + 30p(subiectul III) = 100p.


Probă scrisă la INFORMATICĂ
Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu. Timpul efectiv de lucru este
de 3 ore.
a) Definiţi noţiunea de variabilă. Ce înţelegeţi prin variabilă statică şi variabilă dinamică?

Daţi exemple sugestive.
b) Descrieţi tipul tablou într-un limbaj de programare.
c) Ce înţelegeţi prin sortarea unui şir de date? Daţi exemplu de un algoritm care realizează
sortarea unui şir de date şi discutaţi complexitatea lui.
Se cere:
Citeste n; a) Ce se va afişa dacă se citesc valorile:
s 0; 5, 222, 2043, 29, 2, 20035?
Pentru i1,n executa
nr 1; b) Determinaţi un set de date de intrare astfel încât
Citeste x; valoarea afişată să fie egală cu suma numerelor
Cattimp x>9 executa citite.
nr  nr*10; c) Scrieţi o secvenţă de instrucţiuni echivalentă care
x[x/10]; să utilizeze structura repetitivă Repeta în locul
SfCattimp; structurii Câttimp.
s  s+x*nr;
SfPentru;
Tipareste s;
Se citeşte un şir X de numere naturale pozitive, citirea şirului terminându-se la introducerea

valorii 0 (Exemplu: dacă valorile introduse sunt 1, 2, 3, 0 atunci şirul citit va fi
X  ( x1  1, x 2  2, x3  3) , iar lungimea şirului citit va fi n  3 ). Să se scrie un program care
construieşte şi afişează şirul Y  ( y1 , y 2 ,... y k ) conţinând, în ordine descrescătoare, numerele
palindroame distincte din şirul X. Un număr natural se numeşte palindrom dacă citit de la stânga la
dreapta sau de la dreapta la stânga reprezintă acelaşi număr (Exemplu: 131 este palindrom, iar 12
nu este palindrom). Şirul Y se va construi direct ordonat, fără a se face ordonarea ulterioară
construcţiei.
Exemple:
 Pentru şirul X  (2,2442,2,13,131,1,313,44,677) se obţine Y  (2442,313,131,44,2,1) .
 Pentru şirul X  (21,24,623) se va tipări mesajul 'Sirul Y e vid'.
Se vor folosi subprograme pentru: citirea unui şir, determinarea cifrelor unui număr, verificarea
dacă un număr este palindrom, construirea şirului Y şi tipărirea unui şir.
Programul se poate scrie într-unul dintre limbajele studiate la liceu (Pascal, C++ etc). Folosiţi
comentarii pentru a uşura înţelegerea soluţiei date (explicarea semnificaţiei identificatorilor folosiţi,
descrierea detaliilor de implementare etc).

BAREM de corectare
Oficiu = 10p
Subiectul I = 30p
a) 10p (3p definiţia, 2p variabilă statică, 2p variabilă dinamică, 3p exemple);

b) 10p (5p definiţie, 5p discuţie tablou multidimensional);
c) 10p (3p definiţia problemei de sortare, 5p algoritm, 2p justificare complexitate).
Subiectul II = 30p
a) 10p;
b) 10p;
c) 10p.
Subiectul III = 30 p
Subprograme pentru:
a. Citire şir = 2p;
b. Determinarea cifrelor unui număr = 5p;
c. Verificare palindrom = 5p;
d. Construire şir Y ordonat = 8p
(construire şir Y neordonat + ordonare = 4p)
e. Tipărire şir = 2p;
Programul pentru rezolvarea problemei = 5p.
Stil de programare = 3p
Total punctaj = 10p(oficiu) + 30p(subiectul I) + 30p(subiectul II) + 30p(subiectul III) = 100p.

UNIVERSITATEA BABEŞ-BOLYAI
EXAMEN DE ADMITERE 2012

Toate subiectele sunt obligatorii. Se acorda 10 puncte din oficiu. Timpul efectiv de lucru este de 3 ore.
SUBIECTUL I (30 puncte)
a). Ce înţelegeţi prin căutare binară? Precizaţi deosebirea dintre căutarea secvenţială şi căutarea
binară.
b). Definiţi noţiunile de parametri formali şi parametri efectivi (actuali). Daţi exemple sugestive.
c). Ce înţelegeţi prin interclasare? Scrieţi un algoritm care interclasează două şiruri ordonate şi
discutaţi complexitatea lui.
SUBIECTUL II (30 puncte)
Citeşte n,x Se cere:
v0 a) Ce se va afişa dacă se citesc valorile? Indicaţi
i0 paşii efectuaţi pentru obţinerea rezultatului.
CâtTimp in execută 4 1 1 8 0 -4 -3
Citeşte a b) Ce se va afişa dacă se citesc valorile? Indicaţi
vv∙x+a paşii efectuaţi pentru obţinerea rezultatului.
ii+1 6 -1 -1 3 0 5 -2 4 -8
SfCâtTimp c) Determinaţi un set de date de intrare care începe cu
Tipăreşte v valoarea 3 astfel încât valoarea afişată să fie 0.
SUBIECTUL III (30 puncte)
Se citeşte un şir X  ( x1, x 2 ,...x n ) de numere naturale nenule. Să se scrie un program care
elimină din X secvenţele xi , xi 1 ,...xi l formate din numere asemenea şi formează un şir R cu numerele
distincte eliminate. Spunem ca două numere naturale sunt asemenea daca scrierile celor două numere
(în baza 10) au aceleaşi cifre (Ex.: 13133, 31 şi 3311 SUNT asemenea, iar 123 şi 6132 NU sunt
asemenea). La sfârşit se cere tipărirea sirurilor X şi R.
Exemple
 Pentru şirul X = (15, 1316, 613, 1316, 4, 58, 85, 885) se va tipări X = (15, 4) şi R = (1316, 613, 58, 85,
885)
 Pentru şirul X = (45, 4, 58, 853, 39) se va tipări X = (45, 4, 58, 853, 39) şi ‘R este şirul vid’
Se vor folosi subprograme pentru: citirea unui şir, verificarea dacă două numere sunt asemenea,
eliminarea unui subşir dintr-un şir, eliminarea secvenţelor de numere asemenea dintr-un şir,
construirea şirului R şi tipărirea unui şir precum şi alte subprograme necesare rezolvării problemei.
EXAMEN DE ADMITERE 2012

BAREM
Corectare probă scrisă INFORMATICĂ
SUBIECT I
a) 8p
b) 8p
c) 14p
SUBIECT II
a) Se afiseaza valoarea 2. 7p
b) Se afiseaza valoarea -23. 7p
c) De exemplu: 3 1 1 -1 -1 1 16p
SUBIECT III
Subprograme din care: 23p

 citirea unui şir 2p
 verificarea dacă două numere sunt asemenea 4p
 eliminarea unui subsir dintr-un sir 4p
 eliminarea secvenţelor de numere asemenea dintr-un sir 4p
 construirea şirului R 3p
 tipărirea unui şir. 2p
 alte subprograme 4p
Program principal 2p
Stil 5p
 comentarii, structurare, indentare, corectitudine
apelul corect al subprogramelor
EXAMEN ADMITERE INFORMATICĂ – iulie 2013

Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu. Timpul efectiv de lucru este de 3 ore.

a) Ce ȋnțelegeți prin complexitate a unui algoritm? Daţi cȃte un exemplu sugestiv de algoritm (ȋmpreună cu
complexitatea lui) pentru complexitate ca durată de executare (timp) şi complexitate ca spațiu de memorie
utilizat.
b) Definiți noțiunea de subprogram de tip funcție. Dați un exemplu sugestiv de definire și apel ȋntr-un limbaj de
programare.
c) Definiți șirul lui Fibonacci și scrieți un algoritm pentru determinarea elementului de pe poziția k din șirul lui
Fibonacci. Nu se vor folosi tablouri pentru memorarea elementelor șirului.

Se cere:
Citeste v; 5, 8, 24, 16, 64, 192?
Pentru i 1,n-1 executa b) Determinaţi un set de date de intrare nenule care să ȋnceapă cu
d v; valoarea 4 astfel încât valoarea afişată să fie egală cu 1002.
Citeste a; c) Determinaţi un set de date de intrare nenule care să ȋnceapă cu
Daca a≠0 atunci
valorile 3 și 25 astfel încât valoarea afişată să fie egală cu 225.
gasit fals;
Cattimp (d≤v·a) si (¬ gasit) executa
Daca ([d/a] ·a=d) si ([d/v] ·v=d) atunci
Observație. Prin „¬” s-a notat operatorul logic NOT (negația logică).
gasit adevarat
altfel
d d+1;
SfDaca;
SfCattimp;
SfDaca;
v d;
SfPentru;
Tipareste v;

Se citeşte un şir X de n numere naturale pozitive, citirea şirului terminându-se la introducerea valorii 0.
(Exemplu: dacă valorile introduse sunt 1, 2, 3, 0 atunci şirul citit va fi X = ( x1 = 1, x 2 = 2, x 3 = 3) , iar lungimea şirului
citit va fi n = 3 ), unde 1 ≤ n ≤ 500, 1 ≤ xi ≤ 10000. Să se scrie un program care construieşte și afișează şirul
Y = (( y1 , f1 ), ( y 2 , f 2 ),..., ( y k , f k )) unde
y1 , y 2 ,... y k reprezintă, în ordine crescătoare, numerele distincte din șirul X cu proprietatea că suma cifrelor
fiecărui număr y i ( ∀i, 1 ≤ i ≤ k ) este un număr prim.
f i ( ∀i, 1 ≤ i ≤ k ) reprezintă numărul de apariții a valorii y i ȋn șirul X.
Şirul Y se va construi direct ordonat (după valorile y i ), fără a se face ordonarea după construcţie.
Se vor scrie:
a). Subprogram pentru citirea unui şir.
b). Subprogram pentru verificarea dacă un număr este prim.
c). Subprogram pentru determinarea sumei cifrelor unui număr.
d). Subprogram pentru inserarea ȋn șirul Y a unei valori cu proprietatea cerută.
e). Subprogram pentru construirea şirului Y.
f). Subprogram pentru tipărirea unui şir.
g). Programul principal.
Exemple:
− Pentru şirul X = (142, 13, 89, 21, 91, 11, 8, 142, 21) se obţine Y = ((11, 1), (21, 2), (89, 1), (142, 2)).
− Pentru şirul X = (6, 15, 103) se va tipări mesajul 'Sirul Y este vid'.
Programul se poate scrie într-unul dintre limbajele studiate la liceu (Pascal, C++ etc). Folosiţi comentarii pentru a
uşura înţelegerea soluţiei date (explicarea semnificaţiei identificatorilor folosiţi, descrierea detaliilor de
implementare etc).
EXAMEN ADMITERE – iulie 2013

INFORMATICĂ
BAREM
Corectare INFORMATICĂ
SUBIECT I
a) 8p din care
- complexitate durata de executare 2p
- complexitate spațiu de memorare 2p
- fiecare exemplu 2p
b) 10p din care
- noțiunea de subprogram de tip funcție 5p
- exemplu definire 3p
- exemplu apel 2p
c) 12p din care
– definire șir Fibonacci 3p
– algoritm 9p
(pentru soluție cu tablou se acordă maxim 4p)
SUBIECT II
a) Se afiseaza valoarea 192. 4p

justificare 4p
b) 4 1002 1002 1002 1002 6p
justificare 5p
c) 3 25 9 15 6p
justificare 5p
SUBIECT III
a). Subprogram pentru citirea unui şir 3p

b). Subprogram pentru verificarea dacă un număr este prim 4p
c). Subprogram pentru determinarea sumei cifrelor unui număr 4p
d). Subprogram pentru inserarea ȋn șirul Y a unei valori cu proprietatea cerută 6p
e). Subprogram pentru construirea şirului Y 3p
f). Subprogram pentru tipărirea unui şir 3p
g). Program principal 2p
Stil 5p
− comentarii, structurare, indentare, folosirea subprogramelor,
apelul corect al subprogramelor, comunicarea ȋntre subprograme și programul apelant
prin parametri.
Comisia de admitere
EXAMEN ADMITERE – septembrie 2013

INFORMATICĂ
Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu. Timpul efectiv de lucru este de 3 ore.

a). Ce ȋnțelegeți prin noțiunea de variabilă și noțiunea de constantă ȋn programare? Explicați deosebirile
dintre ele și dați cȃte un exemplu de definire a unei variabile și a unei constante ȋntr-un limbaj de
programare.
b). Ce înţelegeţi prin metoda de ordonare prin inserție a unui șir de numere? Scrieți algoritmul pentru
ordonarea prin inserție a unui șir de numere. Se poate folosi la alegere unul dintre limbajele:
Pseudocod, Pascal, C++.
c). Algoritmul lui Euclid. Descrieți ideea acestuia, scrieți algoritmul și dați un exemplu de aplicare. Se
poate folosi la alegere unul dintre limbajele: Pseudocod, Pascal, C++.

Se cere:
Citeste v; 5, 8, 24, 9, 64, 83?
s 0;
Pentru i 1,n-1 executa Justificați răspunsul.
Citeste a; b) Determinaţi un set de date de intrare care să ȋnceapă cu
x a·v; valoarea 4 astfel încât valoarea afişată să fie egală cu 24.
Cattimp x>9 executa Justificați.
x [x/10]; c) Determinaţi un set de date de intrare care să ȋnceapă cu
SfCattimp; valoarile 3 52 astfel încât valoarea afişată să fie egală cu
s s+x; 5. Justificați.
v a;
SfPentru Notă. Prin [x] s-a notat partea ȋntreagă a lui x.
Tipareste s;
Se citeşte un şir X de numere naturale cu n elemente (1 ≤ n ≤ 500, 1 ≤ Xi ≤ 1000). Scrieţi un program care
determină şirul Y de numere prime distincte, care figurează la puterea întâi în cel puţin o descompunere ȋn factori
primi a unui număr din șirul X. Dacă nici un element al şirului X nu are un factor prim la puterea întâi, atunci se va
tipări mesajul ´Sirul Y e vid.´
Se vor scrie subprograme pentru:

a). citirea unui şir de numere naturale
b). tipărirea unui şir
c). generarea tuturor numerelor prime mai mici sau egale decât un număr dat SAU verificarea dacă un număr
este prim (ȋn funcție de modalitatea de rezolvare aleasă)
d). verificarea dacă un număr figurează la puterea întâi în descompunerea unui număr dat
e). construirea șirului Y.
Exemple:
n=4 n =4 n=4
X = (77, 58, 77, 31) X = (64, 36, 100, 125) X = (5, 25, 125, 625)
Y = (2, 7, 11, 29, 31) Sirul Y e vid. Y = (5)
EXAMEN ADMITERE INFORMATICĂ – septembrie 2013
BAREM
Corectare INFORMATICĂ
SUBIECT I
a) 8p din care
– noțiunea de constantă 2p
– noțiunea de variabilă 2p
– deosebiri 1p
– exemplu constantă 1.5p
– exemplu variabilă 1.5p
b) 11p din care
– explicarea metodei de ordonare prin inserție 3p
– algoritm 8p
c) 11p din care
− descrierea ideii 2p
− algoritm 7p
− exemplu 2p
SUBIECT II
a) - Se afiseaza valoarea 13. 4p

- justificare 4p
b) – de ex. 4 9 9 9 9 6p
- justificare 5p
c) – de ex. 3 52 6 39 6p
- justificare 5p
SUBIECT III
Subprograme: 22p
a). citirea unui şir 2p
b). generarea tuturor numerelor prime mai mici sau egale decât un număr dat
SAU
verificarea dacă un număr este prim 5p
c). verificarea dacă un număr figurează la puterea întâi în descompunerea
unui număr dat 5p
d). construirea șirului Y 8p
e). tipărirea şirului (inclusiv mesajul pentru şirul vid) 2p
Stil 5p
− comentarii, structurare, indentare, folosirea subprogramelor,
apelul corect al subprogramelor, comunicarea ȋntre subprograme și programul apelant
prin parametri.
Comisia de admitere
UNIVERSITATEA BABEȘ-BOLYAI CLUJ-NAPOCA
FACULTATEA DE MATEMATICĂ ȘI INFORMATICĂ
Concursul de admitere (nivel licență) - sesiunea iulie 2015

Proba scrisă la Informatică
VARIANTA 2
a) Să se scrie o funcție care are ca parametri două numere naturale m și n și o matrice A(m, n) avȃnd
elemente numere ȋntregi și returnează numărul de elemente „șa” din matrice. Un element A(i, j ) din
matrice se numește element „șa” dacă este maximul de pe coloana j si minimul de pe linia i sau invers.
Spre exemplu, pentru m=2 și n=6 și
 5 2 8 4 9 3
A   
 7 1 6 3 8 5
se va returna valoarea 2 (elementele „șa” sunt a12 și a 25 ).
b) Să se scrie o funcție care are ca parametru un număr natural n și returnează cel mai mare număr care
poate fi obținut mutȃnd, pe rȃnd, prima cifră a numărului n și a celor obținute pe parcurs, pe ultima
poziție. Nu se vor folosi șiruri de caractere și tablouri auxiliare. Spre exemplu, pentru n=4273 funcția va
returna valoarea 7342 (este cel mai mare număr dintre 2734, 7342, 3427, 4273).
c) Să se scrie două variante de implementare pentru o funcție care are ca parametri un număr natural n, un
șir crescător X de numere reale avȃnd n elemente și un număr natural v și care returnează poziția pe care
apare ȋn șir valoarea v. Ȋn cazul ȋn care v nu apare ȋn șir, se va returna valoarea -1. În cazul în care v
apare în șir pe mai multe poziții, se va returna una dintre acestea.
c1. Soluție iterativă.
c2. Soluție recursivă.
Se dă următoarea funcție care are ca parametri un număr natural n (n<100) un număr natural k (k<n) și
returnează o valoare naturală.
Funcția F(n, k) este Se cere:
Dacă (n<k) atunci a) Care va fi valoarea F(98, 1)? Justificați răspunsul.
returnează 0; b) Precizați valori pentru n și k astfel ȋncȃt F(n, k) să fie 2850.
altfel Justificați alegerea.
returnează n+F(n-1, k); c) Precizați care este efectul funcției.
SfDacă.
SfFuncție
Se citeşte o matrice A  (aij )1in,1 j m de numere naturale nenule, unde 1 ≤ n,m ≤ 100, 1 ≤ aij ≤ 30000. Să se
scrie un program care construiește șirul X  ( x1 , x2 ,..., xnm ) conținȃnd elementele matricei A ȋn următoarea
ordine: elementele de pe coloana 1, apoi de pe coloana 2,..., coloana m (de pe fiecare coloană elementele se
consideră ȋn ordinea crescătoare a liniilor). După construirea șirului X, se va afişa cea mai lungă secvență
xi , xi 1 ,...,xi  p din șirul X avȃnd proprietatea că suma oricăror două numere situate pe poziții consecutive ȋn
secvență este număr „magic”. Un număr se numește „magic” dacă toate sufixele lui (inclusiv numărul) și prima
sa cifră sunt numere prime (293 nu e „magic” deoarece 93 e divizibil cu 3, dar 283 e „magic” deoarece 283,
sufixele lui 83, 3 şi prima sa cifră 2 sunt numere prime).
Exemple:
 Pentru n=2, m=2 și matricea

4 8 
A   
 6 10
se va obține şirul X  (4,6,8,10) și se va tipări mesajul 'Nu există secvență'.

 Pentru n=2, m=3 și matricea
6 2 2 
A   
 3 11 21
Se va obține şirul X  (6,3,2,11,2,21) și se va tipări '3 2' sau ' 2 21'.

a). citirea unei matrice
b). construirea șirului X din matricea A avȃnd n linii și m coloane
c). verificarea dacă un număr este prim
d). verificarea dacă un număr este „magic”
e). determinarea secvenței de lungime maximă xi , xi 1 ,...,xi  p care ȋncepe pe poziția i și satisface
proprietatea cerută (suma oricăror două numere situate pe poziții consecutive ȋn secvență este număr
„magic”)
f). determinarea unei secvențe de lungime maximă din șirul X avȃnd proprietatea cerută
g). tipărirea unei secvențe xi , xi 1 ,...,xi  p .
Programul se poate scrie într-unul dintre limbajele studiate la liceu (Pascal, C++). Folosiţi comentarii pentru
a uşura înţelegerea soluţiei date (explicarea semnificaţiei identificatorilor folosiţi, descrierea detaliilor de
implementare etc). Nu se vor folosi funcții sau biblioteci predefinite (de ex. STL, funcţii predefinite pe şiruri
de caractere, etc).
Notă: Toate subiectele sunt obligatorii. Rezolvările trebuie scrise detaliat pe foile de concurs (ciornele nu se iau
ȋn considerare). Se acordă 10 puncte din oficiu. Timpul efectiv de lucru este de 3 ore.

BAREM
SUBIECT I
b) 10p
- signatura corectă 2p
- implementare 8p
b) 12p
- implementare 10p
c) 13p
- implementarea c1 6p
SUBIECT II
a) - Se returnează valoarea 4851 3p

- Justificare 3p
b) – de ex. n=75 și k=1 5p
- Justificare 4p
n
c) Efect – se calculează suma i
ik
5p
SUBIECT III
Subprograme: 28p
a). citirea unui şir 1p
b). construirea șirului X din matricea A avȃnd n linii și m coloane 5p
c). verificarea dacă un număr este prim 3p
d). verificarea dacă un număr este „magic” 8p
e). determinarea secvenței de lungime maximă xi , xi 1 ,...xi  p care ȋncepe pe poziția i 5p
f). determinarea unei secvențe de lungime maximă din șirul X avȃnd proprietatea cerută 5p
g). tipărirea unei secvențe xi , xi 1 ,...xi  p . 1p
Stil 5p
 comentarii, indentare, folosirea subprogramelor, apelul corect al subprogramelor,
comunicarea ȋntre subprograme și programul apelant prin parametri.
Comisia de concurs
UNIVERSITATEA BABEȘ-BOLYAI CLUJ-NAPOCA
FACULTATEA DE MATEMATICĂ ȘI INFORMATICĂ
Concursul de admitere (nivel licență) - sesiunea septembrie 2015

VARIANTA 1
a) Un număr natural n se numește deosebit dacă există un număr natural m astfel ȋncȃt n  m  S (m) unde
S (m) este suma cifrelor lui m. Spre exemplu, n=15 este număr deosebit (m=12 și 15=12+3). Să se scrie
o funcție care are ca parametru un număr natural n și returnează adevărat sau fals, după cum n este sau
nu deosebit.
b) Să se scrie o funcție care are ca parametru un număr natural n și verifică dacă n are cel puțin un factor
prim care apare la o putere pară ȋn descompunerea sa ȋn factori primi. Spre exemplu, pentru n=12
condiția este verificată, deoarece 2 apare la puterea a 2-a ȋn descompunerea lui n ȋn factori primi. Pentru
n=6 condiția nu este verificată.
c) Să se scrie două variante de implementare pentru o funcție care are ca parametri un număr natural n, un
șir X de numere întregi avȃnd n elemente și verifică dacă elementele șirului X sunt distincte.
c1. Soluție iterativă.
c2. Soluție recursivă.
Nu se vor folosi funcții predefinite (de ex. funcţii predefinite pe şiruri de caractere, etc).
Se cere:
Citeste n; a) Care este valoarea afișată de algoritm dacă numărul n citit este
x1; 91? Justificați răspunsul.
yn/2; b) Precizați o valoare naturală nenulă pentru n astfel ȋncȃt valoarea
Cat timp x 0 și y>0 executa
tipărită să fie 11. Justificați alegerea.
zn;
Cat timp zy executa c) Precizați care este efectul funcției ȋn condițiile ȋn care numărul
z z-y; n citit este natural nenul.
.
SfCatTimp
xz;
y y-1;
SfCatTimp
y y+1;
Tipareste y;
Se citeşte un șir X  ( x1 , x2 ,..., xn ) de numere naturale nenule, unde 1 ≤ n ≤ 200, 1 ≤ xi ≤ 30000. Un element xi
situat ȋn șir pe poziția i (1 ≤ i ≤ n-1) se numește perfect dacă are cel puțin o cifră comună cu toate elementele
situate ȋn șir după el, xi 1 , xi 2 ,..., xn . Să se scrie un program care inserează ȋn șirul X, după fiecare element care
este perfect, divizorii săi proprii (divizorii se vor considera ȋn ordine descrescătoare). După modificarea șirului
X, se va construi șirul O  (o1 , o2 ,...,ok ) conținȃnd ordinea ȋn care ar trebui afișate elementele șirului X pentru a
fi ȋn ordine descrescătoare. La final, se va tipări șirul X ȋn ordinea dată de O.
Notă. Nu se va face ordonarea șirului X.
Exemple:
 Pentru n=4 și X  (24,5,8,218)
se vor construi
X = (24, 5, 8, 4, 2, 218)
O  (6,1,3,2,4,5)
și se va afișa 218,24,8,5,4,2
 Pentru n=5 și X  (24,5,4,42,6)
se vor construi
X = (24, 5, 4, 42, 6)
O  (4,1,5,2,3)
și se va afișa 42,24,6,5,4

a). citirea unui șir
b). verificarea dacă două numere au cel puțin o cifră comună
c). verificarea dacă un element xi este perfect
d). inserarea unei valori v pe o poziție dată ȋn șirul X
e). adăugarea ȋn șirul X, după fiecare element perfect, a divizorilor săi proprii.
f). determinarea șirului O corespunzător șirului X
g). tipărirea unui șir X ȋn ordinea dată de O
Programul se poate scrie într-unul dintre limbajele studiate la liceu (Pascal, C++). Folosiţi comentarii pentru
a uşura înţelegerea soluţiei date (explicarea semnificaţiei identificatorilor folosiţi, descrierea detaliilor de
implementare etc). Nu se vor folosi funcții sau biblioteci predefinite (de ex. STL, funcţii predefinite pe şiruri
de caractere, etc).
Notă: Toate subiectele sunt obligatorii. Rezolvările trebuie scrise detaliat pe foile de concurs (ciornele nu se iau
ȋn considerare). Se acordă 10 puncte din oficiu. Timpul efectiv de lucru este de 3 ore.

BAREM
SUBIECT I
b) 8p
- implementare 6p
b) 12p
- implementare 10p
c) 15p
SUBIECT II
a) - Se returnează valoarea 13 3p
- Justificare 3p
b) – de ex. n=33 5p
- Justificare 4p
c) Efect – se tipărește cel mai mare divizor i (in) al lui n 5p
SUBIECT III
Subprograme: 28p
a). citirea unui șir 1p
b). verificarea dacă două numere au ce puțin o cifră comună 2p
c). verificarea dacă un element xi este perfect 6p
d). inserarea unei valori v pe o poziție dată ȋn șirul X 4p
e). adăugarea ȋn șirul X, după fiecare element perfect, a divizorilor săi proprii 6p
f). determinarea șirului O corespunzător șirului X 6p
g). tipărirea unui șir X ȋn ordinea dată de O 3p
Stil 5p
 comentarii, indentare, folosirea subprogramelor, apelul corect al subprogramelor,
comunicarea ȋntre subprograme și programul apelant prin parametri.
Comisia de concurs
Concurs de admitere (nivel licență) - sesiunea iulie 2016

VARIANTA I
În atenția concurenților:
1. Rezolvările se vor scrie în pseudocod sau într-un limbaj de programare (Pascal/C/C++).
2. Primul criteriu în evaluarea rezolvărilor va fi corectitudinea algoritmului, iar apoi performanța din
punct de vedere al timpului de executare și al spațiului de memorie utilizat.
3. Este necesară folosirea comentariilor pentru a uşura înţelegerea rezolvării date (se va explica
semnificaţia identificatorilor și se vor descrie ideile principale pe care se bazează rezolvarea).
4. Nu se vor folosi funcții sau biblioteci predefinite (de exemplu: STL, funcţii predefinite pe şiruri de
caractere etc.).

1. Turnuri (10 puncte)
Se consideră un număr suficient de mare de monede de dimensiuni
egale pentru a construi din ele turnuri pe baza următoarelor reguli:
R1. cel mai înalt turn are înălțimea de n monede (0 < n ≤ 13), cel mai mic are înălțimea 1 (o monedă);
R2. turnurile se așează unul lângă altul, astfel încât între oricare două turnuri de aceeași înălțime să existe
cel puțin un turn mai înalt decât acestea două.
Scrieți un subalgoritm care calculează numărul maxim de turnuri (nrTurnuri) care se pot construi respectând
regulile date, precum și numărul de monede (nrMonede) necesare construcției. Înălțimea n a celui mai înalt
turn este parametru de intrare al subalgoritmului, iar nrTurnuri și nrMonede vor fi parametri de ieșire.
Exemplu: dacă n = 3, atunci nrTurnuri = 7 și nrMonede = 11.
2. Numere magice (20 puncte)

Se consideră două numere naturale p și q (2 ≤ p ≤ 10, 2 ≤ q ≤ 10). Un număr natural se numește magic
dacă mulțimea cifrelor utilizate în scrierea lui în sistemul de numeraţie având baza p este identică cu
mulțimea cifrelor folosite în scrierea lui în sistemul de numeraţie având baza q. De exemplu, pentru p = 9
și q = 7, (31)10 este număr magic pentru că (34)9 = (43)7, iar pentru p = 3 și q = 9, (9)10 este număr magic
pentru că (100)3 = (10)9.
Scrieți un subalgoritm care, pentru două baze p și q date determină șirul x al tuturor numerelor magice strict
mai mari ca 0 și strict mai mici decât un număr natural n dat (1 < n ≤ 10 000). Parametrii de intrare ai
subalgoritmului sunt p și q (cele două baze) și valoarea n. Parametrii de ieșire vor fi șirul x și lungimea k a
șirului x.
Exemplu: dacă p = 9, q = 7 și n = 500, șirul x va avea k = 11 elemente: (1, 2, 3, 4, 5, 6, 31, 99, 198, 248, 297).
3. Inserare (20 puncte)

Fie a un șir cu n (0 < n ≤ 10 000) numere naturale strict pozitive strict mai mici decât 30 000.
Scrieți un subalgoritm care inserează după fiecare element al șirului un nou număr care reprezintă cea mai
mare valoare mai mică sau egală cu acel element și care este o putere a lui 2. Șirul a și valoarea lui n sunt
atât parametri de intrare, cât și de ieșire pentru subalgoritm.
Exemplu: dacă n = 4 și a = (3, 1, 24, 9), atunci a va deveni (3, 2, 1, 1, 24, 16, 9, 8), iar n = 8.
Se dă următorul subalgoritm care are ca parametri de intrare două numere naturale a și b (0 < a ≤ 10 000,
0 ≤ b ≤ 10 000).
Subalgoritm F(a, b):
c  1
CâtTimp b > 0 execută
Dacă b mod 2 = 1 atunci { mod calculează restul împărțirii întregi a lui b la 2 }
c  (c * a) mod 10
SfDacă
a  (a * a) mod 10
b  b div 2 { div calculează câtul împărțirii întregi a lui b la 2 }
SfCâtTimp
returnează c
SfSubalgoritm
a. Enunțați problema pe care o rezolvă subalgoritmul dat.

b. Ce valoare returnează apelul F(1002,6)?
c. Scrieți o variantă recursivă a subalgoritmului, respectând antetul subalgoritmului din varianta iterativă (ne-
recursivă) de mai sus.
Insule
O companie aeriană a pus la dispoziția călătorilor șirul altitudinilor punctelor geografice deasupra cărora
se va călători cu avionul de la Cluj-Napoca la New York. Șirul a are n (3 ≤ n ≤ 10 000) elemente numere
naturale strict mai mici decât 30 000, unde corespunzător punctelor de pe uscat altitudinile sunt numere
nenule, iar corespunzător oceanului altitudinile sunt egale cu 0. Numim insulă o secvență de puncte de pe
uscat mărginită de apă.
Scrieți un program care:
1. Determină și afișează numărul de ordine al punctului unde începe și numărul de ordine al punctului
unde se termină cea mai lungă insulă. Dacă există mai multe soluții, se va determina o singură
soluție. Dacă nu există nicio insulă, atunci se va afișa mesajul „Nu există insule”.
2. Stabilește dacă cea mai lungă insulă este de tip munte sau nu și afișează mesajul „Este munte”,
respectiv „Nu este munte”. O insulă se consideră de tip munte, dacă altitudinile corespunzătoare ei
formează un șir nevid strict crescător până la un moment dat, apoi formează un șir nevid strict
descrescător.
3. Verifică dacă altitudinile corespunzătoare punctelor de pe uscat sunt distincte (două câte două) sau
nu și afișează mesajul ”Altitudinile sunt distincte”, respectiv „Altitudinile nu sunt distincte”.
4. Dacă răspunsul la punctul 3 este „nu”, determină și afișează valoarea celei mai frecvente altitudini și
numărul aparițiilor acesteia. Dacă există mai multe soluții, se va determina o singură soluție.
Exemplul 1: dacă n = 15 și a = (10, 2, 1, 0, 7, 0, 1, 2, 13, 5, 0, 0, 8, 5, 2), există 2 insule, iar insula cea mai
lungă se află între altitudinile cu numerele de ordine 7 și 10. Insula cea mai lungă este de tip munte.
Altitudinile nu au valori distincte, iar altitudinea cea mai frecventă are valoarea 2 și apare de 3 ori.
Exemplul 2: dacă n = 10 și a = (1, 2, 0, 1, 2, 13, 0, 0, 1, 2), există o singură insulă care se află între
altitudinile cu numerele de ordine 4 și 6 și nu este de tip munte. Altitudinile nu au valori distincte, iar una
dintre cele mai frecvente altitudini are valoarea 1 și apare de 3 ori.
Observație: În exemple indexarea șirului a începe de la 1.
Scrieți subprograme pentru:
a. a citi șirul a și lungimea lui de la tastatură;
b. a determina numărul de ordine al punctului unde începe și a numărul de ordine al punctului unde se
termină cea mai lungă insulă;
c. a stabili proprietatea unei insule de a fi de tip munte;
d. a verifica dacă altitudinile corespunzătoare uscatului sunt distincte (două câte două) sau nu;
e. a determina cea mai frecventă altitudine de pe uscat și numărul de apariții ale acesteia.
Notă:
1. Toate subiectele sunt obligatorii.
2. Rezolvările trebuie scrise detaliat pe foile de examen (ciornele nu se iau în considerare).
3. Se acordă 10 puncte din oficiu.
4. Timpul efectiv de lucru este de 3 ore.
BAREM – VARIANTA I
OFICIU............................................................................................................................................... 10 puncte
SUBIECTUL I ................................................................................................................................... 50 puncte
1. Turnuri ........................................................................................................................................... 10 puncte
 determinarea corectă a valorilor nrTurnuri și nrMonede
• fără a recalcula la fiecare pas puterile lui 2.................................................................. 10 puncte
 nrTurnuri (5 puncte)
 nrMonede (5 puncte)
• cu recalcularea la fiecare pas a puterilor lui 2................................................................ 6 puncte
 nrTurnuri (3 puncte)
 nrMonede (3 puncte)
2. Numere magice .............................................................................................................................. 20 puncte
 verificarea proprietății de număr magic
• pe baza identității vectorilor caracteristici ai mulţimilor de cifre ale numărului dat în cele
două reprezentări (în baza p și, respectiv, baza q) ...................................................... 15 puncte
 determinarea vectorului caracteristic (9 puncte)
 verificarea identității vectorilor caracteristici (6 puncte)
• alte variante de algoritm corect cu performanță mai redusă ............................ maxim 10 puncte
 construirea șirului x ...................................................................................................................... 5 puncte
3. Inserare........................................................................................................................................... 20 puncte
 calcularea celei mai mari puteri a lui 2 mai mică sau egală cu un număr dat .............................. 8 puncte
 inserarea elementelor
 cu o singură parcurgere a șirului a, fără a folosi alte șiruri .......................................... 12 puncte
 alte variante de algoritm corect cu performanță mai redusă ............................. maxim 7 puncte
SUBIECTUL II .................................................................................................................................. 15 puncte
Ultima cifră a lui ab
Cerința a - enunțul problemei................................................................................................................ 5 puncte
Cerința b - rezultatul calculat corect (F(1002,6)= 4) ......................................................................... 3 puncte
Cerința c
 condiția de oprire din recursivitate ............................................................................................... 2 puncte
 autoapelul corect .......................................................................................................................... 2 puncte
 algoritmul .................................................................................................................................... 3 puncte
SUBIECTUL III ................................................................................................................................ 25 puncte
Insule
Subprograme:
 citirea datelor .................................................................................................................................. 1 punct
 determinarea poziției de început și de terminare a celei mai lungi insule
• cu o singură parcurgere a elementelor șirului ............................................................... 5 puncte
• alte variante de algoritm corect cu performanță mai redusă ............................. maxim 3 puncte
 stabilirea proprietății unei insule de a fi de tip munte .................................................................. 3 puncte
 verificarea dacă altitudinile de pe uscat sunt distincte sau nu ..................................................... 3 puncte
 determinarea celei mai frecvente altitudini de pe uscat și
a numărului de apariții ale acesteia ............................................................................................. 3 puncte
Program principal:
 structura logică ............................................................................................................................... 1 punct
 afișarea rezultatelor ........................................................................................................................ 1 punct
 comunicarea prin parametri
(signatura subalgorimilor și apelul corect, câte 1 punct pentru fiecare subalgoritm) ............. 5 puncte
Lizibilitate:
 comentariile .................................................................................................................................... 1 punct
 indentarea ....................................................................................................................................... 1 punct
 denumirile sugestive....................................................................................................................... 1 punct
Concursul de admitere (nivel licență) - iulie 2017
VARIANTA II
1. Rezolvările se vor scrie în pseudocod sau într-un limbaj de programare (Pascal/C/C++).
2. Primul criteriu în evaluarea rezolvărilor va fi corectitudinea algoritmului, iar apoi performanța din punct de
vedere al timpului de executare și al spațiului de memorie utilizat.
3. Este obligatorie descrierea și justificarea (sub) algoritmilor înaintea rezolvărilor. Se vor scrie, de asemenea,
comentarii pentru a uşura înţelegerea detaliilor tehnice ale soluției date, a semnificaţiei identificatorilor, a
structurilor de date folosite etc. Neîndeplinirea acestor cerințe duce la pierderea a 10% din punctajul aferent
subiectului.
4. Nu se vor folosi funcții sau biblioteci predefinite (de exemplu: STL, funcţii predefinite pe şiruri de caractere).

1. Degustare de ciocolată (20 puncte)
O companie de publicitate face reclamă la un nou sortiment de ciocolată și intenționează să distribuie mostre de
ciocolată la n (10 ≤ n ≤ 10 000 000) copii care sunt așezați într-un cerc. Angajații companiei își dau seama că
distribuirea de mostre tuturor copiilor ar costa foarte mult. În consecință, decid să distribuie mostre fiecărui al k-
lea (0 < k < n) copil din cei n, numărând copiii din k în k (atunci când numărătoarea ajunge la ultimul copil, ea
continuă cu primul copil și așa mai departe). În numărătoare se vor considera toți copiii, fie că au primit sau nu
ciocolată. Numărătoarea se oprește atunci când o ciocolată ar trebui distribuită unui copil care deja a primit.
Scrieți un subalgoritm care determină numărul copiilor (nr) care nu primesc mostre de ciocolată. Parametrii de
intrare sunt numerele naturale n și k, iar parametrul de ieșire va fi numărul natural nr.
Exemplu 1: dacă n = 12 și k = 9, atunci nr = 8 (primul, al 2-lea, al 4-lea, al 5-lea, al 7-lea, al 8-lea, al 10-lea, al 11-
lea copil nu primesc ciocolată).
Exemplu 2: dacă n = 15 și k = 7, atunci nr = 0 (toți copiii primesc ciocolată).
2. Reducere (15 puncte)
Se consideră șirurile a și b cu n (1 ≤ n ≤ 10 000), respectiv m (1 ≤ m ≤ 10 000) elemente numere naturale
mai mici decât 30 000. O subsecvență a unui șir este formată din elemente ale șirului aflate pe poziţii
consecutive în șirul dat. Spunem că șirul a „se poate reduce” la șirul b dacă există o împărţire a șirului a în
subsecvenţe disjuncte astfel încât:
 prin concatenare, în ordine, a tuturor subsecvențelor se obține șirul a;
 prin înlocuiri, în ordine, a tuturor subsecvenţelor cu suma elementelor lor se obţin, în ordine,
elementele șirului b.
Scrieți un subalgoritm care stabilește dacă șirul a se poate reduce sau nu la șirul b. În caz afirmativ, identificați
elementul din șirul b (și poziția k a acestui element) obținut prin însumarea valorilor din cea mai lungă
subsecvență a șirului a. Subalgoritmul are ca parametri de intrare cele două șiruri a și b, precum și lungimile lor
n și, respectiv, m. Parametrii de ieșire vor fi răspuns, k și nrMax, unde: răspuns va avea valoarea adevărat
dacă răspunsul la întrebare este afirmativ, respectiv fals, în caz contrar; k reprezintă indicele elementului din
șirul b care se obține însumând elementele din subsecvența de lungime maximă (nrMax). Dacă există mai multe
subsecvențe de lungime maximă, se va considera prima dintre ele. Dacă șirul a nu se poate reduce la șirul b, k și
nrMax vor avea fiecare valoarea -1.
Exemplul 1: dacă n = 12, a = (6, 3, 4, 1, 6, 4, 6, 1, 7, 1, 8, 7), m = 4 și b = (13, 7, 18, 16), atunci răspuns =
adevărat, deoarece 6 + 3 + 4 = 13, 1 + 6 = 7, 4 + 6 + 1 + 7 = 18, 1 + 8 + 7 = 16. Astfel, k = 3 și nrMax = 4.
Exemplul 2: dacă n = 17, a = (10, 12, 11, 2, 2, 3, 2, 3, 13, 3, 41, 5, 4, 5, 6, 5, 2), m = 6 și b = (33, 4, 15, 41, 25,
2), atunci răspuns = fals, deoarece 10 + 12 + 11 = 33, 2 + 2 = 4, dar 3 + 2 + 3 < 15, iar 3 + 2 + 3 + 13 > 15, deci
valoarea b3 = 15 nu se poate obține însumând elemente consecutive din șirul a.
Notă: În exemplele date șirurile sunt indexate începând cu 1.
Se dǎ urmǎtorul subalgoritm unde n este parametru de intrare, iar p și i sunt parametri de ieșire (n, p, i - numere
naturale, 1 ≤ n ≤ 1 000 000, 0 ≤ p ≤ 1 000 000, 0 ≤ i ≤ 1 000 000):
Subalgoritm f(n, p, i): a. Enunțați problema pe care o rezolvă
Dacă n ≤ 9 atunci
Dacă n mod 2 = 0 atunci subalgoritmul dat.
{ n mod 2 calculeazǎ restul ȋmpǎrțirii lui n la 2} b. Ce valori vor avea p și i după apelul
p  n f(205 609, p, i)?
i  0
altfel
c. Scrieți o variantă iterativǎ (ne-recursi-
p  0 vă) a subalgoritmului dat respectând
i  n antetul subalgoritmului din varianta
SfDacă recursivă.
altfel
f(n div 10, p, i)
{ n div 10 calculeazǎ câtul ȋmpǎrțirii lui n la 10}
Dacă n mod 2 = 0 atunci
p  p * 10 + n mod 10
altfel
i  i * 10 + n mod 10
SfDacă
sfDacă
SfSubalgoritm

Prelucrări imagine
O imagine alb-negru este reprezentată codificat printr-un tablou bidimensional cu valori 0 (pixel alb) și 1
(pixel negru). Asupra imaginii se pot efectua transformări precum:
 Inversarea (I), adică valorile 0 se transformă în 1 și valorile 1 se transformă în 0;
 Rotirea cu 90 de grade în sensul acelor de ceasornic (R); 1 1
 Zoom (Z), adică fiecare pixel va fi expandat în 4 pixeli identici cu cel inițial. 1
1 1
O secvență de transformări se definește ca o succesiune de litere I, R și Z (în orice ordine).
Scrieți un program care, fiind dat un tablou bidimensional imagine având m linii și m coloane (m - număr
natural, 2 ≤ m ≤ 10) și o secvență s care conține cel mult cinci transformări, aplică aceste transformări și
afișează imaginea obținută în urma transformărilor.
Exemplu: dacă m = 3, imagine = și s = (R, I, R, Z), atunci rezultatul va fi .
Imaginile intermediare (după aplicarea succesivă a transformărilor R, I, R, Z) sunt:
, , , .
În rezolvare folosiți subprograme pentru:

a. citirea datelor de intrare de la tastatură (datele de intrare se consideră corecte în raport cu cerințele);
b. inversarea unei imagini;
c. rotirea cu 90 de grade a unei imagini;
d. aplicarea operației de zoom pe o imagine;
e. afișarea pe ecran a unei imagini.
Notă:
2. Rezolvările trebuie scrise detaliat pe foile de examen (ciornele nu se iau în considerare).
BAREM – VARIANTA II
OFICIU............................................................................................................................................... 10 puncte
SUBIECTUL I ................................................................................................................................... 35 puncte
1. 1. Degustare de ciocolată .............................................................................................................. 20 puncte
 V1: determinarea corectă a valorii nr (cu formula nr = n – n/cmmdc(n, k) ..................... 20 puncte
 V2: determinarea corectă a valorii nr (simulare, listă circulară) ...................................... 10 puncte
2. Reducere ........................................................................................................................................ 15 puncte
 parcurgerea în paralel a celor două șiruri ..................................................................................... 4 puncte
 calculul sumelor parțiale cu elemente din șirul a și verificarea egalității
cu elementul curent din șirul b ................................................................................................. 4 puncte
 identificarea subsecvenței (din șirul a) de lungime maximă ........................................................ 4 puncte
 test dacă suma parțială curentă depășește elementul curent din b .................................................. 1 punct
 test dacă s-a terminat parcurgerea elementelor din șirul a și suma parțială curentă
depășește elementul curent din șirul b ........................................................................................ 1 punct
 test dacă, inițial, șirul b are mai multe elemente decât șirul a ........................................................ 1 punct
SUBIECTUL II .................................................................................................................................. 15 puncte

Numǎrul format din cifrele pare și numărul format din cifrele impare ale numărului n
Cerința a.
 enunț problemă ............................................................................................................................. 5 puncte
Cerința b.
 rezultat calculat corect (p = 2060, i = 59)..................................................................................... 3 puncte
Cerința c.
 algoritm ....................................................................................................................................... 7 puncte
SUBIECTUL III Prelucrări imagine ............................................................................................... 40 puncte

Subprograme:
a. Citirea datelor de intrare de la tastatură........................................................................................ 4 puncte
 citirea imaginii .............................................................................................................. 2 puncte
 citirea secvenței de transformări ................................................................................... 2 puncte
b. inversarea unei imagini ................................................................................................................ 4 puncte
c. rotirea cu 90 de grade a unei imagini ........................................................................................... 8 puncte
d. aplicarea operației de zoom pe o imagine .................................................................................... 8 puncte
e. afișarea unei imagini .................................................................................................................... 2 puncte
Program principal ........................................................................................................................ 3 puncte

 determinarea rezultaului ............................................................................................................... 3 puncte
 comunicare prin parametri:
(signatura subalgorimilor și apelul corect) ............................................................................. 5 puncte
 lizibilitate:
• comentarii ....................................................................................................................... 1 punct
• indentare ......................................................................................................................... 1 punct
• denumiri sugestive .......................................................................................................... 1 punct
3
O solutie posibila:
#include <iostream>
using namespace std;
/*************************************************************************************
Subiectul I.1. Degustare de ciocolata
*************************************************************************************/
//calculeaza si returneaza cmmdc a 2 numere naturale a si b
int cmmdc(int a, int b){
if ((a == b) && (a == 0))
return 1;
if (a * b == 0)
return a + b;
while (b != 0){
int c = b;
b = a % b;
a = c;
} //while
return a;
}
//determina si returneaza nr de copii care nu primesc ciocolata dintre cei n copii
//numarand din k in k. Putem să consideram numaratoarea in cerc ca o numaratoare
//liniara in mai multe siruri mici, fiecare cu n copii, obtinând un sir mare cu
//p copii (p fiind multiplu de n). Numaratoarea se termina atunci cand al n-lea
//copil (dintr-un sir mic) primeste ciocolata (astfel, urmatorul copil care ar
//trebui sa primeasca ciocolata va fi un al k-lea copil din urmatorul sir mic),
//deci p trebuie sa fie si multiplu de k. Asadar, p = cmmmc(n, k). Dintre cei
//p copii, au primit ciocolată exct p / k copii, deci copiii fara ciocolata sunt
//in numar de
//nr = n - p/k = n - cmmmc(n,k)/k = n - (n*k/cmmdc(n,k))/k = n - n/cmmdc(n,k)
int degustareCiocolata(int n, int k){
return n - n / cmmdc(n, k);
}
/*************************************************************************************
Subiectul I.2. Reducere
*************************************************************************************/
//verifica daca sirul a cu n numere naturale se poate reduce la sirul b cu m numere
//naturale si determina pozitia k din sirul b care retine elementul obtinut prin
//insumarea elementelor din cea mai lunga subsecventa (de lungime nrMax) din sirul a
bool seReduce(int n, int a[], int m, int b[], int &k, int &nrMax){
if (n < m)
return false; // sirul a are mai putine elemente decat sirul b
int i = 0; // index in sirul a
int j = 0; // index in sirul b
int sum = 0; // se va incerca obtinerea, pe rând, a elementelor din sirul b
// ca suma de elemente consecutive din sirul a
int nrInsumate = 0; // numarul elementelor din subsecventa curenta
nrMax = 0; // numarul maxim de elemente din subsecventele sirului a
// ale caror suma este egala cu un element din sirul b
while ((j < m) && (i < n)){ // cat timp nu s-a terminat niciunul dintre siruri
sum += a[i];
nrInsumate++;
if (sum == b[j]){
if (nrInsumate > nrMax){
nrMax = nrInsumate; // daca este cazul, se actualizeaza nrMax si k
k = j;
}
nrInsumate = 0; // eventual, va urma o subsecventa noua
sum = 0;
j++; i++;
} //if
else{
if (sum < b[j])
i++;
else
return false;
} //else
} //while
if ((i < n) || (j < m)) // daca cel putin unul dintre cele doua siruri nu s-a epuizat
return false;
return true;
}
/*************************************************************************************
Subiectul II. Produsul a doua numere
*************************************************************************************/
//Subiectul II.a Numǎrul format din cifrele pare (p) și numărul format din cifrele
//impare (i) ale numărului n considerate de la stanga la dreapta
//Subiectul II.b f(205 609, p, i) => p = 2060, i = 59
//Subiectul II.c
void cifreIterativ(int n, int & pare, int & impare){
pare = 0;
impare = 0;
int putereImpare = 1; //putere lui 10 pentru formarea nr cu cifre impare
int puterePare = 1; //putere lui 10 pentru formarea nr cu cifre pare
while (n){
if (n & 1){ //daca n este impar
impare = impare + putereImpare * (n % 10);
n /= 10;
putereImpare *= 10;
} //if
else{
pare = pare + puterePare * (n % 10);
n /= 10;
puterePare *= 10;
} //else
} //while
}
/*************************************************************************************
Subiectul III Prelucrare imagine
*************************************************************************************/
const int DIMMAX = 320;
//inverseaza valorile unei matrici binare im cu m linii si m coloane

void inversare(int m, int im[][DIMMAX]){
for (int i = 0; i < m; i++){
for (int j = 0; j < m; j++){
im[i][j] = 1 - im[i][j];
} //for j
} //for i
}
//roteste o matrice im cu m linii si m coloane

void rotire(int m, int im[][DIMMAX]){
int copie[DIMMAX][DIMMAX];
for (int i = 0; i < m; i++){
for (int j = 0; j < m; j++){
copie[i][j] = im[i][j];
} //for j
} //for i
for (int i = 0; i < m; i++){
for (int j = 0; j < m; j++){
im[j][m - i - 1] = copie[i][j];
} //for j
} //for i
}
//mareste o matrice im cu m linii si m coloane

void zoom(int &m, int im[][DIMMAX]){
int imNoua[DIMMAX][DIMMAX];
int iNou = 0;
int jNou = 0;
5
for (int i = 0; i < m; i++){
jNou = 0;
for (int j = 0; j < m; j++){
imNoua[iNou][jNou] = im[i][j];
imNoua[iNou][jNou + 1] = im[i][j];
imNoua[iNou + 1][jNou++] = im[i][j];
imNoua[iNou + 1][jNou++] = im[i][j];
} //for j
iNou += 2;
} //for i
m *= 2;
for (int i = 0; i < m; i++){
for (int j = 0; j < m; j++){
im[i][j] = imNoua[i][j];
} //for j
} //for i
}
//afiseaza o matrice im cu m linii si m coloane

void afisare(int m, int im[][DIMMAX]){
for (int i = 0; i < m; i++){
for (int j = 0; j < m; j++){
cout << im[i][j] << " ";
} //for j
cout << endl;
} //for i
}
//aplica o secventa s de k transformari asupra unei matrici im cu

//m linii si m coloane
void transformari(int k, char s[], int &m, int im[][DIMMAX]){
for (int i = 0; i < k; i++){
if (s[i] == 'I')
inversare(m, im);
if (s[i] == 'R')
rotire(m, im);
if (s[i] == 'Z')
zoom(m, im);
} //for i
}
//citeste o matrice im cu m linii si m coloane

void citireImagine(int &m, int im[][DIMMAX]){
cout << "m = "; cin >> m;
for (int i = 0; i < m; i++){
for (int j = 0; j < m; j++){
cin >> im[i][j];
} //for j
} //for i
}
//citeste o secventa s de k transformari

void citireTransformari(int &k, char s[]){
cout << " k = "; cin >> k;
for (int i = 0; i < k; i++)
cin >> s[i];
}
//programul principal
int main(){
int m = 0;
int im[DIMMAX][DIMMAX];
citireImagine(m, im);
int k = 0; char s[5];
citireTransformari(k, s);
transformari(k, s, m, im);
afisare(m, im);
return 0;
}
Concurs admitere - varianta 1
1. Se consideră că indexarea tuturor șirurilor începe de la 1.
2. Problemele tip grilă (Partea A) pot avea unul sau mai multe răspunsuri corecte. Răspunsurile trebuie scrise de candidat pe foaia de
concurs (nu pe foaia cu enunțuri). Obținerea punctajului aferent problemei este condiționată de identificarea tuturor variantelor de
răspuns corecte și numai a acestora.
3. Pentru problemele din Partea B se cer rezolvări complete pe foaia de concurs.
a. Rezolvările se vor scrie în pseudocod sau într-un limbaj de programare (Pascal/C/C++).
b. Primul criteriu în evaluarea rezolvărilor va fi corectitudinea algoritmului, iar apoi performanța din punct de vedere al timpului
de executare și al spațiului de memorie utilizat.
c. Este obligatorie descrierea și justificarea (sub) algoritmilor înaintea rezolvărilor. Se vor scrie, de asemenea, comentarii pentru
a uşura înţelegerea detaliilor tehnice ale soluției date, a semnificaţiei identificatorilor, a structurilor de date folosite etc.
Neîndeplinirea acestor cerințe duce la pierderea a 10% din punctajul aferent subiectului.
d. Nu se vor folosi funcții sau biblioteci predefinite (de exemplu: STL, funcţii predefinite pe şiruri de caractere).
Partea A (30 puncte)
A.1. Oare ce face? (5 puncte)
Se consideră subalgoritmul expresie(n), unde n este un număr natural (1 ≤ n ≤ 10000).
Subalgoritm expresie(n):
Dacă n > 0 atunci
Dacă n MOD 2 = 0 atunci
returnează -n * (n + 1) + expresie(n - 1)
altfel
returnează n * (n + 1) + expresie(n - 1)
SfDacă
altfel
returnează 0
SfDacă
SfSubalgoritm
Precizați forma matematică a expresiei E(n) calculată de acest subalgoritm:

A. E(n) = 1* 2 - 2 * 3 + 3 * 4 + ... + (-1)n+1 * n * (n + 1)
B. E(n) = 1* 2 - 2 * 3 + 3 * 4 + ... + (-1)n * n * (n + 1)
C. E(n) = 1* 2 + 2 * 3 + 3 * 4 + ... + (-1)n+1 * n * (n + 1)
D. E(n) = 1* 2 + 2 * 3 + 3 * 4 + ... + (-1)n * n * (n + 1)
E. E(n) = 1* 2 - 2 * 3 - 3 * 4 - ... - (-1)n * n * (n + 1)
A.2. Calcul (5 puncte)
Se consideră subalgoritmul calcul(n) unde n este un număr natural (1 ≤ n ≤ 10000).
Subalgoritm calcul(n):
x  0, z  1
CâtTimp z ≤ n execută
x  x + 1
z  z + 2 * x
z  z + 1
SfCâtTimp
returnează x
SfSubalgoritm
Care dintre afirmațiile de mai jos sunt false?

A. Dacă n = 25 sau n = 35, atunci calcul(n) returnează 5.
B. Dacă n < 8, atunci calcul(n) returnează 3.
C. Dacă n ≥ 85 și n < 100, atunci calcul(n) returnează 9.
D. Subalgoritmul calculează și returnează numărul pătratelor perfecte strict pozitive și strict mai mici decât n.
E. Subalgoritmul calculează și returnează partea întreagă a radicalului numărului n.
A.3. Expresie logică (5 puncte)
Se consideră următoarea expresie logică: (NOT Y OR Z) OR (X AND Y). Alegeți valorile pentru X, Y, Z astfel încât
rezultatul evaluării expresiei să fie adevărat:
A. X ← fals; Y ← fals; Z ← fals;
B. X ← fals; Y ← fals; Z ← adevărat;
C. X ← fals; Y ← adevărat; Z ← fals;
D. X ← adevărat; Y ← fals; Z ← adevărat;
E. X ← fals; Y ← adevărat; Z ← adevărat;
1
A.4. Ce se afișează? (5 puncte)
Se consideră următorul program:
Varianta C Varianta C++ Varianta Pascal
#include <stdio.h> #include <iostream> type vector=array[1..10] of integer;
using namespace std;
int sum(int n, int a[], int* s){ int sum(int n, int a[], int& s){ function sum(n:integer; a:vector;
*s = 0; s = 0; var s:integer):integer;
int i = 1; int i = 1; var i:integer;
while(i <= n){ while(i <= n){ begin
if (a[i] != 0) if (a[i] != 0) s := 0; i := 1;
*s += a[i]; s += a[i]; while (i <= n) do
++i; ++i; begin
} } if (a[i] <> 0) then
return *s; return s; s := s + a[i];
} } i := i + 1;
end;
sum := s;
end;
int main(){ int main(){ var n, p, s : integer;

int n = 3; int p = 0; int n = 3; int p = 0; a : vector;
int a[10]; int a[10]; begin
a[1] = -1; a[2] = 0; a[3] = 3; a[1] = -1; a[2] = 0; a[3] = 3; n := 3; a[1] := -1; a[2] := 0;
int s = sum(n, a, &p); int s = sum(n, a, p); a[3] := 3; p := 0;
printf("%d;%d", s, p); cout << s << ";" << p; s := sum(n, a, p);
return 0; return 0; write(s,';',p);
} } end.
Care este rezultatul afișat în urma execuției programului?
A. 3;0
B. 2;0
C. 0;2
D. 2;2
E. Niciun răspuns nu este corect
A.5. Număr norocos (5 puncte)
Un număr natural nenul x se numește norocos dacă pătratul său se poate scrie ca sumă de x numere naturale
consecutive. De exemplu, 7 este număr norocos pentru că 72 = 4 + 5 + 6 + 7 + 8 + 9 + 10.
Care dintre următorii subalgoritmi verifică dacă un număr natural x (2 ≤ x ≤ 1000) este norocos? Fiecare subalgoritm
are ca parametru de intrare numărul x, iar ca parametri de ieșire numărul natural nenul start și variabila de tip boolean
esteNorocos. Dacă numărul x este norocos, atunci esteNorocos = adevărat și start va reține primul termen din sumă (de
ex., dacă x = 7, atunci start = 4); dacă x nu este norocos, atunci esteNorocos = fals și start va reține valoarea -1.
A. Subalgoritm norocos(x, start, esteNorocos): B. Subalgoritm norocos(x, start, esteNorocos):

xpatrat ← x * x xpatrat ← x * x
esteNorocos ← fals esteNorocos ← fals
start ← -1, k ← 1, s ← 0 start ← -1, k ← 1
CâtTimp k ≤ xpatrat - x și nu esteNorocos execută CâtTimp k ≤ xpatrat - x și nu esteNorocos execută
Pentru i ← k, k + x - 1 execută s ← 0
s ← s + i Pentru i ← k, k + x - 1 execută
SfPentru s ← s + i
Dacă s = xpatrat atunci SfPentru
esteNorocos ← adevărat Dacă s = xpatrat atunci
start ← k esteNorocos ← adevărat
SfDacă start ← k
SfCâtTimp SfDacă
SfSubalgoritm k ← k + 1
SfCâtTimp
SfSubalgoritm
C. Subalgoritm norocos(x, start, esteNorocos): D. Subalgoritm norocos(x, start, esteNorocos):

Dacă x MOD 2 = 0 atunci Dacă x MOD 2 = 0 atunci
esteNorocos ← fals esteNorocos ← fals
start ← -1 start ← -1
altfel altfel
esteNorocos ← adevărat esteNorocos ← adevărat
start ← (x + 1) DIV 2 start ← x DIV 2
SfDacă SfDacă
SfSubalgoritm SfSubalgoritm
E. Subalgoritm norocos(x, start, esteNorocos):

esteNorocos ← adevărat
start ← (x + 1) DIV 2
SfSubalgoritm
2
A.6. Pune 'b' (5 puncte)
Se consideră o matrice pătratică mat de dimensiune n × n (n - număr natural impar, 3 ≤ n ≤ 100) și subalgoritmul
puneB(mat, n, i, j) care pune caracterul 'b' pe anumite poziții în matricea mat. Parametrii i și j sunt numere naturale
(1 ≤ i ≤ n, 1 ≤ j ≤ n).
Subalgoritm puneB(mat, n, i, j):

Dacă i ≤ n DIV 2 atunci
Dacă j ≤ n - i atunci
mat[i][j] ← 'b'
puneB(mat, n, i, j + 1)
altfel
puneB(mat, n, i + 1, i + 2)
SfDacă
SfDacă
SfSubalgoritm
Precizați de câte ori se autoapelează subalgoritmul puneB(mat, n, i, j) dacă avem secvența de instrucțiuni:
n ← 7, i ← 2, j ← 4
puneB(mat, n, i, j)
A. de 5 ori
B. de același număr de ori ca și în cazul secvenței de instrucțiuni
n ← 9, i ← 3, j ← 5
puneB(mat, n, i, j)
C. de 10 ori
D. de 0 ori
E. de o infinitate de ori
Partea B (60 puncte)

B.1. Calcul cu caractere (10 puncte)
Se consideră subalgoritmul calculCuCaractere(s, n, p, q, nr), unde s este un șir cu n caractere (n este număr
natural, 1 ≤ n ≤ 9), iar p, q și nr sunt numere naturale (1 ≤ p ≤ n, 1 ≤ q ≤ n, p ≤ q).
Subalgoritm calculCuCaractere(s, n, p, q, nr):
rez  0
i  p
CâtTimp i ≤ q execută
CâtTimp i ≤ q și s[i] ≥ '0' și s[i] ≤ '9' execută
nr  nr * 10 + s[i] - '0'
i  i + 1
SfCâtTimp
rez  rez + nr
nr ← 0
i  i + 1
SfCâtTimp
returnează rez
SfSubalgoritm
Scrieți o variantă recursivă a subalgoritmului calculCuCaractere(s, n, p, q, nr) care are același antet cu acesta și
care are același efect în secvența de instrucțiuni:
Citește n, s, p, q
Scrie calculCuCaractere(s, n, p, q, 0)
B.2. Perioadă (25 puncte)

Se spune că un șir de n caractere are perioada k dacă șirul respectiv poate fi format prin concatenarea repetată a unui
șir de caractere de lungime k (2 ≤ n ≤ 200, 1 ≤ k ≤ 100, 2 * k ≤ n). Șirul ”abcabcabcabc” are perioada 3 deoarece
poate fi considerat ca 4 apariții concatenate ale șirului ”abc”; el are de asemenea perioada 6 dacă remarcăm că este
format din 2 apariții concatenate ale șirului ”abcabc”. Șirul ”abcxabc” nu are perioadă. Se numește perioadă maximală
cea mai mare perioadă a unui șir.
Scrieți un subalgoritm care determină perioada maximală pm a unui șir de caractere x cu n elemente (n - număr natural,
2 ≤ n ≤ 200). Dacă șirul x nu are perioadă, pm va avea valoarea -1. Parametrii de intrare ai subalgoritmului sunt x și n,
iar parametrul de ieșire este pm.
Exemplul 1: dacă n = 8 și x = ”abababab”, atunci pm = 4.
Exemplul 2: dacă n = 7 și x = ”abcxabc”, atunci pm = -1.
3
B.3. Robi-grădina (25 puncte)
Un grǎdinar pasionat de tehnologie decide sǎ foloseascǎ o „armatǎ” de roboți pentru a uda straturile din grǎdina sa. El
dorește sǎ foloseascǎ apǎ de la izvorul situat la capǎtul cǎrǎrii principale care strǎbate grǎdina. Fiecǎrui strat ȋi este
asociat un robot și fiecare robot are de udat un singur strat. Toți roboții pornesc de la izvor ȋn misiunea de udare a
straturilor la aceeași orǎ a dimineții (spre exemplu 5:00:00) și lucreazǎ în paralel și neȋncetat un același interval de
timp. Ei parcurg cǎrarea principalǎ pȃnǎ la stratul lor, pe care ȋl udă și revin la izvor pentru a-și reumple rezervorul de
apǎ. La finalul intervalului de timp aferent activității, toți roboții se opresc simultan, indiferent de starea lor curentă.
Inițial, la izvor este amplasat un singur robinet. Grǎdinarul constată însă cǎ apar ȋntȃrzieri ȋn programul de udare a
plantelor deoarece roboții trebuie sǎ aștepte la rȃnd pentru reumplerea rezervoarelor cu apǎ, astfel ȋncȃt considerǎ cǎ
cea mai bunǎ soluție este sǎ instaleze mai multe robinete pentru alimentarea roboților. Roboții pornesc dimineața cu
rezervoarele umplute. Doi roboți nu îşi pot umple rezervorul în acelaşi moment de la acelaşi robinet.
Se cunosc: intervalul de timp t cât cei n roboți lucrează (exprimat în secunde), numărul de secunde di necesare pentru a
parcurge distanța de la izvor la stratul asociat, numărul de secunde ui necesar pentru udarea acestui strat și faptul cǎ
umplerea rezervorului propriu cu apǎ dureazǎ exact o secundǎ pentru fiecare robot (t, n, di, ui - numere naturale, 1 ≤ t ≤
20000, 1 ≤ n ≤ 100, 1 ≤ di ≤ 1000, 1 ≤ ui ≤ 1000, i = 1, 2, ..., n).
Cerințe:
a. Enumerați roboții care se întâlnesc la izvor la un anumit moment de timp mt (1 ≤ mt ≤ t). Justificați răspunsul.
Notă: roboții se identifică prin numărul lor de ordine.
b. Care este numǎrul minim de robinete suplimentare minRobineteSuplim pe care trebuie sǎ le instaleze grǎdinarul
astfel încȃt roboții sǎ nu aștepte deloc unul după altul pentru reumplerea rezervorului? Justificați răspunsul.
c. Scrieți un subalgoritm care determină numǎrul minim de robinete suplimentare minRobineteSuplim. Parametrii
de intrare sunt numerele n și t, șirurile d și u cu câte n elemente fiecare, iar parametrul de ieșire este
minRobineteSuplim.
Exemplu 1: dacă t = 32, n = 5, d = (1, 2, 1, 2, 1), u = (1, 3, 2, 1, 3) atunci minRobineteSuplim = 3. Explicație:

robotul care se ocupǎ de stratul 1 are nevoie de o secundă pentru a ajunge la strat, o secundă pentru a uda stratul
și de încă o secundă pentru a se întoarce la izvor; el se ȋntoarce la izvor pentru a-și reumple rezervorul dupǎ 1 + 1
+ 1 = 3 secunde de la ora de plecare (5:00:00), deci la ora 5:00:03; el își reumple rezervorul ȋntr-o secundă și
pornește ȋnapoi spre strat la ora 5:00:04; revine la ora 5:00:07 pentru a-și reumple rezervorul, continuȃnd ritmul
de udare a straturilor, ș.a.m.d.; deci, primul, al doilea, al patrulea și al cincilea robot se ȋntȃlnesc la izvor la ora
05:00:23; în consecință, este nevoie de 3 robinete suplimentare.
Exemplu 2: dacă t = 37, n = 3, d = (1, 2, 1), u = (1, 3, 2), atunci minRobineteSuplim = 1.
Notă:
2. Ciornele nu se iau în considerare.
4
BAREM
OFICIU .................................................................................................................................................................. 10 puncte
Partea A ................................................................................................................................................................. 30 puncte
A. 1. Oare ce face? Răspunsul A ............................................................................................................................... 5 puncte
A. 2. Calcul. Răspunsurile B, D .................................................................................................................................. 5 puncte
A. 3. Expresie logică. Răspunsurile A, B, D, E ......................................................................................................... 5 puncte
A. 4. Ce se afișează? Răspunsul D............................................................................................................................. 5 puncte
A. 5. Număr norocos. Răspunsurile B, C.................................................................................................................... 5 puncte
A. 6. Pune b. Răspunsurile A, B1 .............................................................................................................................. 5 puncte
Partea B ................................................................................................................................................................. 60 puncte
B. 1. Calcul.............................................................................................................................................................. 10 puncte
 respectarea parametrilor de intrare și ieșire ......................................................................................................... 2 puncte
 condiția de oprire din recursivitate ....................................................................................................................... 1 puncte
 valoarea returnată la oprirea recursivității ............................................................................................................ 1 puncte
 condiția pentru caracter diferit de cifră ................................................................................................................ 2 puncte
 valoarea returnată în cazul unui caracter diferit de cifră ...................................................................................... 2 puncte
 valoarea returnată în cazul unui caracter cifră...................................................................................................... 2 puncte
Dacă p > q atunci
returnează nr
altfel
Dacă s[p] < '0' sau s[p] > '9' atunci
returnează nr + calculCuCaractere(s, n, p + 1, q, 0)
altfel
returnează calculCuCaractere(s, n, p + 1, q, 10 * nr + s[p] - '0')
SfDacă
SfDacă
SfSubalgoritm
B. 2. Perioadă ........................................................................................................................................................ 25 puncte

 parcurgerea valorilor posibile ale perioadei .......................................................................................... maxim 10 puncte
Notă: punctajul acordat depinde și de următoarele aspecte:
i. parcurgerea valorilor posibile ale perioadei
ii. considerarea ca perioadă a divizorilor lui n
 verificarea periodicității ......................................................................................................................... maxim 13 puncte
Notă: punctajul acordat depinde și de numărul de structuri repetitive folosite
B. 3. Robi grădină .................................................................................................................................................. 25 puncte
a. la un anumit moment de timp mt (1 ≤ mt ≤ t) se întâlnesc la izvor roboții care au valoarea q (egală cu
suma dintre timpul necesar deplasării până la strat și înapoi, timpul necesar udării stratului și
timpul necesar umplerii rezervorului) divizor al lui mt ................................................................................. 5 puncte
b. numǎrul minim de robinete suplimentare este egal cu maximul vectorului aux - 1, unde vectorul aux reține,
pentru fiecare moment de timp, câti roboți se întâlnesc la izvor în momentul respectiv .............................. 5 puncte
c. Dezvoltare subalgoritm
 V1: folosirea unui vector de frecvență pentru multiplii timpilor de lucru ai fiecărui robot ......................... 15 puncte
a. respectarea parametrilor de intrare și ieșire ..................................................................................... 2 puncte
b. calcul timp de lucru (q = 2 * deplasare + udare + încărcare)............................................................ 2 puncte
c. prelucrarea vectorului de frecvențe................................................................................................... 5 puncte
d. stabilirea frecvenței maximale .......................................................................................................... 4 puncte
e. determinarea numărului de robinete suplimentare............................................................................ 2 puncte
 V2: simulare................................................................................................................................................. 10 puncte
a. respectarea parametrilor de intrare și ieșire ..................................................................................... 2 puncte
b. calcul timp de lucru (q = 2 * deplasare + udare + încărcare)............................................................ 2 puncte
c. structura repetitivă pentru timp ......................................................................................................... 1 puncte
d. structura repetitivă pentru roboți....................................................................................................... 1 puncte
e. stabilirea numărului de robinete necesare la un anumit moment de timp ........................................... 1 punct
f. stabilirea numărului maxim de robinete ............................................................................................. 1 punct
g. determinarea numărului de robinete suplimentare............................................................................ 2 puncte
1
in varianta subiectului în limba engleză, datorită traducerii ambigue a termenului auto-apel, a fost considerată corectă atât
varianta cu răspunsurile A și B, cât și varianta cu răspunsul B.
5
Partea B (soluții) .................................................................................................................................................... 60 puncte
B. 1. Calcul.............................................................................................................................................................. 10 puncte

Dacă p > q atunci
returnează nr
altfel
Dacă s[p] < '0' sau s[p] > '9' atunci
returnează nr + calculCuCaractere(s, n, p + 1, q, 0)
altfel
returnează calculCuCaractere(s, n, p + 1, q, 10 * nr + s[p] - '0')
SfDacă
SfDacă
SfSubalgoritm
B. 2. Perioadă maximală........................................................................................................................................ 25 puncte
bool verif(int n, char const x[], int perioada){

for (int i = perioada; i < n; ++i) {
if (x[i + 1] != x[i % perioada + 1])
return false;
}
return true;
}
int perioadaMax(int n, char x[]){

int perioada = -1;
for (int per = 2; per * per <= n; ++per){
if (n % per == 0){ // perioada trebuie sa fie printre divizorii lui n
if (verif(n, x, n / per))
return n / per;
if ((per * per < n) && verif(n, x, per)) {

perioada = per;
}
}
}
return perioada;
}
B. 3. Robi grădină .................................................................................................................................................. 25 puncte
int robiGradina(int n, int d[], int u[], int t){

int aux[200000]; //aux(i) va retine cate robinete sunt necesare la momentul i
int max = 1;
for (int i = 1; i <= t; i++)
aux[i] = 0;
for (int j = 1; j <= n; j++){
int q = d[j] * 2 + u[j] + 1;
//se marchează multiplii lui q in vectorul aux
for (int i = q; i <= t; i = i + q){
aux[i]++;
if (max < aux[i]) //se determina maximul din aux
max = aux[i];
}
}
return max - 1;
}
6
Concurs admitere septembrie 2018
1. Se consideră că indexarea tuturor șirurilor începe de la 1.
2. Problemele tip grilă (Partea A) pot avea unul sau mai multe răspunsuri corecte. Răspunsurile trebuie scrise de candidat pe foaia de
concurs (nu pe foaia cu enunțuri). Obținerea punctajului aferent problemei este condiționată de identificarea tuturor variantelor de
răspuns corecte și numai a acestora.
3. Pentru problemele din Partea B se cer rezolvări complete pe foaia de concurs.
a. Rezolvările se vor scrie în pseudocod sau într-un limbaj de programare (Pascal/C/C++).
c. Este obligatorie descrierea și justificarea (sub) algoritmilor înaintea rezolvărilor. Se vor scrie, de asemenea, comentarii pentru
a uşura înţelegerea detaliilor tehnice ale soluției date, a semnificaţiei identificatorilor, a structurilor de date folosite etc.
d. Nu se vor folosi funcții sau biblioteci predefinite (de exemplu: STL, funcţii predefinite pe şiruri de caractere).
Subalgoritmul generare(n) prelucrează un număr natural n (0 < n < 100).
Subalgoritm generare(n):
nr  0
Pentru i  1, 1801 execută
folositi  fals
SfPentru
CâtTimp nu folositn execută
suma ← 0, folositn  adevărat
CâtTimp (n ≠ 0) execută
cifra ← n MOD 10, n ← n DIV 10
suma ← suma + cifra * cifra * cifra
SfCâtTimp
n ← suma, nr ← nr + 1
SfCâtTimp
returnează nr
SfSubalgoritm
Precizați care este efectul acestui subalgoritm.

A. calculează, în mod repetat, suma cuburilor cifrelor numărului n până când suma egalează numărul n și returnează
numărul repetărilor efectuate
B. calculează suma cuburilor cifrelor numărului n și returnează această sumă
C. calculează suma cuburilor cifrelor numărului n, înlocuiește numărul n cu suma obținută și returnează această sumă
D. calculează, în mod repetat, suma cuburilor cifrelor numărului n până când o sumă se obține a doua oară și
returnează numărul repetărilor efectuate
E. calculează numărul înlocuirilor lui n cu suma cuburilor cifrelor sale până când se obține o valoare calculată anterior
sau numărul însuși și returnează acest număr
A.2. Ce valori sunt necesare? (5 puncte)
Se consideră subalgoritmul prelucreaza(v, k), unde v este un șir cu k numere naturale (1 ≤ k ≤ 1 000).
Subalgoritm prelucreaza(v, k)
i ← 1, n ← 0
CâtTimp i ≤ k și vi ≠ 0 execută
y ← vi, c ← 0
CâtTimp y > 0 execută
Dacă y MOD 10 > c atunci
c  y MOD 10
SfDacă
y ← y DIV 10
SfCâtTimp
n ← n * 10 + c
i ← i + 1
SfCâtTimp
returnează n
SfSubalgoritm
Precizați pentru care valori ale lui v și k subalgoritmul returnează valoarea 928.
A. v = (194, 121, 782, 0) și k = 4
B. v = (928) și k = 1
C. v = (9, 2, 8, 0) și k = 4
D. v = (8, 2, 9) și k = 3
E. v = (912, 0, 120, 8, 0) și k = 5
1
A.3. Evaluare logică (5 puncte)
Fie s un șir cu k elemente de tip boolean și subalgoritmul evaluare(s, k, i), unde k și i sunt numere naturale
(0 ≤ i ≤ k ≤ 100).
Subalgoritm evaluare(s, k, i)
Dacă i ≤ k atunci
Dacă si atunci
returnează si
altfel
returnează (si sau evaluare(s, k, i + 1))
SfDacă
altfel
returnează fals
SfDacă
SfSubalgoritm
Precizați de câte ori se autoapelează subalgoritmul evaluare(s, k, i) în următoarea secvență de instrucțiuni:

s ← (fals, fals, fals, fals, fals, fals, adevărat, fals, fals, fals)
k ← 10
i ← 3
evaluare(s, k, i)
A. de 3 ori
B. de același număr de ori ca în următoarea secvență de instrucțiuni
s ← (fals, fals, fals, fals, fals, fals, fals, adevărat)
k ← 8
i ← 4
evaluare(s, k, i)
C. de 6 ori
D. niciodată
E. de o infinitate de ori
A.4. Reuniune (5 puncte)

Se consideră dat subalgoritmul aparține(x, a, n) care verifică dacă un număr natural x aparține mulțimii a cu n
elemente; a este un șir cu n elemente și reprezintă o mulțime de numere naturale (1 ≤ n ≤ 200, 1 ≤ x ≤ 1000).
Fie subalgoritmii reuniune(a, n, b, m, c, p) și calcul(a, n, b, m, c, p), descriși mai jos, unde a, b și c sunt
șiruri care reprezintă mulțimi de numere naturale cu n, m și respectiv p elemente (1 ≤ n ≤ 200, 1 ≤ m ≤ 200, 1 ≤ p ≤
400). Parametrii de intrare sunt a, n, b, m și p, iar parametrii de ieșire sunt c și p.
1. Subalgoritm reuniune(a, n, b, m, c, p): 1. Subalgoritm calcul(a, n, b, m, c, p):
2. Dacă n = 0 atunci 2. p ← 0
3. Pentru i ← 1, m execută 3. reuniune(a, n, b, m, c, p)
4. p ← p + 1 4. SfSubalgoritm
5. cp ← bi
6. SfPentru
7. altfel
8. Dacă nu aparține(an, b, m) atunci
9. p ← p + 1
10. cp ← an
11. SfDacă
12. reuniune(a, n - 1, b, m, c, p)
13. SfDacă
14. SfSubalgoritm
Precizați care dintre afirmațiile de mai jos sunt întotdeauna adevărate:

A. când mulțimea a conține un singur element, apelul subalgoritmului calcul(a, n, b, m, c, p) provoacă
apariția unui ciclu infinit
B. când mulțimea a conține 4 elemente, apelul subalgoritmului calcul(a, n, b, m, c, p) provoacă executarea
instrucțiunii de pe linia 12 a subalgoritmului reuniune de 4 ori
C. când mulțimea a conține 5 elemente, apelul subalgoritmului calcul(a, n, b, m, c, p) provoacă executarea
instrucțiunii de pe linia 2 a subalgoritmului reuniune de 5 ori
D. când mulțimea a are același număr de elemente ca și mulțimea b, în urma execuției subalgoritmului calcul(a,
n, b, m, c, p) mulțimea c va avea același număr de elemente ca și mulțimea a
E. când mulțimea a are aceleași elemente ca și mulțimea b, în urma execuției subalgoritmului calcul(a, n, b, m,
c, p) mulțimea c va avea același număr de elemente ca și mulțimea a
2
A.5. Exponențiere (5 puncte)
Care dintre următorii algoritmi calculează corect valoarea ab, a și b fiind două numere naturale (1 ≤ a ≤ 11, 0 ≤ b ≤ 11).
A. Subalgoritm expo(a, b): B. Subalgoritm expo(a, b):
rezultat ← 1 Dacă b ≠ 0 atunci
CâtTimp b > 0 execută Dacă b MOD 2 = 1 atunci
Dacă b MOD 2 = 1 atunci returnează expo(a * a, b / 2) * a
rezultat ← rezultat * a altfel
SfDacă returnează expo(a * a, b / 2)
b ← b DIV 2 SfDacă
a ← a * a altfel
SfCâtTimp returnează 1
returnează rezultat SfDacă
C. Subalgoritm expo(a, b): D. Subalgoritm expo(a, b):
rezultat ← 1 Dacă b = 0 atunci
CâtTimp b > 0 execută returnează 1
rezultat ← rezultat * a SfDacă
b ← b - 1 aux ← expo(a, b DIV 2)
SfCâtTimp Dacă b MOD 2 = 0 atunci
returnează rezultat returnează aux * aux
SfSubalgoritm altfel
returnează a * aux * aux
SfDacă
SfSubalgoritm
E. Subalgoritm expo(a, b):
Dacă b = 0 atunci
returnează 1
SfDacă
returnează a * expo(a, b - 1)
SfSubalgoritm
A.6. Cel mai mare multiplu (5 puncte)

Care dintre subalgoritmii de mai jos returnează cel mai mare multiplu al numărului natural a, multiplu care este mai mic
sau egal cu numărul natural b (0 < a < 10 000, 0 < b < 10 000, a < b)?
A. Subalgoritm f(a, b): B. Subalgoritm f(a, b):
c  b Dacă a < b atunci
CâtTimp c MOD a = 0 execută returnează f(2 * a, b)
c  c – 1 altfel
SfCâtTimp Dacă a = b atunci
returnează c returnează a
SfSubalgoritm altfel
Subalgoritm f(a, b): returnează b
C. SfDacă
returnează (b DIV a) * a
SfSubalgoritm SfDacă
SfSubalgoritm
D. Subalgoritm f(a, b): E. Subalgoritm f(a, b):
Dacă b MOD a = 0 atunci c  a
returnează b CâtTimp c < b execută
SfDacă c  c + a
returnează f(a, b - 1) SfCâtTimp
SfSubalgoritm Dacă c = b atunci
returnează c
altfel
returnează c – a
SfDacă
SfSubalgoritm
B.1. Evaluare polinom (10 puncte)

Se consideră subalgoritmul evaluare(n, coef, x), unde coef este un vector cu n + 1 elemente numere reale din
intervalul [-100, 100] reprezentând coeficienții unui polinom de grad n, P(x) = coef1 * xn + coef2*xn - 1 + .... + coefn *
x + coefn + 1, dați în ordinea descrescătoare a puterilor lui x (n este număr natural, 1 ≤ n ≤ 10). Subalgoritmul
determină valoarea polinomului într-un punct dat x (x număr real din intervalul [-10, 10]).
Subalgoritm evaluare(n, coef, x):
val  0.0
Pentru i  1, n + 1 execută
val  val * x + coef[i]
SfPentru
returnează val
SfSubalgoritm
Scrieți o variantă recursivă (care nu conține structuri repetitive) a subalgoritmului evaluare(n, coef, x) care are
același antet și același efect cu acesta.
3
B.2. Intersecție (25 puncte)
Se consideră două șiruri, fiecare conținând numere întregi distincte, cuprinse între -30 000 și 30 000. Şirul a are
n (0 < n ≤ 10 000) elemente, iar șirul b are m (0 < m ≤ 10 000) elemente și este ordonat crescător.
Scrieți un subalgoritm care determină șirul c, având k (0 ≤ k ≤ 10 000) elemente, format din toate elementele comune ale
celor două șiruri, luate o singură dată în orice ordine. Parametrii de intrare sunt cele două șiruri (a și b) și lungimile lor (n
și m). Parametrii de ieșire vor fi șirul c și lungimea k a șirului. Dacă nu există elemente comune, k va fi 0.
Exemplu: dacă n = 4, a = (5, -7,-2, 3), m = 5 și b = (-2, 3, 5, 7, 8), șirul c are k = 3 elemente și este c = (5, -2, 3).
B.3. Secvență de numere fără frați (25 puncte)

Se consideră un șir x, având n (0 < n ≤ 10 000) elemente numere naturale distincte nenule mai mici decât 30 000.
Două numere se numesc frați dacă sunt distincte și dacă au cel puțin două cifre distincte comune. De exemplu, 5867 și
17526 sunt frați, dar 5867 și 152 nu sunt frați. De asemenea, 131 și 114 nu sunt frați.
Cerințe:
i. Scrieți un subalgoritm care verifică dacă un număr natural a este frate cu un număr natural b (0 < a ≤ 30 000, 0 <
b ≤ 30 000) Parametrii de intrare sunt cele două numere a și b. Parametrul de ieșire va fi esteFrate și va avea
valoarea adevărat dacă a este frate cu b și fals, altfel. (11 puncte)
ii. Scrieți un subalgoritm care determină cea mai lungă subsecvență a șirului x, formată din elemente care nu au
niciun frate în șirul x. O subsecvență a unui șir este formată din elemente ale șirului aflate pe poziții consecutive.
Parametrii de intrare sunt șirul x și lungimea lui n. Parametrii de ieșire vor fi poziția de început a subsecvenței start
și lungimea acesteia k. Dacă există mai multe subsecvențe de aceeași lungime maximă, se va considera ultima dintre
ele. Dacă nu există nicio astfel de subsecvență, start va fi -1 și k va fi 0. (14 puncte)
Exemplu: Fie n = 11 și x = (12345, 9, 100, 567, 5678, 345, 123, 8989, 222, 11, 78). Numerele fără frați din șirul
x sunt: 9, 100, 8989, 222, 11, iar subsecvența căutată este (8989, 222, 11), deci start = 8 și k = 3.
Notă:
4
BAREM
OFICIU .................................................................................................................................................................. 10 puncte
Partea A ................................................................................................................................................................. 30 puncte

A. 1. Oare ce face? Răspunsul E ................................................................................................................................ 5 puncte
A. 2. Ce valori sunt necesare? Răspunsurile A, C ..................................................................................................... 5 puncte
A. 3. Evaluare logică. Răspunsul B ........................................................................................................................... 5 puncte
A. 4 Reuniune. Răspunsurile B, E ............................................................................................................................. 5 puncte
A. 5. Exponențiere. Răspunsurile A, B, C, D, E ....................................................................................................... 5 puncte
A. 6. Cel mai mare multiplu. Răspunsurile C, D, E .................................................................................................... 5 puncte
Partea B ................................................................................................................................................................. 60 puncte

B. 1. Evaluare polinom .......................................................................................................................................... 10 puncte
 condiția de oprire din recursivitate ....................................................................................................................... 2 puncte
 autoapel ............................................................................................................................................................... 2 puncte
 valoarea returnată la oprirea recursivității ............................................................................................................ 2 puncte
 valoarea returnată la continuarea recursivității .................................................................................................... 2 puncte
B. 2. Intersecție ...................................................................................................................................................... 25 puncte
o variante:
 folosirea căutării binare ..................................................................................................... 23 puncte
 fără căutare binară ................................................................................................. maxim 18 puncte
B. 3. Secvență de numere fără frați ...................................................................................................................... 25 puncte

 proprietatea de frate ............................................................................................................................................ 10 puncte
 determinarea unei secvențe .................................................................................................................................. 9 puncte
 determinarea celei mai lungi secvențe.................................................................................................................. 4 puncte
1
Concurs de admitere – 21 iulie 2019
1. Se consideră că indexarea șirurilor începe de la 1.
2. Problemele tip grilă din Partea A pot avea unul sau mai multe răspunsuri corecte care trebuie indicate de candidat pe formularul
special de pe foaia de concurs. Notarea acestora se face conform sistemului de punctare parțială din regulamentul concursului.
3. Pentru problemele din Partea B se cer rezolvări complete scrise pe foaia de concurs, fiind evaluate în detaliu conform baremului.
a. Rezolvarea cerințelor B1-B4 implică răspunsuri atât în limbaj natural/matematic, cât și în pseudocod sau Pascal/C/C++.
c. Este obligatorie descrierea și justificarea subalgoritmilor înaintea rezolvărilor. Se vor scrie, de asemenea, comentarii pentru
a ușura înțelegerea detaliilor tehnice ale soluției date, a semnificației identificatorilor, a structurilor de date folosite etc.
d. Nu se vor folosi funcții sau biblioteci predefinite (de exemplu: STL, funcții predefinite pe șiruri de caractere).
A.1. Ce se afișează? (6 puncte)
Se consideră programul de mai jos. Care este rezultatul afișat în urma execuției programului?
A. P(a, b) = 253; B. P(a, b) = 132; C. P(a, b) = 22; D. P(a, b) = 253;
a = 11; b = 11 a = 11; b = 121; a = 11; b = 11; a = 11; b = 121;
Varianta C++ Varianta C Varianta Pascal
#include <iostream> #include <stdio.h> function P(x : Integer;
using namespace std; var y : Integer) : Integer;
begin
int P(int x, int &y){ int P(intx, int *y){ y := y * x; x := x + y;
y = y * x; x = x + y; *y = (*y) * x; x = x + (*y); P := x + y
return x + y; return x + (*y); end;
} } var a, b : Integer;
int main(){ Int main(){ Begin
int a = 11; int b = a; int a = 11; int b = a; a := 11; b := a;
cout << "P(a, b) = " << P(a, b); printf("P(a, b) = %d", P(a, &b)); Write('P(a, b) = ', P(a, b))
cout << endl << "; a = " << a; printf(";\na = %d", a); WriteLn('; ');
cout << "; b = " << b << endl; printf("; b = %d\n", b); Write('a = ', a);
return 0; return 0; WriteLn('; b = ', b);
} } End.
A.2. Evaluare (6 puncte)

Se știe că v este un vector care conține n numere naturale mai mici decât 30 000 (1 ≤ n ≤ 10 000).
Care dintre următoarele secvențe de instrucțiuni poate înlocui „ ...” în subalgoritmul prelucrare(v, n, rez, m) astfel
încât vectorul rez, după executarea structurii repetitive, să rețină valorile care sunt multipli ai lui 5 aflate pe poziții pare în
vectorul v. Lungimea vectorului rez se reține în variabila m.
A. Dacă i MOD 2 = 0 ȘI v[i] MOD 5 = 0 B. Dacă i MOD 2 = 0 atunci
atunci Dacă v[i] MOD 10 = 5 atunci
Subalgoritm prelucrare(v,n,rez,m) m ← m + 1; rez[m] ← v[i] m ← m + 1; rez[m] ← v[i]
m ← 0 SfDacă SfDacă
Pentru i = 1, n execută Dacă v[i] MOD 10 = 0 atunci
... C. Dacă v[i] MOD 10 = 0 atunci m ← m + 1; rez[m] ← v[i]
SfPentru Dacă i MOD 2 = 0 atunci SfDacă
SfSubalgoritm m ← m + 1; rez[m] ← v[i] SfDacă
altfel
Dacă v[i] MOD 10 = 5 atunci D. Dacă i MOD 2 = 0 ȘI v[i] MOD 10 = 5
m ← m + 1; rez[m] ← v[i] ȘI v[i] MOD 10 = 0 atunci
SfDacă m ← m + 1; rez[m] ← v[i]
SfDacă SfDacă
SfDacă
A.3. Ce valori sunt necesare? (6 puncte)

Se consideră subalgoritmul calcul(n, v), unde v este un șir cu n numere întregi (n - număr natural, 1 ≤ n ≤ 1 000).
Subalgoritm calcul(n, v)
a ← 0; b ← 0
Pentru i ← 1, n execută Precizați pentru care valori ale parametrilor subalgoritmul returnează
a ← a + v[i] valoarea 0.
SfPentru
Pentru i ← 1, n execută
a ← a - v[i] A. n = 5, v = (4, 5, 7, 3, 6)
Dacă a = b atunci
returnează v[i] B. n = 7, v = (-3, 1, 2, 0 , 5,-2, -3)
SfDacă C. n = 4, v = (-2, 2, 5, -5)
b ← b + v[i]
SfPentru D. n = 8, v = (1, -7, 3, 0, -2, 1, -2, 0)
returnează -1
SfSubalgoritm
1
Subalgoritm ghici(n) Se consideră subalgoritmul ghici(n) , unde n este număr natural
f ← 0; p ← -1
Pentru c ← 0, 9 executǎ (1 ≤ n ≤ 10 000). Precizați efectul subalgoritmului ghici(n):
x ← n; k ← 0
CȃtTimp x > 0 executǎ A. Calculează și returnează numǎrul de cifre din reprezentarea zecimală a
Dacǎ x MOD 10 = c atunci numǎrului n.
k ← k + 1
SfDacǎ B. Calculează și returnează frecvența cifrei maxime din reprezentarea
x ← x DIV 10 zecimală a numǎrului n.
SfCâtTimp
Dacǎ k > f atunci C. Calculează și returnează una dintre cifrele cu frecvența maximǎ din
p ← c; f ← k reprezentarea zecimală a numǎrului n.
SfDacǎ
SfPentru D. Calculează și returnează numărul de cifre egale cu c din reprezentarea
returneazǎ p zecimală a numărului n.
SfSubalgoritm
A.5. Generare șir de numere speciale (6 puncte)

Se știe că într-un șir x cu k elemente x = (x1, x2, x3, ..., xk) o secvență y de lungime p este reprezentată de p elemente ale
șirului x care se află pe poziții consecutive. De ex. y = (x3, x4, x5, x6) este o secvență de lungime p = 4.
Se consideră mulțimea de cifre M ={1, 2, ..., n} și cele n! permutări ale mulțimii M (n – număr natural, n ≤ 9). Se poate
construi cel mai scurt șir ss format cu cifre din M astfel încât oricare dintre cele n! permutări ale mulțimii M să se
regăsească în ss sub forma unei secvențe de n cifre.
De exemplu, dacă n = 3, avem 6 permutări, iar șirul cerut ss are 9 cifre și poate fi, de exemplu următorul: ss =(1, 2, 3, 1,
2, 1, 3, 2, 1). Din permutarea perm1 = (1, 2, 3) se pot folosi ultimele două cifre ale sale și se adaugă o a treia cifră pentru
a obține o altă permutare, adică permutarea perm2 = (2, 3, 1); apoi se poate așeza cifra 2 după ultimele două cifre ale
perm2 și se obține permutarea perm3 = (3, 1, 2). Dacă după (1, 2) s-ar așeza cifra 3, s-ar obține permutarea perm1 care
există deja în șirul de cifre generat până la acest moment. Atunci se folosește doar ultima cifră din perm3 și se caută o
permutare care începe cu cifra 2 și încă nu face parte din șir ș. a. m. d. Astfel, în șirul construit există o secvență de trei
cifre care nu este o permutare (1, 2, 1); restul secvențelor (adică (1, 2, 3), (2, 3, 1), (3, 1, 2), (2, 1, 3), (1, 3, 2) și (3, 2, 1))
sunt permutări.
Precizați numărul minim de elemente de tip cifră din care se poate construi șirul ss în cazul mulțimii M = {1, 2, 3, 4}.
perm1
1 2 3 1 2 1 3 2 1
perm2 A. 55 B. 16 C. 33 D. 37
A.6. Produs cifre (6 puncte)
Subalgoritm cifre(n, d) Se consideră subalgoritmul cifre(n, d), unde n și d sunt numere naturale
Dacă d = 1 atunci
Dacă n = 1 atunci (10 ≤ n ≤ 100 000, 1 ≤ d ≤ 9), care determină și returnează cel mai mic
returnează 0 număr natural format din cifre nenule mai mici sau egale cu d și cu
altfel
returnează -1 proprietatea că produsul cifrelor sale este egal cu n. De exemplu, dacă n =
SfDacă 108, subalgoritmul returnează 269. Dacă nu există un astfel de număr,
altfel
Dacă n MOD d = 0 atunci subalgoritmul returnează -1. Precizați de câte ori se autoapelează
val = cifre(n DIV d, d)
Dacă val < 0 atunci
subalgoritmul cifre(n,d) prin executarea secvenței de instrucțiuni:
returnează -1 Citește n
altfel val = cifre(n, 9)
returnează val * 10 + d
SfDacă
altfel
A. Dacă n = 108, subalgoritmul se autoapelează de 11 ori.
returnează cifre(n, d - 1) B. Dacă n = 109, subalgoritmul se autoapelează de 8 ori.
SfDacă
SfDacă
C. Dacă n = 13, subalgoritmul nu se autoapelează niciodată.
SfSubalgoritm D. Dacă n = 100, subalgoritmul se autoapelează de 10 ori.
A.7. Prelucrare șir (6 puncte)
Se consideră subalgoritmul prelucrare(n, x), unde x este un șir cu n - 1 numere naturale distincte din mulțimea {1, 2,
…, n}. Precizați care este semnificația valorii returnate de către subalgoritm.
A. Subalgoritmul returnează diferența dintre suma primelor n numere
Subalgoritm prelucrare(n, x) naturale nenule și suma elementelor din șirul x.
s ← 0
Pentru i  1, n - 1 execută
B. Subalgoritmul returnează diferența dintre suma primelor n numere naturale
s  s + x[i] nenule și suma elementelor din șir, mai puțin ultimul element din șir.
SfPentru
returnează n * (n + 1) / 2 - s
C. Subalgoritmul returnează acel număr natural din mulțimea {1, 2, …, n}
SfSubalgoritm care nu apare în șirul x.
D. Subalgoritmul returnează 0.
2
A.8. Magie (6 puncte)
Un vrăjitor de cifre face o magie prin care un număr natural x (100 ≤ x ≤ 1000000 și, reprezentat în baza 10, are cel
puțin două cifre nenule) se separă în două numere naturale nenule stânga și dreapta, astfel încât numărul x să se poate
scrie prin concatenarea cifrelor numerelor stânga și dreapta, iar produsul dintre stânga și dreapta este maxim. De
exemplu, numărul x = 1 092, prin magie, se separă în numerele stânga = 10 și dreapta = 92.
Care dintre subalgoritmii de mai jos aplică magia vrăjitorului asupra unui număr natural x care, reprezentat în baza 10, are
cel puțin două cifre nenule (100 ≤ x ≤ 1 000 000), identificând numărul natural z (1 ≤ z ≤ 1 000 000) care reprezintă
dreapta asociată lui x știind că au fost deja definiți subalgoritmii:
 putere(b, p) – determină bp (b la puterea p), b și p fiind numere naturale (1 ≤ b ≤ 20,1 ≤ p ≤ 20);
 nrCifre(nr) – determină numărul cifrelor unui număr natural nr (1 ≤ nr ≤ 1 000 000).
A. Subalgoritm magie(x, z) B. Subalgoritm magie(x, z)
prodMax  -1 t  0
rez  0 Dacă x > 0 atunci
CâtTimp x > 0 execută y  (x MOD 10) * putere(10, nrCifre(z)) + z
z  (x MOD 10) * putere(10, nrCifre(z)) + z t  x DIV 10
x  x DIV 10 Dacă x * z < y * t atunci
Dacă x * z > prodMax atunci returnează magie(y, t)
prodMax  x * z altfel
rez  z returnează t
SfDacă SfDacă
SfCâtTimp altfel
returnează prodMax returnează t
SfSubalgoritm SfDacă
SfSubalgoritm
C. Subalgoritm magie(x, z) D. Subalgoritm magie(x, z)

prodMax  -1 Dacă x > 0 atunci
rez  0 y  (x MOD 10) * putere(10, nrCifre(z)) + z
CâtTimp x > 0 execută t  x DIV 10
z  (x MOD 10) * putere(10, nrCifre(z)) + z Dacă x * z < y * t atunci
x  x DIV 10 returnează magie(y, t)
Dacă x * z > prodMax atunci altfel
prodMax  x * z returnează z
rez  z SfDacă
SfDacă altfel
SfCâtTimp returnează z
returnează rez SfDacă
A.9. Completați (6 puncte)

Se consideră un șir x ordonat crescător cu n (3 ≤ n ≤ 100) elemente numere naturale distincte mai mici decât 30 000.
Subalgoritmul apropiat(x, st, dr, val) determină poziția celui mai mare element din șirul x aflat între pozițiile st și
dr (1 ≤ st < dr ≤ n) și a cărui valoare este mai mică sau egală cu val. În cazul în care nu există un astfel de element,
subalgoritmul apropiat(x, st, dr, val) returnează 0.
Subalgoritmul modul(a) returnează valoarea absolută a numărului întreg a.
Subalgoritmul calcul(n, x, nr) determină acea valoare existentă în șirul x care este cea mai apropiată de valoarea lui
nr. În cazul a două elemente la fel de apropiate de valoarea lui nr, se va considera elementul mai mare.
Fie n = 5, x = (5, 9, 11, 15, 99) și nr = 12. Precizați cu ce se pot înlocui punctele de suspensie în cadrul subalgoritmului
apropiat(x, st, dr, val) pentru ca prin executarea subalgoritmului calcul(n, x, nr) să se returneze valoarea 11.
Subalgoritm apropiat(x, st, dr, val) Subalgoritm calcul(n, x, nr)

Dacă val > x[dr] atunci i ← apropiat(x, 1, n, nr)
returnează dr Dacă i = 0 atunci
SfDacă returnează x[i + 1]
Dacă val < x[st] atunci altfel
returnează st - 1 Dacă modul(x[i]- nr) < modul(x[i + 1] - nr) atunci
SfDacă returnează x[i]
mij ← (st + dr) DIV 2 altfel
Dacă ... atunci returnează x[i + 1]
returnează mij - 1 SfDacă
altfel SfDacă
Dacă val < x[mij] atunci SfSubalgoritm
returnează apropiat(x, st, mij - 1, val)
altfel
returnează apropiat(x, mij + 1, dr, val) A. x[mij - 1] <= val ȘI val < x[mij]
SfDacă B. x[mij - 1] <= val SAU val < x[mij]
SfDacă
SfSubalgoritm C. x[mij - 1] < val ȘI val <= x[mij]
D. x[mij] <= val ȘI val < x[mij - 1]
3
A.10. Cavaleri și mincinoși (6 puncte)
Pe o insulă locuiesc cavaleri care spun întotdeauna adevărul și mincinoși care mint întotdeauna. Un vizitator ajuns pe
insulă dorește să afle natura unei perechi de localnici cu care s-ar întâlni în plimbările lui pe insulă. Astfel, atunci când
el se întâlnește cu doi localnici A și B îi adresează lui A întrebarea „Q1: Amândoi sunteți cavaleri?”, dar răspunsul
primit (R1) nu îl lămurește în privința naturii fiecăruia din cei doi localnici. De aceea vizitatorul îi adresează tot lui A o
nouă întrebare: „Q2: Sunteți la fel, amândoi cavaleri sau amândoi mincinoși?”; de data aceasta, răspunsul primit (R2) îl
lămurește pe vizitator (adică acum știe ce este fiecare dintre cei doi localnici, cavaler sau mincinos).
Ce a răspuns localnicul A știind că vizitatorul a reușit să identifice în mod exact natura celor doi localnici pe baza
scenariului descris anterior?
A. R1: Da, R2: Da B. R1: Da, R2: Nu C. R1: Nu D. Variantele B și C sunt corecte.

Banane
În urma unui naufragiu, marinarii de pe o corabie au reușit să se salveze folosind bărcile de salvare,
iar fiecare barcă, încărcată cu câte trei marinari, a ajuns pe o altă insulă. Căutând mâncare, marinarii
de pe fiecare insulă i au cules bi banane pe care le-au depozitat în barcă și au decis să le împartă între
ei abia a doua zi. În oricare barcă încap cel mult k banane. În timpul nopții, pe o insulă, unul dintre
marinari s-a trezit și a împărțit bananele din barcă în trei grămezi, fiecare grămadă având același
număr de banane, dar a constatat că i-a mai rămas o banană (neplasată în nici una dintre grămezi) pe
care a mâncat-o. Apoi, el a ascuns una dintre grămezi, a pus celelalte două grămezi înapoi în barcă și
s-a culcat. Până dimineața fiecare marinar de pe fiecare insulă a efectuat același tip de intervenție
secretă (a împărțit bananele în trei grămezi egale, a mâncat banana rămasă, a ascuns una dintre
grămezi și a pus înapoi în barcă celelalte două grămezi). Dimineața, pe fiecare insulă, bananele
rămase în barcă au fost împărțite în trei grămezi identice nevide și, din nou, a rămas o banană, pe
care marinarii au dat-o unei maimuțe. Da, pe fiecare insulă trăia și câte o maimuță!
Cerințe:
B.1. Dacă marinarii de pe una din insule au cules înainte de venirea nopții 241 de banane, câte banane au rămas în
fiecare dintre cele trei grămezi finale (de pe insula respectivă)? (2 puncte)
B.2. Dacă pe una din insule, după ultima împărțire, fiecare din cele trei grămezi conținea 15 banane, iar pe o altă insulă,
fiecare din cele trei grămezi conținea 31 banane, câte banane s-au cules în total pe cele două insule? (2 puncte)
B.3. Scrieți un subalgoritm care pentru un număr k dat calculează cea mai mare valoare posibilă a lui bmax care
reprezintă numărul de banane culese de marinarii de pe o insulă. Parametrul de intrare al subalgoritmului este k.
bmax este parametru de ieșire. Identificați formula de calcul a valorii maxime a lui bmax în funcție de valoarea lui
k. Explicați raționamentul folosit (bmax, k – numere naturale, 1 ≤ bmax ≤ k, 100 ≤ k ≤ 10 000 000). (14 puncte)
Exemplu: dacă k = 200, atunci bmax = 160.
B.4. Scrieți un subalgoritm care, pentru o valoare k dată, calculează numărul total maxim de banane culese pe toate
insulele (totalMax). Se știe că pe fiecare insulă marinarii au cules un număr diferit de banane bi (k, bi – numere
naturale, 1 ≤ bi ≤ k, bi ≠ bj, ∀ i, j ∈ {1, 2, …, nr}, 100 ≤ k ≤ 10 000 000). Parametrii de intrare ai subalgoritmului
sunt k și nr – numărul de insule (nr – număr natural, 2 ≤ nr ≤10), iar cel de ieșire este totalMax, reprezentând
numărul total maxim de banane culese pe toate insulele. Valorile variabilelor k și nr sunt date astfel încât problema
are soluție. (12 puncte)
Exemplu: dacă k = 400, nr = 3, atunci pe cele trei insule numărul de banane culese va fi 322, 241 și, respectiv 160.
Prin urmare numărul maxim de banane culese pe toate insulele este totalMax = 322 + 241 + 160 = 723.
Notă:
4
BAREM
OFICIU .................................................................................................................................................................. 10 puncte
Partea A ................................................................................................................................................................. 60 puncte
A.1. Ce se afișează? Răspuns: D ........................................................................................................................... 6 puncte
A.2. Evaluare. Răspuns: A, B ............................................................................................................................... 6 puncte
A.3. Ce valori sunt necesare? Răspuns: B, D ....................................................................................................... 6 puncte
A.4. Oare ce face? Răspuns: C .............................................................................................................................. 6 puncte
A.5. Generare șir de numere speciale. Răspuns: C ............................................................................................. 6 puncte
A.6. Produs de cifre. Răspuns: A, B ..................................................................................................................... 6 puncte
A.7. Prelucrare șir. Răspuns: A, C ....................................................................................................................... 6 puncte
A.8. Magie. Răspuns: orice variantă (vezi nota finală)........................................................................................ 6 puncte
A.9. Completați. Răspuns: A, D ............................................................................................................................ 6 puncte
A.10. Cavaleri și mincinoși. Răspuns: B ............................................................................................................... 6 puncte
Partea B Banane .................................................................................................................................................... 30 puncte
B.1. (241 * 8 - 65 ) / 81 = 23 banane ............................................................................................................ 2 puncte
B.2. (81 * 15 + 65) / 8 + (81 * 31 + 65) / 8 = 482 banane ........................................................................ 2 puncte
B.3. Algoritmul & formula ............................................................................................................................... 14 puncte
o Identificare corectă a formulei 79 + ((k - 79) / 81) * 81 .............................................................. 10 puncte
 Expresia formulei ....................................................................................................................... 4 puncte
 Justificarea ................................................................................................................................. 6 puncte
o Implementare
 Respectarea parametrilor (doar cel de intrare) .......................................................................... 2 puncte
 Algoritm
 V1 pe baza formulei 79 + ((k - 79) / 81) * 81 ...................................................... 2 puncte
 V2 (structură repetitivă ”smart” în care se verifică cu formula (8 * n - 65) MOD 81 = 0
dacă valoarea curentă a lui n este corectă sau nu)......................................................... 7 puncte
 V3 simulare (se determină mărimile grămezilor intermediare) ................................... 5 puncte
B.4. Algoritmul & formula ............................................................................................................................... 12 puncte
o Respectarea parametrilor ........................................................................................................................ 2 puncte
o Algoritm
 Structura repetitivă pentru iterarea insulelor .............................................................................. 3 puncte
 Valori distincte pentru numărul de banane de pe fiecare insulă................................................. 5 puncte
 Însumarea valorilor .................................................................................................................... 2 puncte
int bananeV1(int k){ int bananeToateInsulele(int k, int nr){
return 79 + (k - 79) / 81 * 81; int s = 0;
} for(int i = 1; i <= nr; i++){
int bananeV2(int k){ int ni = bananeV1(k);
while ((8 * k - 65) % 81 != 0) s += ni; k = ni - 1;
k--; }
return k; return s;
} }
int bananeV3(int k){
int n = k;
while (n >= 4){
if (n % 3 == 1){
int n1 = 2 * n / 3;
if (n1 % 3 == 1){
int n2 = 2 * n1 / 3;
if (n2 % 3 == 1){
int n3 = 2 * n2 / 3;
if (n3 % 3 == 1){ return n;}
}
}
}
n--;
}
}
Notă: În cazul problemei A.8. subalgoritmul nrCifre(nr) ar fi trebuit să prelucreze inclusiv valori nule (aspect omis în
enunțul problemei) pentru ca algoritmul magie(x, z) să funcționeze conform cerințelor. În consecință, punctajul obținut
pentru această problemă va fi de 6 puncte (indiferent de răspunsurile indicate pe foaia de examen).
5

Subiecte Admitere Informatica UBB Cluj 2010-2019

Încărcat de

Informații document

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

Subiecte Admitere Informatica UBB Cluj 2010-2019

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEA BABEŞ-BOLYAI CLUJ-NAPOCA

FACULTATEA DE MATEMATICĂ ŞI INFORMATICĂ

EXAMEN DE ADMITERE – 2010

Subiectul I (30 puncte)

Subiectul II (30 puncte)

Subiectul III (30 puncte)

Se citeşte de la tastatură numărul natural n. Se cere să se scrie un program care

EXAMEN DE ADMITERE – 2010

a) 7p (3p definiţia, 2 x 1p exemplele, 2p diferenţa);

a) 8p (4p pt n=1, 4p pt n=10);

Total punctaj = 10p(oficiu) + 30p(subiectul I) + 30p(subiectul II) + 30p(subiectul III) = 100p.

EXAMEN DE ADMITERE – 2011

Subiectul I (30 puncte)

a) Definiţi noţiunea de variabilă. Ce înţelegeţi prin variabilă statică şi variabilă dinamică?

Subiectul II (30 puncte)

Subiectul III (30 puncte)

Se citeşte un şir X de numere naturale pozitive, citirea şirului terminându-se la introducerea

EXAMEN DE ADMITERE – 2011

a) 10p (3p definiţia, 2p variabilă statică, 2p variabilă dinamică, 3p exemple);

Total punctaj = 10p(oficiu) + 30p(subiectul I) + 30p(subiectul II) + 30p(subiectul III) = 100p.

EXAMEN DE ADMITERE 2012

SUBIECTUL I (30 puncte)

SUBIECTUL II (30 puncte)

SUBIECTUL III (30 puncte)

EXAMEN DE ADMITERE 2012

Subprograme din care: 23p

EXAMEN ADMITERE INFORMATICĂ – iulie 2013

Subiectul I (30 puncte)

Subiectul II (30 puncte)

Subiectul III (30 puncte)

EXAMEN ADMITERE – iulie 2013

a) Se afiseaza valoarea 192. 4p

a). Subprogram pentru citirea unui şir 3p

EXAMEN ADMITERE – septembrie 2013

Subiectul I (30 puncte)

Subiectul II (30 puncte)

Subiectul III (30 puncte)

Se vor scrie subprograme pentru:

EXAMEN ADMITERE INFORMATICĂ – septembrie 2013

a) - Se afiseaza valoarea 13. 4p

Concursul de admitere (nivel licență) - sesiunea iulie 2015

Subiectul I (35 puncte)

Subiectul II (20 puncte)

Subiectul III (35 puncte)

 Pentru n=2, m=2 și matricea

se va obține şirul X  (4,6,8,10) și se va tipări mesajul 'Nu există secvență'.

Se vor scrie subprograme pentru:

Concursul de admitere (nivel licență) - sesiunea iulie 2015

a) - Se returnează valoarea 4851 3p

Concursul de admitere (nivel licență) - sesiunea septembrie 2015

Subiectul I (35 puncte)

Subiectul II (20 puncte)

Subiectul III (35 puncte)

 Pentru n=4 și X  (24,5,8,218)

 Pentru n=5 și X  (24,5,4,42,6)

Se vor scrie subprograme pentru:

Concursul de admitere (nivel licență) - sesiunea iulie 2015

Concurs de admitere (nivel licență) - sesiunea iulie 2016

Subiectul I (50 puncte)

2. Numere magice (20 puncte)

3. Inserare (20 puncte)

a. Enunțați problema pe care o rezolvă subalgoritmul dat.

Subiectul I (35 puncte)

Subiectul III (40 puncte)