[C++] Cum verifici dacă o cifră este divizor al altei cifre într-un număr

Salutare, pasionați de programare și logică numerică! 🚀 Astăzi ne aventurăm într-un exercițiu de gândire algoritmică care, deși la prima vedere poate părea simplu, ne va permite să explorăm concepte fundamentale în C++: manipularea numerelor, extragerea cifrelor și verificarea divizibilității. Scopul nostru este să descoperim cum putem determina dacă o cifră dintr-un număr este divizorul altei cifre din același număr. Sună interesant, nu-i așa?

Acest tip de problemă este excelent pentru a-ți șlefui abilitățile de rezolvare a problemelor, de a gândi în pași logici și de a scrie cod robust. Indiferent dacă ești la început de drum sau cauți să-ți perfecționezi cunoștințele, înțelegerea modului de a descompune un număr în elementele sale constitutive (cifrele) și de a le analiza individual este o competență valoroasă.

Ce Înseamnă Mai Exact Problema Noastră? 🤔

Înainte de a ne arunca în cod, să clarificăm exact ce căutăm. Avem un număr întreg, să zicem 12345. Cifrele sale sunt 1, 2, 3, 4, 5. Obiectivul este să verificăm toate perechile posibile de cifre din acest număr și să vedem dacă una dintre ele (prima) este divizor al celeilalte (a doua). De exemplu:

• Este 1 divizor al lui 2? Da.
• Este 1 divizor al lui 3? Da.
• Este 2 divizor al lui 4? Da.
• Este 2 divizor al lui 5? Nu.
• Este 4 divizor al lui 2? Nu.

Observi că ordinea contează! De asemenea, trebuie să ne gândim și la cazuri speciale, cum ar fi cifra 0 sau cifrele identice.

Concepte Fundamentale Necesare 📚

Pentru a aborda această sarcină, vom folosi câteva operații de bază în C++:

1. Extragerea Cifrelor dintr-un Număr 🔢

Aceasta este piatra de temelie a problemei noastre. Un număr întreg poate fi descompus în cifrele sale individuale folosind operatorii modulo (%) și împărțire întreagă (/). Iată cum funcționează:

• Operatorul modulo (%): Ne dă restul împărțirii. Orice număr N % 10 va returna ultima cifră a lui N. De exemplu, 123 % 10 este 3.
• Operatorul împărțire întreagă (/): Ne elimină ultima cifră. Orice număr N / 10 va elimina ultima cifră a lui N. De exemplu, 123 / 10 este 12.

Combinând aceste două operații într-o buclă while, putem extrage toate cifrele unui număr până când numărul devine 0. De obicei, cifrele sunt extrase de la dreapta la stânga (unități, zeci, sute etc.), și este util să le stocăm într-o structură de date, cum ar fi un std::vector, pentru a le putea accesa și compara ulterior.

2. Verificarea Divizibilității ✅

Pentru a verifica dacă un număr A este divizor al unui număr B, trebuie să vedem dacă restul împărțirii lui B la A este 0. În C++, asta se traduce prin B % A == 0.

Atenție la Cazul Special: Împărțirea la Zero! ⚠️

Un aspect crucial este că nu putem împărți niciodată la zero. Dacă una dintre cifrele extrase este 0, iar ea ar urma să fie divizorul într-o operație, programul nostru ar crăpa. Prin urmare, trebuie să includem o verificare explicită pentru a ne asigura că divizorul nu este 0. Orice număr (în afară de zero) nu este divizibil cu zero. Zero este divizibil cu orice număr (mai puțin zero), dar invers nu este valabil. Deci, cifracare_divide % 0 este o operație interzisă.

Algoritmul Pas cu Pas ⚙️

Vom construi algoritmul nostru în câțiva pași logici, pe care îi vom transpune apoi în cod C++. Să ne imaginăm că avem numărul numar_initial.

1. Validarea Inputului: Asigură-te că numărul primit este pozitiv. Deși problema se poate extinde și la numere negative, convenția este să lucrăm cu valoarea absolută pentru extragerea cifrelor. De exemplu, cifrele lui -123 sunt tot 1, 2, 3. Pentru simplitate, ne vom concentra pe numere pozitive.
2. Extragerea și Stocarea Cifrelor:
   • Creează un std::vector gol pentru a stoca cifrele.
   • Folosește o buclă while (numar_temporar > 0).
   • În fiecare iterație:
     • Extrage ultima cifră: int cifra = numar_temporar % 10;
     • Adaugă această cifră în vector.
     • Elimină ultima cifră din număr: numar_temporar /= 10;
   • Caz special: Dacă numărul inițial este 0, vectorul va rămâne gol. Adaugă cifra 0 manual în vector.
3. Parcurgerea și Compararea Cifrelor:
   • Acum că avem toate cifrele stocate, vom folosi două bucle imbricate (for) pentru a itera prin toate perechile posibile de cifre.
   • Prima buclă (pentru indexul i) va selecta „cifra dividend”.
   • A doua buclă (pentru indexul j) va selecta „cifra divizor”.
   • Asigură-te că nu compari o cifră cu ea însăși la aceeași poziție (deci i != j, deși pentru un număr ca 11, 1 este divizor al lui 1, deci această condiție ar putea fi omisă, sau gestionată inteligent). Mai corect este să comparăm *valorile* cifrelor, nu pozițiile. Dacă numărul este 22, avem cifrele [2, 2]. 2 este divizor al lui 2.
4. Verificarea Divizibilității (cu Gestionarea Cazul Zero):
   • În interiorul buclelor imbricate, extrage cifra_dividend = cifre[i] și cifra_divizor = cifre[j].
   • FOARTE IMPORTANT: Verifică dacă cifra_divizor este diferită de 0.
   • Dacă cifra_divizor != 0 și cifra_dividend % cifra_divizor == 0, atunci ai găsit o pereche validă. Poți afișa mesajul corespunzător.

Exemplu de Implementare C++ 💻

Să punem în practică aceste idei într-un program C++ complet. Vom structura codul în funcții pentru o mai bună modularitate și lizibilitate.

#include <iostream> // Pentru intrare/ieșire
#include <vector>   // Pentru std::vector
#include <algorithm> // Pentru std::reverse (opțional, dar util pentru ordinea cifrelor)
#include <cmath>    // Pentru std::abs (gestionarea numerelor negative, dacă e cazul)

// ✨ Funcție pentru extragerea cifrelor dintr-un număr
std::vector<int> extrageCifre(int numar) {
    std::vector<int> cifre;

    // Gestionăm cazul special al numărului 0
    if (numar == 0) {
        cifre.push_back(0);
        return cifre;
    }

    // Luăm valoarea absolută pentru a ignora semnul
    numar = std::abs(numar); 

    while (numar > 0) {
        cifre.push_back(numar % 10); // Adaugă ultima cifră
        numar /= 10;                 // Elimină ultima cifră
    }

    // Cifrele sunt adăugate în ordine inversă (unități, zeci...).
    // Le putem inversa pentru a le avea în ordinea apariției în număr,
    // dar pentru problema noastră nu este strict necesar, deoarece le vom parcurge pe toate.
    // std::reverse(cifre.begin(), cifre.end()); 

    return cifre;
}

// 💡 Funcție pentru a verifica și afișa relația de divizibilitate între cifre
void verificaDivizoriCifre(int numar) {
    std::vector<int> cifre = extrageCifre(numar);

    if (cifre.empty()) {
        std::cout << "Numărul " << numar << " nu are cifre valide." << std::endl;
        return;
    }

    std::cout << "Analizăm numărul: " << numar << std::endl;
    std::cout << "Cifrele extrase: ";
    for (int c : cifre) {
        std::cout << c << " ";
    }
    std::cout << std::endl;

    bool gasitDivizor = false;

    // Parcurgem fiecare cifră ca potențial DIVIDEND
    for (size_t i = 0; i < cifre.size(); ++i) {
        int cifra_dividend = cifre[i];

        // Parcurgem fiecare cifră ca potențial DIVIZOR
        for (size_t j = 0; j < cifre.size(); ++j) {
            int cifra_divizor = cifre[j];

            // Ne asigurăm că nu testăm divizibilitatea unei cifre cu ea însăși
            // dacă nu este necesar, dar pentru "o cifră este divizor al altei cifre"
            // inclusiv ea însăși (2 este divizor al lui 2) este valid.
            // Dacă am dori doar perechi distincte de cifre (ca valori), 
            // logica ar fi ușor diferită. Aici, verificăm toate combinațiile.
            // if (i == j) continue; // Decizia depinde de cerința exactă

            // ⚠️ Verificare crucială: evită împărțirea la zero!
            if (cifra_divizor == 0) {
                // std::cout << "Atenție: Cifra " << cifra_divizor << " nu poate fi divizor." << std::endl;
                continue; // Treci la următorul divizor
            }

            // Verificăm condiția de divizibilitate
            if (cifra_dividend % cifra_divizor == 0) {
                std::cout << "✔️ Cifra " << cifra_divizor 
                          << " este divizor al cifrei " << cifra_dividend 
                          << std::endl;
                gasitDivizor = true;
            }
        }
    }

    if (!gasitDivizor) {
        std::cout << "❌ Nu s-au găsit perechi de cifre în care o cifră să fie divizor al alteia." << std::endl;
    }
    std::cout << "----------------------------------------" << std::endl;
}

int main() {
    // 🚀 Exemple de utilizare
    verificaDivizoriCifre(12345);
    verificaDivizoriCifre(2048);
    verificaDivizoriCifre(7); // Număr cu o singură cifră
    verificaDivizoriCifre(11); // Cifre identice
    verificaDivizoriCifre(357); // Fără divizori semnificativi între ele
    verificaDivizoriCifre(0); // Cazul zero
    verificaDivizoriCifre(999); // Cifre identice multiple
    verificaDivizoriCifre(6); // Cifre simple
    verificaDivizoriCifre(-124); // Test cu număr negativ

    return 0;
}

Explicații Suplimentare despre Cod:

• Am inclus <cmath> pentru std::abs, care ne ajută să tratăm numerele negative convertindu-le la valoarea lor absolută, simplificând extragerea cifrelor.
• Funcția extrageCifre returnează un std::vector<int>. Această abordare este flexibilă și eficientă pentru un număr rezonabil de cifre (în majoritatea cazurilor, un int are maxim 10 cifre).
• Bucla imbricată din verificaDivizoriCifre asigură că fiecare cifră este testată atât ca dividend, cât și ca divizor, față de *toate* celelalte cifre din număr (inclusiv ea însăși).
• Verificarea cifra_divizor == 0 este vitală. Fără ea, programul ar eșua la rulare ori de câte ori ar întâlni 0 ca divizor.
• Am adăugat un bool gasitDivizor pentru a afișa un mesaj de notificare dacă nu se găsește nicio pereche.

Considerații și Optimizări 📈

Deși abordarea de mai sus este clară și funcțională, există întotdeauna loc de discuție și, uneori, de optimizare, în funcție de cerințele specifice:

Eficiență:

• Complexitate Temporală: Extragerea cifrelor este o operație de complexitate O(log N), unde N este numărul. Compararea cifrelor implică două bucle imbricate peste vectorul de cifre. Dacă avem D cifre, complexitatea este O(D^2). Pentru un număr întreg tipic (până la 10 cifre), D este mic, deci D^2 este, de asemenea, foarte mic (max 100 de comparații). Această soluție este extrem de rapidă în practică.
• Complexitate Spațială: Stocăm cifrele într-un vector, deci complexitatea spațială este O(D), unde D este numărul de cifre. Din nou, pentru numere întregi standard, aceasta este neglijabilă.

Alternative pentru Extragerea Cifrelor:

O altă metodă de extragere a cifrelor, mai ales dacă numărul este foarte mare și se potrivește mai bine unui long long sau chiar unei reprezentări de șir de caractere, ar fi conversia numărului la un std::string. Apoi, poți itera prin caracterele șirului și le poți converti înapoi la cifre întregi. Această abordare elimină bucla while cu % și /, dar introduce costul conversiei la și de la șir de caractere.

#include <string> // Pentru std::string
// ...
std::vector<int> extrageCifreDinString(int numar) {
    std::string s_numar = std::to_string(numar);
    std::vector<int> cifre;
    for (char c : s_numar) {
        cifre.push_back(c - '0'); // Converteste caracterul cifră în int
    }
    return cifre;
}

Această variantă este adesea mai ușor de citit pentru unii programatori, dar pentru numere întregi obișnuite, abordarea matematică (cu % și /) este, în general, mai performantă.

Opinia Mea Personală (Bazată pe Experiență) ❤️

Acest tip de problemă, deși la suprafață pare doar un exercițiu didactic, este extrem de valoros. De ce? Pentru că te forțează să gândești la câteva principii cheie de programare robustă. Am văzut de nenumărate ori, în proiecte reale, cum lipsa atenției la cazuri limită (cum ar fi împărțirea la zero sau numerele cu o singură cifră) duce la bug-uri costisitoare și ore întregi pierdute cu depanarea. Statistici din industrie, cum ar fi cele publicate de firme de analiză a calității codului, indică în mod constant că erorile logice și lipsa validării input-ului sunt printre cele mai frecvente surse de vulnerabilități și defecțiuni software.

Un cod bun nu este doar cel care funcționează pentru cazul fericit, ci și cel care eșuează elegant (sau nu eșuează deloc!) în fața input-ului neașteptat sau a situațiilor limită. Gândirea la „ce se întâmplă dacă…?” este o abilitate pe care orice programator aspirant ar trebui să o cultive.

De aceea, insist pe validarea input-ului și pe gestionarea explicită a cazului 0 ca divizor. Nu este o optimizare de viteză, ci una de fiabilitate și corectitudine. În plus, spargerea problemei în funcții mai mici (extrageCifre, verificaDivizoriCifre) face codul mai ușor de înțeles, de testat și de reutilizat. Acestea sunt practici esențiale în orice proiect software, de la aplicații mobile la sisteme enterprise.

Concluzie 📚

Am parcurs un drum interesant, de la înțelegerea unei probleme logice la implementarea ei eficientă și robustă în C++. Am învățat cum să extragim cifre dintr-un număr, cum să le stocăm și cum să le comparăm pentru a verifica relațiile de divizibilitate, acordând o atenție deosebită cazurilor speciale precum cifra zero. Acest exercițiu nu doar că îți consolidează cunoștințele de bază în C++, dar te ajută și să gândești ca un adevărat inginer software, anticipând potențialele probleme și scriind cod rezistent.

Sper că acest ghid detaliat ți-a fost util și te-a inspirat să explorezi și mai mult lumea fascinantă a algoritmilor și a programării. Nu uita, practica face perfecțiunea! Continuă să experimentezi, să pui întrebări și să construiești. Lumea programării te așteaptă! 🚀