Ora 9 - Extragerea Cifrelor unui Număr

TEORIE - 40 minute

Ce vei învăța astăzi?

După această lecție, vei stăpâni extragerea cifrelor și vei putea rezolva probleme bazate pe prelucrarea cifrelor.

Conceptul de bază al cifrelor unui număr

Operatorul modulo (%) și împărțirea întreagă (/)

Algoritmul de extragere a cifrelor

Aplicații practice: suma cifrelor, numărul de cifre

Ce înseamnă "cifrele unui număr"?

Definiție: Orice număr natural poate fi descompus în cifre care sunt unitățile, zecile, sutele, etc. care îl compun.

Exemplu: Numărul 1234 are 4 cifre: 1 (mii), 2 (sute), 3 (zeci), 4 (unități).

MII

SUTE

ZECI

UNITĂȚI

1234 = 1×1000 + 2×100 + 3×10 + 4×1

Analogie: Straturile unei cepe

Gândește-te la un număr ca la o ceapă cu mai multe straturi:

STRAT EXTERIOR

Ultima cifră (unități)

Ușor de extras

STRAT URMATOR

Penultima cifră (zeci)

După ce îndepărtăm primul strat

MIJLOC

Cifrele din mijloc

Continuăm să îndepărtăm

NUCLEU

Prima cifră (cea mai semnificativă)

Ultima care rămâne

Instrumentele noastre: Operatorul modulo și împărțirea

Operatorul MODULO (%)

Returnează restul împărțirii

1234 % 10 = 4

Extrage ultima cifră a numărului

Împărțirea întreagă (/)

Împărțire fără rest (părțile întregi)

1234 / 10 = 123

Elimină ultima cifră

Combinația perfectă

Modulo extrage, împărțirea elimină

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

Extragem toate cifrele

Procesul de extragere a cifrelor lui 1234

Numărul inițial:

1234

→

(1234 % 10)

După eliminarea lui 4:

123

(1234 / 10 = 123)

→

(123 % 10)

După eliminarea lui 3:

(123 / 10 = 12)

→

(12 % 10)

După eliminarea lui 2:

(12 / 10 = 1)

→

(1 % 10)

Algoritmul complet de extragere a cifrelor

ALGORITM ExtrageCifre VARIABILE n, cifra: întreg ÎNCEPUT CITESTE n ┌ CÂT TIMP n ≠ 0 EXECUTĂ │ cifra ← n % 10 # Extrage ultima cifră │ SCRIE cifra, " " # Afișează cifra extrasă │ n ← n / 10 # Elimină ultima cifră └■ # Cifrele vor fi afișate în ordine inversă! # Pentru 1234: 4 3 2 1 SFÂRȘIT

Observație importantă: Acest algoritm extrage cifrele în ordine inversă (de la dreapta la stânga). Pentru a le extrage în ordine corectă, trebuie să le stocăm într-un vector sau să folosim recursivitatea.

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    cout << "Cifrele numarului " << n << " sunt: ";
    
    // Caz special pentru numărul 0
    if (n == 0) {
        cout << "0";
    }
    
    // Extragem cifrele până când numărul devine 0
    while (n != 0) {
        int cifra = n % 10;    // Extrage ultima cifră
        cout << cifra << " ";   // Afișează cifra
        n = n / 10;            // Elimină ultima cifră
    }
    
    return 0;
}

Atenție la cazul special: Pentru n = 0, bucla nu se execută deloc! De aceea avem verificarea specială.

Execuție pas cu pas pentru n = 1234:

Iterația 1:

n = 1234

n % 10 = 1234 % 10 = 4

Afișează 4

n / 10 = 1234 / 10 = 123 (noul n)

Iterația 2:

n = 123

n % 10 = 123 % 10 = 3

Afișează 3

n / 10 = 123 / 10 = 12 (noul n)

Iterația 3:

n = 12

n % 10 = 12 % 10 = 2

Afișează 2

n / 10 = 12 / 10 = 1 (noul n)

Iterația 4:

n = 1

n % 10 = 1 % 10 = 1

Afișează 1

n / 10 = 1 / 10 = 0 (noul n)

Rezultat final: Cifrele sunt afișate în ordine inversă: 4 3 2 1

Bucla se oprește când n devine 0.

#1: Verifică întotdeauna cazul n = 0

Dacă n = 0, bucla nu se execută deloc. Ai nevoie de o verificare specială pentru acest caz.

#2: Folosește variabile temporare

Dacă ai nevoie să păstrezi numărul original, folosește o variabilă copie pentru extragere.

int original = n; while (n != 0) { // extragere cifre } // n a devenit 0, dar original rămâne neschimbat

#3: Ordinea cifrelor

Pentru a obține cifrele în ordinea corectă (de la stânga la dreapta), le poți stoca într-un vector sau le poți procesa recursiv.

#4: Eficiență algoritmică

Complexitatea este O(k) unde k este numărul de cifre. Pentru numere mari (până la 10^9), sunt maxim 10 cifre, deci algoritmul este foarte rapid.

Aplicații practice ale extragerii cifrelor

Probleme comune care folosesc extragerea cifrelor

Suma cifrelor

Calculează suma tuturor cifrelor unui număr

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

Numărul de cifre

Numără câte cifre are un număr

int cnt = 0; while (n != 0) { cnt++; n /= 10; } // Pentru n=0: cnt=1 (caz special)

Inversul unui număr

Formează numărul invers

int invers = 0; while (n != 0) { invers = invers*10 + n%10; n /= 10; }

Cifra maximă/minimă

Găsește cea mai mare/mică cifră

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

Exercițiu de completare - Suma cifrelor:

#include <iostream>

using namespace ______;

______ main() {

int n;

cin >> ______;

int suma = ______;

while (n ______ 0) {

suma = suma + n ______ 10; // sau suma += n % 10

n = n ______ 10; // sau n /= 10

}

cout << ______;

return ______;

}

Bancă de cuvinte:

std int n 0 != % / suma

Test de înțelegere: Câte cifre are?

Test rapid:

Câte iterații va executa bucla while pentru a extrage cifrele numărului 7089?

Algoritmul de extragere:

┌ CÂT TIMP n ≠ 0 EXECUTĂ │ cifra ← n % 10 │ n ← n / 10 └■

3 iterații (7089 → 708 → 70 → 7) 4 iterații (7089 → 708 → 70 → 7 → 0) 5 iterații (7089 → 708 → 70 → 7 → 0 → 0) Nu se execută deloc

Capcane comune și cum le evităm

Greșeli frecvente la extragerea cifrelor:

❌ Uitarea cazului n = 0

while (n != 0) { // pentru n=0, nu se execută deloc // nu afișează nimic pentru 0 }

Soluție: Verifică întotdeauna cazul special:

if (n == 0) { cout << "Numărul are o cifră: 0"; } else { while (n != 0) { // extragere normală } }

❌ Distrugerea numărului original

După extragere, n devine 0. Dacă mai ai nevoie de el, creează o copie:

int copie = n; // Salvează numărul original while (n != 0) { // extragere cifre } // n = 0, dar copie = valoarea inițială

❌ Folosirea greșită a operatorilor

Confuzie între / și %

// GREȘIT: cifra = n / 10; // Obtine n/10, nu ultima cifră n = n % 10; // Devine n%10, nu n/10 // CORECT: cifra = n % 10; // Ultima cifră n = n / 10; // Elimină ultima cifră

Best Practices pentru extragerea cifrelor:

✅ Verifică întotdeauna n = 0 - tratează-l ca caz special

✅ Folosește variabile descriptive - sumaCifre, numarCifre, cifraCurenta

✅ Salvează originalul dacă e necesar - creează o copie

✅ Testează cu numere de o cifră - 0, 1, 9

✅ Testează cu numere cu zerouri în mijloc - 1001, 50005

PROBLEME PBINFO - 15 minute

PbInfo - Suma cifrelor

Enunț:

Cerință: Se citește un număr natural n. Să se calculeze suma cifrelor lui n.

Date de intrare:

Programul citește de la tastatură numărul n.

Date de ieșire:

Programul va afișa pe ecran suma cifrelor lui n.

Exemplu:

Intrare:

Ieșire:

Explicație: 1+2+3+4+5 = 15

Cum gândim soluția:

Citim numărul n
Pregătim o variabilă suma ← 0
Folosim bucla while (n != 0) pentru a extrage toate cifrele
La fiecare iterație:
- Extragem ultima cifră: cifra = n % 10
- Adăugăm cifra la sumă: suma = suma + cifra
- Eliminăm cifra: n = n / 10
Afișăm suma

Execuție pentru n=12345:

n=12345: cifra=5 → suma=0+5=5 → n=1234

n=1234: cifra=4 → suma=5+4=9 → n=123

n=123: cifra=3 → suma=9+3=12 → n=12

n=12: cifra=2 → suma=12+2=14 → n=1

n=1: cifra=1 → suma=14+1=15 → n=0

REZULTAT: Suma = 15

Ce se întâmplă dacă n=0?

Pentru n=0, bucla nu se execută deloc, deci suma rămâne 0. Dar 0 are o cifră (0) și suma cifrelor este 0. Totul este corect!

Scrie soluția în C++:

Soluție corectă:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int suma = 0;
    
    // Cazul n = 0 este tratat corect:
    // bucla nu se execută, suma rămâne 0
    
    while (n != 0) {
        suma += n % 10;   // Adaugă ultima cifră la sumă
        n /= 10;          // Elimină ultima cifră
    }
    
    cout << suma;
    
    return 0;
}

Ce învățăm din această problemă:

Modelul standard: while + n%10 + n/10 este modelul de bază pentru extragerea cifrelor
Acumulare: suma = suma + (n%10) este modelul clasic de acumulare în buclă
Tratarea cazului 0: Bucla nu se execută pentru n=0, ceea ce este corect (suma cifrelor lui 0 este 0)
Operatorii compuși: suma += n%10 și n /= 10 sunt versiuni scurte și elegante

PbInfo - Numărul de cifre

Problemă clasică care folosește extragerea cifrelor

Enunț:

Cerință: Se citește un număr natural n. Să se determine numărul de cifre ale lui n.

Date de intrare:

Programul citește de la tastatură numărul n.

Date de ieșire:

Programul va afișa pe ecran numărul de cifre ale lui n.

Exemplu:

Intrare:

Ieșire:

Explicație: 12345 are 5 cifre

Cum gândim soluția:

Citim numărul n
Pregătim o variabilă cnt ← 0 (counter)
ATENȚIE: Trebuie să tratăm cazul special n = 0 (are 1 cifră)
Pentru n ≠ 0, folosim while (n != 0):
- Incrementăm cnt: cnt = cnt + 1
- Eliminăm o cifră: n = n / 10
Afișăm cnt

Execuție pentru n=123:

n=123, cnt=0: cnt=1, n=12

n=12, cnt=1: cnt=2, n=1

n=1, cnt=2: cnt=3, n=0

REZULTAT: Număr cifre = 3

De ce avem nevoie de tratare specială pentru n=0?

Pentru n=0, bucla nu se execută deloc, deci cnt rămâne 0. Dar 0 are o cifră (0), deci trebuie să setăm cnt=1 manual pentru acest caz.

Scrie soluția în C++:

Soluție corectă:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int cnt = 0;
    
    // Cazul special: n = 0 are o cifră
    if (n == 0) {
        cnt = 1;
    } else {
        // Pentru n ≠ 0, numărăm cifrele
        while (n != 0) {
            cnt++;        // Numără o cifră
            n /= 10;      // Elimină cifra
        }
    }
    
    cout << cnt;
    
    return 0;
}

Varianta alternativă (mai scurtă):

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int cnt = 0;
    
    // Folosim do-while pentru a trata și n=0
    do {
        cnt++;
        n /= 10;
    } while (n != 0);
    
    cout << cnt;
    
    return 0;
}

Ce învățăm din această problemă:

Tratarea cazurilor speciale: n=0 este un caz special care trebuie tratat separat
do-while vs while: do-while se execută cel puțin o dată, permițând tratarea elegantă a cazului n=0
Model de numărare: cnt++ în buclă este modelul standard pentru numărare
Importanța testelor: Testează întotdeauna cu n=0, n=1, n=9, n=10, n=100

EXERCIȚII PRACTICE - 10 minute

Exercițiul Practic: Analiză și implementare

Sarcini de lucru

Completează următoarele sarcini pentru a-ți consolida cunoștințele despre extragerea cifrelor

Sarcina 1: Analiză algoritm extragere cifre

Analizează algoritmul de extragere a cifrelor:

Pentru n=1002, care va fi rezultatul algoritmului care extrage cifrele?

Scrie aici ordinea în care sunt extrase cifrele:

Soluție pentru Sarcina 1:

Analiza pentru n=1002:

Algoritmul standard:
while (n != 0) {
cifra = n % 10;
// procesează cifra
n = n / 10;
}
Execuție pas cu pas:
Iterația 1: n=1002, cifra=2, n devine 100
Iterația 2: n=100, cifra=0, n devine 10
Iterația 3: n=10, cifra=0, n devine 1
Iterația 4: n=1, cifra=1, n devine 0
Cifre extrase (în ordinea extragerii): 2, 0, 0, 1
Observație: Zerourile din mijloc sunt extrase corect!

Verificare: Numărul 1002 are cifrele 1, 0, 0, 2. Algoritmul le extrage în ordine inversă: 2, 0, 0, 1.

Sarcina 2: Implementare în C++

Cerință: Implementează în C++ un program care citește un număr și afișează suma cifrelor pare.

Cod C++ complet:

Soluție pentru Sarcina 2:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int sumaPare = 0;
    
    // Tratăm cazul n=0 separat (0 este par)
    if (n == 0) {
        sumaPare = 0;
    } else {
        // Extragem cifrele și adunăm doar pe cele pare
        while (n != 0) {
            int cifra = n % 10;
            
            // Verificăm dacă cifra este pară
            if (cifra % 2 == 0) {
                sumaPare += cifra;
            }
            
            n /= 10;  // Eliminăm cifra procesată
        }
    }
    
    cout << "Suma cifrelor pare este: " << sumaPare << endl;
    
    return 0;
}

Explicații importante:

Verificare paritate: cifra % 2 == 0 testează dacă cifra este pară
Tratare n=0: 0 este par, dar suma cifrelor pare este 0 (corect)
Teste recomandate:
n=2468 → suma=20 (2+4+6+8)
n=1357 → suma=0 (toate cifrele impare)
n=1234 → suma=6 (2+4)
n=0 → suma=0

Descarcă toate exercițiile și soluțiile

Vor fi descărcate toate exercițiile completate, soluțiile tale și problemele PbInfo.