Encontrar la longitud de un número entero en C

Question

Me gustaría saber cómo puedo encontrar la longitud de un número entero en C.

Por ejemplo:

• 1 => 1
• 25 => 2
• 12512 => 5
• 0 => 1

y así sucesivamente.

¿Cómo puedo hacer esto en C?

Answer 1

C:

¿Por qué no tomar el registro de base 10 del valor absoluto del número, alrededor de ella hacia abajo, y añadir uno? Esto funciona para los números positivos y negativos que no son 0, y evita tener que utilizar ninguna función de conversión de cadena.

Los log10, abs, y funciones floor son proporcionados por math.h. Por ejemplo:

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

Se debe terminar con esto de una cláusula que garantice que the_integer != 0, ya que los rendimientos log10(0) -HUGE_VAL acuerdo con man 3 log.

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

Java:

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

---

N.B. La naturaleza de coma flotante de los cálculos implicados en este método puede provocar que sea más lento que un enfoque más directo. Ver los comentarios de respuesta de Kangkan por alguna discusión de la eficiencia.

Answer 2

Si está interesado en un rápido y muy simple solución, el siguiente podría ser más rápido (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 no puede ganar premios para la solución más ingeniosa, es trivial para entender y también trivial para ejecutar -. Por lo que es rápido

En un Q6600 usando MSC I como punto de referencia esto con el siguiente bucle:

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

Esta solución toma 0.062s, el segundo mejor solución por Pete Kirkham utilizando un enfoque inteligente-logaritmo toma 0.115s - casi el doble de tiempo. Sin embargo, para los números de alrededor de 10.000 y por debajo, el Smart-registro es más rápido.

A expensas de un poco de claridad, se puede vencer con mayor fiabilidad smart-log (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 0.062s en gran número, y se degrada a alrededor de 0,09 s para los números más pequeños - más rápido en ambos casos que el enfoque inteligente-registro. (Gcc hace más rápido el código; 0,052 para esta solución y 0,09 s para el enfoque inteligente-log).

Answer 3

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

y segundo trabajarán para los números negativos también:

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

Answer 4

Se puede escribir una función como esta:

unsigned numDigits(const unsigned n) {
    if (n < 10) return 1;
    return 1 + numDigits(n / 10);
}

Answer 5

longitud de n:

length =  ( i==0 ) ? 1 : (int)log10(n)+1;

Answer 6

El número de dígitos de un número entero x es igual a 1 + log10(x). Así que usted puede hacer esto:

#include <math.h>
#include <stdio.h>

int main()
{
    int x;
    scanf("%d", &x);
    printf("x has %d digits\n", 1 + (int)log10(x));
}

O puede ejecutar un bucle para contar los dígitos a sí mismo: hacer número entero división por 10 hasta que el número es 0:

int numDigits = 0;
do
{
    ++numDigits;
    x = x / 10;
} while ( x );

Hay que ser un poco cuidadoso para volver 1 si el entero es 0 en la primera solución y es posible que también desee enteros negativos tratar (trabajo con -x si x < 0).

Answer 7

La forma más eficiente, posiblemente, podría ser utilizar un enfoque basado en logaritmo rápido, similar a los utilizados para determinar la más alta conjunto de bits en un número entero.

size_t printed_length ( int32_t x )
{
    size_t count = x < 0 ? 2 : 1;

    if ( x < 0 ) x = -x;

    if ( x >= 100000000 ) {
        count += 8;
        x /= 100000000;
    }

    if ( x >= 10000 ) {
        count += 4;
        x /= 10000;
    }

    if ( x >= 100 ) {
        count += 2;
        x /= 100;
    }

    if ( x >= 10 )
        ++count;

    return count;
}

Este (posiblemente prematuro) optimización toma 0.65s por 20 millones de llamadas en mi netbook; división iterativa como zed_0xff tiene tarda 1,6 s, la división recursiva como Kangkan toma 1.8s, y el uso de las funciones de punto flotante (código Jordan Lewis) realiza un 6.6s friolera. Usando snprintf toma 11.5s, pero le dará el tamaño que snprintf requiere para cualquier formato, no sólo números enteros. Jordán informa que el orden de los tiempos no son mantenidos en su procesador, que no coma flotante más rápido que el mío.

La forma más fácil es probablemente para pedir snprintf para la longitud impresa:

#include <stdio.h>

size_t printed_length ( int x )
{
    return snprintf ( NULL, 0, "%d", x );
}

int main ()
{
    int x[] = { 1, 25, 12512, 0, -15 };

    for ( int i = 0; i < sizeof ( x ) / sizeof ( x[0] ); ++i )
        printf ( "%d -> %d\n", x[i], printed_length ( x[i] ) );

    return 0;
}

Answer 8

Sí, usando sprintf.

int num;
scanf("%d",&num);
char testing[100];
sprintf(testing,"%d",num);
int length = strlen(testing);

Como alternativa, puede hacer esto matemáticamente usando la función log10.

int num;
scanf("%d",&num);
int length;
if (num == 0) {
  length = 1;
} else {    
  length = log10(fabs(num)) + 1;
  if (num < 0) length++;
}

Answer 9

Una aplicación correcta snprintf:

int count = snprintf(NULL, 0, "%i", x);

Answer 10

int digits=1;

while (x>=10){
    x/=10;
    digits++;
}
return digits;

Answer 11

sprintf(s, "%d", n);
length_of_int = strlen(s);

Answer 12

Es posible utilizar este -

(data_type) log10 (variable_name) 1

por ejemplo:

  

len = (int) log10 (número) 1;

Answer 13

Muy sencillo

int main() {
    int num = 123;
    char buf[50];

    // convert 123 to string [buf]
    itoa(num, buf, 10);

    // print our string
    printf("%s\n", strlen (buf));

    return 0;
}

Answer 14

seguir dividiendo por diez hasta llegar a cero, a continuación, sólo la salida el número de divisiones.

int intLen(int x)
{
  if(!x) return 1;
  int i;
  for(i=0; x!=0; ++i)
  {
    x /= 10;
  }
  return i;
}

Answer 15

En mi opinión la solución más corto y más fácil sería:

int length , n;

printf("Enter a number: ");

scanf("%d", &n);

length = 0;

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

printf("Length of the number: %d", length);

Answer 16

Mi manera:

Divide tanto tiempo como número no más divisible es por 10:

u8 NumberOfDigits(u32 number)
{
    u8 i = 1;
    while (number /= 10) i++;

    return i;
}

No sé qué tan rápido es en comparación con otras proposiciones ..

Answer 17

int intlen(int integer){
    int a;
    for(a = 1; integer /= 10; a++);
    return a;
}

Answer 18

A más prolija forma sería la de utilizar esta función.

int length(int n)
{
    bool stop;
    int nDigits = 0;
    int dividend = 1;
    do
    {
        stop = false;
        if (n > dividend)
        {
            nDigits = nDigits + 1;
            dividend = dividend * 10;
        }
        else {
            stop = true;
        }


    }
    while (stop == false);
    return nDigits;
}

Answer 19

Esto se aplica a tanto negativas como positivas intigers

    int get_len(int n)
    {
        if(n == 0)
        return 1;

        if(n < 0)    
        {
           n = n * (-1); // if negative
        }

        return  log10(n) + 1;
    }

Mismo lógica va bucle for

  int get_len(int n)
  {
       if(n == 0)
       return 1;

       int len = 0;
       if(n < 0)
       n = n * (-1);

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

       return len;
  }

Answer 20

int returnIntLength(int value){
    int counter = 0;
    if(value < 0)
    {
        counter++;
        value = -value;
    }
    else if(value == 0)
        return 1;

    while(value > 0){
        value /= 10;
        counter++;
    }

    return counter;
}

Creo que este método es muy adecuado para esta tarea:

valor y respuestas:

• -50 -> 3 // contará - como un carácter así si no quieres que contar                minus continuación, quitar contador ++ de quinta línea.

• 566 666 -> 6

• 0 -> 1

• 505 -> 3

Answer 21

Creo que tengo la forma más eficiente para encontrar la longitud de un entero es una manera muy simple y elegante aquí está:

int PEMath::LengthOfNum(int Num)
{
int count = 1;  //count starts at one because its the minumum amount of digits posible
if (Num < 0)
{
    Num *= (-1);
}

for(int i = 10; i <= Num; i*=10)
{
     count++;
}      
return count;
                // this loop will loop until the number "i" is bigger then "Num"
                // if "i" is less then "Num" multiply "i" by 10 and increase count
                // when the loop ends the number of count is the length of "Num".
}

Answer 22

int main (void) {     unsigned int n, tamaño = 0;

printf("get the int:");
scanf("%u",&n);

/*the magic*/
for(int i = 1; n >= i; i*=10){
    size++;
}

printf("the value is: %u \n", n);
printf("the size is: %u \n", size);

return 0;

}

Answer 23

Por favor encontrar mi respuesta es en una línea de código:

#include <stdio.h> int main(void){ int c = 12388884; printf("length of integer is: %d",printf("%d",c)); return 0; }

que es simple y elegante! Upvote si así!