Multiplicar 2 variables char byte a byte[C]

[RoDaVi]

Hola.

….Lo que quiero hacer es multiplicar 2 cifras alojadas en sendas cadenas, con un bucle de sumas ya lo logré y ahora intento hacerlo byte a byte, de tanto buscar en internet encontré un video donde decía que para saber la correspondencia de un número binario a decimal se asía algo como esto…

Al fin me desvié del objetivo que era lo que escribí más arriba y aclarar que abrí un nuevo hilo porque el tema me parece que puede resultar de utilidad a alguien que está estudiando como yo y el otro título, el de el post anterior no era lo suficientemente relacionado, por lo menos es lo que yo creo.-
El caso en definitiva es, alguien me puede orientar como pasar una cadena en C a binario.-

Saludos.
Daniel

[eferion]

Una cadena de caracteres en C está compuesta por una serie de longitud indeterminada de caracteres que finaliza con la aparición de un carácter nulo. Las cadenas en C ya están en binario.

Lo único que tienes que hacer para conseguir la información de una forma u otra es convertir con un cast el array de char en un array del tipo que te de la gana:

Código C:

int main(void)
{
  const char* cadena = "Programacion";
  int length = strlen(cadena);
  int i;
 
  printf( "cadena: %s\n", cadena);
  printf( "bytes: "  );
  const unsigned char* cadena_uchar = (const unsigned char*)cadena;
  for ( i=0; i<=length; i++)
    printf( "0x%02X ", cadena_uchar[ i ] );
 
  printf( "\n32 bytes: " );
 
  const unsigned int* cadena_uint = (const unsigned int*)cadena;
  for ( int i=0; i<length/4; i++ )
    printf( "0x%04X ", cadena_uint[ i ] );
 
  printf( "\n" );
}
 

[RoDaVi]

Hola eferion.
Casi me da vergüenza preguntar pero debo hacerlo porque de lo contrario no puedo seguir adelante, seguramente voy a preguntar algo infantil pero me pase todo el día buscando sobre el resultado que me arroja la variable cadena y no encontré nada que se relacione, pase dicha variable a número y me da resultados que no logro interpretar, por lo menos con la frase que pusiste lo que muestra es más entendible para mi.-
¿Debo pasar el resultado a binario o que debo hacer ?.-
Si pregunte una animalada discúlpame.-

Un gran abrazo.
Daniel

[Profesor_Falken]

Buenas,

El ejemplo que te da eferion es ya completo. Te da el binario en formato hexadecimal y solo tienes que convertir la representacion:

0000 <-> 0
0001 <-> 1
0010 <-> 2
0011 <-> 3
0100 <-> 4
0101 <-> 5
0110 <-> 6
0111 <-> 7
1000 <-> 8
1001 <-> 9
1010 <-> A
1011 <-> B
1100 <-> C
1101 <-> D
1110 <-> E
1111 <-> F

Si lo que quieres es ir por la via rapida:

Código C:

#include <stdio.h>
#include <string.h>
 
void printStringAsBinary(const char *input)
{
    const char *temp = input;
    int i = 7, j =0;;
    int inputLen = strlen(input);
 
    for (j = 0; j < inputLen; j++) {
        while (i>=0) {
            if (*temp & (1 << i)) {
               printf("1");
            } else {
                printf("0");
            }
            i--;
        }
        temp = temp+1;
        i = 7;
        printf(" ");
    }
}
 
int main(void)
{
  const char* cadena = "Programacion";
 
  printStringAsBinary(cadena);
 
  return 0;
}
 

Resultado: 01010000 01110010 01101111 01100111 01110010 01100001 01101101 01100001 01100011 01101001 01101111 01101110


Un saludo

[leosansan]

Iniciado por Profesor_Falken

Buenas,

El ejemplo que te da eferion es ya completo. Te da el binario en formato hexadecimal y solo tienes que convertir la representación:

0000 <-> 0
.................................

Si lo que quieres es ir por la vía rápida:
.........................................
Un saludo

Venga, otra de char a binario:

Código C++:

#include <stdio.h>
 
void CharBinario ( char ch ) {
 int i;
 for ( i = 7 ; i >= 0  ; i-- )
  putchar ( ( ch & ( 1 << i ) ) ? '1' : '0' ) ;
 putchar (' ') ;
}
 
int main ( ) {
  int i = 0 ;
  char cadena [ ] = "Programacion" ;
  while( cadena [ i ] != '\0' )
    CharBinario ( cadena [ i++ ] ) ;
  return 0;
}
 

Resultado:

Código C++:

01010000 01110010 01101111 01100111 01110010 01100001 01101101 01100001 01100011 01101001 01101111 01101110
 

Por cierto, ¿qué tiene que ver esto con multiplicar dos variables en formato char?- ¿No querrías decir otra cosa y te hemos interpretado mal?.

Y por cierto amigo Daniel respecto a:

….Lo que quiero hacer es multiplicar 2 cifras alojadas en sendas cadenas, con un bucle de sumas ya lo logré...................

Pues si que has iterado/sumado al hacer:

factor1= 34567891234567890123456789987654325123456789109876 5432112345612345678
91234567890123456789987654325123456789999876543212 399987654321098765432112345612
34567891234567890123456789987654325123456789256845 678912345678901234567899876543
2512345678978901234567899876543251234567890123
*
factor2 = 99987654321098765432112345612345678912345678901234 567899876543251234
56789256845678912345678901234567899876542512345678 978901234567899876543251234567
89012399912345678901234567899876543251234567891234 567890123456789987654325123456
78910987654321123456123456789123456789012345678998 765432512345678999987654321239
99876543210987654321123456123456789123456789012345 678998765432512345678925684567
89123456789012345678998765432512345678978901234567 899876543251234567890123 =



factor1 * factor2 = 3456362359371314236185502192775492617496724696
52111181826131566910999369719930420774253226327488 382013190683949548852174241673
03869499456970740898253759211944159462133587935643 319556365476675874448718255967
41062464373905046824065928980650349059992325182676 172243321949248172744389886833
98489700921770896381544800265653467050205186356058 321426865505523671201692715214
92052563665498118108956760423892760447992045135762 236987569214623652041999776466
04605891613529794749276525796835521915084539988376 563337594670017224833623383861
05121350345008280468437829333386218986176076439164 502587577076191641875476697220
41052073040664226325080084265422747020953319455947 380385619265582372757236248447
08452175477897815324889672618627251482275580095512 9

¡¡¡Saluditos!!!

[RoDaVi]

Hola Profe…
Gracias por el aporte, muy esclarecedor.-
Leo muchas gracias como siempre.

Por cierto, ¿qué tiene que ver esto con multiplicar dos variables en formato char?- ¿No querrías decir otra cosa y te hemos interpretado mal?

No entiendo el porqué de tu duda.-
Voy a ser pragmático para hacerles perder menos tiempo y yo lograr el cometido.-

13 x 11 = 143

1 1 0 1 (13)
x 1 0 1 1 (11)
------------------
1 1 0 1
1 1 0 1
0 0 0 0
1 1 0 1
------------------
1 0 0 0 1 1 1 1 (143)

Esto es lo que quiero lograr, tan simple como eso, lo que pasa es que en el programa de Uds. si pongo:
char cadena[] = "4294967295";
Debo lograr que el binario sea:
11111111111111111111111111111111
Y me sale:

Por último y releyendo mis post me parece que no fui lo suficientemente claro, ahora tengo fe de que si.-

Un gran abrazo.
Daniel

[Profesor_Falken]

Buenas,

Si hubieses sido asi de concreto en el primer post, la primera respuesta hubiese sido la buena y nos ahorrariamos todos tiempo.

Esto es lo que quiero lograr, tan simple como eso, lo que pasa es que en el programa de Uds. si pongo:
char cadena[] = "4294967295";
Debo lograr que el binario sea:
11111111111111111111111111111111

Tu funcion "atob"

Código C:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int c[32];  char s[40];
 
char *atob (const char* str) {
  int i, j, k = 0;  char *p;
  unsigned long int n = atol(str);
 
  for (i = 0; i < 32; i++)
    c[i] = (n >> i) & 0x1;
 
  for (i = 0, j = 31; j >= 0; i++, j--)
  {
    if (k == 4)
    {
      k = 0;
    }
    s[i] = c[j]+'0';  k++;
  }
  if ((p = strchr (s, '1')) == NULL)
    return s+35;
  k = p - s;
  k /= 5;  k *= 5;
  return s+k;
}
 
int main(void) {
  const char* cadena = "4294967295";
 
  printf("Equivalente en binario: %s", atob(cadena));
 
 
  return 0;
}
 

Resultado:

Código consola:

Equivalente en binario: 11111111111111111111111111111111
 

Nota: la he cogido y adaptado un poquito a partir de aqui:
http://cboard.cprogramming.com/c-pro...onversion.html



Un saludo

[RoDaVi]

Hola Profesor_Falken, que tengas un muy buen día.
Tú código no es lo que necesito, lo que quiero hacer es multiplicaciones que se limiten en el resultado únicamente por la capacidad de la memoria que disponga la máquina con la cual se corra el programa.-
326478932541233317723325987980 x 132987452314789994
Gracias a tú aporte, al de eferion y leo pude aprender unas cuantas cosas más.-

.......y nos ahorrariamos todos tiempo.

Leo, en algún otro foro seguramente nos estaremos escribiendo.-

Un gran abrazo a todos.
Daniel

[eferion]

Entonces necesitas una estructura que te permita almacenar números grandes.

Quizás puedes probar a utilizar la librería [URL="https://gmplib.org"]GNU Multiple Precision Arithmetic Library[/URL]. Te lo comento porque diseñar una estructura propia puede llevar bastante tiempo y penalizar seriamente el rendimiento.

[leosansan]

Iniciado por Profesor_Falken

Buenas,
Si hubieses sido así de concreto en el primer post, la primera respuesta hubiese sido la buena y nos ahorraríamos todos tiempo.
.................................................. ...
Tu funcion "atob"...............

Pues yo no quiero quedarme atrás así que ahí va amigo Daniel un código que pasa un char en decimal a binario.....pero como ya me conoces, un código "cortito" de mi propia cosecha:

Código C++:

#include<stdio.h>
#include <stdlib.h>
 
 int main( ) {
    const char *cadena = "123456789" ;
    int i = 0 , strlenBase2 ;
    long long int n , N  = atoll (cadena) ;
    for ( strlenBase2 = 0  , n = N ; n ; n /= 2 , strlenBase2++ ) ;
    char digito [ strlenBase2 + 1 ] ;
    for ( i = 0 , n = N ; n ; n/= 2 , i++ ) digito [ strlenBase2 - 1 - i ] = n % 2  + '0' ;
    return digito [ strlenBase2  ] = '\0' , printf ("\n%s en binario es igual a %s" , cadena , digito ) , 0 ;}
 

Código C++:

123456789 en binario es igual a 111010110111100110100010101
 

Pero.....es limitado ya que no podrás ingresar números superiores a un ULL.

Y que veo ahora en tu nuevo mensaje:

Hola Profesor_Falken, que tengas un muy buen día.
Tú código no es lo que necesito, lo que quiero hacer es multiplicaciones que se limiten en el resultado únicamente por la capacidad de la memoria que disponga la máquina con la cual se corra el programa.-
326478932541233317723325987980 x 132987452314789994

Por lo que veo ahora no estaba desencaminado cuando comenté:

Por cierto, ¿qué tiene que ver esto con multiplicar dos variables en formato char?- ¿No querrías decir otra cosa y te hemos interpretado mal?

Así que ahora sí, volvemos a la duda planteada ya en éste y otros foros, pero como a mí me está gustando éste foro más que otros, aquí te respondo. Y para los que sigan este tema, no es una tarea resuelta sin más ya que Daniel ha aportado en otros foros respuestas parciales al tema que propone de multiplicar números que yo llamo "big", poco original pero es lo que hay.

A ver si ahora acierto con tu propósito de multiplicar números grandes sin más limitación que la memoria.

Te aclaro del código un par de cositas:

* La función "imprimir" es totalmente opcional. La he incluido porque ya vi en otro foro que querías los números separados en grupos de tres. Por lo tanto, puedes prescindir de ella si así lo deseas, pero a cambio tienes que eliminar en la función main las referencias a "imprimir" y activar los "printf" que están desactivados. No lo he probado lo suficiente, lo del punto decimal, así que si no queda bien lo eliminas y ya está.

* Puedes elegir multiplicar tanto en decimal como en binario, tan solo tienes que cambiar el valor BASE del "define" e introducir los valores en lo que corresponda, decimal o binario.

* He puesto MAX_DIGITOS = 10000 pero puedes ir probando con valores mayores si los números son "muy grandes" .

* La "crema" del código es la función "Producto", ahí me salí xD pero en esencia es muy sencilla, es la clásica multiplicación "como" si la hicieras con lápiz y papel. Ya con más tiempo la mejoraré, pero para que vayas viendo y haciendo pruebas.

Y antes del código una salida de muestra:

Código C++:

Numero de digitos del producto = 738
 
Numero de digitos del factor1 = 275
 
Numero de digitos del factor2 = 463
 
 34.567.891.234.567.890.123.456.789.987.654.325.123.456.789.109.876.543.211.
234.561.234.567.891.234.567.890.123.456.789.987.654.325.123.456.789.999.876.
543.212.399.987.654.321.098.765.432.112.345.612.345.678.912.345.678.901.234.
567.899.876.543.251.234.567.892.568.456.789.123.456.789.012.345.678.998.765.
432.512.345.678.978.901.234.567.899.876.543.251.234.567.890.123
 
    *
 
  9.989.876.543.210.987.654.321.123.456.123.456.789.123.456.789.012.345.678.
998.765.432.512.345.678.925.684.567.891.234.567.890.123.456.789.987.654.251.
234.567.897.890.123.456.789.987.654.325.123.456.789.012.399.912.345.678.901.
234.567.899.876.543.251.234.567.891.234.567.890.123.456.789.987.654.325.123.
456.789.109.876.543.211.234.561.234.567.891.234.567.890.123.456.789.987.654.
325.123.456.789.999.876.543.212.399.987.654.321.098.765.432.112.345.612.345.
678.912.345.678.901.234.567.899.876.543.251.234.567.892.568.456.789.123.456.
789.012.345.678.998.765.432.512.345.678.978.901.234.567.899.876.543.251.234.
567.890.123
 
    =
 
    345.328.965.792.478.474.571.731.563.916.767.309.034.843.781.063.001.241.
651.611.862.189.865.279.170.758.374.287.301.864.621.761.221.061.195.610.493.
845.008.696.900.056.316.216.177.358.205.430.885.308.746.865.366.147.115.455.
686.701.063.209.680.194.075.441.228.639.144.790.187.287.157.864.726.704.667.
141.897.575.794.157.510.922.022.017.246.651.846.261.818.257.813.933.213.898.
868.339.848.970.092.177.089.638.154.480.026.565.346.705.020.518.635.605.832.
142.686.550.552.367.120.169.271.521.492.052.563.665.498.118.108.956.760.423.
892.760.447.992.045.135.762.236.987.569.214.623.652.041.999.776.466.046.058.
916.135.297.947.492.765.257.968.355.219.150.845.399.883.765.633.375.946.700.
172.248.336.233.838.610.512.135.034.500.828.046.843.782.933.338.621.898.617.
607.643.916.450.258.757.707.619.164.187.547.669.722.041.052.073.040.664.226.
325.080.084.265.422.747.020.953.319.455.947.380.385.619.265.582.372.757.236.
248.447.084.521.754.778.978.153.248.896.726.186.272.514.822.755.800.955.129
 

Código C++:

#include <stdio.h>
#include <string.h>
 
#define MAX_DIGITOS 10000
#define BASE 10
 
 
void imprimir ( char cadena [ ] ) {
    int i , j , sp ;
    if ( BASE == 2 ) 
         sp = 4 ;
    if ( BASE == 10 )
         sp = 3 ;        
    for ( i = 0 , j = strlen ( cadena ) ; cadena [ i ] ; i++ , j-- ) {
        if ( i == 0 && j % sp != 0 )
             printf ( "%*c" , sp - j % sp , ' ' ) ;
        if ( i == 0 && j % sp == 0 )
             printf ( "%*c" , 4 , ' ' ) ;
     if ( j < strlen ( cadena ) && j % sp == 0 )
         putchar ( '.' ) ;
     if ( ( i - strlen ( cadena  ) % sp + sp ) %  57 == 0  )
             putchar ( '\n' ) ;
         printf ( "%c" , cadena [ i ] ) ;
    }
}
 
 void Producto ( char factor1 [ ] , char factor2 [ ] ,  char producto [ ] ) {
  int lon_factor1 = strlen ( factor1 ) , lon_factor2 = strlen ( factor2 ) , lon = lon_factor1 + lon_factor2 ;
  int i , j , temp [ lon ] ;
  producto [ lon ] = '\0' ;
    for ( i = 0 ; i < lon ; i++ ) temp [ i ] = 0  ;
  for ( j = 0 ; j < lon_factor2 ; j++ )
    for ( i = 0 ; i < lon_factor1 ; i++ )
      temp [ i + j + 1 ] += ( factor1 [ i ] - '0' ) * ( factor2 [ j ] - '0' ) ;
  for ( i = lon - 1 ; i >= 1 ; i-- )
    producto [ i ] = temp [ i ] % BASE + '0'  , temp [ i - 1 ] += temp [ i ] / BASE ;
  producto [ 0 ] = temp [ 0 ] + '0' ;
    if ( producto [ 0 ] == '0' )
         memmove ( producto , producto + 1 , lon ) ;
 }
 
int main ( void ) {
  char producto [ MAX_DIGITOS ] ;
  char factor1 [ MAX_DIGITOS ] = /*"11011"*/"3456789123456789012345678998765432512345678910987654321123456123"
                        "4567891234567890123456789987654325123456789999876543212399987654"
                        "3210987654321123456123456789123456789012345678998765432512345678"
                        "9256845678912345678901234567899876543251234567897890123456789987"
                        "6543251234567890123" ;
 
  char factor2 [ MAX_DIGITOS ] = /*"1011"*/"998987654321098765432112345612345678912345678901234567899876543251"
                        "23456789256845678912345678901234567899876542512345678978901234567"
                        "899876543251234567890123999123456789012345678998765432512345678912"
                        "345678901234567899876543251234567891098765432112345612345678912345"
                        "678901234567899876543251234567899998765432123999876543210987654321"
                        "123456123456789123456789012345678998765432512345678925684567891234"
                        "56789012345678998765432512345678978901234567899876543251234567890123" ;
 
  Producto ( factor1 , factor2 , producto ) ;
  printf ( "\nNumero de digitos del producto = %d\n" , strlen ( producto ) ) ;
  printf ( "\nNumero de digitos del factor1 = %d\n" , strlen ( factor1 ) ) ;
  printf ( "\nNumero de digitos del factor2 = %d\n\n" , strlen ( factor2 ) ) ;
  imprimir ( factor1 ) ;
  printf ( "\n\n    *   \n\n"  ) ;
  imprimir ( factor2 ) ;
  printf ( "\n\n    =   \n\n"  ) ;
  imprimir ( producto ) ;
  /*printf ( "\n\n  factor1 = %s   \n * \n  factor2 = %s =\n\n " , factor1 , factor2 ) ;
  printf ( "\n\n\t factor1 * factor2 = %s\n\n" , producto ) ;*/
  return 0;
}
 

Obvio es decirte que es algo de mi propia cosecha y a lo rapidito así que si encuentras bug please comunícame lo. No obstante lo he probado, también rapidito para no hacerte esperar, como aplicación en el cálculo de factoriales y he obtenido hasta 2500! sin errores, así como otra aplicación en el cálculo de números combinatorios también big sin errores, pero....lo dicho, si encuentras algún fallo reportámelo, please.

Espero que ahora si te haya interpretado bien .

Y no se corten, si les parece útil y/o interesante picar en "Me gusta", a ver si voy acumulando puntitos .

¡¡¡Saluditos!!!