Wie erhalten Sie die Ziffern einer Zahl, ohne sie in ein String/Char-Array umzuwandeln?

Question

Wie bekomme ich, was die Ziffern einer Zahl in C++ sind, ohne es in Zeichenfolgen oder Zeichenarrays umzuwandeln?

Answer 1

Die folgenden druckt die Ziffern in der Reihenfolge der Bedeutung aufsteigend (das heißt Einheiten, dann zehn, usw.):

do { 
    int digit = n % 10; 
    putchar('0' + digit); 
    n /= 10; 
} while (n > 0); 

Answer 2

Verwenden Sie eine Sequenz von mod 10 und div 10 Operationen (unabhängig von der Syntax in C++), um die Ziffern nacheinander anderen Variablen zuzuweisen.

In Pseudo-Code

lsd = number mod 10 
number = number div 10 
next lsd = number mod 10 
number = number div 10 

etc ...

schmerzhaft! ... aber keine Zeichenfolgen oder Zeichenfelder.

Answer 3

Erste Ziffer (am wenigsten signifikant) = Nummer% 10, zweite Ziffer = Stock (Nummer/10)% 10, 3. Ziffer = Stock (Nummer/100)% 10.

etc

Answer 4

Etwas wie folgt aus:

int* GetDigits(int num, int * array, int len) { 
    for (int i = 0; i < len && num != 0; i++) { 
    array[i] = num % 10; 
    num /= 10; 
    } 
} 

Die Mod 10 ist sehen Sie die Ziffern erhalten. Die div 10s werden die Nummer voranbringen.

Answer 5

Sie wollen etwas, was wie das?

int n = 0; 
    std::cin>>n; 

    std::deque<int> digits; 
    if(n == 0) 
    { 
     digits.push_front(0); 
     return 0; 
    } 

    n = abs(n); 
    while(n > 0) 
    { 
     digits.push_front(n % 10); 
     n = n /10; 
    } 
    return 0; 

Answer 6

Da jeder läutet, ohne die Frage zu kennen.
Hier ist mein Versuch Vergeblichkeit:

#include <iostream> 

template<int D> int getDigit(int val)  {return getDigit<D-1>(val/10);} 
template<>  int getDigit<1>(int val) {return val % 10;} 

int main() 
{ 
    std::cout << getDigit<5>(1234567) << "\n"; 
} 

Answer 7

Was floor(log(number))+1?

Mit n Ziffern und unter Verwendung von Basis b Sie eine beliebige Anzahl von bis zu pow(b,n)-1 ausdrücken können. Um die Anzahl der Ziffern einer Zahl x in der Basis b zu erhalten, können Sie die Umkehrfunktion der Potenzierung verwenden: base-b logarithm. Um nicht ganzzahlige Ergebnisse zu verarbeiten, können Sie den Trick floor()+1 verwenden.

PS: Dies funktioniert für Ganzzahlen, nicht für Zahlen mit Dezimalzahlen (in diesem Fall sollten Sie wissen, welche Genauigkeit der von Ihnen verwendete Typ hat).

Answer 8

Ich habe viele Antworten gesehen, aber sie alle vergessen do {...} while() Schleife zu verwenden, die eigentlich die kanonische Weise, dieses Problem zu lösen und 0 ordnungsgemäß zu behandeln.

Meine Lösung basiert auf this eins von Naveen.

int n = 0; 
std::cin>>n; 

std::deque<int> digits; 
n = abs(n); 
do { 
    digits.push_front(n % 10); 
    n /= 10; 
} while (n>0); 

Answer 9

Nicht so wie Martin York Antwort cool, aber Adressierung nur ein willkürliches ein Problem:

Sie können eine positive ganze Zahl größer als Null drucken eher einfach mit Rekursion:

#include <stdio.h> 
void print(int x) 
{ 
    if (x>0) { 
     print(x/10); 
     putchar(x%10 + '0'); 
    } 
} 

Dieser Wille die niedrigstwertige Ziffer zuletzt ausdrucken. vor

Answer 10

Jahren, als Antwort auf die oben gestellten Fragen würde ich den folgenden Code schreiben:

int i2a_old(int n, char *s) 
{ 
    char d,*e=s;//init begin pointer 
    do{*e++='0'+n%10;}while(n/=10);//extract digits 
    *e--=0;//set end of str_number 
    int digits=e-s;//calc number of digits 
    while(s<e)d=*s,*s++=*e,*e--=d;//reverse digits of the number 
    return digits;//return number of digits 
} 

Ich denke, dass die Funktion printf (...) funktioniert so ähnlich.

Jetzt werde ich dies schreibe:

int i2a_new(int n, char *s) 
{ 
    int digits=n<100000?n<100?n<10?1:2:n<1000?3:n<10000?4:5:n<10000000?n<1000000?6:7:n<100000000?8:n<1000000000?9:10; 
    char *e=&s[digits];//init end pointer 
    *e=0;//set end of str_number 
    do{*--e='0'+n%10;}while(n/=10);//extract digits 
    return digits;//return number of digits 
} 

Vorteile: Lookup-Tabelle indipendent; C, C++, Java, JavaScript, PHP-kompatibel; Anzahl der Ziffern erhalten, min comparisons: 3; Anzahl der Ziffern erhalten, max comparisons: 4; schneller Code; ein Vergleich ist sehr einfach und schnell: cmp reg, immediate_data -> 1 CPU-Uhr.

Answer 11

Integer-Version ist trivial:

int fiGetDigit(const int n, const int k) 
{//Get K-th Digit from a Number (zero-based index) 
    switch(k) 
    { 
     case 0:return n%10; 
     case 1:return n/10%10; 
     case 2:return n/100%10; 
     case 3:return n/1000%10; 
     case 4:return n/10000%10; 
     case 5:return n/100000%10; 
     case 6:return n/1000000%10; 
     case 7:return n/10000000%10; 
     case 8:return n/100000000%10; 
     case 9:return n/1000000000%10; 
    } 
    return 0; 
} 

Answer 12

wie ein Array, das alle einzelnen Ziffern in etwas holen - zwei Varianten:

int i2array_BigEndian(int n, char a[11]) 
{//storing the most significant digit first 
    int digits=//obtain the number of digits with 3 or 4 comparisons 
    n<100000?n<100?n<10?1:2:n<1000?3:n<10000?4:5:n<10000000?n<1000000?6:7:n<100000000?8:n<1000000000?9:10; 
    a+=digits;//init end pointer 
    do{*--a=n%10;}while(n/=10);//extract digits 
    return digits;//return number of digits 
} 

int i2array_LittleEndian(int n, char a[11]) 
{//storing the least significant digit first 
    char *p=&a[0];//init running pointer 
    do{*p++=n%10;}while(n/=10);//extract digits 
    return p-a;//return number of digits 
} 

Answer 13

einfache Rekursion:

#include <iostream> 

// 0-based index pos 
int getDigit (const long number, int pos) 
{ 
    return (pos == 0) ? number % 10 : getDigit (number/10, --pos); 
} 

int main (void) { 
    std::cout << getDigit (1234567, 4) << "\n";  
} 

Answer 14

Diese Lösungen sind alles rekursiv oder iterativ. Könnte ein direkterer Ansatz ein wenig effizienter sein?

Von links nach rechts:

int getDigit(int from, int index) 
{ 
    return (from/(int)pow(10, floor(log10(from)) - index)) % 10; 
} 

Von rechts nach links:

int getDigit(int from, int index) 
{ 
    return (from/pow(10, index)) % 10; 
}