Probleme simple cu cifrele unui număr în C++

problemele cu cifrele unui număr au rolul de a te obișnui cu împărțirea întreagă (ce

presupune obținerea unui cât și a unui rest) și cu reprezentarea numerelor în baza 10.

Problema 1.
Se dă un număr natural  n. Să se afișeze ultima sa cifră.
Cam la asta se reduc majoritatea problemelor cu cifrele unui număr. Un număr natural
de forma a0a1…am−1 este egal cu a0⋅10m−1+a1⋅10m−2+⋯+am−1⋅10. Observăm
că, din această sumă, doar ultimul termen (care reprezintă ultima cifră) nu este un
multiplu nenul de 10, așa că prin împărțirea numărului la 10, restul obținut va fi chiar
ultima sa cifră.

int lastDigit = n % 10;

Problema 2.
Se dă un număr natural  n. Să se afișeze numărul format prim eliminarea ultimei sale
cifre.

Ne vom folosi din nou de forma unui număr natural scris în baza 10, din care se deduce
că împărțirea lui nn la 10 va produce câtul a0⋅10m−2+a1⋅10m−3+⋯+am−2⋅10 la
putere 0. Fiecare termen devine de 10 ori mai mic, iar ultimul dispare, numărul
obținut find practic cel cerut.

int lastDigitCut = n / 10;

Problema 3.
Se dă un număr natural  n. Să se afișeze numărul format din ultimele  k cifre ale lui  n.

Vom generaliza problema 1. Restul împărțirii lui n la 10 este ultima sa cifră, restul

împărțirii lui n la 100 este numărul format din ultimele sale două cifre etc. Așadar,
trebuie să calculăm restul împărțirii lui n la 10 la putere k.
int p = 1;
for (int i = 0; i < k; i++)
p *= 10;
cout << n % p << '\n';
Problema 4.
Se dă un număr natural  nn. Să se afișeze numărul format prin eliminarea
ultimelor  kk cifre ale lui  nn.

Procedăm ca la problema 2. Dacă restul împărțirii lui nn la 10k10k este numărul format

din ultimele kk cifre, atunci câtul împărțirii este numărul format prin eliminarea acelor
cifre.
int p = 1;
for (int i = 0; i < k; i++)
p *= 10;
cout << n / p << '\n';
Copy
Problema 5.
Se dă un număr natural  nn. Să se afișeze a  kk-a cifră a sa, considerându-le
numerotate de la  11, de la stânga la dreapta.

Folosind ce am învățat până acum, putem calcula numărul format din primele kk cifre
(prin eliminarea ultimelor m−km−k). Din acesta avem nevoie doar de ultima cifră, deci
îi calculăm restul împărțirii la 1010.
int p = 1;
for (int i = 0; i < m - k; i++)
p *= 10;
cout << n / p % 10 << '\n';
Copy
Problema 6.
Se dă un număr natural  nn. Să se calculeze numărul lui de cifre.

Soluția este să împărțim numărul la 1010 până când acesta devine 00, iar la fiecare pas
să incrementăm numărul de cifre. De exemplu, la pasul 00 avem numărul 618618, la
pasul 11 avem 6161, la pasul 22 avem 66, la pasul 33 avem 00, iar aici ne oprim.
Numărul de cifre ale lui 618618 este 33. Vom trata separat cazul n=0n=0, pentru că
dacă numărul este 00 din start, nu s-ar mai intra în while.
int nrDigits = 0;
if (!n)
nrDigits = 1;

// Nu are rost să punem else pentru că oricum

// dacă n == 0 nu se intră în while.
while (n) {
nrDigits++;
n /= 10;
}
cout << nrDigits << '\n';
Copy
Totuși, if-ul ăla este cam enervant. Îl putem evita folosind structura do while:
int nrDigits = 0;
do {
nrDigits++;
n /= 10;
} while (n);
cout << nrDigits << '\n';
Copy
Dacă n≠0n≠0, do while-ul va face exact aceeași pași ca while-ul de la început,
singura diferență fiind momentul la care se testează condiția. Dacă n=0n=0, se
incrementează numărul de cifre, nn se împarte la 1010, obținând tot 00, și se iese
din do while. Rezultatul va fi așadar 11, ceea ce este corect.
Se observă că, la final, în nn nu vom mai avea stocată valoarea inițială a numărului,
ci 00. Dacă avem nevoie de aceasta și după calcularea numărului de cifre, îi putem face
la început o copie în variabila cpycpy, și să o prelucrăm în schimb pe aceasta.
int cpy = n;
int nrDigits = 0;
do {
nrDigits++;
cpy /= 10;
} while (cpy);
cout << nrDigits << '\n';
Copy
Problema 7.
Se dă un număr natural  nn. Să se calculeze suma cifrelor acestuia.
În multe probleme cu cifrele unui număr se folosește șablonul de la problema
anterioară. Înainte de eliminarea ultimei cifre de la fiecare pas, o putem prelucra
accesând-o prin n % 10. În cazul nostru, prelucrarea înseamnă să o adăugăm la sumă.
int sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}
cout << sum << '\n';
Copy
Problema 8.
Se dă un număr natural  nn. Să se afișeze cifra sa maximă.

Din nou, eliminăm pe rând ultima cifră a lui nn până când acesta devine 00, iar la
fiecare pas actualizăm maximul.
int max = 0;
while (n) {
if (n % 10 > max)
max = n % 10;
n /= 10;
}
cout << max << '\n';
Copy
Problema 9.
Se dă un număr natural  nn. Să se determine prima sa cifră (cea mai semnificativă
cifră).

Putem extrage câte o cifră din nn până când nn devine mai mic decât 1010, adică până
când nn devine o cifră. Aceasta va fi, evident, ultima cifră a lui nn.
while (n > 9)
n /= 10;
cout << n << '\n';
Copy
Problema 10.
Se dau  kk cifre. Să se construiască numărul natural  nn format din aceste cifre în
ordinea în care sunt date.

La fiecare cifră citită îl vom înmulți pe nn cu 1010, pentru a-i face loc cifrei curente, xx.
După înmulțire, nn va avea un 00 la final, iar adunând xx, 00-ul va deveni xx.
int k; cin >> k;
int n = 0;
for (int i = 0; i < k; i++) {
int x; cin >> x;
n = n * 10 + x;
}
cout << n << '\n';
Copy
Problema 11.
Se dau  kk cifre. Să se construiască numărul natural  nn format din aceste cifre în
ordinea inversă celei în care sunt date.
Procedăm aproape ca la problema anterioară, numai că vom reține pe parcurs și o
putere a lui 1010 (10i10i). La fiecare pas vom înmulți cifra curentă xx cu această
putere, adăugând la finalul său ii zerouri (ii fiind egal și cu numărul de cifre ale lui nn la
pasul respectiv). Astfel, putem adăuga nn-ul vechi la acest număr, formând un nou nn.
int k; cin >> k;
int n = 0;
for (int i = 0, p = 1; i < k; i++, p *= 10) {
int x; cin >> x;
 n = x * p + n;
}
cout << n << '\n';
Copy
Problema 12.
Se dă un număr natural  nn. Să se calculeze răsturnatul (oglinditul) său. Răsturnatul
unui număr este numărul format prin scrierea în ordine inversă a cifrelor sale. De
exemplu, răsturnatul lui  618618 este  816816.

Aici vom combina problemele 7 și 10. Pe măsură ce eliminăm câte o cifră din nn, o
adăugăm la răsturnatul lui nn, pe care îl vom nota cu mm.
int m = 0;
while (n) {
m = m * 10 + n % 10;
n /= 10;
}
cout << m << '\n';
Copy
Problema 13.
Se dă un număr natural  nn. Să se determine dacă  nn este un palindrom. Un număr
palindrom este un număr care citit atât de la dreapta la stânga, cât și de la stânga la
dreapta, este același.

Cu alte cuvinte, nn este palindrom dacă nn este egal cu răsturnatul său. Vom reține o

copie a lui nn pe care o vom prelucra pentru a obține răsturnatul ( mm). Apoi, testăm
egalitatea dintre nn și mm.
int m = 0;
int cpy = n;

while (cpy) {
m = m * 10 + cpy % 10;
cpy /= 10;
}

if (n == m)
cout << "DA\n";
else
cout << "NU\n";
Copy
Problema 14.
Se dă un număr natural  nn. Să se determine cifra de control a lui  nn. Cifra de control
a unui număr este cifra de control a sumei cifrelor sale, dacă numărul are măcar două
cifre. Altfel, este chiar numărul în sine.
Cam așa sună o definiție recursivă a cifrei de control. Altfel spus, cât timp nn nu este o
cifră, nn devine suma cifrelor lui nn. La final, răspunsul va fi nn.
int sum;
while (n > 9) {
sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}
n = sum;
}
cout << n << '\n';
Copy
Dar putem găsi o soluție ceva mai eficientă. Se poate observa că dacă nn are cifra de
control cc, atunci toate numerele naturale de forma n+9kn+9k, cu kk întreg, au și ele
cifra de control cc. Asta înseamnă că cifra de control a lui nn este restul împărțirii sumei
cifrelor sale la 99 dacă restul este nenul, sau 99 în caz contrar.
int sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}

if (sum % 9)
cout << sum % 9 << '\n';
else
cout << "9\n";

Determinarea cifrelor unui număr

Să ne gândim la un număr (natural), n = 274 – aici n este o variabilă de tip int.

Care dintre cifrele sale poate fi determinată cu o simplă operație aritmetică? Constatăm că
putem determina ultima cifră a numărului cu operația C++ % 10 – restul împărțirii la 10. Într-
adevăr, 274 % 10 este 4, adică ultima cifră (a unităților) a lui 274.

Cum putem determina cifra zecilor? Sigur, o soluție ar fi n % 100 / 10. Într-adevăr, n %
100 este 74, iar 74 /10 este 7. Ne amintim că, dacă operanzii sunt întregi,
operația / reprezintă câtul împărțirii întregi.

Dar mai există o variantă, mai utilă pe termen lung :). Știm că n % 10 reprezintă cifra
unităților lui n și vrem să determinăm cifra zecilor. Putem să modificăm mai întâi valoarea
lui n, astfel: n = n / 10, și să determinăm ultima cifră a acestui număr. Este cifra unităților
pentru valoarea curentă a lui n și cifra zecilor pentru valoarea inițială.

int n = 274;
cout << n % 10; // se va afisa 4
n = n / 10; // n devine 27
cout << n % 10; // se va afisa 7

Vom numi trunchiere operația prin care se elimină ultima cifră a valorii unei variabile
întregi. Pentru a realiza trunchierea, folosim operația de atribuire și împărțirea la 10: n =
n / 10 sau n /= 10.

Cum aflăm cifra sutelor? Trunchiem încă o dată valoarea lui n. n devine 2, iar n %
10 este 2, adică cifra sutelor pentru valoarea inițială a lui n. Mai mult, acum n are o singură
cifră, și printr-o nouă trunchiere devine 0.

Să tragem câteva concluzii:

 ultima cifră a lui n este n % 10;

 prin trunchiere se elimină ultima cifră a lui n; ultima cifră a valorii curente este cifra
zecilor a valorii inițiale;
 prin trunchieri succesive valoarea lui n devine 0. Numărul de trunchieri este în
concordanță cu numărul de cifre din valoarea inițială a lui n.

Astfel, se conturează următorul program pentru determinarea cifrelor unui număr:

#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
while(n != 0) // cat timp n este nenul - mai are cifre
{
int uc = n % 10; //determinam ultima cifra a lui n
cout << uc << " "; // prelucram ultima cifra
n /= 10; // eliminam ultima cifra (trunchiem numarul)
}
return 0;
}

Observații:

 În programul de mai sus am afișat cifrele determinate. În probleme pot fi diverse

cerințe.
 În program se obțin cifre lui n în ordine inversă, de la ultima spre
prima! Pentru n=274 se va afișa:

4 7 2

 dacă pentru n se citește valoarea 0, nu se va afișa nimic, deoarece expresia n !=

0 este de la început nulă. Acest lucru are o importanță deosebită în anumite situații –
de exemplu dacă s-ar cere numărul de cifre ale lui n.
 în urma determinării cifrelor lui n prin procedeul de mai sus, valoarea inițială a
lui n se pierde – devine 0. Dacă la final avem nevoie de ea, trebuie să o copiem într-
o altă variabilă.

Construirea unui număr cu cifre date

Să considerăm următorul șir de cifre, în ordine: 2 8 5 3

Cu ele se poate construi un număr, astfel:

 pornim de la valoarea R = 0;
 cifrele se adaugă în ordine:
o la sfârșitul lui R
o la începutul lui R

Dacă cifrele se adaugă la sfârșit, procedăm astfel:

1. R = 0
2. c = 2. R = 10 * R + c, adică R devine 10 * 0 + 2 = 2
3. c = 8. R = 10 * R + c, adică R devine 10 * 2 + 8 = 28
4. c = 5. R = 10 * R + c, adică R devine 10 * 28 + 5 = 285
5. c = 3. R = 10 * R + c, adică R devine 10 * 285 + 3 = 2853

Dacă cifrele se inserează la început, procedăm astfel:

1. R = 0
2. c = 2. R = R + 1 * c, adică R devine 0 + 1 * 2 = 2
3. c = 8. R = R + 10 * c, adică R devine 2 + 8 * 10 = 82
4. c = 5. R = R + 100 * c, adică R devine 82 + 100 * 5 = 582
5. c = 3. R = R + 1000 * c, adică R devine 582 +1000 * 3 = 3582
Ambele metode folosesc de fapt scrierea zecimală a numărului:

3582 = 0 + 1 * 2 + 10 * 8 + 100 * 5 + 1000 * 3

Pe de altă parte:

2853 =
285 * 10 +3 =
(28*10 + 5) * 10 +3 =
((2 * 10 + 8)*10 + 5) * 10 +3 =
(((0 * 10 + 2) * 10 + 8)*10 + 5) * 10 +3

În practică, cifrele cu care se construiește numărul pot să provină din diverse surse. O
situație frecventă este construirea unui număr folosind cifrele altui număr cunoscut.

Exemple
Exemplul 1: Determinarea oglinditului unui număr dat

Prin oglinditul (inversul) unui număr se înțelege un numărul scris cu cifrele numărului inițial,
în ordine inversă. De exemplu, oglinditul lui 274 este 472, iar oglinditul lui 1300 este 31 –
numerele nu pot să înceapă cu cifra 0.

Rezolvare:

 Fie n numărul dat, și ogl variabila în care vom calcula rezultatul.

 Inițial ogl = 0.
 Vom aplica procedeul de determinare prin trunchieri succesive a cifrelor lui n.
 Fiecare cifră a lui n, calculată prin n % 10 va fi adăugată la sfârșitul lui ogl, prin
atribuirea ogl = 10 * ogl + n % 10.

Program C++:

#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
int ogl= 0;
while(n){
ogl =10*ogl + n%10;
n /= 10;
}
 cout << ogl << endl;
return 0;
}

Exemplul 2: Se dă un număr natural. Să se modifice acest număr, micșorând cu o unitate

fiecare cifră impară. Dacă numărul dat este 275 rezultatul va fi 264.

Rezolvare: Vom determina cifrele numărului dat și vom construi rezultatul, inserând cifrele
la început. Cifrele pare se inserează ca atare, cifrele impare se inserează micșorate.

 Fie n numărul dat și R rezultatul. Vom utliliza o variabilă suplimentară, p, pentru a

calcula puterile lui 10.
 Inițial R = 0, p = 1
 Vom determina prin trunchieri succesive cifrele lui n în variabila uc, uc = n % 10.
o Dacă uc este par, R = R + p * uc, apoi p = p * 10.
o Dacă uc este impar, R = R + p * (uc - 1), apoi p = p * 10.

Program C++

#include <iostream>
int main()
{
int n , R = 0, p = 1;
std :: cin >> n;
while(n)
{
int uc = n % 10;
if(uc % 2 == 0)
R += p * uc;
else
R += p * (uc - 1);
p *= 10;
n /= 10;
}
std :: cout << R << std :: endl;
return 0;
}
Se citesc două numere x şi y, cu cel mult 4 cifre fiecare. Să se afişeze numărul obţinut prin
concatenarea cifrelor lui y cu cifrele lui x. Exemplu:x=1234 şi y=5678, se obţine numărul 12345678.
#include<iostream>
using namespace std;
int main()
{
    int x,y,invy;
    cout<<"x=";cin>>x;
    cout<<"y=";cin>>y;
    invy=0;
    while(y!=0)
    {
        invy=invy*10+y%10;
        y=y/10;
    }
    while(invy!=0)
    {
        x=x*10+invy%10;
        invy=invy/10;
    }
    cout<<x;
}

Algoritmi fundamentali in C++

// Suma cifrelor lui n
 
#include<iostream.h>
int n,s,c;
void main()
{
cout<<„n=”;
cin>>n;
while(n!=0)
{
c=n%10; // extrag ultima cifra
s=s+c;
n=n/10; // tai ultima cifra
}
 
cout<<„Suma cifrelor=”<<s;
}
—————————————————————————–
// Numarul de cifre ale lui n
 
#include<iostream.h>
int n, nr;
void main()
{
cout<<„n=”;
cin>>n;
while(n!=0)
{
nr=nr+1;
n=n/10; // tai cifrele
}
cout<<„Nr. de cifre=”<<nr;
}
 
—————————————————————————–
// Inversul lui n
 
#include<iostream.h>
int n, inv,c;
void main()
{
cout<<„n=”;
cin>>n;
inv=0;
while(n!=0)
{
c=n%10;
inv=inv*10+c;
n=n/10;
}
cout<<„Inversul=”<<inv;
}
—————————————————————————
// Palindrom
 
#include<iostream.h>
int n,inv, c, copie;
void main()
{
cout<<„n=”;
cin>>n;
copie=n;
while(n!=0)
{
c=n%10;
inv=inv*10+c;
n=n/10;
}
if(copie==inv)
cout<<„Palindrom”;
else
cout<<„Nu”;
}
——————————————————————————-
 
// Numarul PRIM
#include<iostream.h>
int n, ok, d;
void main()
{
cin>>n;
d=2; ok=1;
while(d<=n/2&&ok==1)
if(n%d==0)
ok=0;
else
d++;
if(ok==1)
cout<<„Prim”;
else
cout<<„Nu”;
}
——————————————————————————-
// Descompunerea in factori primi
 
#include<iostream.h>
 void main()
{
int a,d,p;
cout<<„=a”;
cin>>a;
d=2;
while(a>1)
{
p=0;
while(a%d==0)
{
p=p+1;
a=a/d;
}
if(p) // <=> if(p!=0)
cout<<d<<„^”<<p<<” „;
d++;
}
}
———————————————————————-
// Multimea divizorilor proprii ai lui n, adica in afara de 1 si n
 
#include<iostream.h>
int n,d;
void main()
{
cin>>n;
d=2;
while(d<=n/2)
{
if(n%d==0)
cout<<d<<” „; // afisez divizorii proprii ai lui n, care se pot gasi in [2,n/2]
d++;
}
}
 
———————————————-
// CMMDC a 2 nr a si b
#include<iostream.h>
int a,b;
void main()
{
cin>>a>>b;
while(a!=b)
if(a>b)
a=a-b;
else
b=b-a;
cout<<„CMMDC=”<<a;
}
———————————————–
 
// CMMMC
 
#include<iostream.h>
int a,b,x,y;
void main()
{
cin>>x>>y;
a=x; b=y;
while(x!=y)
if(x>y)
x=x-y;
else y=y-x;
cout<<„CMMC=”<<(a*b)/x;
}
Operatii / Lucrul cu numere mari in C+
+
Ce sunt numerele mari?
De ce este necesar sa lucram cu numere mari? Numerele mari sunt numere ce nu
pot fi stocate in tipurile de date cunoscute de noi pana acum (int, long long, etc).
Daca avem o problema in care ni se cere sa adunam doua numere mari (de 500
de cifre, de exemplu), trebuie sa implementam noi operatiile generale (adunare,
scadere, inmultire si impartire).

Ce solutie vom implementa?

Vom reprezenta un numar mare ca un vector in care retinem in ordine cifrele
sale, incepand cu unitatile. De exemplu, numarul 123456 va fi retinut in vector
astfel:

Deoarece pentru fiecare numar am avea nevoie de o variabila auxiliara care sa

memoreze numarul total de cifre, apelam la un truc: memoram numarul total de
cifre pe pozitia 0.

Definirea unui numar mare

#define MAX 501

typedef int NrMare[MAX];

Definim un numar mare ca fiind un vector de 501 elemente. Primul element

( NrMare[0] ) – va reprezenta numarul total de cifre ale numarului, in timp ce
restul de 500 elemente vor fi cifrele efective ale numarului nostru.
Citirea si afisarea unui numar mare
void citire(NrMare x)

char s[MAX];

cin >> s; //Citim numarul ca un sir de caractere

int n = strlen(s); //Calculam numarul de cifre a numarului

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

x[n - i] = (int)(s[i] - '0'); //Retinem cifrele invers

x[0] = n; //Memoram numarul total de cifre

void afisare(NrMare x)

for(int i = x[0]; i > 0; i--)

cout << x[i];

Compararea a doua numere mari

Mai intai verificam daca cele doua numere sunt memorate corect: sa nu aiba
zero-uri nesemnificative. De exemplu, verificam ca numarul „13” sa nu fie
memorat drept „3100” (doua zerouri nesemnificative).

Dupa care parcurgem cifrele in ordinea inversa, iar atunci cand gasim o diferenta,
returnam numarul mai mare.

int compara(NrMare a, NrMare b)

// Eliminam zero-urile semnificative, daca exista.

while (a[0] && !a[a[0]]) a[0]--;

while (b[0] && !b[b[0]]) b[0]--;

// Comparam numarul de cifre

if (a[0] < b[0])

return -1;

else

if (a[0] > b[0])

return +1;

// Daca numerele au un numar egal de cifre

// Parcurgem numerele incapand cu cifra cea mai semnificativa

// Pana la prima diferenta intalnita

for (int i = a[0]; i > 0; --i)

if (a[i] < b[i])

return -1;

else

if (a[i] > b[i])

return +1;

// Cazul final: cele doua numere sunt egale

return 0;

Suma a doua numere mari

Pentru a calcula suma a doua numere mari, trebuie mai intai sa ne asiguram ca
amandoua au acelasi numar de cifre. De exemplu, daca vrem sa adunam
numerele 124 si 96, cele doua vor arata in memorie astfel:
Daca numarul nostru y era mai mic, evident, adaugam mai multe 0-uri
nesemnificative. Dupa aceasta vom parcurge simultan cele doua
numere,incepand de la unitati. Vom aduna cele doua cifre de pe pozitii
corespondente si vom lua in calcul si eventuala cifra in plus care s-a obtinut de la
adunarea precedenta. Retinem in suma cifra obtinuta prin adunare si recalculam
cifra in plus.

Suma ar putea avea o cifra in plus fata de cel mai mare dintre cele doua numere
(daca la sfarsit cifra in plus este nenula). Functia suma() va avea ca parametri
cele doua numere mari care se aduna si numarul mare rezultat.

void suma(NrMare a, NrMare b, NrMare rezultat)

int t = 0, max;

// Completam numarul cel mai mic cu zeroouri nesemnificative

if(a[0] < b[0])

max = b[0];

for(int i = a[0] + 1; i <= b[0]; i++)

a[i] = 0;

else

max = a[0];

for(int i = b[0] + 1; i <= a[0]; i++)

b[i] = 0;

int i;

for(i = 1; i <= max; i++)

int cifra = a[i] + b[i] + t;

rezultat[i] = cifra % 10;

t = cifra/10;

if(t)

rezultat[i] = t;

else

i--;

rezultat[0] = i;

Diferenta a doua numere mari

Vom presupune ca descazutul este mai mare sau egal cu scazatorul.Pentru a
calcula diferenta a doua numere mari vom parcurge dezcazutul incepand de la
unitati. Vom scadea din cifra curenta a descazutului cifra curenta a scazatorului si
vom lua in calcul si eventuala cifra de transport, obtinuta la scaderea precedenta.
Daca rezultatul este negativ, imprumutam 10 de pe pozitia urmatoare (este
posibil doar daca descazutul este mai mare ca scazatorul), si in acest caz cifra de
transport devine -1.

Diferenta ar putea avea mai putine cifre decat descazutul, astfel incat la sfarsit
calculam numarul de cifre din diferenta, ignorand zerourile nesemnificative.

void diferenta(NrMare a, NrMare b, NrMare rezultat)

if(a[0] < b[0])

diferenta(b, a, rezultat);

else

int i, t = 0;

for(i = 1; i <= a[0]; i++)

rezultat[i] = a[i] - b[i] + t;

if(rezultat[i] < 0)

rezultat[i] += 10;

t = -1;

else

t = 0;

i--;

while(i && !rezultat[i])

i--;

rezultat[0] = i;

Inlocuirea primei cifre cu

ultima C++
#include
<iostream>
using namespace std;
//se declara variabilele n,cn,ultima si p de tip intreg
//variabila n memoreaza numarul introdus de la tastatura
//variabila cn memoreaza numarul obtinut prin inlocuirea primei cifre cu ultima
//variabila ultima memoreaza ultima cifra a numarului n
//variabila p memoreaza o putere a lui 10 care indica ordinul pozitiei primei cifre in numarul n (unita
int n,cn,ultima,p;
int main()
{
cout<<"Introduceti numarul n: ";
//se citeste numarul n
cin>>n;
//se memoreaza ultima cifra
ultima=n%10;
//se initializeaza cn cu valoarea numarului n
cn=n;
//p se initializeaza cu valoarea elementului neutru la inmultire
p=1;
while(n>9)//eliminam cifre din numar pana cand n este egal cu prima sa cifra
{
p=p*10;//se mareste puterea lui 10 pana cand se ajunge la prima cifra a lui n

n=n/10;//se elimina o cifra din numar

}
// ultima*p- ultima cifra ia prima pozitie in noul numar
// +cn%p - se adauga cifrele de pe restul pozitiilor la numar
// /10)*10- se elimina ultima cifra din numar pentru a fi inlocuita cu prima
// +n- ultima cifra devine prima cifra memorata in n
cn=((ultima*p + cn%p)/10)*10+n;
//se afiseaza numarul obtinut
cout<<"Numarul format prin inlocuirea primei cifre cu ultima in numarul n este : "<<cn;
return 0;
}