ianuarie 31

2014
Probleme Atestat
Informatică 2013‐2014
Subiecte și soluții
PROGRAMARE
Cuprins

Subiectul 1 .............................................................................................. 3
Subiectul 2 .............................................................................................. 3
Subiectul 3 .............................................................................................. 4
Subiectul 4 .............................................................................................. 4
Subiectul 5 .............................................................................................. 5
Subiectul 6 .............................................................................................. 6
Subiectul 7 .............................................................................................. 6
Subiectul 8 .............................................................................................. 7
Subiectul 9 .............................................................................................. 8
Subiectul 10............................................................................................. 8
Subiectul 11............................................................................................. 9
Subiectul 12........................................................................................... 10
Subiectul 13........................................................................................... 10
Subiectul 14........................................................................................... 11
Subiectul 15........................................................................................... 12
Subiectul 16........................................................................................... 12
Subiectul 17........................................................................................... 13
Subiectul 18........................................................................................... 13
Subiectul 19........................................................................................... 14
Subiectul 20........................................................................................... 14
Subiectul 21........................................................................................... 15
Subiectul 22........................................................................................... 16
Subiectul 23........................................................................................... 16
Subiectul 24........................................................................................... 17
Subiectul 25........................................................................................... 17
Subiectul 26........................................................................................... 18
Subiectul 27........................................................................................... 19
Subiectul 28........................................................................................... 19
Subiectul 29........................................................................................... 20
Subiectul 30........................................................................................... 21
Subiectul 31........................................................................................... 22
Subiectul 32........................................................................................... 22
Subiectul 33........................................................................................... 23
Subiectul 34........................................................................................... 24
Subiectul 35........................................................................................... 25
Subiectul 36........................................................................................... 25
Subiectul 37........................................................................................... 26
Subiectul 38........................................................................................... 27
Subiectul 39........................................................................................... 27
Subiectul 40........................................................................................... 28
Subiectul 1
Scrieţi un program care citeşte de la tastatura un număr natural n (n<100) și un șir cu n numere întregi din
intervalul [100, 999]. Programul construieşte un șir de numere rezultat prin înlocuirea fiecărui număr din şirul
citit cu numărul obţinut prin interschimbarea cifrei unităților cu cifra sutelor. Numerele din noul șir se vor afişa
pe ecran separate printr-un singur spaţiu.
Exemplu : pentru n=3 si şirul 123 , 904 , 500
se afişează 321 , 409 , 5.

#include <iostream>
using namespace std;
int main()
{
int n,v[100],i,x,j=0;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)

Cuprins
{
cout<<"x=";cin>>x;
j++;
v[j]=x%10*100+x/10%10*10+x/100;
}
n=j;
for(i=1;i<=n;i++)
cout<<v[i]<<" ";
}

Subiectul 2
Scrieţi un program care afişează toate numerele naturale, mai mari decât 10 și mai mici decât o valoare data n,
n<=2.000.000 , formate doar din cifre identice.
Exemplu: pentru n=195 se afişează : 11 , 22 , 33 , 44 , 55 , 66 , 77 , 88 , 99 , 111.

#include <iostream>
using namespace std;
int main()
{
int n,uc,i,ok,x;
cout<<"n=";cin>>n;
for(i=10;i<=n;i++)
{
x=i;ok=1;
uc=x%10;
while(x && ok)
{
if(uc!=x%10)
ok=0;
x/=10;
}
if(ok)
cout<<i<<" ";
}
}
Subiectul 3
În fişierul Numere.txt pe prima linie este memorat un număr natural n (n<10000), iar pe linia următoare un şir
de n numere naturale distincte cu maximum 4 cifre fiecare, separate prin câte un spaţiu. Afişaţi pe prima linie a
fişierului de ieşire Rezultat.out poziţia pe care s-ar găsi primul element din şirul aflat pe linia a doua a fişierului,
daca şirul ar fi ordonat crescător. Numerotarea poziţiilor elementelor în cadrul şirului este de la 1 la n.
Exemplu: Dacă fişierul Numere.txt are următorul conţinut:
6
267 13 45 628 7 79
Fişierul Rezultat.out va avea următorul conţinut:5
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int n,i,x,y,j=0;
ifstream f("Numere.txt");
ofstream g("Rezultat.out");
f>>n;f>>x;
for(i=2;i<=n;i++)
{
f>>y;
if(y<x)
j++;
Cuprins
}
g<<j+1;
f.close();
g.close();
}

Subiectul 4
Se citește p un număr natural. Construiţi în memorie o matrice pătratica cu n linii și n coloane,unde n este
numărul de cifre al numărului citit. Matricea va fi construită astfel: pe diagonal principală va conţine 0, deasupra
diagonalei principale cea mai mare cifră a numărului p, iar sub diagonala principală cea mai mică cifră a
numărului p. Matricea va fi afişata pe următoarele n linii elementele fiecărei linii fiind separate de câte un
singur spaţiu. Veţi utiliza un subprogram care primeşte ca parametru un număr natural p de cel mult 9 cifre şi
returnează prin intermediul parametrilor n, max, min numărul de cifre, cifra maximă, respectiv cifra minimă a
numărului p.
Exemplu: p=824
Se va afișa:
088
208
220
#include <iostream>
using namespace std;
void s(int p,int &n,int &max,int &min)
{
n=0;max=0;min=9;
while(p)
{
n++;
if(p%10>max)
max=p%10;
if(p%10<min)
min=p%10;
p/=10;
}
}
int main()
{
int a[10][10],n,i,j,max,min,p;
cout<<"p=";cin>>p;
s(p,n,max,min);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(i==j)
a[i][j]=0;
else
if(i<j)
a[i][j]=max;
else
a[i][j]=min;
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
Cuprins
cout<<a[i][j]<<" ";
cout<<endl;
}
}

Subiectul 5
Se citește un cuvânt format doar din litere mici, separate prin unul sau mai multe spaţii. Definim randamentul
unui cuvânt ca fiind numărul de caractere distincte din cuvânt / lungimea cuvântului. De exemplu şirul
“caractere“ are randamentul 1/9=0.11. Afişaţi în fişierul Rezultate.out, randamentul cuvântului citit – cu două
zecimale.
Exemplu: dacă se citește cuvântul:
probleme
Fişierul Rezultate.out va avea următorul conţinut:
0.75
#include <iostream>
#include <cstring>
#include <iomanip>
#include <fstream>
using namespace std;
int main()
{
char s[100];
int k=0,n,i,fr[32]={0};
ofstream g("Rezultate.out");
cout<<"Introduceti cuvantul:";
cin.get(s,100);
n=strlen(s);
for(i=0;s[i];i++)
fr[s[i]-'a']++;
for(i=0;i<=32;i++)
if(fr[i]==1)
{
cout<<(char)(i+'a')<<" ";
k++;
}
cout<<"Numarul de caractere distincte este "<<k<<"."<<endl;
cout<<"Lungimea sirului de caractere este "<<n<<"."<<endl;
cout<<"Randamentul cu doua zecimale ";
cout<<" este "<<fixed<<setprecision(2)<<(float)k/n<<".";
g<<fixed<<setprecision(2)<<(float)k/n;
g.close();
}
Subiectul 6
O matrice pătratică A de dimensiune n cu p elemente nenule este memorată economic în fişierul de intrare
Matrice.txt sub următoarea formă.: pe prima linie a fişierului se găsesc două numere n şi p, dimensiunea
matricei respectiv numărul de elemente nenule iar pe următoarele p linii triplete de numere naturale (v, l, c)
care reprezintă valoarea, linia respectiv coloana pe care se găsesc elementele nenule. Scrieţi un program care
citeşte informaţiile din fişierul de intrare, reface şi scrie în fişierul de ieşire Matrice.out matricea A.

Exemplu: dacă fişierul Matrice.txt are următorul conţinut:

58
111
512
123
225
332
441
243
854
Fişierul Matrice.out va avea următorul conţinut:
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int a[100][100]={0},n,p,v,l,c,i,j,k;
ifstream f("Matrice.txt");
ofstream g("Matrice.out");
f>>n>>p;
for(k=1;k<=p;k++)
{
f>>v>>l>>c;
i=l;j=c;

}
a[i][j]=v;
Cuprins
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
g<<a[i][j]<<" ";
g<<endl;
}
f.close();
g.close();
}

Subiectul 7
Pentru un şir de caractere s, citit de la tastatură să se construiască și să se afișeze un “şablon”acesta fiind un alt
şir de caractere de aceiași lungime cu s, ce conține doar caractere din mulţimea {*, ?, #}, astfel încât fiecare
poziţie din s în care se găseşte o vocală să fie codificată cu caracterul *, pe fiecare poziţie din s în care apare o
consoană să fie codificată cu # şi pe fiecare poziţie din s în care apare orice alt caracter să fie codificat cu ?. Se
consideră vocală orice literă din mulţimea {a,e,i,o,u}.
Exemplu: pentru șirul: informatica_
Pe ecran se va afişa
*##*##*#*#*?
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
char s[100];
int i;
cout<<"Introduceti sirul:";
cin.get(s,100);
for(i=0;s[i];i++)
{
if(isalnum(s[i])==0)
cout<<"?"; Cuprins
else
if(strchr("aeiou",s[i])==0)
cout<<"#";
else
cout<<"*";
}
}

Subiectul 8
Fişierul atestat.in conţine două linii. Pe prima linie este scris un număr natural nenul n, (5<n<30).Pe cea de-a
doua linie a fişierului sunt scrise n numere naturale separate prin câte un spaţiu, formate fiecare din cel mult 4
cifre, reprezentând un şir de n numere naturale. Şirul conţine cel puţin două numere impare.
Să se scrie un program care:
a) să afişeze pe ecran, în linie, în ordinea inversă citirii, toate numerele din şir,separate prin câte un spaţiu;
b) să afişeze pe ecran, în linie, numărul de cifre din care este format fiecare numărdin şirul iniţial, separându-le
prin câte un spaţiu;
Exemplu:
Dacă fișierul atestat.in conține:
6
13 555 71 2 242 1001
Se va afișa:
1001 242 2 71 555 13
232134
#include <iostream>
#include <fstream>
using namespace std;
int contor(int x)
{
if(x==0)
return 0;
else
return contor(x/10)+1;
}
int main()
{
int n,v[30],i;
ifstream f("atestat.in");
f>>n;
for(i=1;i<=n;i++)
f>>v[i];
//a
for(i=n;i>=1;i--)
cout<<v[i]<<" ";
cout<<endl;
//b
for(i=1;i<=n;i++)
cout<<contor(v[i])<<" "; f.close();
}
Subiectul 9
Fişierul atestat.in conţine o singură linie pe care se află scris un text format din cel mult 200 de caractere,
primul caracter fiind literă, iar cuvintele din text sunt separate prin câte un spaţiu. Fiecare cuvânt este format
doar din litere mari sau mici ale alfabetului limbii engleze.
Să se scrie un program care:
c) să afişeze textul pe o singură linie a ecranului, scris cu majuscule;
d) să afişeze în fișierul atestat.out numărul consoanelor din text;
Exemplu:
atestat.in
Imi place Informatica
Se va afișa:
IMI PLACE INFORMATICA
10

#include <iostream>
#include <cstring>
#include <fstream>
using namespace std;
int main()
{
char s[200];
int i,nr=0;
ifstream f("atestat.in");
ofstream g("atestat.out");
f.get(s,200);
cout<<strupr(s)<<endl;
for(i=0;s[i];i++)
if(strchr("AEIOU",s[i])==0 and s[i]!=' ')
nr++;
g<<nr;
//sau
i=0; Cuprins
while(s[i])
{
if(s[i]>='A' && s[i]<='Z' || s[i]==' ')
i++;
else
s[i]=toupper(s[i]);//s[i]=s[i]-32;
}
for(i=0;s[i];i++)
if(strchr("AEIOU",s[i])==0 and s[i]!=' ')
nr++;
cout<<s<<endl;
g<<nr;
f.close();
g.close();
}

Subiectul 10
10. Se citeşte de la tastatură un şir de n numere naturale de maxim 9 cifre (n<=100). Să se afişeze pe ecran cifra
de control a numerelor din șir. Se va utiliza un subprogram care determină suma cifrelor unui număr natural.
Cifra de control a unui număr se obţine calculând suma cifrelor numărului, apoi se realizează suma cifrelor
sumei numărului, ş.a.m.d. până când se obţine ca sumă un număr de o cifră.
Exemplu: n=6
13, 452, 1198, 986, 24, 881
Se va afișa:
4, 2, 1, 5, 6, 8
#include <iostream>
using namespace std;
int suma(int x)
{
int s=0;
while(x)
{
s=s+x%10;
x/=10;
}
return s;
}
int main()
{
int n,i,v[100];
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
{
cout<<"v["<<i<<"]=";
cin>>v[i];
}
for(i=1;i<=n;i++)
{
while(v[i]>9)
Cuprins
{
v[i]=suma(v[i]);
}
cout<<v[i]<<" ";
}
}

Subiectul 11
Scrieţi programul care citeşte de la tastatură un număr natural n (1 <n<10), apoi n*n numere întregi, mai mici
decât 32000, reprezentând elementele unui tablou bidimensional cu n linii şi n coloane, şi care determină şi
afişează pe ecran ultima cifră a produsului numerelor prime de pe diagonala principală a tabloului sau mesajul
imposibil dacă nu există numere prime.
Exemplu: n=4
15 10 9 2
40 12 13 2
20 14 7 7
31 15 14 2
Se va afișa 4(deoarece produsul este 14)

#include <iostream>
using namespace std;
int prim(int x)
{
int d;
for(d=2;d<=x/2;d++)
if(x%d==0)
return 0;
return 1;
}
int main()
{
int a[10][10],n,i,j,p=1;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
cout<<"a["<<i<<"]["<<j<<"]=";
cin>>a[i][j];
}
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
if(i==j && prim(a[i][j]))
p=p*a[i][j];
cout<<p%10;
}

Subiectul 12
Scrieţi un program C/C++ care citeşte de la tastură un număr natural n cu cel mult 8 cifre (n≥10) şi care creează
fişierul text NR.TXT ce conţine numărul n şi toate prefixele nenule ale acestuia, pe o singură linie, separate prin
câte un spaţiu, în ordine descrescătoare a valorii lor.
Exemplu: pentru n=10305 fişierul NR.TXT va conţine numerele:
10305 1030 103 10 1

#include <iostream>
#include <fstream>
using namespace std;
int main() Cuprins
{
int n;
ofstream f("NR.TXT");
cout<<"n=";cin>>n;
while(n)
{
f<<n<<" ";
n/=10;
}
f.close();
}

Subiectul 13
Se consideră un text alcătuit din cel mult 250 de caractere, în care cuvintele sunt formate doar din litere mici ale
alfabetului englez şi sunt separate prin unul sau mai multe caractere *. Scrieţi un program C/C++ care citeşte
de la tastatură textul şi afişează pe ecran, pe câte o linie, toate secvenţele formate din câte două litere identice,
ca în exemplu.
Exemplu: dacă textul citit este:
cand*lucreaza**pe*grupe***copiii*trebuie*sa*coopereze
se afișează perechile de mai jos
ii
ii
oo
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
char s[250],*p,cuv[25];
int i;
cout<<"Introduceti textul: ";
cin.get(s,250);
p=strtok(s,"*");
while(p)
{
strcpy(cuv,p);
for(i=0;cuv[i];i++)
if(cuv[i]==cuv[i+1])
cout<<cuv[i]<<cuv[i+1]<<endl;
p=strtok(NULL,"*");
}
}

Subiectul 14
Se citesc de la tastatură două numere naturale: n și m de maxim 9 cifre fiecare. Să se afișeze câte cifre comune
au cele două numere citite și care sunt aceste cifre.
Exemplu : Numerele 21348 și 14513 au 3 cifre comune : 1, 3, 4.

#include <iostream>
using namespace std;
int main() Cuprins
{
int n,m,nr=0,frn[10]={0},frm[10]={0},i;
cout<<"n=";cin>>n;
cout<<"m=";cin>>m;
while(n)
{
frn[n%10]++;
n/=10;
}
while(m)
{
frm[m%10]++;
m/=10;
}
for(i=0;i<10;i++)
if(frn[i]!=0 and frm[i]!=0)
{cout<<i<<" ";nr++;}
cout<<endl<<nr;
}
Subiectul 15
Se citesc de la tastatura n numere naturale, cu cel mult 9 cifre fiecare. Scrieti un program care pentru o cifră k
citită de la tastatură, afișează pe ecran câte numere în scrierea cărora apare cifra k, se găsesc în șirul dat.
Exemplu: pentru n=4 , cifra k=2 si valorile citite 23, 603, 122, 27 se obtine numarul nr = 3.

#include <iostream>
using namespace std;
int main()
{
int n,i,k,nr=0,ok,x;
cout<<"n=";cin>>n;
cout<<"k=";cin>>k;
for(i=1;i<=n;i++)
{
cout<<"x=";cin>>x;
ok=0;
while(x && !ok)
{
if(x%10==k)
ok=1;
x/=10;
}
if(ok==1)
nr++; Cuprins
}
cout<<nr;
}

Subiectul 16
Se citesc de la tastatură n numere naturale, cu cel mult 9 cifre fiecare. Scrieţi un program care afişează cifra care
apare de cele mai multe ori în numerele citite. Dacă există mai multe astfel de cifre se vor afişa toate.
Exemplu: Pentru n=4 şi valorile 23, 431, 154, 452 se afişează 4 pentru că cifra 4 apare de 3 ori în numerele
citite.
#include <iostream>
using namespace std;
int main()
{
int n,fr[10]={0},i,x,max=0;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
{
cout<<"x=";cin>>x;
while(x)
{
fr[x%10]++;
if(fr[x%10]>max)
max=fr[x%10];
x/=10;
}
}
for(i=0;i<10;i++)
if(fr[i]==max)
cout<<i<<" ";
}
Subiectul 17
Fişierul numere.in conţine pe prima linie mai multe numere naturale în ordine crescătoare dintre care cel puțin
o putere a lui 3. Scrieţi un program care afişează pe ecran numerele din fişier ce sunt puteri ale lui 3.
Exemplu: 27, 43, 54, 81, 452, 729 se afişează 27, 81,729.

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int x,c;
ifstream f("numere.in");
while(f>>x)
{
c=x;
while(x%3==0)
x=x/3;
if(x==1)
cout<<c<<" ";
}
f.close(); Cuprins
}

Subiectul 18
Să se scrie un program care să verifice dacă suma cifrelor de pe poziţiile impare şi suma cifrelor de pe poziţiile
pare ale unui număr natural n citit de la tastatură sunt egale. Poziţiile se numără de la dreapta la stânga
începând cu poziţia 1. Se afişează sumele şi un mesaj corespunzător pe ecran.
Exemplu: se citeşte: n=12345 şi se afişează: sp=6 şi simp=9 Nu coincid!.

#include <iostream>
using namespace std;
int main()
{
int n,sp=0,simp=0,i=0;
cout<<"n=";cin>>n;
while(n)
{
i++;
if(i%2!=0)
simp=simp+n%10;
else
sp=sp+n%10;
n/=10;
}
cout<<"sp="<<sp<<" si simp="<<simp<<" ";
if(sp!=simp)
cout<<"Nu coincid!";
else
cout<<"Coincid!";
}
Subiectul 19

Se consideră o matrice oarecare de dimensiune mxn cu elemente numere naturale. Să se afişeze numerele cu
număr impar de divizori din matrice şi să se indice numărul lor. Exemplu: se citeşte: m=2 şi n=3 şi matricea
12 7 25
4 11 8
se afişează: 4, 25, 2 numere.

#include <iostream>
using namespace std;
int main()
{
int a[10][10],n,m,i,j,d,k,nr=0;
cout<<"m=";cin>>m;
cout<<"n=";cin>>n;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{
cout<<"a["<<i<<"]["<<j<<"]=";
cin>>a[i][j];
}
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{k=2;
for(d=2;d<=a[i][j]/2;d++)
if(a[i][j]%d==0)
Cuprins
k++;
if(k%2!=0)
{cout<<a[i][j]<<", ";nr++;}
}
cout<<nr<<" numere";
}

Subiectul 20
Scrieţi un program C/C++ care citeşte de la tastatură numerele întregi m şi n (1<=m<=50,1<=n<=50) şi
elementele unui tablou bidimensional cu m linii şi n coloane, numere întregi distincte de cel mult 4 cifre fiecare.
Programul va afişa pe prima linie a ecranului numărul de elemente prime de pe fiecare coloana a matricii,
separate prin câte un spațiu. Definiți o funcţie care verifică dacă un număr întreg este prim şi folosiți apeluri ale
ei pentru rezolvarea cerinţei.Exemplu: pentru m=3 şi n=4 şi tabloul de mai jos
17 1 4
4 6 12 3
9 22 8 5
Pe ecran se va afişa:
1112
#include <iostream>
using namespace std;
int prim(int x)
{
int d;
for(d=2;d<=x/2;d++)
if(x%d==0)
return 0;
return 1;
}
int main()
{
int a[50][50],m,n,i,j,nr;
cout<<"m=";cin>>m;
cout<<"n=";cin>>n;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{
cout<<"a["<<i<<"]["<<j<<"]=";
cin>>a[i][j];
}
for(j=1;j<=n;j++)
{ nr=0;
for(i=1;i<=m;i++)
if(prim(a[i][j]))
nr++;
cout<<nr<<" ";
}
}

Subiectul 21
Se dă o înregistrare cu numele cerc, în care sunt stocate abscisa și ordonata centrului cercului și raza acestuia.
Pentru un n număr natural <100, citiți datele pentru n cercuri și sortați structurile descrescător în funcție de
diametru. Exemplu: pentru n=4 și perechile de forma (x,y,r): (2,3,4) (1,2,7) (3,2,6) (7,8,5)
Se afișează:
(1,2) d=14
(3,2) d=12
(7,8) d=10
(2,3) d=8

#include <iostream>
using namespace std;
int main()
{ Cuprins
struct cerc
{
int abscisa,ordonata,r,d;
} x[100],aux;
int n,i,j;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
{
cout<<"Cercul nr. "<<i<<":";
cout<<"Abscisa cercului nr. "<<i<<":";cin>>x[i].abscisa;
cout<<"Ordonata cercului nr. "<<i<<":";cin>>x[i].ordonata;
cout<<"Raza cercului nr. "<<i<<":";cin>>x[i].r;
x[i].d=2*x[i].r;
}
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if(x[i].d<x[j].d)
{
aux=x[i];x[i]=x[j];x[j]=aux;
}
for(i=1;i<=n;i++)
cout<<"("<<x[i].abscisa<<","<<x[i].ordonata<<")d="<<x[i].d<<endl;
}
Subiectul 22
Se citesc de la tastatură elementele unui vector cu n numere naturale sortat crescător şi un număr natural k. Să
se insereze numărul k în şirul dat astfel încât șirul să rămână sortat crescător. Exemplu: n=4 și k=100 și
numere: 90 95 110 120
Se va afișa : 90 95 100 110 120.

#include<iostream>
using namespace std;
int main()
{
int v[100],n,i,s,d,m,k;
cout<<"n=";cin>>n;
cout<<"k=";cin>>k;
for(i=1;i<=n;i++)
{
cout<<"v["<<i<<"]=";
cin>>v[i];
}
s=1;d=n;
while(s<=d)
{
m=(s+d)/2;
if(k<v[m])
d=m-1;
else
s=m+1;
}
for(i=n+1;i>s;i--) Cuprins
v[i]=v[i-1];
v[s]=k;
for(i=1;i<=n+1;i++)
cout<<v[i]<<" ";
}

Subiectul 23
Fişierul note.in conţine pe prima linie un număr natural n (2 < n < 100), iar pe a doua linie sunt n numere
naturale cuprinse între 1 şi 10, reprezentând notele a n elevi dintr-o clasă, cel puţin 3 note fiind distincte. Să se
scrie un program care determină şi afişează pe ecran media aritmetică a celor n note, ştiind că notele cele mai
mici (<5) şi notele cele mai mari(>=9) nu se iau în considerare la calculul mediei.
Exemplu: note.in
5
28497
Se va afişa: 7.5 (deoarece notele 2, 4 şi nota 9 se elimină).
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int x,n,k=0,i,s=0;
ifstream f("note.in");
f>>n;
for(i=1;i<=n;i++)
{
f>>x;
if(x>=5 && x<9)
{s=s+x;k++;}
}
cout<<(float)s/k; f.close();
}
Subiectul 24
Se citesc din fişierul numere.in mai multe numere naturale nenule de cel mult 6 cifre până la întâlnirea
numărului 0. Să se afişeze în fişierul numere.out numerele prime.
Exemplu:
numere.in
25 31 100 123456 23 0
numere.out
31 23
#include <iostream>
#include <fstream>
using namespace std;
int prim(int x)
{
int d;
for(d=2;d<=x/2;d++)
if(x%d==0)
return 0;
return 1;
}
int main()
{
int x;
ifstream f("numere.in");
ofstream g("numere.out");
f>>x;
while(x)
{ Cuprins
if(prim(x))
g<<x<<" ";
f>>x;
}
f.close();
g.close();
}

Subiectul 25

Fişierul numere.in conţine pe prima linie numărul natural n (2 < = n < = 25000), pe a doua linie un şir de n
numere naturale cuprinse între 1 şi 1000, iar pe a treia linie un număr natural x cuprins între 1 şi 1000. Să se
memoreze şirul într-un vector și să se înlocuiască toate elementele egale cu x cu produsul dintre x și numărul
divizorilor lui x. Vectorul rezultat va fi afişat în fişierul numere.out.
Exemplu:
numere.in

7
3 3 3 999 3 67 24
3
numere.out
6 6 6 999 6 67 24

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int n,v[100],i,x,d,nr;
ifstream f("numere.in");
ofstream g("numere.out");
f>>n;
for(i=1;i<=n;i++)
{
f>>v[i];
}
f>>x;
for(i=1;i<=n;i++)
{
if(v[i]==x)
{
nr=2;
for(d=2;d<=v[i]/2;d++)
if(v[i]%d==0)
nr++;
v[i]=nr*x;
}
g<<v[i]<<" ";
Cuprins
}
f.close();
g.close();
}

Subiectul 26
Se știe că orice număr par n>=4 se poate scrie ca sumă a doua numere prime. Să se afișeze în fișierul sume.txt
toate sumele posibile de numere prime ce dau ca rezultat n.Exemplu:pentru n=20 se vor afișa sumele 1+19,
3+17, 7+13, 13+7, 17+3,19+1.
#include <iostream>
#include <fstream>
using namespace std;
int prim(int x)
{
int d;
for(d=2;d<=x/2;d++)
if(x%d==0)
return 0;
return 1;
}
int main()
{
ofstream f("sume.txt");
int n,a,b;cout<<"n=";cin>>n;
if(n%2!=0)
cout<<"Numarul trebuie sa fie par!";
else
if(n==4)
cout<<2<<" + "<<2;
else
{
for(a=1;a<=n;a++,a++)
if(prim(a))
{
b=n-a;if(prim(b))
f<<a<<" + "<<b<<endl;
}
} f.close();
}
Subiectul 27
Din fișierul propozitie.in se citește un șir de caractere, reprezentând mai multe cuvinte separate între ele prin
următorii separatori: ,, ;, ,!,?. Să se verifice dacă după eliminarea acestora șirul este palindromic ( se va afișa DA
în caz afirmativ și NU în caz contrar).Exemplu: pentru propozitia
Ele fac … cafele ? se afișează DA.
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
int main()
{
ifstream f("propozitie.in");
char s[200],inv[200];
int i;
f.get(s,200);
i=0;
while(s[i])
if(strchr(",:;.!? ",s[i]))
strcpy(s+i,s+i+1);
else
i++;
strupr(s);strcpy(inv,s);
if(strcmp(s,strrev(inv))==0)

Cuprins
cout<<"DA";
else
cout<<"NU";
f.close();
}

Subiectul 28
Definim operaţia de compactare a unui tablou ca fiind eliminarea zerourilor din tablou. Dacă întâlnim un
element nul toate elementele situate la dreapta sa vor deplasa cu o poziţie la stânga, în locul său. Se citesc
elementele unui tablou cu n numere intregi, se cere să-l compactați. Exemplu: pentru n=4 și numerele: 9 0 0 5
Se va afișa 9 5.

Metoda nr.1 - cu ajutorul unui vector auxiliar în care se rețin valorile diferite de 0. Metoda este simplă, dar nu
respectă în totalitate cerințele problemei.

#include <iostream>
using namespace std;
int main()
{
int n,v[100],a[100],j=0,i;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
{
cout<<"v["<<i<<"]=";
cin>>v[i];
}
for(i=1;i<=n;i++)
if(v[i]!=0)
{
j++;a[j]=v[i];
}
n=j;
for(i=1;i<=n;i++)
cout<<a[i]<<" ";
}
Metoda nr.2, mai complexă, dar respectă în totalitate cerințele problemei.

#include <iostream>
using namespace std;
int v[100],n,poz1,poz2,i;
int pozitie(int poz)
{
while(poz<n && v[poz]==0)
poz++;
if(poz<=n && v[poz]!=0)
return poz;
else
return 0;
}
int main()
{
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
{
cout<<"v["<<i<<"]=";
cin>>v[i];
}
/*
cautam pozitia primului element 0 in vector
si memoram pozitia acestuia in poz1
*/
for(poz1=1;poz1<n && v[poz1]!=0;poz1++);
if(v[poz1]==0)
{
/* Cuprins
cautam pozitia primului element diferit de 0
si memoram pozitia in poz2
*/
poz2=pozitie(poz1+1);
/*
cat timp poz2 exista
atribuim elementului de la poz1
valoarea elementului de la poz2
*/
while(poz2!=0)
{
v[poz1]=v[poz2];
poz1++;
poz2=pozitie(poz2+1);
}
n=poz1-1;//pozitia ultimului element din vectorul compactat
}
for(i=1;i<=n;i++)
cout<<v[i]<<" ";
}

Subiectul 29
Se citesc mai multe cuvinte din fișierul șiruri.txt. Afisati pe ecran, cuvintele ordonate lexicografic.Exemplu:
Siruri.txt conține maine am examen, pe ecran se afișează am examen maine.
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
int main()
{
ifstream f("siruri.txt");
char s[200],*p,cuv[20][20],aux[20];
int i=0,n,j;
f.get(s,200);
p=strtok(s," ");
while(p)
{
i++;
strcpy(cuv[i],p);
p=strtok(NULL," ");
}
n=i;
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if(strcmp(cuv[i],cuv[j])>0)
{
strcpy(aux,cuv[i]);
strcpy(cuv[i],cuv[j]);
strcpy(cuv[j],aux);
}
for(i=1;i<=n;i++)
cout<<cuv[i]<<" ";
Cuprins
f.close();
}

Subiectul 30
Folosind vectori de structură, să se calculeze pentru n numere complexe modulul lor. Vectorii se vor citi dintr-
un fișier complexe.in care va conține pe fiecare rând partea reală și coeficientul părții imaginare a fiecărui
număr complex.
Exemplu: complexe.in 3 și apoi pe câte o linie 3 4, 6 3, 2 7, se va afișa, pe câte o linie 5, 6.7, 7.3.

#include <iostream>
#include <fstream>
#include <cmath>
#include <iomanip>
using namespace std;
int main()
{
struct complex
{
float real,imaginar, modulul;
}c[20];
int n,i=0;
ifstream f("complexe.in");
f>>n;
for(i=1;i<=n;i++)
{
f>>c[i].real>>c[i].imaginar;
c[i].modulul=sqrt(pow(c[i].real,2)+pow(c[i].imaginar,2));
}
for(i=1;i<=n;i++)
cout<<fixed<<setprecision(1)<<c[i].modulul<<endl;
f.close();
}
Subiectul 31
Știind că orice număr natural se poate scrie ca sumă de puteri distincte ale lui 2, să se determine o modalitate de
scriere a numărului n, citit de la tostatura, ca sumă de puteri ale lui 2 în fișierul suma.txt.
Exemplu: n=5
suma.txt 22+20
#include <iostream>
#include <fstream>
#include <cmath>
using namespace std;
int main()
{
int n,x,nr,i;
ofstream f("suma.txt");
cout<<"n="; cin>>n;
/*determinam cea mai mare putere a lui 2
in scrierea lui n si o salvam in variabila x*/
for(i=0; i<=n/2; i++)
if(pow(2,i)<=n)
x = i;
//afisam cea mai mare putere a lui 2
f<<2<<" ^ "<<x<<" ";
nr = pow(2,x);
/*determinam exponentii care sunt mai mici
decat exponentul maxim si ii afisam*/
for(i=x-1; i>=0; i--)
if(nr + pow(2,i) <= n)
{
f<<2<<" ^ "<<i<<" ";
nr=nr+pow(2,i);
Cuprins
}
f.close();
}

Subiectul 32

Fiind dată o matrice patratică de dimensiune n, să se afișeze în fișierul matrice.txt această matrice, fără a afișa
cele 2 diagonale și să se calculeze media artimetică a elementelor pozitive și media geometrică a elementelor
negative din matrice.
Exemplu:n=3
123
-4 5 -6
7 -8 9
matrice.txt
2
-4 -6
-8

4.5 – media arithmetică a elementelor pozitive

5.769 – media geometrică a elementelor negative

#include <iostream>
#include <fstream>
#include <cmath>
using namespace std;
int main()
{
int a[10][10],n,i,j,p=1,sp=0,k=0,w=0;
ofstream f("matrice.txt");
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
cin>>a[i][j];
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
if(i!=j && i+j!=n+1)
f<<a[i][j]<<" ";
f<<endl;
}
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(a[i][j]>=0)
{sp=sp+a[i][j];k++;}
else
{p=p*a[i][j];w++;}

Cuprins
f<<endl<<(float)sp/k<<endl;
if(p<0)
p=-p;
f<<endl<<pow(p,1.0/w);
f.close();
}

Subiectul 33
Pe fiecare linie a fișierului numere.txt este scris câte un număr natural n. Să se găsească pentru fiecare număr
citit cel mai mare număr prim strict mai mic decat n și cel mai mic număr prim mai mare strict decat n și să se
afișeze aceste două numere în fișierul rezultate.txt.
Exemplu:
numere.txt
7
36
10
18
rezultate.txt
5 11
31 37
7 11
17 19
#include <iostream>
#include <fstream>
#include <limits.h>
using namespace std;
int prim(int x)
{
int d;
for(d=2;d<=x/2;d++)
if(x%d==0)
return 0;
return 1;
}
int main()
{
ifstream f("numere.txt");
ofstream g("rezultate.txt");
int n,a,b,i;
while(f>>n)
{
for(i=n-1;i>=0;i--)
if(prim(i))
{a=i;break;}
for(i=n+1;i<INT_MAX;i++)
if(prim(i))
{b=i;break;}
g<<a<<" "<<b<<endl;
}
f.close();
g.close();
}

Subiectul 34
Se citesc din fișierul fractii.txt câte două numere, reprezentând număratorul și numitorul fiecărei fracții. Să se
afișeze în fișierul rezultate.txt aceste fracții simplificate.
Exemplu:
fractii.txt
64
10 5
150 20
rezultate.txt
32
21
15 2
#include <iostream> Cuprins
#include <fstream>
using namespace std;
int cmmdc(int a,int b)
{
int r;
while(b)
{
r=a%b;
a=b;
b=r;
}
return a;
}

int main()
{
int x,y,z;
ifstream f("fractii.txt");
ofstream g("rezultate.txt");
while(f>>x>>y)
{
z=cmmdc(x,y);
g<<x/z<<" "<<y/z<<endl;
}
f.close();
g.close();
}
Subiectul 35
Se citesc din fisierul text numere.txt, numere întregi. Să se calculeze cel mai mare divizor comun dintre
numerele de pe poziții impare(primul număr, al treilea, etc,) și cel mai mic multiplu comun dintre numerele de
pe poziții pare (al doilea numar, al patrulea, etc) și să se afișeze.
Exemplu:
numere.txt: 2 3 18 5 27
cmmdc(2,18,27)=1
cmmmc(3,5)=15

#include <iostream>
#include <fstream>
using namespace std;
int cmmdc(int a,int b)
{
int r;
while(b)
{
r=a%b;
a=b;
b=r;
}
return a;
}
int cmmmc(int a,int b)
{
return (a*b)/cmmdc(a,b);
}
int main()
Cuprins
{
ifstream f("numere.txt");
int i,a,b,x,y,z,w,t;
i=5;
f>>x>>y>>z>>t;
a=cmmdc(x,z);
b=cmmmc(y,t);
while(f>>w)
{
if(i%2)
a=cmmdc(a,w);
else
b=cmmmc(b,w);
i++;
}
cout<<a<<" "<<b;
f.close();
}

Subiectul 36
Un număr a este imperfect dacă suma divizorilor săi, exceptând numărul însuși este mai mică decât a. Fiind dat
un număr n de la tastatură să se construiască vectorul cu primele n numere imperfecte.
Exemplu:n=5 se afișează 2 3 4 5 7
#include <iostream>
using namespace std;
int imperfect(int x)
{
int s=1,d;
for(d=2;d<=x/2;d++)
if(x%d==0)
s+=d;
return (s<x);
}
int main()
{
int n,i,k,j=0,v[100];
cout<<"n=";cin>>n;
for(i=1,k=1;k<=n;i++)
if(imperfect(i))
{j++;v[j]=i;k++;}
for(i=1;i<=n;i++)
cout<<v[i]<<" ";
}

Subiectul 37
Se citesc mai multe cuvinte din fișierul de intrare fraze.txt. Să se afișeze, pe câte un rând, cuvintele din fișier,
lungimile lor și să se afișeze în final lungimea maximă și minimă a cuvintelor citite din fișier.
Exemplu:
eu sunt printre cei cuminti din scoala
Eu 2
Sunt 4
Printre 7
Cei 3
Cuminti 7
Din 3
Scoala 6
Cuprins
Lungimea minima a cuvintelor este 2
Lungimea maxima a cuvintelor este 7
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
int main()
{
ifstream f("fraze.txt");
char s[255],*p;
int min,max;
f.get(s,255);
f.close();
p=strtok(s," ");
min=255;max=0;
while(p)
{
*p=toupper(*p);
cout<<p<<" "<<strlen(p)<<endl;
if(strlen(p)>max)
max=strlen(p);
if(strlen(p)<min)
min=strlen(p);
p=strtok(NULL," ");
}
cout<<"Lungimea minima a cuvintelor este "<<min<<endl;
cout<<"Lungimea maxima a cuvintelor este "<<max;
}
Subiectul 38
Se citeşte un şir de numere naturale până la citirea lui 0 (care nu face parte din şir). Să se calculeze media
aritmetică a numerelor de 3 cifre din şir care au cel puţin o cifră egală cu k, citit de la tastatură.
Exemplu:k=5
Pentru şirul 2, 751, 215, 210, 2157, 85, 550, 620, 0 media aritmetică este 505.3
#include <iostream>
#include <iomanip>
using namespace std;
int contor(int x,int k)
{
int i=0,ok=0;
while(x)
{
i++;
if(k==x%10)
ok=1;
x/=10;
}
return (i==3 and ok==1);
}
int main()
{
int n,s=0,k,i=0;
cout<<"k=";cin>>k; Cuprins
cout<<"n=";cin>>n;
while(n)
{
if(contor(n,k))
{
s+=n;i++;
}
cout<<"n=";cin>>n;
}
cout<<fixed<<setprecision(1)<<(float)s/i;
}

Subiectul 39
Să se realizeze un program care să afișeze numerele din fișierul atestat.in care au numărul cifrelor pare egal cu
numărul cifrelor impare. Afișați și numărul acestor numere. Exemplu: atestat.in : 12 1524 99 6543
Se va afisa : 12 1524 6543

#include <iostream>
#include <fstream>
using namespace std;
int egale(int x)
{
int cp=0,ci=0;
while(x)
{
if(x%2==0)
cp++;
else
ci++;
x/=10;
}
return (cp==ci);
}
int main()
{
ifstream f("atestat.in");
int x,k=0;
while(f>>x)
{
if(egale(x))
{cout<<x<<" ";k++;}
}
f.close();
cout<<endl<<"S-au gasit "<<k<<" numere.";
}

Subiectul 40
Realizați un program care să folosească un subprogram recursiv pentru afișarea numerelor ce conțin numărul
maxim de cifre distincte, citirea celor n valori intregi se face de la tastatură. Exemplu: n=5 , 121 38 7 1188 22 se
va afișa: 1188 38 121.

#include <iostream>
using namespace std;
int v[100],n;
int contor_distincte(int x)
{
int fr[10]={0},i,c=0;
while(x)
{
fr[x%10]=1;
x/=10; Cuprins
}
for(i=0;i<10;i++)
if(fr[i]==1)
c++;
return c;
}
void afisare(int i,int max)
{
if(i!=n)
{
afisare(i+1,max);
if(contor_distincte(v[i])==max)
cout<<v[i]<<" ";
}
}
int main()
{
int x,j=0,k,max=0;
cout<<"n=";cin>>n;
for(k=1;k<=n;k++)
{
cout<<"x=";cin>>x;
v[j]=x;j++;
if(contor_distincte(x)>max)
max=contor_distincte(x);
}
afisare(0,max);
}