Hallar la longitud de un entero en C

Hola usuario de nuestro sitio web, hallamos la solución a tu pregunta, has scroll y la verás a continuación.

Solución:

C:

¿Por qué no simplemente tomar el logaritmo en base 10 del valor absoluto del número, redondearlo hacia abajo y agregar uno? Esto funciona para números positivos y negativos que no son 0 y evita tener que usar cualquier string funciones de conversión.

los log10, absy floor funciones son proporcionadas por math.h. Por ejemplo:

int nDigits = floor(log10(abs(the_integer))) + 1;

Debe envolver esto en una cláusula que asegure que the_integer != 0ya que log10(0) devoluciones -HUGE_VAL de acuerdo a man 3 log.

Además, es posible que desee agregar uno al resultado final si la entrada es negativa, si está interesado en la longitud del número, incluido su signo negativo.

Java:

int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;

---

nótese bien La naturaleza de punto flotante de los cálculos involucrados en este método puede hacer que sea más lento que un enfoque más directo. Vea los comentarios de la respuesta de Kangkan para una discusión sobre la eficiencia.

Si estás interesado en un rápido y muy simple solución, la siguiente podría ser la más rápida (esto depende de la distribución de probabilidad de los números en cuestión):

int lenHelper(unsigned x) 
    if (x >= 1000000000) return 10;
    if (x >= 100000000)  return 9;
    if (x >= 10000000)   return 8;
    if (x >= 1000000)    return 7;
    if (x >= 100000)     return 6;
    if (x >= 10000)      return 5;
    if (x >= 1000)       return 4;
    if (x >= 100)        return 3;
    if (x >= 10)         return 2;
    return 1;


int printLen(int x) 
    return x < 0 ? lenHelper(-x) + 1 : lenHelper(x);

Si bien es posible que no gane premios por la solución más ingeniosa, es trivial de entender y también de ejecutar, por lo que es rápido.

En un Q6600 usando MSC, comparé esto con el siguiente bucle:

int res = 0;
for(int i = -2000000000; i < 2000000000; i += 200) res += printLen(i);

Esta solución tarda 0,062 s, la segunda solución más rápida de Pete Kirkham utilizando un enfoque de logaritmo inteligente tarda 0,115 s, casi el doble. Sin embargo, para números alrededor de 10000 e inferiores, el registro inteligente es más rápido.

A expensas de cierta claridad, puede superar de manera más confiable el registro inteligente (al menos, en un Q6600):

int lenHelper(unsigned x)  
    // this is either a fun exercise in optimization 
    // or it's extremely premature optimization.
    if(x >= 100000) 
        if(x >= 10000000) 
            if(x >= 1000000000) return 10;
            if(x >= 100000000) return 9;
            return 8;
        
        if(x >= 1000000) return 7;
        return 6;
     else 
        if(x >= 1000) 
            if(x >= 10000) return 5;
            return 4;
         else 
            if(x >= 100) return 3;
            if(x >= 10) return 2;
            return 1;
        
    

Esta solución sigue siendo de 0,062 s para números grandes y se degrada a alrededor de 0,09 s para números más pequeños, más rápido en ambos casos que el enfoque de registro inteligente. (gcc crea un código más rápido; 0,052 para esta solución y 0,09 s para el enfoque de registro inteligente).

int get_int_len (int value)
  int l=1;
  while(value>9) l++; value/=10; 
  return l;

y el segundo también funcionará para números negativos:

int get_int_len_with_negative_too (int value)
  int l=!value;
  while(value) l++; value/=10; 
  return l;

Tienes la opción de añadir valor a nuestro contenido informacional tributando tu experiencia en las críticas.

---

---

Utiliza Nuestro Buscador