Când ne gândim la un număr, ne gândim la o înșiruire de cifre, având o semnificație clară: numărul 123 este alcătuit din trei cifre, în această ordine: 1, 2, 3. Însă, pentru un calculator, un număr este o valoare de sine stătătoare, cifrele sale neputând fi prelucrate individual.

Din fericire, însă, folosind diverse operații matematice putem să prelucrăm cifrele unui număr într-un mod ușor (și destul de intuitiv).

De regulă vom prelucra cifrele unui număr întreg — de tip int sau long long. Cu toate acestea, putem să extindem noțiunile și pentru alte tipuri, precum float sau double (deși poate fi mai periculos).

Descompunerea cifrelor

Luăm un număr ca un exemplu: 123. Să analizăm ce se întâmplă dacă împărțim la 10 (cu cât și rest):

• 123 : 10 = 12 rest 3

Observăm două aspecte:

• Restul acestei împărțiri, 3, este egal cu ultima cifră a numărului nostru inițial;
• Câtul acestei împărțiri, 12, este egal cu numărul nostru inițial, cu ultima cifră tăiată.

În cod, pentru a găsi ultima cifră a unui număr vom apela n % 10, iar pentru a tăia ultima cifră dintr-un număr vom apela n = n / 10 (în exemplul de mai devreme, n = 123).

int n = 123;
int u = n % 10;
cout << u << "\n"; //Se va afișa 3
n /= 10;
cout << n << "\n"; //Se va afișa 12

Să extindem un pic mai mult această idee: vrem să găsim ultimele două cifre ale unui număr și numărul nostru fără aceste două cifre. În loc să aplicăm operația de împărțire și de rest la 10, vom împărți la 100: n % 100 va returna ultimele două cifre ale unui număr, iar n / 100 va returna numărul fără ultimele două cifre. De exemplu, pentru n = 123, ultimele două cifre sunt n % 100 = 23, iar numărul fără ultimele două cifre este n / 100 = 1.

Intuitiv putem deduce o formulă generalizată: pentru a găsi ultimele k cifre ale lui n, vom apela n % 10…0 (k cifre de 0), iar numărul fără ultimele k cifre ale lui n este n / 10…0 (de asemenea, k cifre de 0).

int n = 34931;
int ultimeleTreiCifre = n % 1000; //Trei cifre de 0
cout << ultimeleTreiCifre << "\n"; //Se va afișa 931
n /= 1000; //Trei cifre de 0
cout << n << "\n"; //Se va afișa 34

Aflarea cifrei zecilor, cifrei sutelor, …

Să zicem că vrem să extragem cumva doar cifra zecilor a unui număr n. Pentru asta, tăiem ultima cifră a numărului folosind n = n / 10, după care extragem ultima cifră a acestui nou număr (care reprezenta cifra zecilor în numărul inițial), folosind n = n % 10.

int n = 123;
n = n / 10; //n este acum 12
n = n % 10; //n este acum 2, adică cifra zecilor lui 123
cout << n << "\n";

Aceasta este varianta recomandată, deoarece, dacă vrem să aflăm cifra sutelor de exemplu, putem să îl împărțim pe n la 100 în loc de 10, tot restul codului rămânând la fel ca cel precedent — codul fiind astfel mai ușor de gestionat.

//Tot ce schimbăm este n / 10 -> n / 100
int n = 34931;
n = n / 100; //n este acum 349
n = n % 10; //n este acum 9, adică cifra sutelor lui 34931
cout << n << "\n";

Determinarea cifrelor unui număr

Până acum am învățat următoarele:

• Ultima cifră a lui n se poate obține aplicând n % 10;
• Pentru a tăia ultima cifră din n putem aplica n = n / 10.

Vom deduce următorul lucru:

• Dacă tăiem ultima cifră din n, când acesta are o singură cifră, atunci n devine egal cu 0. Asta se întâmplă deoarece, pentru un număr de o cifră, n : 10 = 0 rest n , așadar operația n / 10 este egală cu 0.

Folosind observația tocmai descoperită, ne dăm seama că putem să iterăm (parcurgem) cifrele unui număr astfel:

int n = 34931;
do {
    int u = n % 10; //Determinăm ultima cifră curentă a lui n
    cout << u << " "; //Prelucrăm ultima cifră a lui n: în acest caz, o afișăm
    n /= 10; //Tăiem ultima cifră a lui n
} while(n != 0); //Cât timp n mai are cifre (este diferit de 0)

Programul va afișa 1 3 9 4 3 — mai exact, cifrele lui n în ordine inversă.

Iată o animație care parcurge exemplul pas cu pas:

int n = 34931;
do {
    int u = n % 10;
    cout << u << " ";
    n /= 10;
} while(n != 0);

int n = 34931;
do {
    int u = n % 10;
    cout << u << " ";
    n /= 10;
} while(n != 0);

int n = 34931;
do {
    int u = n % 10;
    cout << u << " ";
    n /= 10;
} while(n != 0);

int n = 34931;
do {
    int u = n % 10;
    cout << u << " ";
    n /= 10;
} while(n != 0);

int n = 34931;
do {
    int u = n % 10;
    cout << u << " ";
    n /= 10;
} while(n != 0);

int n = 34931;
do {
    int u = n % 10;
    cout << u << " ";
    n /= 10;
} while(n != 0);

Consolă: 

Când folosim while și când folosim do while?

Observăm că în exemplul de mai sus am folosit structura repetitivă de tip do while. Ca o reamintire:

Instrucțiunea while verifică condiția (în cazul nostru n != 0), după care execută codul dintre acolade. Instrucțiunea do while mai întâi execută codul dintre acolade, după care verifică condiția, executând încă odată codul dacă condiția mai este validă.

Să luăm cazul particular, când n = 0. Răspunsul la care ne-am aștepta ar fi 0, deoarece 0 are o singură cifră (0). Cu toate acestea, dacă am fi folosit while în loc de do while, ar fi verificat condiția mai întâi (n != 0), ar fi văzut că este falsă (deoarece n este egal cu 0) și nu ar fi executat codul dintre acolade, așadar nu ar fi afișat nimic. Folosind, în schimb, do while, codul ar fi executat (s-ar afișa 0), după care s-ar verifica dacă n este diferit de 0, după care s-ar opri.

Astfel, când folosim do while, codul va merge și pentru n = 0 și de aceea se recomandă folosirea structuriido while când lucrăm cu cifre. Acest caz particular este deseori nebăgat în seamă în lecții, însă este un aspect important ce trebuie reținut.

Construirea unui număr folosind cifre

Am învățat să descompunem un număr în cifre individuale, însă acum ne propunem să formăm un număr folosind cifre.

Construirea unui număr de la sfârșit la început

Să zicem că avem un număr n = 123 și ne propunem să adăugăm cifra 4 la coadă (formând numărul n = 1234). Observăm că dacă îl înmulțim pe n cu 10 și adunăm cifra 4, obținem numărul dorit:

int n = 123;
n *= 10; //n devine 1230
n += 4; //n devine 1234
//Puteam scrie și n = n * 10 + 4;
cout << n << "\n";

Practic, am făcut loc unei cifre noi mutând toate cifrele la stânga cu o poziție și am adăugat cifra dorită printr-o adunare.

Putem să aplicăm repetat acest algoritm: să zicem că vrem să formăm numărul 1234. Începem printr-un număr egal cu 0, după care adăugăm repetat cifrele la n:

int n = 0;
n = n * 10 + 1; //n devine 0 * 10 + 1 = 1
n = n * 10 + 2; //n devine 1 * 10 + 2 = 12
n = n * 10 + 3; //n devine 12 * 10 + 3 = 123
n = n * 10 + 4; //n devine 123 * 10 + 4 = 1234
cout << n << "\n";

Ca o generalizare, să zicem că ni se dau n cifre și trebuie să formăm numărul cu cele n cifre în ordinea dorită:

//Intrare: n = 5, cifrele: 3 4 9 3 1
//Ieșire: 34931
int n, nr = 0;
cin >> n;
for(int i = 1; i <= n; ++i) {
    int cif;
    cin >> cif;
    nr = nr * 10 + cif;
}
cout << nr << "\n";

Construirea unui număr de la început la sfârșit

Să zicem că vrem să formăm un număr cu cifrele 1, 2, 3, 4, dar de data aceasta adăugând cifrele de la început spre sfârșit. Vom aborda astfel problema:

int n = 0;
n = 1 * 1 + n; //n devine 1 * 1 + 0 = 1
n = 2 * 10 + n; //n devine 2 * 10 + 1 = 21
n = 3 * 100 + n; //n devine 3 * 100 + 21 = 321
n = 4 * 1000 + n; //n devine 4 * 1000 + 321 = 4321
cout << n << "\n";

Observăm că atunci când vrem să adăugăm o cifră nouă la n, practic adăugăm valoarea cifrei, înmulțită cu o putere de a lui 10 în funcție de numărul de cifre ale lui n.

Ca o generalizare, să zicem că ni se dau n cifre și trebuie să formăm numărul cu cele n cifre, adăugând fiecare cifră la început. Vom crea o valoare auxiliară p, inițial egală cu 1 și la fiecare pas înmulțită cu 10, reprezentând valoarea putere de 10 pe care am menționat-o mai devreme.

//Intrare: n = 5, cifrele: 1 3 9 4 3
//Ieșire: 34931
int n, nr = 0, p = 1;
cin >> n;
for(int i = 1; i <= n; ++i) {
    int cif;
    cin >> cif;
    nr = cif * p + nr;
    p *= 10;
}
cout << nr << "\n";

Probleme rezolvate

Iată câteva aplicații, împreună cu rezolvări.

Numărul de cifre

Dându-se un număr natural n, să se determine numărul de cifre ale sale. Testează-ți rezolvarea pe această pagină.

Exemple: Pentru n = 328, rezultatul va fi 3, iar pentru n = 0, rezultatul va fi 1.

Rezolvare: Iterăm printre cifrele lui n folosind o structură repetitivă de tip do while (vezi mai sus de ce nu una de tip while), la fiecare pas incrementând cu 1 o variabilă care reține numărul de cifre.

#include <iostream>

using namespace std;

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

Suma cifrelor

Dându-se un număr natural n, să se determine suma cifrelor sale. Testează-ți rezolvarea pe această pagină.

Exemple: Pentru n = 328, rezultatul va fi 3 + 2 + 8 = 13, iar pentru n = 0, rezultatul va fi 0.

Rezolvare: Iterăm printre cifrele lui n folosind o structură repetitivă de tip do while (vezi mai sus de ce nu una de tip while), la fiecare pas incrementând cu cifra curentă o variabilă care reține numărul de cifre.

#include <iostream>

using namespace std;

int main()
{
    int n, sumcif = 0;
    cin >> n;
    do {
        int u = n % 10;
        sumcif += u;
        n /= 10;
    } while(n != 0);
    cout << sumcif;
    return 0;
}

Oglinditul unui număr

Dându-se un număr natural n, să se determine răsturnatul (sau oglinditul) numărului. Testează-ți rezolvarea pe această pagină.

Exemple: Pentru n = 328, rezultatul va fi 823, iar pentru n = 0, rezultatul va fi 0.

Rezolvare: Iterăm printre cifrele lui n folosind o structură repetitivă de tip do while (vezi mai sus de ce nu una de tip while). În timp ce luăm și ștergem cifrele lui n, construim în paralel un nou număr, care va reține la final oglinditul.

#include <iostream>

using namespace std;

int main()
{
    int n, oglindit = 0;
    cin >> n;
    do {
        int u = n % 10;
        oglindit = oglindit * 10 + u;
        n /= 10;
    } while(n != 0);
    cout << oglindit << "\n";
    return 0;
}

Bibliografie sau alte resurse

Dacă aveți nevoie vreodată doar de formulele din această lecție, puteți să vizionați copiuțele pentru cifrele unui număr.

• PbInfo
• InfoGenius
• 100din100
• UAIC