¿Error al convertir nùmero grande a binario?
Tachikomaia:
En el dibujo de arriba izquierda:
debería formarse esto:
┌
es como una L reflejada verticalmente.
pero como ven, está mal.
Ahí hay 7*7 dibujos (cuadros) compuestos de 8*8 cuadraditos cada uno.
El problema ocurre con esos números, no ocurre con números menores como
2 y 3
3 y 4
...
6 y 7
como ven siempre pongo que CuadrosPorFila = CuadraditosPorFila-1
Creo que el problema está en cómo se genera la variable DibujoaMostrar, en esta función, que se usa al inicio y cada vez que cambian esos números:
Código
function AjustarVariables () {
Cuadros = CuadrosPorFila*CuadrosPorFila;
MaxCuadro = Cuadros-1;
Cuadraditos = CuadraditosPorFila*CuadraditosPorFila;
MaxCuadradito = Cuadraditos-1;
LargoDeCuadraditos = 384/(CuadraditosPorFila*CuadrosPorFila+CuadrosPorFila-1);
LargoDeCuadros = CuadraditosPorFila*LargoDeCuadraditos;
// Esto es para que el 1er dibujo sea una L al revés...
// Se averigua su número representante en binario:
// Para formar la _
DibujoEnBinario = String(Math.round(Math.pow(10, CuadraditosPorFila)));
// Quitar el 1:
DibujoEnBinario = DibujoEnBinario.substring(1, CuadraditosPorFila+1);
// Esto forma las filas siguientes, con el 1ero pintado:
NroDelCaracter = Cuadraditos-CuadraditosPorFila;
AnterioraPintar = MaxCuadradito-CuadraditosPorFila;
do {
NroDelCaracter--;
if (NroDelCaracter != AnterioraPintar) {
DibujoEnBinario = 1+DibujoEnBinario;
} else {
DibujoEnBinario = 0+DibujoEnBinario;
AnterioraPintar = AnterioraPintar-CuadraditosPorFila;
}
} while (NroDelCaracter>0);
// trace("DibujoEnBinario que hace la L invertida: "+DibujoEnBinario);
// Convertirlo en decimal:
DibujoaMostrar = 0;
do {
DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
NroDelCaracter++;
} while (NroDelCaracter<Cuadraditos);
DibujoaMostrar = Number(DibujoaMostrar);
trace("DibujoaMostrar calculado desde la L invertida: "+DibujoaMostrar);
}
Porque tengo una función que convierte DibujoaMostrar a binario y...
Si CuadroPorFila es 2 y CuadraditosPorFila es 3, la conversión dice:
Convirtiendo a binario esto: 432
DibujoEnBinario: 110110000
y está bien, vean que tiene 4 0s al final. Los dibujos se muestran al revés a eso, o sea:
000
011
011
y 0 es negro, vean que se forma la ┌
son 3 0s y uno más que sigue en la siguiente fila. 4.
Si pongo 3 y 4:
Convirtiendo a binario esto: 61152
DibujoEnBinario: 1110111011100000
5 0s, la cantidad de 0s aumentó 1.
Con 4 y 5:
Convirtiendo a binario esto: 32472000
DibujoEnBinario: 1111011110111101111000000
6, de nuevo aumentó 1.
5 y 6:
Convirtiendo a binario esto: 67628691328
DibujoEnBinario: 111110111110111110111110111110000000
7, de nuevo +1.
6 y 7:
Convirtiendo a binario esto: 558517276622592
DibujoEnBinario: 1111110111111011111101111110111111011111100000000
8, de nuevo +1.
7 y 8:
Convirtiendo a binario esto: 1.83744039008715e+19
DibujoEnBinario: 1111111011111110111111101111111011111110111111110000000000000000
Con esto ocurre el problema. Vean que en 1er lugar el número se muestra raro, y el binario en vez de tener 9 0s al final tiene 16.
Creo haber confirmado que la función que convierte a binario no es el problema, falla porque se le da ese número raro.
¿Se puede corregir el error o es un número muy largo y por eso fallará sí o sí?
Explico por qué uso números grandes:
Supongan que el programa calcula cuántos dibujos pueden formarse con las condiciones dadas. Siendo 8*8 cuadraditos, si mal no recuerdo el cálculo es 2^64, que en la calculadora dice que es:
18446744073709551616
ese número convertido a binario forma lo que sería el dibujo todo pintado, con uno 1 delante que sobra:
10000000000000000000000000000000000000000000000000000000000000000
se vería así si quitamos el 1:
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
son 8*8 0s.
Supongan que esa cantidad la queremos dividir entre 7, para que cada cuadro muestre la misma cantidad de esos posibles dibujos a lo largo de cierto tiempo.
El cuadro nro 1 mostrará los 1eros 1000 dibujos posibles, por decir algo, el 2ndo los siguientes, y así.
Básicamente por eso es que necesito los números grandes. A la cantidad de dibujos posible le voy restando la cantidad que va a mostrar cada cuadro, para saber qué dibujo se mostrará 1ero en cada cuadro. Eso no lo puse en el código aquí porque no creo que sea el problema.
¿Hay alguna otra cosa importante que deba decir sobre esto?
La conversión es:
Código
function ConvertiraBinario (numero) {
// trace("Convirtiendo a binario esto: "+numero);
// Averiguar cómo es en binario:
DibujoEnBinario = "";
while (numero>0) {
DibujoEnBinario = numero%2+DibujoEnBinario;
numero = Math.floor(numero/2);
}
// Agregar 0s a DibujoEnBinario si hacen falta:
while (DibujoEnBinario.length<Cuadraditos) {
DibujoEnBinario = 0+DibujoEnBinario;
}
// trace("DibujoEnBinario: "+DibujoEnBinario);
}
Tachikomaia:
Según GPT, Flash falla en guardar números demasiado grandes. Asumo que el problema es ese.
A ver, tengo una cadena que representa a un binario.
Necesito convertirlo en decimal, pero si es un número falla, así que necesito que sea una cadena.
¿Cómo convierto una cadena que representa a un binario, en una cadena que representa a un decimal? Sin convertirlo todo junto a número porque sino falla.
Luego a la cadena obtenida, que representa a un decimal, necesito dividirla por otro número, nunca tan grande. Y que el resultado sea una cadena también, porque puede ser muy grande.
¿Cómo a una cadena que representa a un decimal, la puedo dividir por un número, de modo que el resultado sea representado por una cadena? Mismo comentario.
Con eso tenemos Decimal y ResultadoDeDivision.
Por último, a Decimal necesito restarle ResultadoDeDivision varias veces, en un loop. Esto parece lo más sencillo, como hacer una resta manualmente, viendo cuales son los últimos caracteres.
¿Cómo a una cadena que representa a un decimal, le puedo restar otra que representa a otro? Mismo comentario.
O quizá sería más fácil hacer las operaciones usando las cadenas binarias, creo que no necesito los decimales.
Le preguntaré a GPT si nadie responde.
Mr.Byte:
Demasiadas preguntas, no me queda claro, no se si esto te sirve
Existen dos metodos
Decimal a binario:
Código:
var decimal:int = 42;
var binario:String = decimal.toString(2); // "101010"
Binario a decimal:
Código:
var binarioStr:String = "101010";
var decimal:int = parseInt(binarioStr, 2); // 42
Tachikomaia:
Intento resumir y corregir algunos posibles errores que haya cometido en posts anteriores.
Se consigue el número binario que forma la L invertida, aunque es un string:
"1111111011111110111111101111111011111110111111101111111000000000"
Se intenta convertir a decimal, pero como el número resultante es tan grande, Flash falla:
9.22337203685478e+18
Según GPT, el resultado debería ser 18374686492081295424 y el número raro que pone Flash es casi la mitad de eso. Falla.
Entonces, en principio necesito un método de convertir un string que representa un número binario, en un string que represente un decimal, pero sin que dicho método use variables tipo número que sean demasiado grandes, porque sino falla.
El método que usaba, para convertir DibujoEnBinario en DibujoaMostrar, es:
Código
// Convertirlo en decimal:
DibujoaMostrar = 0;
do {
DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.round(Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter)));
trace("Convirtiendo en decimal... "+DibujoaMostrar);
NroDelCaracter++;
} while (NroDelCaracter<Cuadraditos);
DibujoaMostrar = Number(DibujoaMostrar);
Le expliqué a GPT y me dijo esto:
Código
function binaryToDecimalString(binStr) {
var decimal = "0";
var i = 0;
while (i < binStr.length) {
// Multiplicar el decimal actual por 2
decimal = multiplyDecimalStringByTwo(decimal);
// Sumar el bit actual si es 1
if (binStr.charAt(i) == "1") {
decimal = addDecimalString(decimal, "1");
}
i++;
}
return decimal;
}
// Multiplica un string decimal por 2
function multiplyDecimalStringByTwo(decimal) {
var result = "";
var carry = 0;
for (var i = decimal.length - 1; i >= 0; i--) {
var digit = Number(decimal.charAt(i)) * 2 + carry;
carry = Math.floor(digit / 10);
result = String(digit % 10) + result;
}
if (carry > 0) {
result = String(carry) + result;
}
return result;
}
// Suma dos strings decimales
function addDecimalString(a, b) {
var result = "";
var carry = 0;
var i = a.length - 1;
var j = b.length - 1;
while (i >= 0 || j >= 0 || carry > 0) {
var digitA = i >= 0 ? Number(a.charAt(i)) : 0;
var digitB = j >= 0 ? Number(b.charAt(j)) : 0;
var sum = digitA + digitB + carry;
carry = Math.floor(sum / 10);
result = String(sum % 10) + result;
i--;
j--;
}
return result;
}
Lo voy a pensar.
Luego creo que tendría que dividir un número entre otro, pero siendo strings, y también tendría que hacer restas usando strings.
Flamer:
hola en javascript puedes usar el comando BigInt asi
Código
BigInt("0b" + binarioGigante)
pero tiene limites no creas que todos los convierte si es demasiado grande no puede
saludos Flamer
-----Edito-----
lei mal el titulo es alreves, bueno toString(2) creo que no te sirve ya que para numeros muy grandes no puede en fin saludos
Navegación
[#] Página Siguiente