Como calcular cuantos dígitos tiene un entero

[kutcher]

Buenas, estoy codificando un programa y me urge saber cuantos dígitos tiene un
número que es de tipo int por ejem:

15742 = 5 dígitos
1234 = 4 dígitos
13 = 2 dígitos

He probado con sizeof pero no funciona ¿Alguien tiene alguna idea de como hacer esto?

[ivancea96]

sizeof() retorna el tamaño en bytes de una variable.

Ahora al tema, dado que el entero no guarda decimales, simplemente se pierden, puedes dividirlo entre 10 X veces, hasta que sea 0. En ese momento, X será el número de cifras que tendrá.

[Blaster]

¿Alguien tiene alguna idea de como hacer esto?

Otra opción seria aplicar el logaritmo (en base 10) al número del que deseas saber las cifras y luego sumarle uno:

Log(1)=>0
Log(9)=>0,95
Log(10)=>1
Log(11)=>1,04

Código (cpp) [Seleccionar] Expandir

digitos = log10(num) + 1

En digitos tendrás el número de cifras de num

Saludos

[leosansan]

Buenas, estoy codificando un programa y me urge saber cuantos dígitos tiene un
número que es de tipo int
...........................

Por ejemplo, como comentó ivancea96:

Código (cpp) [Seleccionar] Expandir

 int digitos , n = 123456789 ;
 for ( digitos = 0 ; n ; digitos++ , n /= 10 ) ;
 printf ( "%d" , digitos ) ;

¡¡¡¡ Saluditos! ..... !!!!

[kutcher]

Gracias a todos por responder, voy aprobar el método que expuso Blaster me llamo la atención ¿nosé si es seguro esto? 

[engel lex]

De que es seguro, dará seguramente la respuesta, si tienes dudas al respecto recomiendo revisar los temas de exponencial y logaritmo para resolver dudas puntuales sobre ello

Aunque yo preferiría el metodo de leosansan ya aunque es mas largo en códigos es menos exigente en procesasor

[Blaster]

¿nosé si es seguro esto? 

Es un metodo matemático muy preciso ten por seguro que obtendrás el resultado esperado.

Aunque yo preferiría el metodo de leosansan ya aunque es mas largo en códigos es menos exigente en procesasor

Lo dudo aunque así fuera la diferencia seria mínima

[engel lex]

Lo dudo aunque así fuera la diferencia seria mínima

bueno, si es para un calculo independiente, efectivamente la diferencia es instrumental, pero para calcularlo múltiples veces, la diferencia de tiempo si es notable, ya que es la diferencia entre un ciclo con una división (operacion matematica simple posible de hacer por el procesador con un solo paso) contra logaritmo (intenta sacarlo solo con suma, resta, división y multiplicación para que veas cuantos pasos toma)

de resto, ya es cosa de kutcher que escoja que se le hace más mejor para su programa

[eferion]

ya que es la diferencia entre un ciclo con una división (operacion matematica simple posible de hacer por el procesador con un solo paso)

Perdón por la intromisión, pero la división es la operación más costosa con diferencia de las interpretadas como básicas: suma, resta, producto, división. Y cuando digo costosa me refiero en una proporción que puede llegar a ser de 8 a 1.

Dicho esto me ha surgido la duda de saber cual era el algoritmo más óptimo... manos a la obra salió algo tal que:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <chrono>
#include <math.h>

int DigitosV1( int numero )
{
 int digitos;
 for ( digitos = 0; numero > 0; digitos++, numero /= 10 ) ;
 return digitos;
}

int DigitosV2( int numero )
{
 return log( numero ) + 1;
}

const int NUMERO = 1234567890;
const int MAXBUCLE = 1000000000;

int main( )
{
 int temp;
 std::chrono::time_point<std::chrono::system_clock> start, end;
 start = std::chrono::system_clock::now( );
 for ( int i=0; i < MAXBUCLE; i++ )
 {
   temp = DigitosV1( NUMERO );
 }
 end = std::chrono::system_clock::now();

 std::chrono::duration<double> elapsed_seconds = end-start;

 std::cout << "Tiempo division: " << elapsed_seconds.count() << "s\n";

 start = std::chrono::system_clock::now( );
 for ( int i=0; i < MAXBUCLE; i++ )
 {
   temp = DigitosV2( NUMERO );
 }
 end = std::chrono::system_clock::now();

 elapsed_seconds = end-start;

 std::cout << "Tiempo logaritmo: " << elapsed_seconds.count() << "s\n";
}


¿Qué sucede con los resultados? Son contundentes (aviso, abstenerse personas sensibles):

Editado: Estos resultados son con el programa compilado en modo debug... lo siento.

Código [Seleccionar] Expandir


Tiempo division: 43.1613s
Tiempo logaritmo: 29.538s

Luego por 5 cabezas de ventaja, la opción del logaritmo es más óptima que la opción de la división.



Edito: Para probar opciones menos extremistas, he reducido el número de prueba a uno con 5 dígitos y he ejecutado el programa... los resultados son los siguientes:

Editado: Estos resultados son con el programa compilado en modo debug... lo siento.

Código [Seleccionar] Expandir


Tiempo division: 19.1429s
Tiempo logaritmo: 29.564s

Se ve por tanto que la opción del logaritmo es estable en el tiempo, mientras que la división, obviamente, ha reducido su tiempo a la mitad ( tiene la mitad de dígitos ).

Dicho esto me surgió una nueva duda... log trabaja con "double"... y si la idea es trabajar con números más grandeS??

Un poco de refactorización y listo:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <chrono>
#include <limits>
#include <math.h>

const int INT5 = 12345;
const int INT7 = 1234567;
const int INT10 = 1234567890;

const double DOUBLE5 = 12345.0;
const double DOUBLE7 = 1234567.0;
const double DOUBLE10 = 1234567890.0;

template< class T >
int DigitosDIV( T numero )
{
 int digitos;
 T divisor = 10;
 T min = 1; // para que el bucle funcione con decimales
 for ( digitos = 0; numero >= min; digitos++, numero /= divisor ) ;
 return digitos;
}

template< class T >
int DigitosLOG( T numero )
{
 return log( numero ) + 1;
}

template< class T >
std::chrono::duration< double > Bucle( T numero, int(*func)(T) )
{
 int temp;

 auto start = std::chrono::system_clock::now( );

 const int max = std::numeric_limits< int >::max( );
 for ( int i=0; i < max; i++ )
 {
   temp = func( numero );
 }
 auto end = std::chrono::system_clock::now( );

 return end - start;
}

int main( )
{
 auto DivInt5  = Bucle( INT5,  DigitosDIV< int > );
 auto DivInt7  = Bucle( INT7,  DigitosDIV< int > );
 auto DivInt10 = Bucle( INT10, DigitosDIV< int > );

 auto LogInt5  = Bucle( INT5,  DigitosLOG< int > );
 auto LogInt7  = Bucle( INT7,  DigitosLOG< int > );
 auto LogInt10 = Bucle( INT10, DigitosLOG< int > );

 auto DivDouble5  = Bucle( DOUBLE5,  DigitosDIV< double > );
 auto DivDouble7  = Bucle( DOUBLE7,  DigitosDIV< double > );
 auto DivDouble10 = Bucle( DOUBLE10, DigitosDIV< double > );

 auto LogDouble5  = Bucle( DOUBLE5,  DigitosLOG< double > );
 auto LogDouble7  = Bucle( DOUBLE7,  DigitosLOG< double > );
 auto LogDouble10 = Bucle( DOUBLE10, DigitosLOG< double > );

 std::cout << "Tiempo division (int 5):     " << DivInt5.count( )     << " s\n";
 std::cout << "Tiempo division (int 7):     " << DivInt7.count( )     << " s\n";
 std::cout << "Tiempo division (int 10):    " << DivInt10.count( )    << " s\n\n";
 std::cout << "Tiempo log (int 5):          " << LogInt5.count( )     << " s\n";
 std::cout << "Tiempo log (int 7):          " << LogInt7.count( )     << " s\n";
 std::cout << "Tiempo log (int 10):         " << LogInt10.count( )    << " s\n\n";
 std::cout << "Tiempo division (double 5):  " << DivDouble5.count( )  << " s\n";
 std::cout << "Tiempo division (double 7):  " << DivDouble7.count( )  << " s\n";
 std::cout << "Tiempo division (double 10): " << DivDouble10.count( ) << " s\n\n";
 std::cout << "Tiempo log (double 5):       " << LogDouble5.count( )  << " s\n";
 std::cout << "Tiempo log (double 7):       " << LogDouble7.count( )  << " s\n";
 std::cout << "Tiempo log (double 10):      " << LogDouble10.count( ) << " s\n\n";
}

Y su correspondiente resultado (ahora sí en modo release):

Código (bash) [Seleccionar] Expandir


Tiempo division (int 5):     23.6144 s
Tiempo division (int 7):     33.9994 s
Tiempo division (int 10):    49.798 s

Tiempo log (int 5):          60.28 s
Tiempo log (int 7):          60.415 s
Tiempo log (int 10):         60.8651 s

Tiempo division (double 5):  81.3541 s
Tiempo division (double 7):  113.471 s
Tiempo division (double 10): 162.253 s

Tiempo log (double 5):       60.7651 s
Tiempo log (double 7):       60.8521 s
Tiempo log (double 10):      60.7481 s

La conclusión final... cada uno que saque las suyas... pero simplificando yo obtengo las siguientes:

* El logaritmo es más estable... ideal para tareas de tiempo real.
* La división es, de media, más rápida si se trabaja con enteros... el logaritmo es más eficiente con decimales.
* Es curioso como se nota la bajada de tiempos de la división en modo release frente a modo debug

[leosansan]

Otra opción seria aplicar el logaritmo (en base 10) al número del que deseas saber las cifras y luego sumarle uno:

Log(1)=>0
Log(9)=>0,95
Log(10)=>1
Log(11)=>1,04

Código (cpp) [Seleccionar] Expandir

digitos = log10(num) + 1

En digitos tendrás el número de cifras de num

Saludos

Sólo una pequeña observación y es la referida a la importancia de trabajar con double si hay operaciones tipo producto o división implicadas.

Me explico con un simple ejemplo. Si queremos las cifras del resultado de 3 * 5 sin hacerlo podemos aplicar la propiedad de que el logaritmo de un producto es la suma de los logaritmos y, si estamos trabajando con enteros, el resultado sería:

Código (cpp) [Seleccionar] Expandir

digitos ( 3 * 5) =  log10 ( 3 * 5 ) = log10 (3) + log10 (5) + 1  = 0 + 0 + 1 = 1

En contra de lo que sabemos, 3 * 5 = 15 que tiene dos cifras. Lo anterior se evita trabajando don double, ya que entonces :

Código (cpp) [Seleccionar] Expandir

digitos ( 3 * 5) =  log10 ( 3 * 5 ) = log10 (3) + log10 (5) + 1  ==  2.176091

y tan sólo hay que tomar la parte entera para obtener el resultado deseado.

Código (cpp) [Seleccionar] Expandir


n_digitos 3 * 5 = 2.176091 ==> de aqui tomamos la parte entera :
n_digitos 3 * 5 = 2


Parece una nimiedad lo que comento ya que podíamos haber multiplicado previamente y aplicado el log10 en forma entera al resultado de 15.

¿Pero es esto siempre posible?. Pongo un caso práctico: calcular las cifras que tiene 1500!. En este caso no es tan simple obtener el resultado numérico y ojo que no digo que no sea posible hacerlo en C, incluso sin librerías externas, que sí que se puede. Pero como un factorial no es más que un producto se puede calcular la cifra como suma de logaritmos pero en tipo flotante y el resultado final pasarlo a entero obteniendo:

Código (cpp) [Seleccionar] Expandir

n_digitos [ 1500! ] = 4115.682325

n_digitos [ 1500! ] = 4115 ---> PERFECTO <----


Y la suma de los log10 se puede realizar con un simple for:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <math.h>
#define N  1500

int main( ) {
 double n_digitos = 1 ;
 int digitos , i ;
 for( i = 1 ; i <= N ; i++ )
   n_digitos += ( log10 ( i ) ) ;
 printf( "n_digitos [ 1500! ] = %lf\n\n" , n_digitos );
 digitos = ( int ) n_digitos ;
 printf( "n_digitos [ 1500! ] = %d\n\n" , digitos );
 return 0;
}

Y conste que empieza el for en 1 innecesariamente ya que su log es cero, por lo que podía haber empezado en 2, pero es por ponerlo "bonito".  

Como comenté al principio, se trataba de una simple observación en la diferencia, y obligación en según qué casos, de trabajar con enteros o flotantes para no equivocar el resultado del cálculo del número de dígitos.

¡¡¡¡ Saluditos! ..... !!!!