-----------------------------------------------------------------------------------

--------------------------

Se citeste n si construieste o matrice in care toate elementele de deasupra

diagonalei principale sunt 0,
elementele de pe ultima linie sunt numerele de la 1 la n, iar restul elementelor se
obtin prin insumarea
elementelor vecine adica aflate pe linia imediat urmatoare, pe aceeasi coloana cu
el si pe una din coloanele
alaturate.

#include <iostream>
#include <iomanip>
using namespace std;

int a[10][10];
int main() {
int n, i, j;
cin>>n;
for (j=1; j<=n; j++)
a[n][j]=j;
for (i=n-1; i>=1; i--)
for (j=n-1; j>=1; j--)
if (i<j)
a[i][j]=0;
else a[i][j]=a[i+1][j]+a[i+1][j+1]+a[i+1][j-1];
for (i=1; i<=n; i++){
for (j=1; j<=n; j++)
cout<<setw(4)<<a[i][j]<<" ";
cout<<endl;
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int a[10][10];
int main() {
int n, m, k=1, i, j;
cin>>n>>m;
for (j=1; j<=m; j++)
for (i=1; i<=n; i++){
a[i][j]=k;
k++;
}
for (i=1; i<=n; i++){
for (j=1; j<=m; j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un n si un m. Sa se construiasca o matrice de dimensiuni n*m care

contine toate numerele
de la 1 la n*m.

#include <iostream>
using namespace std;

int a[10][10];
int main() {
int n, m, k=1, i, j;
cin>>n>>m;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++){
a[i][j]=k;
k++;
}
for (i=1; i<=n; i++){
for (j=1; j<=m; j++)
cout<<a[i][j];
cout<<endl;
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int a[10][10];
int main() {
int n, m, i, j, suma=0;
cin>>n>>m;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++)
cin>>a[i][j];
for (i=1; i<=n; i++){
suma=0;
for (j=1; j<=m; j++)
suma=suma+a[i][j];
cout<<suma<<endl;
}
for (i=1; i<=n; i++){
for (j=1; j<=m; j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;
int a[10][10];
int main() {
int n, m, i, j, suma=0;
cin>>n>>m;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++)
cin>>a[i][j];
for (i=2; i<=n; i=i+2)
for (j=1; j<=m; j=j+2)
suma=suma+a[i][j];
cout<<suma;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un numar n cu maxim noua cifre nenule si o cifra para k. Sa se scrie

numarul care se formeaza
prin eliminarea tuturor cifrelor egale cu k din n.

#include <iostream>
using namespace std;

int main() {
int n, k, nou=0, c, f=1;
cin>>n>>k;
while (n>0){
c=n%10;
if (c!=k){
nou=c*f+nou;
f=f*10;
}
n=n/10;
}
cout<<nou;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se da un numar n si se citesc n numere intregi. Sa se afiseze in ordine crescatoare

numerele care au ultima
cifra 0 si penultima cifra 2.

#include <iostream>
using namespace std;

int main() {
int n, v[100], w[100], m, i, a, b, j, aux;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
m=0;
for (i=1; i<=n; i++)
if (v[i]%100==20){
m++;
 w[m]=v[i];
}
for (i =1; i<=n-1; i++)
for (j=i+1; j<=n; j++)
if (v[i]>v[j]){
aux=v[i];
v[i]=v[j];
v[j]=aux;
}
for (i=m-1; i<=m; i++)
cout<<w[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Se da un numar intreg n de cel mult 9 cifre dintre care cel putin una para. Sa se
afiseze cel mai mare si cel
mai mic numar care se pot forma cu cifrele pare ale lui n.

#include <iostream>
using namespace std;

int v[10];
int main() {
int x, c, i, maxi=0, mini=0, p=10;
cin>>x;
while (x>0){
c=x%10;
v[c]=v[c]+1;
x=x/10;
}
for (i=8; i>=0; i=i-2)
if (v[i]!=0)
maxi=maxi*10+i;
if (v[0]==0){
for (i=2; i<=8; i=i+2)
if (v[i]!=0)
mini=mini*10+i;
}
else{
for (i=2; i<=8; i=i+2)
if (v[i]!=0){
mini=mini*p+i;

p=p*10;
}
}
cout<<maxi<<" "<<mini;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se cisteste de la tastatura un numar natural n si apoi se citesc n numere. Sa se

afiseze toate numerele
citite care au cifra zecilor impara. Daca nu exista un astfel de numar sa se
afiseze "Nu exista!".
#include <iostream>
using namespace std;

int main() {
int n, x, i, a, b, nr=0;
cin>>n;
for (i=1; i<=n; i++){
cin>>x;
if (x>=10){
a=x%100;
b=a/10;
if (b%2==1){
cout<<x<<" ";
nr++;
}
}
}
if (nr==0)
cout<<"Nu exista!";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Sa se afiseze toate numerele naturale de trei cifre care au inversul tot un numar
natural prim.

#include <iostream>
using namespace std;

int main() {
int i, d, x, nr, c, invers, e, index;
for (i=100; i<=999; i++){
x=i;
nr=0;
invers=0;
for (d=2; d<=x/2; d++)
if (x%d==0)
nr=nr+1;
if (nr==0){
while (x>0){
c=x%10;
invers=invers*10+c;
x=x/10;
}
index=0;
for (e=2; e<=invers/2; e++)
if (invers%e==0)
index=index+1;
if (index==0)
cout<<i<<" ";
}
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Se citesc de la tastatura n numere naturale cu cel mult 9 cifre fiecare. Scrieti un
program care, pentru o
cifra k citita de la tastatura afiseaza pe ecran numarul de valori prime din sirul
dat, in scriere carora
apare cifra k.

#include <iostream>
using namespace std;

int main() {
int n, k, d, i, x, v[100], j=0, nr, c, adevarat;
cin>>n>>k;
for (i=1; i<=n; i++){
nr=0;
cin>>x;
for (d=2; d<=x/2; d++)
if (x%d==0)
nr++;
if (nr==0){
adevarat=0;
while (x>0){
c=x%10;
if (c==k)
adevarat=1;
x=x/10;
}
if (adevarat==1)
j++;
}
}
cout<<j;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se da un numar n si n numere naturale. Sa se calculeze cmmdc-ul dintre cel mai mai

mare si cel mai mic
element din sir.

#include <iostream>
using namespace std;

int main() {
int n, v[50], mini, maxi, i;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
maxi=v[1];
for (i=1; i<=n; i++)
if (v[i]>maxi && v[i]>=1000 && v[i]<=9999)
maxi=v[i];
mini=maxi;
for (i=1; i<=n; i++)
if (v[i]<mini && v[i]>=1000 && v[i]<=9999)
mini=v[i];
while (maxi!=mini)
 if (maxi>mini)
maxi=maxi-mini;
else mini=mini-maxi;
cout<<mini;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se da un numar n si n numere naturale. Sa se scrie numarul cifrelor impare a

numerelor impare din sir.

#include <iostream>
using namespace std;

int main() {
int n, v[50], i, index, x, c;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=n; i++){
x=v[i];
index=0;
if (v[i]%2==1 && x>=1000 && x<=9999){
while (x>0){
c=x%10;
if (c%2==1)
index++;
x=x/10;
}
cout<<v[i]<<" Are "<<index<<" cifre impare."<<endl;
}
}
index=0;
for (i=1; i<=n; i++){
x=v[i];
if (v[i]%2==1 && x>=1000 && x<=9999)
while (x>0){
c=x%10;
if (c%2==1)
index++;
x=x/10;
}
}
cout<<"In total "<<index<<" cifre impare.";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, v[1000], i, x, y=0, a=0, b=1, inloc, invers, c, nr;
cin>>nr;
i=0;
 while (nr!=0){
i=i+1;
v[i]=nr;
cin>>nr;
}
n=i;
for (i=1; i<=n; i++){
inloc=v[i];
invers=0;
while (inloc>0){
c=inloc%10;
invers=invers*10+c;
inloc=inloc/10;
}
if (invers==v[i]){
a++;
if (a==1)
y=v[i];
else b=v[i];
}
}
if (a==0)
cout<<"Nu exista numere palindrome!";
else cout<<"Primul numar palindrom este "<<y<<", iar ultimul este "<<b;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, v[1000], i, x, y=0, a=0, b=1;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=n; i++){
if (v[i]%2==0)
a++;
if (a==1){
x=v[b];
b=b-1;
}
b++;
}
if (a==0)
cout<<"Nu exista numere pare!";
for (i=b+1; i<=n; i++)
if (v[i]%2==0)
y=v[i];
if (y==0)
cout<<"Exista doar un numar par: "<<x;
else cout<<"Primul numar par este "<<x<<", iar ultimul este "<<y;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citesc n numre de maxim 4 cifre. Sa se afiseze cel mai mare numar palindrom.

#include <iostream>
using namespace std;

int main() {
int n, v[1000], i, x, c, invers, max=0;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=n; i++){
x=v[i];
invers=0;
while (x>0){
c=x%10;
invers=invers*10+c;
x=x/10;
}
if (v[i]==invers && v[i]>max)
max=v[i];
}
cout<<max;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citesc de la tastatură două şiruri de litere mici ale alfabetului englez, de

lungime maxim 100
fiecare. Să se afișeze literele care apar de acelaşi număr de ori în cele două
şiruri sau mesajul NU
EXISTA dacă șirurile nu conțin litere cu același număr de apariții.

#include <iostream>
#include <cstring>
using namespace std;

int v[28], w[28];

int main() {
char s[100], t[100];
int x, y, i;
cin>>s>>t;
for (i=0; i<strlen(s); i++){
x=s[i]-'a';
v[x]++;
}
for (i=0; i<strlen(t); i++){
y=t[i]-'a';
w[y]++;
}
for (i=0; i<=28; i++)
if (v[i]==1 && v[i]==w[i])
cout<<char(i+'a');

return 0;
}
-----------------------------------------------------------------------------------
--------------------------

Să se verifice dacă cele n (3≤n≤100) elemente întregi ale unui vector v pot forma,
în ordinea din
vector, o progresie aritmetică. În caz afirmativ să se afișeze rația, în caz
negativ să se afișeze mesajul
NU.

#include <iostream>
using namespace std;

int main() {
int n, v[50], i, ok=1, x;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
x=v[2]-v[1];
for (i=3; i<=n; i++)
if (v[i]-v[i-1]!=x)
ok=0;
if (ok==1)
cout<<x;
else cout<<"Nu formeaza o progresie aritmetica!";

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citesc n numere sa se afiseze numerele de 2 cifre care nu au fost citite.

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

-----------------------------------------------------------------------------------
--------------------------

Numerele a şi b se numesc asemenea dacă scrierile lor în baza 10 conţin aceleaşi

cifre (de exemplu
2113 şi 323121 sunt asemenea). Determinaţi dacă două numere naturale a și b, citite
de la tastatură,
cu cel mult 9 cifre fiecare, sunt asemenea.
#include <iostream>
using namespace std;

int v[10], w[10], c, i, adevarat=1;

int main() {
int a, b;
cin>>a>>b;
while (a>0){
c=a%10;
v[c]=1;
a=a/10;
}
while (b>0){
c=b%10;
w[c]=1;
b=b/10;
}
for (i=1; i<=10; i++)
if (v[i]!=w[i])
adevarat=0;
if (adevarat==1)
cout<<"Numerele sunt asemenea!";
else cout<<"Numerele nu sunt asemenea!";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Numerele a şi b se numesc asemenea dacă scrierile lor în baza 10 conţin aceleaşi

cifre (de exemplu
2113 şi 323121 sunt asemenea). Determinaţi dacă două numere naturale a și b, citite
de la tastatură,
cu cel mult 9 cifre fiecare, sunt asemenea.

#include <iostream>
using namespace std;

int main() {
int a, b, i, c, x, ok, d, adevarat, asemenea, y;
cin>>a>>b;
asemenea=1;
for (i=1; i<=9; i++){
x=a;
ok=0;
while (x>0 && ok==0){
c=x%10;
x=x/10;
if (i==c)
ok=1;
}
if (ok==1){
y=b;
adevarat=0;
while (y>0 && adevarat==0){
d=y%10;
y=y/10;
if (i==d)
 adevarat=1;
}
}
if (ok!=adevarat)
asemenea=0;
}
if (asemenea=1)
cout<<"Numerele sunt asemenea.";
else cout<<"Numerele nu sunt asemenea.";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Fie doi vectori a și b cu m respectiv n elemente numere întregi (m, n≤100), citite
de la tastatură.
Să se afișeze câte din componentele vectorului a sunt strict mai mici decât toate
componentele
vectorului b.

#include <iostream>
using namespace std;

int main() {
int m, n, a[50], b[50], minb, i;
cin>>m>>n;
for (int i=1; i<=m; i++)
cin>>a[i];
for (int i=1; i<=n; i++)
cin>>b[i];
minb=b[1];
for (i=2; i<=n; i++)
if (b[i]<minb)
minb=b[i];
for (i=1; i<=m; i++)
if (a[i]<minb)
cout<<a[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un sir de numere naturale. Sa se transforme sirul astfel

incat numerele multiplu
de 3 sa fie eliminate.

#include <iostream>
using namespace std;

int main() {
int n, i, v[50], j;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n)
if (v[i]%3==0){
 for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se dau n numere naturale. Sa se afiseze cel mai mic numar impar si pozitia primei
sale aparitii.

#include <iostream>
using namespace std;

int main() {
int n, a, i, mini, nr, ok=0, j;
cin>>n;
i=1;
while (i<=n && ok==0){
cin>>a;
if (a%2==1){
ok=1;
mini=a;
}
else i++;
}
if (i<=n){
for (j=i+1; j<=n; j++){
cin>>a;
if (a%2==1 && a<mini){
mini=a;
nr=j;
}
}
cout<<mini<<" "<<nr;
}
else cout<<"NU EXISTA";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se da un numar narural n. Sa se scrie numarul obtinut dupa ce s-a facut o premutare

circulara spre stanga a
cifrelor sale.

#include <iostream>
using namespace std;

int main() {
int n, c, p=1, b, x, y;
cin>>n;
b=n;
 while (n>9){
p=p*10;
n=n/10;
}
x=b/p;
y=b%p;
n=y*10+x;
cout<<n;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se dau n numere naturale. Sa se afiseze cel mai mare numar care are toate cifrele
pare.

#include <iostream>
using namespace std;

int main() {
int n, a, i, c, ok, x, v[10], j, p=0, maxi;
cin>>n;
for (i=1; i<=n; i++){
cin>>a;
ok=1;
x=a;
while (a>0 && ok==1){
c=a%10;
if (c%2==1)
ok=0;
a=a/10;
}
if (ok==1){
p++;
v[p]=x;
}
}
maxi=v[1];
for (i=2; i<=p; i++)
if (maxi<v[i])
maxi=v[i];
cout<<maxi<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se dau n numere naturale. Sa se afiseze toate numerele care au toate cifrele pare.

#include <iostream>
using namespace std;

int main() {
int n, a, i, c, ok, x;
cin>>n;
for (i=1; i<=n; i++){
cin>>a;
 ok=1;
x=a;
while (a>0 && ok==1){
c=a%10;
if (c%2==1)
ok=0;
a=a/10;
}
if (ok==1)
cout<<x<<" ";
}
return 0;
}
-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se modifice

ordinea valorilor din
tablouastfel incat toate valorile mai mari decat ultimul element din vector sa
ocupe primele pozitii din v
iar celelalte sa se regaseasca in continuarea acestora.

#include <iostream>
using namespace std;

int main() {
int n, v[50], w[50], i, j, a;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<n)
if (v[i]>v[n]){
a=v[i];
for (j=i-1; j>=1; j++)
v[j+1]=v[j];
v[1]=a;
}
else i++;
for (i=1; i<=n; i++)
cout<<v[i]<<" ";

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se mute pe

ultimele pozitii
elementele care au suma cifrelor un numar patrat perfect.

#include <iostream>
#include <cmath>
using namespace std;

int main() {
int n, v[50], w[50], i, j, d, a, s, x, c;
cin>>n;
 for (i=1; i<=n; i++)
cin>>v[i];
i=1;
a=0;
while (i<=n){
s=0;
x=v[i];
while (x>0){
c=x%10;
s=s+c;
x=x/10;
}
if (sqrt(s)==int(sqrt (s))){
a++;
w[a]=v[i];
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
}
i=n+1;
j=1;
while (j<=a){
v[i]=w[j];
n++;
i++;
j++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se mute pe

ultimele pozitii
elementele patrate perfecte.

#include <iostream>
#include <cmath>
using namespace std;

int main() {
int n, v[50], w[50], i, j, d, a;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
a=0;
while (i<=n){
if (sqrt(v[i])==int(sqrt (v[i]))){
a++;
w[a]=v[i];
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
 n--;
}
else i++;
}
i=n+1;
j=1;
while (j<=a){
v[i]=w[j];
n++;
i++;
j++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se mute pe

ultimele pozitii
elementele numere prime.

#include <iostream>
using namespace std;

int main() {
int n, v[50], w[50], i, j, x=2, y, d, a;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
a=0;
while (i<=n){
y=0;
for (d=1; d<=v[i]; d++)
if (v[i]%d==0)
y++;
if (y==x){
a++;
w[a]=v[i];
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
}
i=n+1;
j=1;
while (j<=a){
v[i]=w[j];
n++;
i++;
j++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
 return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se mute pe

ultimele pozitii
elementele cu suma cifrelor un numar par.

#include <iostream>
using namespace std;

int main() {
int n, a, v[50], w[50], i, j, s, c, x;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
a=0;
while (i<=n){
s=0;
x=v[i];
while (x>0){
c=x%10;
s=s+c;
x=x/10;
}
if (s%2==0){
a++;
w[a]=v[i];
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
}
i=n+1;
j=1;
while (j<=a){
v[i]=w[j];
n++;
i++;
j++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int fr[9];
int main() {
 int n, i, x, nr, p, aux, y;
cin>>n;
for (i=1; i<=n; i++){
cin>>x;
aux=x;
p=1;
while (aux>9){
p=p*10;
aux=aux/10;
}
cout<<x%p<<endl;
nr=x/p;
fr[nr]++;
}
for (i=1; i<=9; i++)
cout<<fr[i]<<" ";
y=0;
for (i=9; i>=1; i--)
if (fr[i]>0)
while (fr[i]>0){
y=y*10+i;
fr[i]--;
}
cout<<y;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se considera un numar natural n. Sa se determine numarul din intervalul [1,n] care

au un numar maxim de
divizori.

#include <iostream>
using namespace std;

int main() {
int n, v[50], nr, max, i, j, aux, d;
cin>>n;
for (i=1; i<=n; i++){
nr=0;
for (d=1; d<=i; d++)
if (i%d==0)
nr++;
v[i]=nr;
}
aux=v[1];
for (i=2; i<=n; i++)
if (aux<v[i])
aux=v[i];
for (i=1; i<=n; i++)
if (v[i]==aux)
cout<<i<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Citeste un vector si afiseaza cele mai mari 2 numere.

#include <iostream>
using namespace std;

int main() {
int n, v[50], w[50], i, j, aux, numere_afisate;
cin>>n>>numere_afisate;
for (i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=n; i++)
for (j=i+1; j<=n; j++)
if (v[i]>v[j]){
aux=v[i];
v[i]=v[j];
v[j]=aux;
}
for (i=n; i>n-numere_afisate; i--)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se mute pe

ultimele pozitii
elementele impare.

#include <iostream>
using namespace std;

int main() {
int n, v[50], w[50], i, j, a;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
a=0;
while (i<=n)
if (v[i]%2==1){
a++;
w[a]=v[i];
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
i=n+1;
j=1;
while (j<=a){
v[i]=w[j];
n++;
i++;
j++;
}
for (i=1; i<=n; i++)
 cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemenete numere intregi. Sa se elimine

din vector elementele
aflate pe pozitii divizibile cu 3.

#include <iostream>
#include <cmath>
using namespace std;

int main() {
int n, v[10], i, j;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n){
if (i%3==0){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
i++;
}
else i++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemenete numere intregi. Sa se elimine

din vector toate numerele
patrate perfecte.

#include <iostream>
#include <cmath>
using namespace std;

int main() {
int n, v[10], i, j;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n){
if (sqrt(v[i])==int(sqrt (v[i]))){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
 }
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemenete numere intregi. Sa se elimine

din vector toate
elementele care au suma cifrelor divizibila cu un numar p dat.

#include <iostream>
using namespace std;

int main() {
int n, v[10], i, j, s, c, aux, p;
cin>>n>>p;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n){
s=0;
aux=v[i];
while (aux>0){
c=aux%10;
s=s+c;
aux=aux/10;
}
if (s%p==0){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemenete numere intregi. Sa se elimine

din vector toate numerele
care au ultima cifra un numar par.

#include <iostream>
using namespace std;

int main() {
int n, v[10], i, j, aux;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n){
 aux=v[i];
while (aux>9)
aux=aux/10;
if (aux%2==0){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemenete numere intregi. Sa se elimine

din vector numerele
palindrom.

#include <iostream>
using namespace std;

int main() {
int n, v[10], i, j, invers, c, aux;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n){
invers=0;
aux=v[i];
while (aux>0){
c=aux%10;
invers=invers*10+c;
aux=aux/10;
}
if (v[i]==invers){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un vector v cu n elemente numere intregi. Sa se elimine

din vector elementul
maxim. (Vectorul poate contine mai multe elemente egale cu valoarea maxima)

#include <iostream>
using namespace std;

int main() {
int n, v[50], i, max, j;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
max=v[1];
for (i=2; i<=n; i++)
if (max<v[i])
max=v[i];
i=1;
while (i<=n)
if (v[i]==max){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citste de la tastatura un vector v cu n elemente numere intregi. Sa se elimine

din vector numerele impare.

#include <iostream>
using namespace std;

int main() {
int n, v[50], i, j;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n)
if (v[i]%2==1){
for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n--;
}
else i++;
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Fie x un vector cu n elemente numere naturale. Sa se construiasca un vector y care

sa contina elementele
prime din x.

#include <iostream>
using namespace std;

int main() {
int n, x[10], y[10], a, nr, d;
cin>>n;
for (int i=0; i<n; i++)
cin>>x[i];
a=0;
for (int i=0; i<n; i++){
nr=0;
for (d=1; d<=x[i]; d++)
if (x[i]%d==0)
nr++;
if (nr==2){
a++;
y[a]=x[i];
}
}
for (int i=1; i<=a; i++)
cout<<y[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se considera un un vector v cu n elemente numere intregi si doua numere a si b. Sa

se copieze intr-un vector
x elemente din v aflate in intervalul [a;b].

#include <iostream>
using namespace std;

int main() {
int n, a, b, v[100], x[100], i, m, chestie;
cin>>a>>b>>n;
for (i=1; i<=n; i++)
cin>>v[i];
if (a>b){
chestie=a;
a=b;
b=chestie;
}
m=0;
for (i=1; i<=n; i++)
if (v[i]>=a && v[i]<=b){
m++;
x[m]=v[i];
}
for (i=1; i<=m; i++)
cout<<x[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Fie v un vector cu n elemente intregi. Sa se construiasca alti doi vectori care sa

contina elementele pare,
respectiv impare ale vectorului initial.

#include <iostream>
using namespace std;

int main() {
int n, x[100], y[100], z[100], i, a, b;
cin>>n;
for (i=1; i<=n; i++)
cin>>x[i];
a=0;
b=0;
for (i=1; i<=n; i++){
if (x[i]%2==0){
a++;
y[a]=x[i];
}
else{
b++;
z[b]=x[i];
}
}
cout<<"Numerele pare sunt: ";
for (i=1; i<=a-1; i++)
cout<<y[i]<<" ";
cout<<y[a]<<endl;
cout<<"Numerele impare sunt: ";
for (i=1;i<=b; i++)
cout<<z[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un vector v cu n elemente numere intregi. Parcurgeti si afisati

elementele simetrice primul cu
ultimul, al doilea cu penultimul, samd.

#include <iostream>
using namespace std;

int main() {
int n, v[11], i, x=0;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=2; i++)
while (x<=n/2){
if (x<n/2)
cout<<v[i]+x<<" "<<v[n-x]<<endl;
else cout<<v[i+x];
x++;
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Fiind dat un vector cu n elemente intregi, scrieti un program care calculeaza suma
si numarul elementelor
pozitive aflte pe pozitii impare din vector.

#include <iostream>
using namespace std;

int main() {
int n, v[100], nr=0, spatiu=1, i, s=0;
cin>>n;
for(i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=n; i++){
if (v[i]>0 && spatiu%2==1){
nr++;
s=s+v[i];
}
spatiu++;
}
cout<<"Exista "<<nr<<" numere pozitive pe pozitii impare, iar suma lor este
"<<s;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Sa se scrie un program care afiseaza numarul elementelor pozitive, negative si

respectiv nule dintr-un vector
de numere intregi.

#include <iostream>
using namespace std;

int main() {
int n, v[100], poz=0, nul=0, neg=0, i;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
for (i=1; i<=n; i++){
if (v[i]>0)
poz++;
if (v[i]==0)
nul++;
if (v[i]<0)
neg++;
}
cout<<"Exista "<<poz<<" numere pozitive, "<<nul<<" numere nule si "<<neg<<"
numere negative";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Fie v un vector cu n elemente numere intregi. Sa se precizeze de cate ori apare o

valoare data x in vector.
#include <iostream>
using namespace std;

int main() {
int n, v[50], x, nr, i;
cin>>x>>n;
for (i=1; i<=n; i++)
cin>>v[i];
nr=0;
for (i=1; i<=n; i++)
if (v[i]==x)
nr=nr+1;
cout<<nr;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Fie un vector v cu n elemente numere intregi. Sa se stearga din vector numerele

nepalindromice.

#include <iostream>
using namespace std;

int main() {
int n, v[50], i, x[50], a, c, p, copie;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
a=0;
for (i=1; i<=n; i++){
p=0;
copie=v[i];
while (copie>0){
c=copie%10;
p=p*10+c;
copie=copie/10;
}
if (p==v[i]){
a++;
x[a]=v[i];
}
}
for (i=1; i<=a; i++)
cout<<x[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un vector cu n elemente numere intregi. Sa se stearga din vector

numerele impare.

#include <iostream>
using namespace std;
int main() {
int n, x[50], v[50], a, i;
cin>>n;
for (i=1; i<=n; i++)
cin>>x[i];
a=0;
for (i=1; i<=n; i++){
if (x[i]%2==0){
a=a+1;
v[a]=x[i];
}
}
for (i=1; i<=a; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citesc n numere intregi. Sa se afiseze cel mai mare umar dintre numerele citite
si rangul numarului. Daca
valoarea maxima se gaseste de mai multe ori printre numerele citite, se va afisa
pozitia ultimului element
maxim.

#include <iostream>
using namespace std;

int main() {
int n, a, max, r;
cin>>n;
cin>>a;
max=a;
for (int i=2; i<=n; i++){
cin>>a;
if (max<a){
max=a;
r=i;
}
else
if (max==a)
r=i;
}
cout<<"Cel mai mare numar este "<<max<<" si are rangul "<<r;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, i, s;
cin>>n;
for(i=1; i<=n; i++)
if (i%2==1) s=s+i*(i+1);
 else s=s-i*(i+1);
cout<<s;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, i, s, t=1;
cin>>n;
for(i=1; i<=n; i++){
t=t*i;
s=s+t;}
cout<<s;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, i, p=1, t;
cin>>n;
for(i=2; i<=n; i++){
t=1-1/i*i;
p=p*t;}
cout<<p;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int a, ok;
do{
cin>>a;
if (a==1) cout<<"Luni";
if (a==2) cout<<"Marti";
if (a==3) cout<<"Miercuri";
if (a==4) cout<<"Joi";
if (a==5) cout<<"Vineri";
if (a==6) cout<<"Sambata";
if (a==7) cout<<"Duminica";
if (a>7) cout<<"Nu este o zi a saptamanii!";
cout<<endl;
cout<<"Doresti sa continui?";
cin>>ok;
}while (ok!=0);
 return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int a, d=2, nr;
while(a>1)
if(a%d==0){
nr=0;
while(a%d==0){
nr=nr+1;
a=a/d;}
cout<<d<<" Apare de "<<nr<<" ori. "<<endl;
}
else d++;
return 0;

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, d=2;
cin>>n;
while (n>1)
if (n%d==0){
while (n%d==0)
n=n/d;
cout<<d;}
else d=d++;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, p=1, e, x, d=2, nr=0, y;
cin>>n;
for(int i=1; i<=n; i++){
cin>>x;
p=p*x;}
while (p>1)
if (p%d==0){
e=0;
if (d>nr) nr=d;
 while(p%d==0){
p=p/d;
e++;}
y=e;
}
else d++;
cout<<"Cel mai mare divizor prim este "<<d<<" si apare la puterea "<<e;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, p=1, e, x, d=2, nr=0, y;
cin>>n;
for(int i=1; i<=n; i++){
cin>>x;
p=p*x;}
while (p>1)
if (p%d==0){
e=0;
while(p%d==0){
p=p/d;
e++;}
if (nr<e){
nr=e;
y=d;

}
}
else d++;
cout<<"Divizorul care apare la cea mai mare putere este "<<y<<" si apare la
puterea "<<nr;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int e, x, d=2, nr=0, y, s, a;
for(int i=1; i<=2; i++){
cin>>x;
a=x;
s=0;
while (x>1)
if (x%d==0){
e=0;
 while(x%d==0){
x=x/d;
e++;
}
s=s+e;
}
else d++;
if (nr<s){
nr=s;
y=a;
}
}
cout<<" Cea mai mare suma a exponentilor este "<<nr<<" si ii apartine lui
"<<y<<endl;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int a, b, x, y, d;
cin>>a>>b;
for(d=1 ; d<=a/2 ; d++)
if(a%d==0) x=x+d;

for(d=1 ; d<=b/2 ; d++)

if(b%d==0) y=y+d;

if(y==a && x==b) cout<<"Numerele sunt prietene";

else cout<<"Numerele nu sunt prietene";

return 0;
}

-----------------------------------------------------------------------------------
----------

#include <iostream>
using namespace std;

int main() {
int n, nr, c, x, i, a;
cin>>n;
for(i=1 ; i<=n ; i++)
{
nr = 1;
cin>>a;
x=a%10;
while(a>0)
{
a=a/10;
c=a%10;
 if(c==x) nr=nr+1;
}
cout<<nr<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int i, n, nr, a, d, k;
cin>>n;
cin>>k;
int ok=0;
for(i=1 ; i<=n ; i++)
{
nr = 0;
cin>>a;
for(d=2 ; d<=a/2 ; d++)
if(a%d==0) nr=nr+1;
if(nr==k) {cout<<a<<" ";
ok=1;}
}
if(ok==0) cout<<"Nu exista numere";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Sa se determine numarul de cifre al unui numar citit de la tastatura.

#include <iostream>
using namespace std;

int main() {
int n, nr=0;
cin>>n;
while(n>0){
nr=nr+1;
n=n/10;
}
cout<<nr;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Sa se determine cea mai mare cifra a unui numar natural citit de la tastatura.

#include <iostream>
using namespace std;

int main() {
int n, a=0, c;
cin>>n;
 while(n>0){
c=n%10;
if(c>a)a=c;
n=n/10;
}
cout<<a;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------
Sa se scrie un program care sa determine inversul unui numar natural citit de la
tastatura.

#include <iostream>
using namespace std;

int main() {
int n, inv=0;
cin>>n;
while(n>0){
inv=inv*10+n%10;
n=n/10;
}
cout<<inv;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citste un numar natural n. Sa se scrie numarul format prin eliminarea ultimei

cifre numarului.

#include <iostream>
using namespace std;

int main() {
int n, nou;
cin>>n;
nou=n/10;
cout<<nou;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se dau n numere naturle nenule. Determinati cel mai mare numar prim care apare in
descompunerea in factori
a produsului celor n numere, precum si exponentul sau in descompunere.

#include <iostream>
using namespace std;

int main() {
int n, nou;
cin>>n;
 while (n>9){
nou=nou*10+(n%10);
n=n/10;}
n=0;
while (nou>0){
n=n*10+(nou%10);
nou=nou/10;}
cout<<n;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se da un numar ntural n. Afisati factorul prim care apare la putearea cea mai mare
in descompunerea in
factori primi a lui n.

#include <iostream>
using namespace std;

int main() {
int n, p=1; e; x; d=2; nr=0; y;
cin>>n;
for (int i=1; i<=n; i++){
cin>>x;
p=p*x;
}
while (p>1)
if (p%d==0){
e=0;
if (d>nr) nr=d;
while (p%d==0){
p=p/d;
e++
}
y=e;
}
else d++;
cout<<"Cel mai mare divizor prim este "<<nr<<" si apare la puterea "<<y;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste de la tastatura un numar natural n si o cifra c. Sa se adauge la

sfarsitul numarului cifra c si
sa se afiseze numarul astfel obtinut.

#include <iostream>
using namespace std;

int main() {
int n, i, nr=0, p=1, m, c, r, rez, aux;
cin>>n;
aux=n;
while (n>0){
 nr=nr+1;
n=n/10;}
m=nr/2;
for (i=1; i<=m; i++)
p=p*10;
if (nr%2==1)
c=aux/(p*10)*p+aux%p;
else{ c=aux/p/10;
r=aux%p%(p/10);
c=c*p/10+r;
}
cout<<c;

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un numar n. Sa se afiseze primele n numere prime.

#include <iostream>
using namespace std;

int main() {
int n, nr, a;
cin>>n;
a=2;
while (nr<n){
int nd=0;
for (int d=2; d<=a/2; d++)
if(a%d==0)
nd=nd+1;
if (nd==0){
cout<<a<<" ";
nr=nr+1;}
a++;
}

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un numar n. Sa se afiseze toate numerele perfecte mai mici ca n.

#include <iostream>
using namespace std;

int main() {
int n;
cin>>n;
for (int i=1; i<n; i++){
int s=0;
for (int d=1; d<=i/2; d++)
if (i%d==0)
s=s+d;
if (s==i)
 cout<<i<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citesc doua numere a si b care reprezinta capetele unui interval [a,b]. Sa se

verifice daca printre
numerele din interval sunt numere palindromice si sa se afiseze un mesaj
corespunzator.

#include <iostream>
using namespace std;

int main() {
int a, b, aux, i, inv, ok=0;
cin>>a>>b;
if (a>b){
aux=b;
b=a;
a=aux;
}
for(i=a; i<=b; i++){
int x=i;
inv=0;
while (x>0){
int c=x%10;
inv=inv*10+c;
x=x/10;
}
if (i==inv)
ok=1;
}
if (ok==1)
cout<<"Exista numere palindromice!";
else cout<<"Nu exista numere palindromice!";

return 0;
}

-----------------------------------------------------------------------------------
--------------------------
===================================================================================
==========================
===================================================================================
==========================
Se citeste un numar natural. Sa se afiseze inversul sumei cifrelor sale.

#include <iostream>
using namespace std;

int main() {
int n, c, d, nou, s=0;
cin>>n;
while (n>0){
c=n%10;
s=s+c;
 n=n/10;
}
while (s>0){
d=s%10;
nou=nou*10+d;
s=s/10;
}
cout<<nou;
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Sa se afiseze toate numerele din intervalul [a;b] care au suma cifrelor un numar
par. Valorile pentru a si b
se citesc de la tastatura.

#include <iostream>
using namespace std;

int main() {
int a, b, x, c, i, s, y;
cin>>a>>b;
if (a>b){
x=a;
a=b;
b=x;
}
for (i=a; i<=b; i++){
s=0;
y=i;
while (y>0){
c=y%10;
s=s+c;
y=y/10;
}
if (s%2==1)
cout<<i<<" ";
}

return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se introduce de la tastatura un sir de n numere. Sa se aiseze catul si restul

dintre suma numerelor si suma
cifrelor sumei numerelor.

#include <iostream>
using namespace std;

int main() {
int n, a, sn=0, i, sc=0, c, x, m, p;
cin>>n;
for (i=1; i<=n; i++){
cin>>a;
 sn=sn+a;
}
x=sn;
while (x>0){
c=x%10;
sc=sc+c;
x=x/10;
}
m=sn/sc;
p=sn%sc;
cout<<"Catul este "<<m<<" iar restul este "<<p;
return 0;

-----------------------------------------------------------------------------------
--------------------------

Se citeste un numar n si apoi se citesc n numere. Sa se afiseze pentru fiecare

numar cifra semnifcativa
(prima cifra)

#include <iostream>
using namespace std;

int main() {
int n, x, i, f=1;
cin>>n;
for (i=1; i<=n; i++){
cin>>x;
while(x>9)
x=x/10;
cout<<x<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Prin injumatatirea unui numar natural se intelege inlocuirea fiecarei cifre pare
(diferita de 0) cu jumatatea
ei. De exemplu, prin injumatatirea numarului 5622 se obtine numarul 5311. Sa se
citeasca mai multe numere
pana la intalnirea lui 0. Sa se afiseze numerele citite injumatatite. Numerele care
contin cel putn o cifra
impara nu se modifica.

#include <iostream>
using namespace std;

int main() {
int x, y, c, f, nou, nr;
cin>>x;
while (x>0){
y=x;
nou=0;
nr=0;
f=1;
while (y>0){
c=y%10;
 if (c==0)
nou=c*f+nou;
else
if (c%2==0)
nou=(c/2)*f+nou;
else nr=1;
f=f*10;
y=y/10;
}
if (nr==1)
cout<<x<<" ";
else cout<<nou<<" ";
cin>>x;
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citesc de la tastatura doua numere naturale a si b. Sa se modifice valoarea

fiecarui numar din intervalul
[a;b] inversand ordinea cifrelor lui, cu exceptia primei cifre care ramane in
aceeasi pozitie si sa se
afiseze numerele astfel modificate.

#include <iostream>
using namespace std;

int main() {
int a, b, c, nou, x, y, rez;
cin>>a>>b;
for (int i=a; i<=b; i++){
x=i;
int f=1;
rez=0;
y=0;
nou=0;
while (x>0){
c=x%10;
nou=nou*10+c;
f=f*10;
x=x/10;
}
y=nou%10;
nou=nou/10;
rez=y*(f/10)+nou;
cout<<rez<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Sa se afiseze numerele de trei cifre care au toate cifrele de aceeasi paritate.

(111, 113, 115...)

#include <iostream>
using namespace std;

int main() {
int n, c, x;
for (int i=100; i<=999; i++){
n=i;
x=0;
while (n>0){
c=n%10;
if (c%2==1)
x++;
n=n/10;
}
if (x==3)
cout<<i<<", ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un numar k si apoi se citesc mai multe numere pana la intalnirea lui 0.
Sa se verifice si sa se
afiseze un mesaj corespunzator daca printre numerele citite se afla si numarul sau
sa se afiseze mesajul
"Nu exista" daca numarul k nu se afla printre numerele citite.

#include <iostream>
using namespace std;

int main() {
int k=73, n, nr=0;
cin>>n;
while (n!=0){
if (n==k)
nr=nr+1;
cin>>n;
}
if (nr>=1)
cout<<"K se afla printre numere!";
else cout<<"K nu se afla printre numere!";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se citeste un numar natural n. Sa se afiseze toate numerele mai mici decat n care
sunt egale cu suma
patratelor cifrelor lor.

#include <iostream>
using namespace std;

int main() {
int n, x, s, c;
cin>>n;
for (int i=1; i<n; i++){
 x=i;
s=0;
while (x>0){
c=x%10;
s=s+(c*c);
x=x/10;
}
if (s==i)
cout<<i<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

Se introduc de la tastatura n numere. Sa se afiseze cea mai mare cifra a fiecarui

numar.

#include <iostream>
using namespace std;

int main() {
int n, a, c, nr;
cin>>n;
for (int i=1; i<=n; i++){
cin>>a;
nr=0;
while (a>0){
c=a%10;
if (nr<c)
nr=c;
a=a/10;
}
cout<<nr<<" ";
}
return 0;
}

-----------------------------------------------------------------------------------
--------------------------

#include <iostream>
using namespace std;

int main() {
int n, v[50], i, d, j, nr;
cin>>n;
for (i=1; i<=n; i++)
cin>>v[i];
i=1;
while (i<=n){
nr=0;
for (d=1; d<=v[i]; d++)
if (v[i]%d==0)
nr++;
if (nr==2){
 for (j=i+1; j<=n; j++)
v[j-1]=v[j];
n=n-1;
}
else i++;
}
for (i=1; i<=n; i++)
cout<<v[i]<<" ";
return 0;
}

-----------------------------------------------------------------------------------
--------------------------