[SOLUCIONADO] Función decimal -> binario

[tur2ra]

Hola buenas,

estoy dando mis primeros pinitos en el mundo de la programación y me he encontrado con un problema que no sé resolver. Intento hacer una acción que muestre un número entrado en forma decimal en forma binaria. Sé que hay métodos recursivos que llaman a la misma función pero no es lo que busco. Quisiera poder tener ese número binario con las propiedades de un int.

Lo curioso de esto es que según con que números muestra el resultado correcto pero según con que otros no.

Les dejo lo que ahora estoy mantelando ya que por más que lo retoque siempre hay algun número que se me escapa.

void decimalAbinari(int x){
//Declarem variables
int binari=0, diferencia=x, comprovador=0, iteracio=1;
//ALGORITME
int b1=binari;
while (diferencia!=0){

int potencia=0;

if (diferencia==1){
b1=b1+1;
diferencia=diferencia-1;
cout << "entra a dif==1"<<endl;
}

else if (diferencia==2){
b1=b1+10;
diferencia=diferencia-2;
cout << "entra a dif==2" << endl;
}

else if (diferencia>2){
while(diferencia>=(pow(2, potencia+1)))potencia++;
b1=b1+pow(10, potencia);
diferencia=diferencia-pow(2, potencia);
cout << "entra a dif>2"<< endl;
}

else break;
}

Gracias por intentar ayudarme.

[aguml]

se me ocurre que puedes hacerlo usando el operador binario & para saber el estado de cada uno de sus bits y asi saber si es 1 o 0 y los vas concatenando.

[tur2ra]

Lo siento, creo que no entiendo muy bien lo que quieres decir... Lo que me interesa es que este todo el resultado en forma decimal, por eso el binario le voy sumando 10^potencia, siendo esa potencia el mayor numero al que se puede elevar a 2 la diferencia (la cual se va restando dependiendo de la potencia que encuentre). Según lo veo pueden pasar dos cosas, depeniendo si es par o impar. Por eso lo de si diferencia==1 y diferencia==2. Siento si no queda lo bastante claro, puedo volver a subirlo con comentarios.

Gracias por contestar!

[tur2ra]

Es que lo curioso es que en algunos valores me resta 1 usando exactamente el mismo algoritmo y en otras no. Por ejemplo:

Entro el 4 en decimal y me retorna 99 ( en lugar de 100)

entro el 32 y me retorna 100000 (correcto)

entro el 8 -> 1000 (correcto)

entro el 16 -> 9999 (fail)


No tengo ni idea de que probar ya
------------------------------------------------CÓDIGO----------------------------------------------

void decimalAbinari(int x){
//Declarem variables
int binari=0, diferencia=x;
//ALGORITME
while (diferencia!=0){
int potencia=0;

if (diferencia==1){
binari=binari+1;
diferencia=diferencia-1;
}

else if (diferencia==2){
binari=binari+10;
diferencia=diferencia-2;
}

else if (diferencia>2){
int potencia=0;
while(diferencia>(pow(2, potencia+1)))potencia++;
if(diferencia==(pow(2, potencia+1))){
potencia++;
binari=pow(10, potencia);
diferencia=0;
}
else{
binari=binari+pow(10, potencia);
diferencia=diferencia-pow(2, potencia);
}
}

else break;
}

[aguml]

sinceramente pienso que no deberias hacerlo asi. ¿Que pasa si por ejemplo metes 50000? Pues que al pasar a binario desborde el valor de un entero. Deberias pasarlo a char* y luego usas atoi o sprintf para pasarlo a entero. De todos modos mañana echare un vistazo a ver que haces mal.

[aguml]

Aquí lo tienes corregido:

Código C:

#include <stdio.h>
#include <math.h>
 
//Prototipo de funcion
int DecimalToBinary(int x, int *overflow);
 
int main()
{
   int i, binario, error;
 
   // Como un entero tiene 4 bytes en mi maquina, si hago:
   // (2^8)*4=1024 y como el 0 tambien cuenta, quiere decir que el rango valido
   // es de 0 a 1023. Si intentaras imprimir un valor superior desbordarias el entero
   for(i=0; i <= 1023; i++){
      binario = DecimalToBinary(i, &error);
      if(error == 1)
         printf("Se desbordo el valor maximo posible para un entero binario.\n");
      else
         printf("%4d = %.10d\n", i, binario);
   }
   getchar();
   return 0;
}
//---------------------------------------------------------------------------
 
int DecimalToBinary(int x, int *overflow){
   //Declarem variables
   int binary=0, potencia;
 
   //El valor maximo se saca elevando 2 al numero de bits de un byte que son 8
   //y luego lo multiplicas por el numero de bytes del tipo
   //Esto es util si se usa en una máquina en la que un entero tiene un tamaño diferente
   int sizeMax = pow(2,8) * sizeof(int);
 
   if(x >= sizeMax){
      *overflow=1;
   }else{
      *overflow = 0;
      //ALGORITME
      while (x != 0){
         potencia=1; //¿para que empezar por 0?
         if (x ==1 ){
            binary++;
            x--;
         }else{ //Esta parte la he simplificado bastante
            while(x > (pow(2, potencia)))
               potencia++;
            if(x < (pow(2, potencia)))
               potencia--;
            x -= pow(2, potencia);
            binary += pow(10, potencia); //Aqui necesitabas sumar y tu asignabas
         }
      }
   }
   return binary;
}
//---------------------------------------------------------------------------
 

Si tienes alguna duda preguntala, la cuestion es que lo entiendas, no que lo copies sin mas.

Y aqui otro modo de hacerlo:

Código C:

int DecimalToBinary(int x, int *overflow)
{
   int binary=0;
   int valueMax = 1024;
   int digito;
   int exponente = 1;
 
   if(x >= valueMax){
      *overflow=1;
   }else
   {
      *overflow = 0;
      //ALGORITME
      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;
}
 

[tur2ra]

Buenos días aguml!

Para empezar tengo que darte las gracias. Me has ayudado lo que no está escrito...
Te digo que no tengo intención de copiar el código sin más, ni mucho menos, puesto que ahora mismo no estoy estudiando nada relacionado con este mundo, lo hago simplemente por aprender y ver si algún día puedo hacer algo útil en la sociedad. ;D


Bueno, te informo de los progresos:

1. Implementare una función en lugar de una acción, porque lo de pasar el parametro overflow lo veo cuánto menos necesario.

2. El primer algoritmo sigue sin dar los resultados esperados, algunos son correctos pero en otros tantos se cuelan 9, exactamente como sucedía con el que te pasé. Acabo de comprobarlo, y hasta el 127 funciona perfectamente. No alcanzo a ver el porque de eso.

3. El segundo algoritmo es una joya. Mucho más simple y eficaz, aunque no se me hubiese ocurrido lo del mod para saber si era par o impar. Intentaré recordarlo para los próximos programas que haga.

[aguml]

a mi el primer metodo me funciona y sobre el segundo, te aconsejo que busques info ya que realmente no es lo que piensas. Los pcs trabajan en binario y por eso todas sus medidas son multiplos de 2. El byte son 8 bits ¿Por que? Pues porque cuando se inicio todo esto pensaron que era lo que se necesitaba ya que con 8 bits se podia guardar cualquier valor de la tabla ASCII. Con 8 bits podemos almacenar 256 valores diferentes (de 0 a 255). Entonces lo que hago es dividir el valor entre 2 y el resto o residuo me da el estado del bit y asi hasta que de 0. Entonces por ejemplo para 10, 10/2=5 r=0; 5/2=2 r=1; 2/2=1 r=0; 1/2=0 r=1 y da 1010 ya que se van colocando de derecha a izquierda y por eso se usa una variable que se multiplica por diez en cada pasada.

[lareto]

Iniciado por tur2ra

El primer algoritmo sigue sin dar los resultados esperados...

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)

[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;
}
//---------------------------------------------------------------------------
 

[aguml]

Lo siguiente ya seria usar un unsigned int64 como entrada y un array de caracteres como salida:

Código C:

void DecimalToBinaryString(uint64_t x, char* binary, int sizeMax, int *overflow)
{
   int digito;
   int contador = sizeMax;
   char *aux;
 
   if(sizeMax > 0){
      aux=malloc(sizeMax);
      if(aux != NULL){
         memset(aux,0,sizeMax);
         memset(binary,0,sizeMax);
         *overflow=0;
 
         do{
            contador--;
            if(contador < 0){
               *overflow=1;
               memset(aux,0,sizeMax);
            }else{
               //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 binario
               aux[contador] = digito + 0x30;
            }
         }while (x > 0 && *overflow != 1);
         strncpy(binary, &aux[contador], sizeMax-contador);
         free(aux);
      }
   }
}
 

y para probarla:

Código C:

char binari[100];
uint64_t valor=11234567899999999901;
DecimalToBinaryString(valor, binari, sizeof(binari), &error);
if(error == 1)
   printf("Se desbordo el valor maximo posible para un entero binario.\n");
else
   printf("%I64u = %s\n", valor, binari);
 

Esto nos permitiria obtener una cadena con el binario de un numero muy muy grande jejeje.

[tur2ra]

buf... deu n'hi do! vaya telita con el problema... y yo que pensaba que era relativamente sencillo!!

Bueno os comento, probé la primera manera que dijiste aguml (los arrays mejor los dejo por otro momento xD)

He intentado entender el código y ciertamente gracias a los comentarios creo que me hago una idea. Hay una cosa pero que no logro dislumbrar, y es bastante importante además. En la muestra de el bit pones los siguientes carácteres:

else
printf("%6d = %.*I64u\n", i, maxLenBin, binario);

Me he imaginado que %6d es para mostrar un int, sin embargo el %.*I64u no logro ver como actúa. Si pudierais decirme de donde sacar información para hacer este tipo de muestra os lo agradecería eternamente, la verdad es que es mucho más práctico que tener que hacer las '<<' cada vez que quiero mostrar una variable.

Repito: Muchas gracias por todo, ojala algún día pueda ayudar a otros como ustedes me están ayudando a mí.

PD: ¿Cual es el método para embutir el código con tabuladores y color?

[aguml]

I64u es para mostrar un entero de 64 bits sin signo. Si quisieras con signo se pone I64d. El 6d muestra un entero con un minimo de 6 caracteres y si tiene menos se rellena con espacios a la izquierda. Para poner el codigo identado y con color usas Highlight y eliges el lenguaje deseado.

[tur2ra]

Perfecto! Además acabo de probar el programa y muestra hasta 10^20 o sea que de lujo:D

[aguml]

pues si, la de 64 bits muestra valores binarios de hasta 10^20 y la que devuelve string 10^70 aproximadamente.