¿Cómo puedo contar los dígitos en un número entero sin un molde de cuerda?

Question

Me temo que hay una respuesta simple y obvia a esta pregunta. Necesito determinar cuántos dígitos tiene un conteo de elementos, de modo que pueda rellenar cada número de artículo con el mínimo número de ceros iniciales necesarios para mantener la alineación. Por ejemplo, no deseo ceros a la izquierda si el total es < 10, 1 si es entre 10 y 99, etc.

Una solución sería convertir el recuento de elementos en una cadena y luego contar los caracteres. ¡Yuck! ¿Hay una mejor manera?

Editar: No hubiera pensado usar el common logarithm (no sabía que existiera tal cosa). Entonces, no es obvio, para mí, pero definitivamente simple.

Answer 1

Esto debe hacerlo:

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

Answer 2

Una solución es proporcionada por logaritmo en base 10, un poco excesivo.

Answer 3

Puede utilizar un bucle while, que probablemente será más rápido que un logaritmo porque esto sólo utiliza la aritmética de enteros:

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

lo dejo como ejercicio para el lector para ajustar este algoritmo para manejar cero y números negativos.

Answer 4

Puede recorrer y eliminar por 10, contar el número de veces que realiza un ciclo;

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

Answer 5

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

Es posible que necesite para tener en cuenta el signo negativo ..

Answer 6

Si va a rellenar el número en .Net, entonces

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

podría hacer lo que quiera .

Answer 7

Dado que un número no tiene ceros a la izquierda, de todos modos está convirtiendo para agregarlos. No estoy seguro de por qué estás tan esforzándote por evitarlo para encontrar la longitud en la que el resultado final tendrá que ser una cadena de todos modos.

Answer 8

Está bien, no puedo resistir: utilizar /=:

#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

Una solución más eficiente que la división repetida se repetiría si las declaraciones con multiplica por ejemplo ... (Donde n es el número se requiere cuyo número de dígitos)

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

Si hay algún límite en el número de elementos (por ejemplo, la gama de 32 bits de un unsigned int), entonces una forma aún mejor superior razonable es comparar con miembros de una matriz estática, por ejemplo

// 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

Hubiera publicado un comentario pero mi puntaje de representante no me otorgará esa distinción.

Todo lo que quería señalar es que a pesar de que el Log (10) es una solución muy elegante (léase: muy pocas líneas de código), es probablemente la que más grava al procesador.

Creo que la respuesta de Jherico es probablemente la solución más eficiente y, por lo tanto, debería ser recompensada como tal.

Especialmente si usted va a estar haciendo esto por un montón de números ..