Bilet NR 1

Fișierul numere.in conține pe prima linie un număr natural, n (1<n<100) și pe a doua

linie n numere naturale, cu cel mult 4 cifre fiecare.

a. Să se scrie definiția completă a unui subprogram Concatenare, cu doi parametrii,

numere naturale, a și b (de maxim 4 cifre fiecare) care returnează numărul obținut prin
concatenarea lui a cu b. (ex: dacă subprogramul primește a=154, b=45, va returna
15445.)
b. Scrieți un program care citește datele din fișierul numere.in și afișează în fișierul
numere.out, n-1 numere naturale, folosind apeluri utile ale subprogramului
Concatenare. Pentru fiecare pereche de numere citite consecutiv, se va afișa cel mai
mare număr obținut prin concatenerea celor două.
De exemplu, dacă numerele citite consecutiv sunt 123 și 95, se va alege cel mai mare
dintre cele două numere obținute prin concatenare: dintre 12395 și 95123, se va alege
95123. Proiectați un algoritm eficient din punctul de vedere al memoriei folosite și al
timpului de executare.

Rezolvare:
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;

int Concatenare(int a, int b) {

// Concatenează două numere naturale a și b și returnează numărul obținut.
return stoi(to_string(a) + to_string(b));
}

int main() {
ifstream fin("numere.in");
ofstream fout("numere.out");

int n;
fin >> n;

vector<int> numbers(n);
for (int i = 0; i < n; i++) {
fin >> numbers[i];
}

vector<int> result;
for (int i = 0; i < n - 1; i++) {
int max_concatenation = max(Concatenare(numbers[i], numbers[i + 1]), Concatenare(numbers[i
+ 1], numbers[i]));
result.push_back(max_concatenation);
}
for (int i = 0; i < result.size(); i++) {
fout << result[i] << "\n";
}

fin.close();
fout.close();

return 0;
}

Bilet nr 2
Fișierul date.in conține maximum 1000 de numere naturale.
a. Să se scrie definiția completă a unui subprogram FactorPutereMax cu un
singur parametru n, număr natural. Subprogramul returnează factorul prim cu
puterea cea mai mare din descompunerea în factori primi a lui n. În cazul în care
există factori primi cu puteri egale, atunci se va returna factorul cel mai mare. De
exemplu, pentru n = 90 = 21 * 32 * 51, cea mai mare putere este 2, deci se va
returna factorul 3. Pentru n = 36 = 22 * 32, puterile fiind egale, se va returna
factorul 3.
b. Scrieți un program C++ care citește cel mult 1000 de numerele naturale din
fișierul date.in și, folosind apeluri utile ale subprogramului
FactorPutereMax, scrie în fișierul date.out: pe prima linie, pentru fiecare
număr citit, factorul prim la puterea cea mai mare, apoi pe linia următoare cel
mai mare dintre acești factori.

Rezolvare
a.
#include <cmath>

int FactorPutereMax(int n) {
// Găsește factorul prim cu puterea cea mai mare în descompunerea în factori primi a lui n.
int factorMax = 0;
int putereMax = 0;

// Se parcurg factorii primi până la radicalul numărului n

for (int i = 2; i <= sqrt(n); i++) {
int putere = 0;

// Se verifică dacă i este factor prim al numărului n

while (n % i == 0) {
putere++;
n /= i;
}

// Se actualizează factorul și puterea maximă

if (putere > putereMax) {
 factorMax = i;
putereMax = putere;
}
}

// Dacă numărul n nu a fost redus la 1, atunci el este ultimul factor prim cu puterea 1
if (n > 1) {
factorMax = n;
putereMax = 1;
}

return factorMax;
}

B.
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;

int FactorPutereMax(int n) {
// Definiția funcției FactorPutereMax
// ...

int main() {
ifstream fin("date.in");
ofstream fout("date.out");

int n;
fin >> n;

vector<int> numbers(n);
for (int i = 0; i < n; i++) {
fin >> numbers[i];
}

vector<int> factors;
for (int i = 0; i < n; i++) {
int factorMax = FactorPutereMax(numbers[i]);
factors.push_back(factorMax);
}

int maxFactor = *max_element(factors.begin(), factors.end());

for (int i = 0; i < n; i++) {

fout << factors[i] << "\n";
}
fout << maxFactor;

fin.close();
fout.close();

return 0;
}
Bilet nr 3:
Fișierul atestat.in conține maximum 100000 de numere naturale.
a. Să se scrie definiția completă a unui subprogram CifraMax, cu un singur parametru
n, număr natural. Subprogramul returnează cea mai mare cifră a numărului n. De
exemplu, pentru n = 65706, se va returna 7.
b. Scrieți un program C++ care citește numerele din atestat.in și, folosind apeluri
utile ale subprogramului CifraMax, scrie în fișierul atestat.out cifra care este
maximă pentru cele mai multe numere din fișier. Dacă există mai multe astfel de cifre,
se vor afișa toate cu această proprietate, în ordine crescătoare. Proiectați un algoritm
eficient din punctul de vedere al memoriei folosite și al timpului de executare.

A.
int CifraMax(int n) {
// Găsește cea mai mare cifră a numărului n
int maxDigit = 0;

while (n > 0) {
int cifra = n % 10;
if (cifra > maxDigit) {
maxDigit = cifra;
}
n /= 10;
}

return maxDigit;
}

B.
#include <iostream>
#include <fstream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

int CifraMax(int n) {
// Definiția funcției CifraMax
// ...

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int n;
fin >> n;

vector<int> numbers(n);
for (int i = 0; i < n; i++) {
 fin >> numbers[i];
}

unordered_map<int, int> digitCount;

int maxCount = 0;

for (int i = 0; i < n; i++) {

int maxDigit = CifraMax(numbers[i]);
digitCount[maxDigit]++;
maxCount = max(maxCount, digitCount[maxDigit]);
}

vector<int> maxDigits;
for (auto it : digitCount) {
if (it.second == maxCount) {
maxDigits.push_back(it.first);
}
}

sort(maxDigits.begin(), maxDigits.end());

for (int i = 0; i < maxDigits.size(); i++) {

fout << maxDigits[i] << " ";
}

fin.close();
fout.close();

return 0;
}

Bilet nr 4:
a. Să se scrie definiția completă a unui subprogram Inversez cu trei paramentrii: v –
tablou unidimensional cu maximum 100 de elemente, numere reale, si doi parametrii
întregi: p, q - două poziții din tabloul v, p < q < 100 . Subprogramul modifică
tabloul prin inversarea elementelor între poziția p și poziția q și returnează prin
același parametru tabloul modificat. (Dacă v ={1.2, 2, 3.1 ,4.25, 5, 6.3),
p = 2, q = 5, după inversare tabloul va avea conținutul: v ={1.2, 5,
4.25 ,3.1, 2, 6.3).
b. Să se scrie definiția completă a unui subprogram Stergp cu trei paramentrii: v –
tablou unidimensional cu maximum 100 de elemente, numere reale, si doi
parametrii întregi: n, p – numărul de elemente din vector și p < 100 .
Subprogramul modifică tabloul prin ștergerea elementului de pe poziția p și
returnează prin același parametru tabloul modificat.
c. Scrieți un program C++ care citește din fișierul numere.in de pe prima linie număr
natural, n (n < 100) și de pe a doua linie un șir cu maxim 100 de numere reale.
Folosind apeluri utile ale subprogramului Stergp, șterge elementul din mijlocul
șirului, în cazul în care acesta are un număr impar de elemente. Folosind apeluri utile
 ale subprogramului Inversez, se vor inversa fiecare din cele două jumătăți ale
șirului, apoi afișează, în fișierul numere.out, conținutul șirului modificat.

A.
void Inversez(float v[], int p, int q) {
// Inversează elementele tabloului v între poziția p și poziția q
while (p < q) {
float temp = v[p];
v[p] = v[q];
v[q] = temp;
p++;
q--;
}
}

B.
void Stergp(float v[], int& n, int p) {
// Șterge elementul de pe poziția p din tabloul v
for (int i = p; i < n - 1; i++) {
v[i] = v[i + 1];
}
n--;
}

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

void Inversez(float v[], int p, int q);

void Stergp(float v[], int& n, int p);

int main() {
ifstream fin("numere.in");
ofstream fout("numere.out");

int n;
fin >> n;

float v[100];

for (int i = 0; i < n; i++) {

fin >> v[i];
}

if (n % 2 != 0) {
Stergp(v, n, n / 2);
}

int jumatate = n / 2;
Inversez(v, 0, jumatate - 1);
 Inversez(v, jumatate, n - 1);

for (int i = 0; i < n; i++) {

fout << v[i] << " ";
}

fin.close();
fout.close();

return 0;
}

Bilet nr 5:
a. Să se scrie definiția completă a unui subprogram CifrePare cu un paramentru n,
număr natural, care returnează numărul format doar din cifrele pare ale lui n, având
cifrele în ordinea inițială. (Ex: pentru n = 12245, se returnează 224)
b. Să se scrie definiția completă a unui subprogram CifreCresc cu un paramentru n,
număr natural, care returnează 1 dacă cifrele lui n sunt în ordine crescătoare și 0
altfel. (Ex: pentru n = 12245, se returnează 1, iar pentru 12436, returnează 0)
c. Fișierul date.in conține maximum 1000000 de numere naturale, fiecare din ele
conținând cel puțin o cifră pară. Scrieți un program C++ care citește numerele din
date.in și, folosind apeluri utile ale celor două subprograme, scrie în fișierul
date.out suma formată prin adunarea numerelor obținute din cifrele pare ale
numerelor citite, dacă numerele astfel obtinute au cifrele în ordine crescătoare.

A.
int CifrePare(int n) {
int rezultat = 0;
int putere = 1;

while (n > 0) {
int cifra = n % 10;
if (cifra % 2 == 0) {
rezultat += cifra * putere;
putere *= 10;
}
n /= 10;
}

return rezultat;
}

B.
bool CifreCresc(int n) {
int cifraAnterioara = n % 10;
n /= 10;
 while (n > 0) {
int cifra = n % 10;
if (cifra > cifraAnterioara) {
return false;
}
cifraAnterioara = cifra;
n /= 10;
}

return true;
}

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

int CifrePare(int n);

bool CifreCresc(int n);

int main() {
ifstream fin("date.in");
ofstream fout("date.out");

int n;
fin >> n;

int suma = 0;

for (int i = 0; i < n; i++) {

int numar;
fin >> numar;

int cifrePare = CifrePare(numar);

if (CifreCresc(cifrePare)) {
suma += cifrePare;
}
}

fout << suma;

fin.close();
fout.close();

return 0;
}

Bilet nr 6:
 a. Să se scrie definiția completă a unui subprogram Cmmdc cu doi parametrii, numere
naturale a și b, care returnează cel mai mare divizor comun al numerelor a și b
(Pentru 20 și 8, returnrază 4)
b. Să se scrie definiția completă a unui subprogram Cmmmc cu doi parametrii, numere
naturale a și b, care returnează cel mai mic multiplu comun al numerelor a și b
(Pentru 20 și 8, returnează 40)
c. Fișierul atestat.in conține maximum 1000000 de numere naturale. Scrieți un
program C++ care citește numerele din atestat.in și, folosind apeluri utile al
subprogramelor Cmmdc si Cmmmc, scrie pe prima linie a fișierului atestat.out
cel mai mare divizor comun al numerelor citite din fișier, iar pe a doua, cel mai mic
multiplu comun al numerelor citite din fișier.

A.
unsigned int Cmmdc(unsigned int a, unsigned int b) {
while (b != 0) {
unsigned int temp = b;
b = a % b;
a = temp;
}
return a;
}

B.
unsigned int Cmmmc(unsigned int a, unsigned int b) {
unsigned int cmmdc = Cmmdc(a, b);
return (a * b) / cmmdc;
}

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

unsigned int Cmmdc(unsigned int a, unsigned int b);

unsigned int Cmmmc(unsigned int a, unsigned int b);

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

unsigned int n;
fin >> n;

unsigned int divizorComunMaxim = 0;

unsigned int multipluComunMinim = 0;
 for (unsigned int i = 0; i < n; i++) {
unsigned int numar;
fin >> numar;

if (i == 0) {
divizorComunMaxim = numar;
multipluComunMinim = numar;
} else {
divizorComunMaxim = Cmmdc(divizorComunMaxim, numar);
multipluComunMinim = Cmmmc(multipluComunMinim, numar);
}
}

fout << divizorComunMaxim << endl;

fout << multipluComunMinim;

fin.close();
fout.close();

return 0;
}

Bilet nr 7:
a. Să se scrie definiția completă a unui subprogram InserezP cu patru paramentrii: n –
numărul de elemente al vectorului v, v – vector cu maximum 100 de
elemente, numere întregi, p, p <=100 reprezentând o poziție în vector și val – o
valoare întreagă. Subprogramul modifică vectorul prin inserarea, pe poziția p a unui
element de valoare val și returnează prin parametrul v vectorul modificat. (Ex:
pentru n=4, v={2, 5, 6, 9}, p = 2, val = 100 , vectorul modificat este:
{2, 100, 5, 6, 9}, considerând că indexarea s-a făcut de la 1)
b. Să se scrie definiția completă a unui subprogram SumaCifre, cu un singur
parametru x, număr natural. Subprogramul returnează suma cifrelor lui x. De
exemplu, pentru n = 27, se va returna 9.
c. Fișierul numere.in conține pe prima linie n, număr natural, n<100, și pe a doua linie
maximum 100 de numere naturale. Scrieți un program C++ care citește datele din
numere.in și, folosind apeluri utile ale subprogramelor InserezP și SumaCifre,
inserează în vector, după fiecare element, suma cifrelor sale, apoi afișează în
numere.out vectorul modificat.

A.
void InserezP(int& n, int v[], int p, int val) {
if (n >= 100) {
cout << "Vectorul are deja numarul maxim de elemente!";
return;
 }

if (p < 1 || p > n + 1) {
cout << "Pozitia p nu este valida!";
return;
}

for (int i = n; i >= p; i--) {

v[i] = v[i - 1];
}

v[p - 1] = val;
n++;
}

B.
int SumaCifre(int x) {
int suma = 0;

while (x != 0) {
suma += x % 10;
x /= 10;
}

return suma;
}

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

void InserezP(int& n, int v[], int p, int val);

int SumaCifre(int x);

int main() {
ifstream fin("numere.in");
ofstream fout("numere.out");

int n;
fin >> n;

int v[100];
for (int i = 0; i < n; i++) {
fin >> v[i];
}

for (int i = n - 1; i >= 0; i--) {

int suma = SumaCifre(v[i]);
InserezP(n, v, i + 1, suma);
}

for (int i = 0; i < n; i++) {

fout << v[i] << " ";
 }

fin.close();
fout.close();

return 0;
}

Biletul nr. 8

a. Să se scrie definiția completă a unui subprogram EPrim, cu un singur parametru x,

număr natural, care returnează 1 dacă numărul este prim și 0 în caz contrar. De
exemplu, pentru n = 27, se va returna 0, iar pentru 13 se returnează 1.
b. Fișierul numere.in conține cel mult 100000 de numere naturale, fiecare având cel
mult doua cifre. Scrieți un program C++ care citește datele din numere.in și,
utilizând apeluri ale subprogramului EPrim, determina numărul prim din fișier care
apare de cele mai multe ori in fișier. Programul afișează în fișierul numere.out,
numărul prim determinat și numărul său de apariții, sau mesajul „Nu exista”,
daca în fișier nu se găsește niciun număr prim.

A.
#include <cmath>

int EPrim(int x) {
if (x < 2)
return 0;

for (int i = 2; i <= sqrt(x); i++) {

if (x % i == 0)
return 0;
}

return 1;
}

B.
#include <iostream>
#include <fstream>
#include <unordered_map>
using namespace std;

int EPrim(int x);

int main() {
ifstream fin("numere.in");
ofstream fout("numere.out");
 int numar;
unordered_map<int, int> primCount;

while (fin >> numar) {

if (EPrim(numar)) {
primCount[numar]++;
}
}

int maxPrim = -1;

int maxCount = 0;

for (auto it = primCount.begin(); it != primCount.end(); ++it) {

if (it->second > maxCount) {
maxCount = it->second;
maxPrim = it->first;
}
}

if (maxPrim != -1) {
fout << "Numar prim determinat: " << maxPrim << endl;
fout << "Numar de aparitii: " << maxCount << endl;
} else {
fout << "Nu exista" << endl;
}

fin.close();
fout.close();

return 0;
}

Biletul nr. 9

a. Să se scrie definiția completă a unui subprogram CifreDistincte cu un

paramentru n, număr natural, care returnează 1 dacă numărul n are toate cifrele
distincte, și 0 în caz contrar. (Ex: pentru n = 12245, se returnează 0, iar pentru n =
2659 se returnează 1.)
b. Fișierul date.in conține maximum 1000 de numere naturale. Scrieți un program C+
+ care citește toate numerele din date.in și, folosind apeluri utile ale
subprogramului CifreDistincte, scrie în fișierul date.out pe prima linie, toate
numerele citite care au cifre distincte, urmate de numărul lor (câte au fost găsite), iar
pe a doua linie a fișierului numerele citite care nu au cifre distincte, urmate de
 numărul lor. Dacă una din cele două categorii de numere nu există, se va afișa un
mesajul “Nu exista” pe linia corespunzătoare.

A.
#include <unordered_set>

int CifreDistincte(int n) {
std::unordered_set<int> digits;

while (n > 0) {
int digit = n % 10;

if (digits.count(digit) > 0) {
return 0;
}

digits.insert(digit);
n /= 10;
}

return 1;
}

B.
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

int CifreDistincte(int n);

int main() {
ifstream fin("date.in");
ofstream fout("date.out");

vector<int> cifreDistincte;
vector<int> cifreNedistincte;

int numar;

while (fin >> numar) {

if (CifreDistincte(numar)) {
cifreDistincte.push_back(numar);
} else {
cifreNedistincte.push_back(numar);
}
}

if (cifreDistincte.empty()) {
fout << "Nu exista" << endl;
} else {
fout << "Numere cu cifre distincte: ";
for (int i = 0; i < cifreDistincte.size(); i++) {
 fout << cifreDistincte[i];
if (i < cifreDistincte.size() - 1) {
fout << ", ";
}
}
fout << " (" << cifreDistincte.size() << ")" << endl;
}

if (cifreNedistincte.empty()) {
fout << "Nu exista" << endl;
} else {
fout << "Numere fara cifre distincte: ";
for (int i = 0; i < cifreNedistincte.size(); i++) {
fout << cifreNedistincte[i];
if (i < cifreNedistincte.size() - 1) {
fout << ", ";
}
}
fout << " (" << cifreNedistincte.size() << ")" << endl;
}

fin.close();
fout.close();

return 0;
}

Biletul nr. 10

a. Să se scrie definiția completă a unui subprogram PozitiiPare, cu 4 parametrii: n

– numărul de elemente ale unui tablou unidimensional, v – tablou unidimensional cu
elemente numere întregi, prim, ultim – doi parametri de ieșire prin care
subprogramul furnizează pozițiile primului respectiv al ultimului element par din
tabloul v. (Ex v={1, 3, 4, 3, 8, 10, 6, 5, 3}, se va calcula prim = 3,
ultim = 7)
b. Scrieți un subprogram Sortpq care, primind ca parametrii: n, numărul de elemente
ale unui vector, v - vectorul si doua poziții întregi, p si q, sortează crescător
elementele vectorul între pozițiile p si q. ( p < q < n)
c. Fișierul numere.in conține pe prima linie n, număr natural, n<100, și pe a doua linie
maximum 100 de numere întregi, dintre care cel puțin două sunt pare. Scrieți un
program C++ care citește din fișierul numere.in un număr natural n (n < 100), apoi
un șir cu n numere întregi având cel mult 9 cifre fiecare, și utilizând apeluri ale celor
 doua subprograme, sortează crescător elementele cuprinse între primul și ultimul
număr par. Programul afișează în numere.out vectorul modificat.

A.
#include <iostream>

void PozitiiPare(int n, int v[], int& prim, int& ultim) {

prim = -1;
ultim = -1;

for (int i = 0; i < n; i++) {

if (v[i] % 2 == 0) {
if (prim == -1) {
prim = i;
}
ultim = i;
}
}
}

B.
void Sortpq(int n, int v[], int p, int q) {
for (int i = p; i <= q; i++) {
for (int j = i + 1; j <= q; j++) {
if (v[i] > v[j]) {
int temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
}
}

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

void PozitiiPare(int n, int v[], int& prim, int& ultim);

void Sortpq(int n, int v[], int p, int q);

int main() {
ifstream fin("numere.in");
ofstream fout("numere.out");

int n;
fin >> n;

int v[100];
for (int i = 0; i < n; i++) {
fin >> v[i];
}
 int prim, ultim;
PozitiiPare(n, v, prim, ultim);

if (prim == -1 || ultim == -1) {

fout << "

Biletul nr. 11

Se consideră două şiruri de caractere a, de lungime na şi b, de lungime nb. Şirul a este

numit sufix al şirului b dacă na≤nb şi este un subşir al lui b determinat de ultimele sale na
caractere.

Scrieți un program C/C++ care pentru un cuvânt S citit, afișează toate sufixele lui în ordine
descrescătoare a lungimii, precum și numărul de sufixe corespunzătoare cuvântului dat.

Date de intrare: Se citeşte de la tastatură un şir S cu cel mult 20 de caractere şi minimum

un caracter, format doar din litere mici ale alfabetului englez.

Date de ieșire: Programul va afișa în fișierul sufixe.out, pe prima linie, în ordine

descrescătoare a lungimii, separate prin câte un spaţiu, toate sufixele şirului memorat în variabila S,
iar pe a doua linie numărul de sufixe afișate, ca în exemplu.

A.
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
ofstream fout("sufixe.out");

string S;
cin >> S;

int n = S.length();
vector<string> sufixe;

for (int i = n; i >= 0; i--) {

sufixe.push_back(S.substr(i));
}

sort(sufixe.begin(), sufixe.end(), [](const string& a, const string& b) {

 return a.length() > b.length();
});

for (const string& sufix : sufixe) {

fout << sufix << " ";
}
fout << endl;

fout << sufixe.size() << endl;

fout.close();

return 0;
}

Biletul nr. 12

Se consideră două şiruri de caractere a, de lungime na şi b, de lungime nb. Şirul a este

numit centru al şirului b dacă na≤nb şi este un subşir al lui b determinat prin eliminarea primelor,
respectiv ultimelor x litere ale șirului b(1≤x≤nb).

Pentru un cuvânt dat se cere să se afișeze toate subșirurile centru care se pot obține,
precum și numărul acestora.

Date de intrare: Programul citeşte din fișierul cuvinte.in un şir de caractere s cu cel mult
20 de caractere şi minim un caracter, format doar din litere mici ale alfabetului englez.

Date de ieșire: Programul va scrie în fișierul cuvinte.out, pe prima linie numărul de

subșiruri centru corespunzătoare șirului s citit, iar pe a doua linie toate aceste subșiruri, în
ordinea descrescătoare a lungimii, separate prin câte un spaţiu, ca în exemplu.

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
ifstream fin("cuvinte.in");
ofstream fout("cuvinte.out");

string s;
fin >> s;

int n = s.length();
 vector<string> subșiruri;

for (int i = 0; i <= n; i++) {

string centru = s.substr(0, i);
subșiruri.push_back(centru);
}

sort(subșiruri.begin(), subșiruri.end(), [](const string& a, const string& b) {

return a.length() > b.length();
});

fout << subșiruri.size() << endl;

for (const string& subșir : subșiruri) {

fout << subșir << " ";
}
fout << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 13

Un număr natural x se numește număr vocal asociat unui șir de caractere a, dacă este
format din cifrele corespunzătoare numerelor de ordine ale vocalelor din șirul a. Numerele de ordine
ale caracterelor din șirul a se consideră numerotate de la stânga la dreapta, începând cu valoarea 1.
Dacă numărul de ordine al unei vocale este mai mare decât 9, cifra se obține scăzând din valoarea
acestuia, valoarea 10.

Scrieţi un program C/C++ care pentru un cuvânt dat, determină și afișează numărul vocal
asociat.

Date de intrare: Programul va citi din fișierul cuvant.in un şir de caractere a cu cel mult
30 caractere şi minim un caracter, format doar din litere mici ale alfabetului englez.

Date de ieșire: Programul va scrie în fișierul numar.out, numărul vocal asociat şirului
memorat în variabila a, ca în exemplu. Dacă șirul a are mai mult de 17 caractere, sau este format
doar din consoane, se va afișa mesajul Imposibil.

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main() {
ifstream fin("cuvant.in");
ofstream fout("numar.out");

string a;
fin >> a;

int n = a.length();
if (n > 17 || n == 0) {
fout << "Imposibil" << endl;
} else {
string numar;
for (int i = 0; i < n; i++) {
char ch = a[i];
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
int ordine = i + 1;
if (ordine > 9) {
numar += to_string(ordine - 10);
} else {
numar += to_string(ordine);
}
}
}

if (numar.empty()) {
fout << "Imposibil" << endl;
} else {
fout << numar << endl;
}
}

fin.close();
fout.close();

return 0;
}

Biletul nr. 14

Un număr natural x se numește număr cons asociat unui șir de caractere a, dacă este
format din cifrele corespunzătoare numerelor de ordine ale consoanelor din șirul a. Numerele de
ordine ale caracterelor din șirul a se consideră numerotate de la stânga la dreapta, începând cu
valoarea 1. Dacă numărul de ordine al unei consoane este mai mare decât 9, cifra se obține scăzând
din valoarea acestuia, valoarea 10.

Scrieţi un program C/C++ care, pentru un cuvânt dat, determină și afișează numărul cons
asociat.
 Date de intrare: Programul va citi din fișierul cuvant.in un şir a cu cel mult 30 caractere
şi minim un caracter, format doar din litere mici ale alfabetului englez.

Date de ieșire: Programul va scrie în fișierul numar.out, numărul cons asociat şirului
memorat în variabila a, ca în exemplu. Dacă șirul a are mai mult de 17 caractere, sau este format
doar din vocale, se va afișa mesajul Imposibil.

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

int main() {
ifstream fin("cuvant.in");
ofstream fout("numar.out");

string a;
fin >> a;

int n = a.length();
if (n > 17 || n == 0) {
fout << "Imposibil" << endl;
} else {
string numar;
for (int i = 0; i < n; i++) {
char ch = a[i];
if (ch != 'a' && ch != 'e' && ch != 'i' && ch != 'o' && ch != 'u') {
int ordine = i + 1;
if (ordine > 9) {
numar += to_string(ordine - 10);
} else {
numar += to_string(ordine);
}
}
}

if (numar.empty()) {
fout << "Imposibil" << endl;
} else {
fout << numar << endl;
}
}

fin.close();
fout.close();

return 0;
}

Biletul nr. 15
 Se consideră un text cu cel mult 255 de caractere (litere mici ale alfabetului englez și spații),
în care cuvintele sunt separate printr-un singur spațiu. Înaintea primului cuvânt și după ultimul
cuvânt nu există spații.

Scrieți un program C/C++ care citește un număr natural x și un text de tipul menționat mai
sus și afișează numărul de cuvinte din textul dat în care litera o apare cel puțin o dată și de cel mult x
ori, iar apoi, cuvintele ce îndeplinesc această condiție.

Date de intrare: Programul va citi din fișierul atestat.in, de pe prima linie, un număr
natural x (x≤10), apoi de pe linia următoare un text t cu cel mult 255 de caractere şi minim
un caracter, scris pe o singură linie, format doar din litere mici ale alfabetului englez și spații.

Date de ieșire: Programul va scrie în fișierul atestat.out, pe prima linie, numărul de

cuvinte determinat corespunzător cerinței, iar pe următoarele linii, cuvintele care îndeplinesc
condițiile cerute.

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

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int x;
fin >> x;
fin.ignore();

string text;
getline(fin, text);

istringstream iss(text);
string word;
int count = 0;

while (iss >> word) {

int o_count = 0;
for (char ch : word) {
if (ch == 'o') {
o_count++;
}
}

if (o_count >= 1 && o_count <= x) {

count++;
fout << word << endl;
 }
}

fout << count << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 16

Se consideră un text cu cel mult 100 de caractere (litere mici ale alfabetului englez și spații),
în care cuvintele sunt separate printr-un singur spațiu. Înaintea primului cuvânt și după ultimul
cuvânt nu există spații.

Scrieți un program C/C++ care citește un text t de tipul menționat mai sus și o literă mică c.
Programul determină dublarea fiecărei litere c în șirul t și afișează pe ecran numărul de modificari
realizate și textul modificat în memorie.

Date de intrare: Programul va citi din fișierul atestat.in, de pe prima linie, un text t
cu cel mult 100 de caractere şi minim un caracter, scris pe o singură linie, format doar din litere mici
ale alfabetului englez și spații. De pe linia următoare se va citi un singur caracter c.

Date de ieșire: Programul va scrie în fișierul atestat.out, pe prima linie, numărul de

modificări realizate conform cerinței, iar pe următoarea linie, textul modificat în memorie. Dacă
litera corespunzătoare caracterului c, nu se gasește în text, acesta va fi afișat nemodificat.

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

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

string text;
getline(fin, text);

char c;
fin >> c;

int modifications = 0;
for (char& ch : text) {
 if (ch == c) {
text.insert(text.begin() + (&ch - &text[0]) + 1, ch);
modifications++;
}
}

fout << modifications << endl;

fout << text << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 17

Se consideră un text cu cel mult 255 de caractere (litere mici ale alfabetului englez și spații),
în care cuvintele sunt separate printr-un singur spațiu. Înaintea primului cuvânt și după ultimul
cuvânt nu există spații. Fiecare cuvânt are cel puțin o consoană.

Scrieți un program C/C++ care citește un număr natural x, un text de tipul menționat mai
sus și apoi modifică textul astfel: se vor șterge primele x vocale din fiecare cuvânt al textului. Dacă
într-un cuvânt nu există cel puțin x vocale atunci cuvântul din text va rămâne nemodificat.

Date de intrare: Programul va citi din fișierul atestat.in, de pe prima linie, un număr
natural x (x≤10), apoi de pe linia următoare un text t cu cel mult 255 de caractere şi minim
un caracter, scris pe o singură linie, format doar din litere mici ale alfabetului englez și spații.

Date de ieșire: Programul va scrie în fișierul atestat.out textul modificat conform cerinței

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

bool isVowel(char ch) {

ch = tolower(ch);
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}

string modifyText(const string& text, int x) {

string modifiedText;
string word;

for (char ch : text) {

if (isalpha(ch)) {
 word += ch;
} else {
int vowelCount = 0;
for (char& c : word) {
if (isVowel(c)) {
vowelCount++;
if (vowelCount <= x) {
c = ' ';
}
}
}
modifiedText += word;
modifiedText += ch;
word.clear();
}
}

int vowelCount = 0;
for (char& c : word) {
if (isVowel(c)) {
vowelCount++;
if (vowelCount <= x) {
c = ' ';
}
}
}
modifiedText += word;

return modifiedText;
}

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int x;
fin >> x;
fin.ignore(); // Ignore newline character

string text;
getline(fin, text);

string modifiedText = modifyText(text, x);

fout << modifiedText << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 18
 Se consideră un text cu cel mult 255 de caractere (litere mici ale alfabetului englez și spații),
în care cuvintele sunt separate printr-un singur spațiu. Înaintea primului cuvânt și după ultimul
cuvânt nu există spații. Fiecare cuvânt are cel puțin o vocală.

Scrieți un program C/C++ care citește un număr natural x, un text de tipul menționat mai
sus și apoi modifică textul astfel: se vor șterge ultimele x consoane din fiecare cuvânt al textului.
Dacă într-un cuvânt nu există cel puțin x consoane atunci cuvântul din text va rămâne nemodificat.

Date de intrare: Programul va citi din fișierul atestat.in, de pe prima linie, un număr
natural x (x≤10), apoi de pe linia următoare un text t cu cel mult 255 de caractere şi minim
un caracter, scris pe o singură linie, format doar din litere mici ale alfabetului englez și spații.

Date de ieșire: Programul va scrie în fișierul atestat.out textul modificat conform

cerinței.

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

bool isVowel(char ch) {

ch = tolower(ch);
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}

string modifyText(const string& text, int x) {

string modifiedText;
string word;

for (char ch : text) {

if (isalpha(ch)) {
word += ch;
} else {
int consonantCount = 0;
for (int i = word.size() - 1; i >= 0; i--) {
char c = word[i];
if (!isVowel(c)) {
consonantCount++;
if (consonantCount <= x) {
word[i] = ' ';
}
}
}
modifiedText += word;
modifiedText += ch;
word.clear();
}
}
 int consonantCount = 0;
for (int i = word.size() - 1; i >= 0; i--) {
char c = word[i];
if (!isVowel(c)) {
consonantCount++;
if (consonantCount <= x) {
word[i] = ' ';
}
}
}
modifiedText += word;

return modifiedText;
}

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int x;
fin >> x;
fin.ignore(); // Ignore newline character

string text;
getline(fin, text);

string modifiedText = modifyText(text, x);

fout << modifiedText << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 19

Se consideră un text cu cel mult 50 de caractere (litere mici ale alfabetului englez și spații), în
care cuvintele sunt separate prin câte un singur spațiu. Înaintea primului cuvânt și după ultimul
cuvânt nu există spații. Textul are cel puțin o vocală.

Scrieți un program C/C++ care citește un text t de tipul menționat mai sus. Programul
determină modificarea în memorie a textului prin inserarea după fiecare vocală a unui grup de două
litere format din cele două litere ce succed (urmează) vocala în alfabetul englez.
 Date de intrare: Programul va citi din fișierul atestat.in, de pe prima linie un text t
cu cel mult 50 de caractere şi minim un caracter, scris pe o singură linie, format doar din litere mici
ale alfabetului englez și spații.

Date de ieșire: Programul va scrie în fișierul atestat.out textul modificat conform

cerinței.

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

bool isVowel(char ch) {

ch = tolower(ch);
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}

string modifyText(const string& text) {

string modifiedText;
for (char ch : text) {
modifiedText += ch;
if (isVowel(ch)) {
char nextLetter1 = (ch + 1 - 'a') % 26 + 'a';
char nextLetter2 = (ch + 2 - 'a') % 26 + 'a';
modifiedText += nextLetter1;
modifiedText += nextLetter2;
}
}
return modifiedText;
}

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

string text;
getline(fin, text);

string modifiedText = modifyText(text);

fout << modifiedText << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 20
 Se consideră un text codificat cu cel mult 255 de caractere (litere mici ale alfabetului englez
și spații), în care cuvintele sunt separate prin câte un singur spațiu. Înaintea primului cuvânt și după
ultimul cuvânt nu există spații. Codificarea acestui text s-a realizat prin inserarea după fiecare vocală
a unui grup de două litere format din cele două litere ce succed (urmează) vocala în alfabetul englez.

Scrieți un program C/C++ care citește un text de tipul menționat mai sus. Programul
decodifică textul prin ștergerea grupului de două litere inserate inițial după fiecare vocală și afișează
pe ecran textul astfel modificat.

Date de intrare: Programul va citi din fișierul atestat.in, de pe prima linie un text t
cu cel mult 255 de caractere şi minim un caracter, scris pe o singură linie, format doar din litere mici
ale alfabetului englez și spații.

Date de ieșire: Programul va scrie în fișierul atestat.out textul modificat conform

cerinței.

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

bool isVowel(char ch) {

ch = tolower(ch);
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}

string decodeText(const string& text) {

string decodedText;
int length = text.length();
int i = 0;
while (i < length) {
char ch = text[i];
decodedText += ch;
if (isVowel(ch)) {
i += 2; // Omitim cele două litere adăugate după vocală
} else {
i++;
}
}
return decodedText;
}

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

string text;
getline(fin, text);

string decodedText = decodeText(text);

 fout << decodedText << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 21

În fișierul atestat.in, pe prima linie se află un număr n (2 ≤ n ≤ 20),

reprezentând numărul de linii și de coloane ale unui tablou bidimensional si un număr natural k (1
≤ k ≤ n), iar pe următoarele n linii se află câte n numere naturale de maxim 6 cifre, ce
reprezintă elementele tabloului.

Scrieți un program care citește din fișierul atestat.in numerele n si k, tabloul

bidimensional cu n*n elemente și afișează în fișierul atestat.out indicii liniilor (diferite de k)
care au cel puțin un element comun cu linia k a tabloului. Liniile și coloanele tabloului au indicii de
la 1 la n. Valorile se vor afișa pe prima linie a fișierului de ieșire, separate prin exact un spațiu.

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

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int n, k;
fin >> n >> k;

// Citim tabloul bidimensional

vector<vector<int>> tablou(n, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
fin >> tablou[i][j];
}
}

// Determinăm linia k
vector<int>& linieK = tablou[k - 1];

// Set pentru a stoca indicii liniilor cu elemente comune cu linia k

unordered_set<int> indiciLiniilor;
 // Parcurgem fiecare linie a tabloului
for (int i = 0; i < n; i++) {
if (i != k - 1) { // Excludem linia k
vector<int>& linie = tablou[i];

// Verificăm dacă există elemente comune între linia k și linia curentă

for (int j = 0; j < n; j++) {
if (linieK[j] == linie[j]) {
indiciLiniilor.insert(i + 1); // Adăugăm indicele liniei (i + 1) în set
break; // Trecem la următoarea linie
}
}
}
}

// Afișăm indicii liniilor

for (int indice : indiciLiniilor) {
fout << indice << " ";
}
fout << endl;

fin.close();
fout.close();

return 0;
}

Biletul nr. 22

.
a. Scrieți definiția completă a subprogramului interschimbL cu patru parametri:
 a, reprezentând un tablou bidimensional cu cel mult 200 de linii și 200 de
coloane;
 m, reprezentând numărul de coloane;
 k1 și k2, două numere naturale, reprezentând numărul de ordine a două linii
din tablou.
Subprogramul interschimbă elementele de pe linia k1 cu elementele de pe linia k2.
b. În fișierul atestat.in, pe prima linie se află două numere n și m (2 ≤ n, m ≤
200) reprezentând numărul de linii, respectiv de coloane ale unui tablou
bidimensional, iar pe următoarele n linii se află câte m numere naturale de maxim 9
cifre, ce reprezintă elementele tablouluiScrieți un program care citește din fișierul
atestat.in numerele n și m, apoi tabloul bidimensional cu n*m elemente și,
folosind apeluri utile ale subprogramului interschimbL, schimbă între ele
elementele liniei pe care apare prima dată valoarea minimă din tablou cu elementele
liniei pe care apare prima data valoarea maximă. Tabloul modificat se va scrie în
 fișierul atestat.out, fiecare linie a tabloului se va scrie pe o linie din fișier, iar
elementele de pe aceeași linie vor fi separate printr-un spațiu. Dacă cele două valori
apar pentru prima data pe aceeași linie, tabloul nu va fi modificat.

A.
void interschimbL(int a[][200], int m, int k1, int k2) {
for (int j = 0; j < m; j++) {
int temp = a[k1][j];
a[k1][j] = a[k2][j];
a[k2][j] = temp;
}
}

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

void interschimbL(int a[][200], int m, int k1, int k2);

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int n, m;
fin >> n >> m;

int tablou[200][200];

// Citirea tabloului din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fin >> tablou[i][j];
}
}

int minVal = tablou[0][0];

int minI = 0, minJ = 0;

int maxVal = tablou[0][0];

int maxI = 0, maxJ = 0;

// Căutarea valorii minime și a valorii maxime în tablou

for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (tablou[i][j] < minVal) {
minVal = tablou[i][j];
minI = i;
minJ = j;
} else if (tablou[i][j] > maxVal) {
maxVal = tablou[i][j];
 maxI = i;
maxJ = j;
}
}
}

// Verificare dacă valorile minime și maxime se află pe aceeași linie

if (minI != maxI) {
// Interșchimbarea liniilor
interschimbL(tablou, m, minI, maxI);
}

// Scrierea tabloului modificat în fișierul de ieșire

for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fout << tablou[i][j] << " ";
}
fout << endl;
}

fin.close();
fout.close();

return 0;
}

void interschimbL(int a[][200], int m,

Biletul nr. 23

a. Scrieți definițiile complete ale următoarelor două subprograme:

 Subprogramul nrpare_p are doi parametri, prin care primește: n, un număr natural
din intervalul [2, 100]; a, un tablou bidimensional cu n linii și n coloane de numere
naturale din intervalul [0, 103]; Subprogramul returnează numărul elementelor
pare situate pe diagonala principală a tabloului a sau valoarea -1 dacă diagonala nu
conține valori pare.
 Subprogramul nrpare_s are doi parametri, prin care primește: n, un număr
natural din intervalul [2, 100]; a, un tablou bidimensional cu n linii și n coloane de
numere naturale din intervalul [0, 103 ]; Subprogramul returnează numărul
elementelor pare situate pe diagonala secundară a tabloului a sau -1 dacă diagonala
nu conține valori pare.
b. Fișierul matrice.in conține pe prima linie un număr natural n (2 ≤ n ≤ 100), iar
pe următoarele n linii câte n numere naturale din intervalul [0,103], separate prin câte
un spațiu. Scrieți un program care să citească din fișier n apoi cele n*n elemente ale unui
tablou bidimensional și să afișeze pe ecran numărul valorilor impare situate pe cele două
 diagonale ale tabloului. Pentru afișarea valorii cerute se folosesc apeluri utile ale
subprogramelor nrpare_p și nrpare_s. Dacă nu există nicio valoare impară pe
diagonale atunci pe ecran se afișează mesajul nu exista.
A.
// Subprogramul nrpare_p
int nrpare_p(int n, int a[][100]) {
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i][i] % 2 == 0) {
count++;
}
}
if (count > 0) {
return count;
} else {
return -1;
}
}

// Subprogramul nrpare_s
int nrpare_s(int n, int a[][100]) {
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i][n - 1 - i] % 2 == 0) {
count++;
}
}
if (count > 0) {
return count;
} else {
return -1;
}
}

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

int nrpare_p(int n, int a[][100]);

int nrpare_s(int n, int a[][100]);

int main() {
ifstream fin("matrice.in");
int n;
fin >> n;

int tablou[100][100];

// Citirea tabloului din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
 fin >> tablou[i][j];
}
}

int count_p = nrpare_p(n, tablou);

int count_s = nrpare_s(n, tablou);

// Afișarea rezultatelor
if (count_p == -1 && count_s == -1) {
cout << "Nu exista" << endl;
} else {
cout << "Diagonala principala: " << count_p << " elemente pare" << endl;
cout << "Diagonala secundara: " << count_s << " elemente pare" << endl;
}

fin.close();

return 0;
}

Biletul nr. 24

a. Scrieți definiția completă pentru subprogramul suma cu trei parametri:

– x, matrice pătratică cu elemente întregi;
– n, număr natural ce reprezintă numărul efectiv de linii și coloane ale matricei x,
2 ≤ n ≤ 10;
– p, număr natural, 1 ≤ p ≤ n.
Subprogramul va returna suma elementelor aflate pe linia p a matricei.

b. Scrieți un program care citește din fișierul matrice.in un număr natural n și o matrice cu
n linii ți n coloane și afișează în fișierul matrice.out indicii liniilor din matrice pentru care
suma elementelor are valoare maximă. Se va folosi subprogramul definit la punctul a. Liniile
și coloanele tabloului au indicii de la 1 la n.

A.
int suma(int x[][10], int n, int p) {
int sum = 0;
for (int j = 0; j < n; j++) {
sum += x[p - 1][j];
}
return sum;
}

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

int suma(int x[][10], int n, int p);

int main() {
ifstream fin("matrice.in");
ofstream fout("matrice.out");

int n;
fin >> n;

int matrice[10][10];

// Citirea matricei din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
fin >> matrice[i][j];
}
}

int maxSum = 0;
int liniiMaxime[10];
int count = 0;

// Calcularea sumelor pentru fiecare linie și găsirea valorii maxime

for (int i = 0; i < n; i++) {
int sum = suma(matrice, n, i + 1);
if (sum > maxSum) {
maxSum = sum;
count = 0;
liniiMaxime[count] = i + 1;
count++;
} else if (sum == maxSum) {
liniiMaxime[count] = i + 1;
count++;
}
}

// Afișarea rezultatelor în fișierul de ieșire

for (int i = 0; i < count; i++) {
fout << liniiMaxime[i] << " ";
}

fin.close();
fout.close();

return 0;
}

int suma(int x[][10], int n, int p) {

int sum = 0;
for (int j = 0; j < n; j++) {
sum += x[p - 1][j];
}
return sum;
}
 Biletul 25

a. Scrieți definiția completă pentru subprogramul numarare cu trei parametri: x, matrice

pătratică cu elemente întregi;n, număr natural ce reprezintă numărul efectiv de linii și coloane
ale matricei x, 2≤n≤10; p, număr natural, 1≤p≤n. Subprogramul va returna numărul
elementelor nenule aflate pe coloana p a matricei. Scrieți definiția completă pentru
subprogramul toateNule cu trei parametri:x, matrice pătratică cu elemente întregi;n, număr
natural ce reprezintă numărul efectiv de linii și coloane ale matricei x, 2≤n≤10; p, număr
natural, 1≤p≤n.Subprogramul va returna true (sau 1) dacă toate elementele liniei p din
matricea x au valoare 0, altfel va returna false (sau 0) .
b. Scrieți un program care citește din fișierul atestat.in un număr natural n (2≤n≤100) și
elementele unui tablou bidimensional cu cifre binare dispuse pe n linii și n coloane. Utilizând
apeluri utile ale subprogramelor de la punctul a, programul modifică tabloul în memorie astfel:
fiecare linie formată doar din valori 0 va fi înlocuită cu valorile reprezentând numărul de 1 de pe
coloana corespunzătoare din tabloul inițial. Tabloul modificat va fi afișat pe ecran.

A.
int numarare(int x[][10], int n, int p) {
int count = 0;
for (int i = 0; i < n; i++) {
if (x[i][p - 1] != 0) {
count++;
}
}
return count;
}

bool toateNule(int x[][10], int n, int p) {

for (int i = 0; i < n; i++) {
if (x[p - 1][i] != 0) {
return false;
}
}
return true;
}

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

int numarare(int x[][10], int n, int p);

bool toateNule(int x[][10], int n, int p);

int main() {
 ifstream fin("atestat.in");
int n;
fin >> n;

int tablou[10][10];

// Citirea tabloului din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
fin >> tablou[i][j];
}
}

// Modificarea tabloului în memorie

for (int i = 0; i < n; i++) {
if (toateNule(tablou, n, i + 1)) {
int numarDeUnu = numarare(tablou, n, i + 1);
for (int j = 0; j < n; j++) {
tablou[i][j] = numarDeUnu;
}
}
}

Biletul nr. 26

Într-un tablou bidimensional, cu elemente având valori numai din mulțimea {0,1}, numim coloane
”complementare” două coloane cu proprietatea că oricare două elemente ale acestora, aflate pe
aceeași linie, sunt diferite.

a. Scrieți definiția completă a subprogramului complementare cu următorii parametri: a,

reprezentând un tablou bidimensional cu cel mult 200 de linii și 200 de coloane; n,
reprezentând numărul de linii ale tabloului a, k1 și k2, două numere naturale, reprezentând
numărul de ordine a două coloane din tablou. Subprogramul returnează true (sau valoarea 1)
dacă coloanele k1 și k2 sunt complementare, în caz contrar returnează false (sau valoarea
0).
b. Scrieți un program care citește din fișierul atestat.in două numere naturale din intervalul
[2,200], n și m și elementele unui tablou bidimensional cu n linii și m coloane, numere din
mulțimea {0,1}. Programul afișează pe ecran, utilizând apeluri utile ale subprogramului
complementare, numărul de coloane ale tabloului care sunt complementare cu prima
coloană a acestuia.
A.
bool complementare(int a[][200], int n, int k1, int k2) {
for (int i = 0; i < n; i++) {
if (a[i][k1 - 1] == a[i][k2 - 1]) {
return false;
 }
}
return true;
}

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

bool complementare(int a[][200], int n, int k1, int k2);

int main() {
ifstream fin("atestat.in");
int n, m;
fin >> n >> m;

int tablou[200][200];

// Citirea tabloului din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fin >> tablou[i][j];
}
}

int numarColoaneComplementare = 0;

// Verificarea complementarității coloanelor

for (int j = 2; j <= m; j++) {
if (complementare(tablou, n, 1, j)) {
numarColoaneComplementare++;
}
}

// Afișarea rezultatului
cout << "Numarul de coloane complementare cu prima coloana: " << numarColoaneComplementare <<
endl;

return 0;
}

Biletul nr. 27

a. Scrieți definiția completă a subprogramului interschimbC, cu patru parametri:

- a, reprezentând un tablou bidimensional cu cel mult 200 de linii și 200 de
coloane;
- n, reprezentând numărul de linii;
 - k1 și k2, două numere naturale, reprezentând numărul de ordine a două coloane
din tablou. Subprogramul interschimbă elementele de pe coloana k1 cu elementele
de pe coloana k2.
b. În fișierul atestat.in, pe prima linie se află două numere n și m (2≤n, m≤200)
reprezentând numărul de linii, respectiv de coloane ale unui tablou bidimensional, iar
pe următoarele n linii se află câte m numere naturale de maxim 9 cifre, ce reprezintă
elementele tabloului.
Scrieți un program care citește din fișierul atestat.in numerele n și m, apoi tabloul
bidimensional cu n*m elemente și, folosind apeluri utile ale subprogramului
interschimbC, schimbă între ele elementele coloanei pe care apare prima dată
valoarea minimă din tablou cu elementele coloanei pe care apare prima data valoarea
maximă. Tabloul modificat se va scrie în fișierul atestat.out, fiecare linie a
tabloului se va scrie pe o linie din fișier, iar elementele de pe aceeași linie vor fi
separate printr-un spațiu. Dacă cele două valori apar pentru prima data pe aceeași
linie, tabloul nu va fi modificat.
A.
void interschimbC(int a[][200], int n, int k1, int k2) {
for (int i = 0; i < n; i++) {
int temp = a[i][k1 - 1];
a[i][k1 - 1] = a[i][k2 - 1];
a[i][k2 - 1] = temp;
}
}

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

void interschimbC(int a[][200], int n, int k1, int k2);

int main() {
ifstream fin("atestat.in");
ofstream fout("atestat.out");

int n, m;
fin >> n >> m;

int tablou[200][200];

// Citirea tabloului din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fin >> tablou[i][j];
}
}

int minColoana = 0;
 int maxColoana = 0;

// Determinarea coloanelor cu valorile minime și maxime

for (int j = 1; j < m; j++) {
if (tablou[0][j] < tablou[0][minColoana]) {
minColoana = j;
}
if (tablou[0][j] > tablou[0][maxColoana]) {
maxColoana = j;
}
}

// Verificarea dacă valorile minime și maxime apar pe aceeași linie

bool modificare = (tablou[0][minColoana] != tablou[0][maxColoana]);

// Efectuarea interschimbului de coloane

if (modificare) {
interschimbC(tablou, n, minColoana + 1, maxColoana + 1);
}

// Scrierea tabloului modificat în fișierul de ieșire

for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fout << tablou[i][j] << " ";
}
fout << endl;
}

fin.close();
fout.close();

return 0;
}

Biletul nr. 28

a. Scrieți definiția completă a subprogramului maxim_d, cu doi parametri, prin care

primește: n, un număr natural din intervalul [2, 100]; a, un tablou bidimensional
cu n linii și n coloane cu elemente numere naturale din intervalul [0, 106] și
returnează valoarea maximă dintre elementele pare situate pe diagonala principală sau
pe diagonala secundară a tabloului a, respectiv valoarea -1 dacă cele două diagonale nu
conțin nici o valoare pară.

b. Fișierul matrice.in conține pe prima linie un număr natural n (2 ≤ n ≤ 100), iar

pe următoarele n linii câte n numere naturale din intervalul [0,106], separate prin câte
un spațiu. Scrieți un program care să citească din fișier n, apoi cele n*n elemente ale
unui tablou bidimensional și utilizând apeluri utile ale subprogramului maxim_d, să
 modifice în memorie tabloul citit astfel: toate elementele impare, cu excepția celor de pe
diagonale, se vor înlocui cu valoarea maximă pară de pe diagonala principală sau
secundară a tabloului. Tabloul astfel modificat va fi afișat în fișierul matrice.out. Dacă
pe diagonalele tabloului nu există nicio valoare pară, în fișier se afișează mesajul
tablou nemodificat.
A.
int maxim_d(int n, int a[][100]) {
int maxPar = -1;

// Verificare diagonala principală

for (int i = 0; i < n; i++) {
if (a[i][i] % 2 == 0 && a[i][i] > maxPar) {
maxPar = a[i][i];
}
}

// Verificare diagonala secundară

for (int i = 0; i < n; i++) {
if (a[i][n - i - 1] % 2 == 0 && a[i][n - i - 1] > maxPar) {
maxPar = a[i][n - i - 1];
}
}

return maxPar;
}

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

int maxim_d(int n, int a[][100]);

int main() {
ifstream fin("matrice.in");
ofstream fout("matrice.out");

int n;
fin >> n;

int tablou[100][100];

// Citirea tabloului din fișierul de intrare

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
fin >> tablou[i][j];
}
}

int maxPar = maxim_d(n, tablou);

bool modificare = false;

 // Modificarea tabloului
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (tablou[i][j] % 2 != 0 && (i != j && i != n - j - 1)) {
tablou[i][j] = maxPar;
modificare = true;
}
}
}

// Scrierea tabloului modificat în fișierul de ieșire

if (modificare) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
fout << tablou[i][j] << " ";
}
fout << endl;
}
} else {
fout << "tablou nemodificat" << endl;
}

fin.close();
fout.close();

return 0;
}

Biletul nr. 29

La un magazin au fost aduse mai multe sortimente de produse, pentru fiecare cunoscându-
se cantitatea (exprimată în bucăţi), preţul de achiziţie şi adaosul comercial (exprimat în procent din
valoarea de achiziţie). În decursul uneisăptămâni s-a contorizat, cantitatea vândută din fiecare
produs.

Realizați un program care citește din fișierul vanzari.in numărul natural n (reprezentând
numărul de produse vândute, numerotate de la 1 la n), apoi de pe următoarele n linii cate trei
numere reale reprezentând cantitatea, prețul și adaosul comercial pentru fiecare din cele n produse
vândute. Programul afișează pe ecran valoarea totală a vânzărilor obținute pe întreaga săptămână
precum și numărul de ordine (din fișier) al celui mai vândut produs (produsul care a fost vândut în
cantitatea cea mai mare). Dacă există mai multe produse vândute în aceeași cantitate maximă se va
lua în considerare cel cu adaosul comercial mai mare.
#include <iostream>
#include <fstream>
using namespace std;

struct Produs {
int numar;
float cantitate;
float pret;
float adaos;
};

int main() {
ifstream fin("vanzari.in");

int n;
fin >> n;

Produs produse[100];

// Citirea datelor despre produsele vandute

for (int i = 0; i < n; i++) {
fin >> produse[i].cantitate >> produse[i].pret >> produse[i].adaos;
produse[i].numar = i + 1;
}

fin.close();

float vanzariTotal = 0.0;

float cantitateMaxima = 0.0;
int numarProdusMaxim = 0;

// Calcularea valorii totale a vanzarilor si gasirea produsului cel mai vandut

for (int i = 0; i < n; i++) {
float vanzariProdus = produse[i].cantitate * produse[i].pret * (1 + produse[i].adaos / 100);
vanzariTotal += vanzariProdus;

if (produse[i].cantitate > cantitateMaxima ||

(produse[i].cantitate == cantitateMaxima && produse[i].adaos > produse[numarProdusMaxim -
1].adaos)) {
cantitateMaxima = produse[i].cantitate;
numarProdusMaxim = produse[i].numar;
}
}

cout << "Valoarea totala a vanzarilor: " << vanzariTotal << endl;
cout << "Numarul produsului cel mai vandut: " << numarProdusMaxim << endl;

return 0;
}

Biletul nr. 30
 Pentru elevii clasei a XII-a, profesorul diriginte are nevoie de următoarele informații,
pentru a calcula nota la purtare a unui elev: numele, prenumele, numărul total de absențe și
numărul de absențe motivate. Pentru fiecare 10 absențe nemotivate, elevul pierde un punct la
nota de la purtare. Dacă numărul absențelor nemotivate este mai mare de 50, elevul primește
media 4.

Realizați un program care citește din fișierul elevi.in de pe prima linie, numărul
natural n (reprezentând numărul elevilor din clasă), apoi de pe următoarele n linii ale
fișierului datele fiecărui elev: numele (șir de caractere fără spații), prenumele (șir de
caractere fără spații), număr_total de absențe (nr. natural) și numărul de absențe
motivate (nr. natural). Programul calculează notele la purtare ale elevilor și afișează
în fișierul elevi.out, o listă a elevilor (numele, prenumele, nota la purtare) ordonată
descrescător după nota de la purtare.

Precizări: toate numerele din fișierul de intrare sunt mai mici decât 200,

iar lungimea șirurilor de caractere nu depășește valoarea 50.

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

struct Elev {
string nume;
string prenume;
int absenteTotale;
int absenteMotivate;
int notaPurtare;
};

bool comparareNote(const Elev& elev1, const Elev& elev2) {

return elev1.notaPurtare > elev2.notaPurtare;
}

int main() {
ifstream fin("elevi.in");
ofstream fout("elevi.out");

int n;
fin >> n;

vector<Elev> elevi(n);
 // Citirea datelor despre elevi
for (int i = 0; i < n; i++) {
fin >> elevi[i].nume >> elevi[i].prenume >> elevi[i].absenteTotale >> elevi[i].absenteMotivate;

// Calcularea notei de la purtare

int absenteNemotivate = elevi[i].absenteTotale - elevi[i].absenteMotivate;
elevi[i].notaPurtare = 10 - absenteNemotivate / 10;
if (absenteNemotivate > 50) {
elevi[i].notaPurtare = 4;
}
}

fin.close();

// Sortarea elevilor in functie de nota de la purtare

sort(elevi.begin(), elevi.end(), comparareNote);

// Afisarea elevilor in fisier

for (const auto& elev : elevi) {
fout << elev.nume << " " << elev.prenume << " " << elev.notaPurtare << endl;
}

fout.close();

return 0;
}