Cita:
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++:
Ver original#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++:
Ver original123456789 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:
Cita: 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é:
Cita: 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++:
Ver originalNumero 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++:
Ver original#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 )
if ( j
< strlen ( cadena
) && j
% sp
== 0 ) if ( ( i
- strlen ( cadena
) % sp
+ sp
) % 57 == 0 ) 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 ) ;
imprimir ( factor2 ) ;
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!!!
