Wie kann ich die Ziffern in einer Ganzzahl ohne eine Zeichenfolge zählen?

Question

Ich fürchte, es gibt eine einfache und offensichtliche Antwort auf diese Frage. Ich muss bestimmen, wie viele Stellen eine Anzahl von Elementen breit ist, so dass ich jede Artikelnummer mit der Minimum Nummer der führenden Nullen auffüllen kann, die erforderlich sind, um die Ausrichtung beizubehalten. Zum Beispiel möchte ich keine führenden Nullen, wenn die Summe < 10 ist, 1, wenn es zwischen 10 und 99 usw.

Eine Lösung wäre, die Elementanzahl in eine Zeichenfolge zu konvertieren und dann Zeichen zu zählen. Yuck! Gibt es einen besseren Weg?

Edit: Ich hätte nicht gedacht, die common logarithm zu verwenden (ich wusste nicht, dass so etwas existiert). Also, nicht offensichtlich - für mich - aber auf jeden Fall einfach.

Answer 1

Dies sollte es tun:

int length = (number ==0) ? 1 : (int)Math.log10(number) + 1; 

Answer 2

Eine Lösung von Basis 10 Logarithmus vorgesehen ist, ein bisschen übertrieben.

Answer 3

Sie können eine while-Schleife verwenden, die als ein Logarithmus wahrscheinlich schneller sein wird, weil dies nur Integer-Arithmetik verwendet:

int len = 0; 
while (n > 0) { 
    len++; 
    n /= 10; 
} 

ich es als eine Übung für den Leser überlassen, diesen Algorithmus zu justieren Null zu handhaben und negative Zahlen.

Answer 4

Sie können durchschleifen und löschen um 10, zählen Sie die Anzahl der Male, die Sie Schleife;

int num = 423; 
int minimum = 1; 
while (num > 10) { 
    num = num/10; 
    minimum++; 
} 

Answer 5

int length = (int)Math.Log10(Math.Abs(number)) + 1; 

Sie können für das negative Vorzeichen berücksichtigen müssen ..

Answer 6

Wenn Sie Pad, um die Zahl in .Net werden, dann

num.ToString().PadLeft(10, '0') 

könnte tun, was Sie wollen .

Answer 7

Da eine Zahl keine führenden Nullen enthält, konvertieren Sie sie trotzdem, um sie hinzuzufügen. Ich bin mir nicht sicher, warum Sie so sehr versuchen, es zu vermeiden, um die Länge zu finden, wenn das Endergebnis sowieso eine Schnur sein muss.

Answer 8

Okay, ich kann nicht widerstehen: verwenden /=:

#include <stdio.h> 

int 
main(){ 
     int num = 423; 
     int count = 1; 
     while(num /= 10) 
       count ++; 
     printf("Count: %d\n", count); 
     return 0; 
} 
534 $ gcc count.c && ./a.out 
Count: 3 
535 $ 

Answer 9

Eine effizientere Lösung als wiederholte Teilung wiederholt werden würde, wenn Aussagen mit vervielfacht ... z (Wobei n die Zahl, deren Anzahl der Stellen erforderlich ist)

unsigned int test = 1; 
unsigned int digits = 0; 
while (n >= test) 
{ 
    ++digits; 
    test *= 10; 
} 

Wenn es eine vernünftige Obergrenze für die Elementanzahl ist (zB der 32-Bit-Bereich eines unsigned int) dann eine noch bessere Weg ist, Vergleichen Sie mit Mitgliedern eines statischen Arrays, z

// this covers the whole range of 32-bit unsigned values 
const unsigned int test[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 }; 

unsigned int digits = 10; 
while(n < test[digits]) --digits; 

Answer 10

Ich hätte einen Kommentar gepostet, aber mein Rep-Score wird mir diese Unterscheidung nicht gewähren.

Alles, was ich war, darauf hinzuweisen wollte, dass, obwohl die Log (10) eine sehr elegante (sprich: sehr wenige Zeilen Code) ist Lösung, ist es wahrscheinlich die auf dem Prozessor ein am meisten zu besteuern ist.

Ich denke, Jhericos Antwort ist wahrscheinlich die effizienteste Lösung und sollte daher als solche belohnt werden.

Vor allem, wenn Sie für eine Menge von Zahlen tun dies gehen werden ..