Función decimal -> binario

[aguml]

Iniciado por lareto

Yo no pude reproducir el problema, pero de todos modos encuentro que hay un par de comparaciones que piden problemas:

Código:

while(x > (pow(2, potencia)))

Código:

if(x < (pow(2, potencia)))

x es un int, mientras que pow() devuelve un double (cuando los dos parámetros con los que se invoca son int); y no está bien comparar variables de tipo real con tipos enteros así como así.

Vale la pena imprimirse para leer en las próximas vacaciones:
https://www.topcoder.com/community/d...als-section-1/
(abajo en esa página hay un link a la section 2, no pasárselo)

La verdad es que yo tampoco he sido capaz de que me salgan 9s. Uso C++Builder 6.
Si quieres algo mas potente puedes usar unsigned int64 que en mi caso me permite llegar hasta el 1048575U (0xFFFFF) que es 11111111111111111111 sin desbordarse.
La version que usa un unsigned int solo puede llegar hasta 1023U (0x3FF) que es 1111111111.
O sea que el int64 permite trabajar con binarios el doble de grandes.

Aqui el código:

Código C:

#include <stdio.h>
#include <stdint.h>
#include <math.h>
 
//Prototipo de funcion
uint64_t DecimalToBinary64(int x, int *overflow);
int DecimalToBinary32(int x, int *overflow);
int ObtainLimitBinForInt32(void);
int ObtainLimitBinForInt64(void);
int ObtainMaxDigitsBinInt32(void);
int ObtainMaxDigitsBinInt64(void);
 
int main()
{
   int i, error;
   uint64_t binario;
 
   int numMax = ObtainLimitBinForInt64();
   int maxLenBin = ObtainMaxDigitsBinInt64();
 
   for(i=0; i <= numMax; i++){
      binario = DecimalToBinary64(i, &error);
      if(error == 1)
         printf("Se desbordo el valor maximo posible para un entero binario.\n");
      else
         printf("%6d = %.*I64u\n", i, maxLenBin, binario);
   }
   getchar();
   return 0;
}
//---------------------------------------------------------------------------
 
//nos devuelve un entero binario de hasta 10 digitos
int DecimalToBinary32(int x, int *overflow)
{
   int binary=0;
   int digito;
   int exponente = 1;
   int binMax;
   int producto;
   int valueMax;
 
   valueMax = ObtainLimitBinForInt32();
 
   if(x > (int)valueMax){
      *overflow=1;
   }else
   {
      *overflow = 0;
      //ALGORITME
      exponente=1;
 
      do{
         //Obtenemos el valor del digito a escribir(0 ó 1)
         digito = x % 2;
         //Dividimos el numero por 2 para seguir
         x /= 2;
         //Añadimos el nuevo digito al numero binario
         binary += digito * exponente;
         //Aumentamos el exponente el exponente
         exponente *= 10;
      }while (x > 0);
   }
   return binary;
}
//---------------------------------------------------------------------------
 
int ObtainLimitBinForInt32(void)
{
   int contador=0;
   int binMax=1;
   int producto;
   int exponente=1;
   int valueMax=0;
 
   //Obtengo el numero de digitos maximo para el tipo
   contador = ObtainMaxDigitsBinInt32();
 
   //Obtengo el valor binario maximo para el tipo
   contador--;
   while(contador > 0){
      binMax *= 10;
      binMax += 1;
      contador--;
   }
 
   //Paso el valor binario maximo a decimal para obtener el decimal maximo permitido
    while(binMax>0)
    {
        producto=0;
        producto=exponente*(binMax%10);
        valueMax+=producto;
        exponente*=2;
        binMax/=10;
    }
   return valueMax;
}
//---------------------------------------------------------------------------
 
int ObtainMaxDigitsBinInt32(void)
{
   //Obtengo el numero de digitos maximo para el tipo
   int contador=0;
   unsigned int valueMax=0;
   valueMax--;
 
   //Cuento los digitos binarios
   while(valueMax > 0){
      valueMax /= 10;
      contador++;
   }
   return contador;
}
//---------------------------------------------------------------------------
 
int ObtainMaxDigitsBinInt64(void)
{
   //Obtengo el numero de digitos maximo para el tipo
   int contador=0;
   uint64_t valueMax=0;
   valueMax--;
 
   //Cuento los digitos binarios
   while(valueMax > 0){
      valueMax /= 10;
      contador++;
   }
   return contador;
}
//---------------------------------------------------------------------------
 
int ObtainLimitBinForInt64(void)
{
   int contador=0;
   uint64_t binMax=1;
   int producto;
   int exponente=1;
   uint64_t valueMax=0;
 
   contador = ObtainMaxDigitsBinInt64();
 
   //Obtengo el valor binario maximo para el tipo
   contador--;
   while(contador > 0){
      binMax *= 10;
      binMax += 1;
      contador--;
   }
 
   //Paso el valor binario maximo a decimal para obtener el decimal maximo permitido
    while(binMax>0)
    {
        producto=0;
        producto=exponente*(binMax%10);
        valueMax+=producto;
        exponente*=2;
        binMax/=10;
    }
   return valueMax;
}
//---------------------------------------------------------------------------
 
//nos devuelve un entero binario de hasta 19 digitos
uint64_t DecimalToBinary64(int x, int *overflow)
{
   uint64_t binary=0;
   int digito;
   uint64_t exponente = 1;
   uint64_t binMax;
   int producto;
   uint64_t valueMax;
 
   valueMax = ObtainLimitBinForInt64();
 
   if(x > valueMax){
      *overflow=1;
   }else
   {
      *overflow = 0;
      //ALGORITME
      exponente=1;
 
      do{
         //Obtenemos el valor del digito a escribir(0 ó 1)
         digito = x % 2;
         //Dividimos el numero por 2 para seguir
         x /= 2;
         //Añadimos el nuevo digito al numero binario
         binary += digito * exponente;
         //Aumentamos el exponente el exponente
         exponente *= 10;
      }while (x > 0);
   }
   return binary;
}
//---------------------------------------------------------------------------