GPT me dijo:
=DIRECCION(FILA(D8)-1+COINCIDIR(MIN(D8:D22);D8:D22;0); COLUMNA(D8))
y funciona pero sólo entiendo lo que está en negrita, quisiera una alternativa o a ver si me lo pueden hacer entender.

(MIN(D8:D22):
haya el mínimo en ese rango de celdas.
(ll, el foro me cambia la palabra)

COINCIDIR(MIN(D8:D22);D8:D22;0):
Asumo que se lee como:
Buscar índice de (Valor; en el rango; coincidencia total)

¿ DIRECCION(qué fila; qué columna) ?

FILA(D8)-1:
No tengo mucha idea. Creo que le suma 7 al resultado de COINCIDIR, pero ahí dice -1, además pone una D no sé para qué.
Edit: Ya entendí esto, de D8 toma el 8, le resta 1, queda 7, y luego la fórmula dice +, así que ese 7 se suma...


COLUMNA(D8):
Idem. Si toma la columna del parámetro D8, sería más fácil simplemente poner D.

O sea, de D8 a D22 tengo unos datos, y en otra celda quiero que me diga en cual de esas celdas está el mínimo valor. No creo que sea tan complicado ¿GPT se lió?

Edit: Ya entendí más, pero hay como cosas innecesarias, que deberían ser más simples ¿se pueden simplificar?

Edit 2: Según probé se puede simplificar así:
=DIRECCION(7+COINCIDIR(MIN(D8:D22);D8:D22;0); COLUMNA(D8))
Faltaría la columna. Si siempre va a ser D...

La mira es a donde tiene que ir el meteoro cuando toque la nave de abajo. Cuando queda en una punta es como si estuvieses jugando al tenis y apuntando a la punta, es normal.

No importa aquí qué lugar de la nave de abajo toque el meteoro. Mover la nave no cambia la posición de la mira, es como un "charging", apretás A o S y en vez de que el tiro sea más fuerte debe ir más a la punta.

Tengo pensado hacer eso pero no veo que sea la solución al problema... Eso va a ser una 2nda etapa del charging, que vaya justo al centro y rebote, ya que es efectivo contra la IA. Así como está el juego es muy difícil hacerle un punto.

Creo que hay confusión, la trayectoria del tiro debe decidirse cuando toca la nave de abajo y por ahora no debe tocar las paredes. Hago un dibujo...

Cuando el meteoro toque la nave de abajo, debe rebotar siguiendo la línea verde, hacia la mira, sin tocar las paredes.
Si va a tardar 100 frames en recorrer la distanciaY, debe tardar 100 frames en recorrer la distanciaX. Ese es el razonamiento que hago y el cálculo que intento hacer, pero no sé qué pasa.


En tu ejemplo a veces choca en la pared, esa no es la idea, lo demás está bien, no sé cómo hiciste el cálculo...

Ignora la pared por ahora, se va a usar más adelante. Supón que es un juego de golf de cuando usas el palo que la pelota no sube, o sea, todo 2d, visto de arriba, y la mira el hoyo, y se quiere que la pelota vaya ahí.
Se determina una velocidad Y al azar:
MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
¿y luego? Capaz que me falla el cálculo porque esa velocidad es negativa, luego veo.

Si elipse es muy complicado será rectángulo.

Quiero imitar una nube cambiando, más o menos. Circulos aparecerían detrás, crecerían y se achicarían hasta desaparecer. Hay un video que me gustó que más o menos hace eso pero no lo encuentro.

Entonces, tenemos una elipse de 200 de ancho y 100 de alto. Supongamos que está colocado en las coordenadas 0, 0. ¿Cómo los circulos podrían aparecer en cualquier parte del perímetro con igual probabilidad? No en el área.

Si es muy complicado, tenemos un rectángulo, digamos de la misma medida y lugar. Y misma pregunta.
Sobre este lo pensé y no supe. Puedo hacer que aparezca en el perímetro, pero con igual chance cada punto no sé.

https://youtu.be/TmACx8Du3as

Cuando el meteoro se está acercando a la nave de abajo, si presiono A o S aparece una mira, que se va moviendo a la izquierda si apreté A y a la derecha si apreté S.
Cuando el meteoro toque la nave de abajo, debe ir hacia donde haya quedado la mira.

Pueden ver que a veces funciona, y a veces no, no sé por qué...

La pantalla es de 800 pixeles de ancho y 600 de largo. Las coordenadas avanzan a la derecha y abajo, así que arriba a la izquierda es 0, 0
y abajo a la derecha es 800, 600
El 1er número corresponde a X, el 2ndo a Y.

La mira es algo provisorio para mostrar la falla, no habrá mira en el juego.

Creo que el error está acá:

	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;

Código completo:

// Algo como esto if (MeteorYSpeed>0) { se está haciendo 2 veces,
// pero evitarlo implicaría unir cosas del jugador y la IA?
//
fscommand ("fullscreen", "true");
// Varía según diferencia de puntajes:
Dificultad = 0;
// Player:
attachMovie("sShip", "Player", 1);
setProperty ("Player", _x, 400);
setProperty ("Player", _y, 579.5);
PlayerSpeed = 3;
PlayerScore = 0;
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
IAScore = 0;
// Meteor:
attachMovie("sMeteor", "Meteor", 3);
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
// Se define acá para que luego el programa considere que...
// hubo contacto entre la nave del jugador y el meteoro:
MeteorYSpeed = 1;
// Para que la curvatura dependa de MeteorYSpeed
// (1 es hacia arriba, -1 hacia abajo):
MeteorYDirection = -1;
// Valores del color más brillante del meteoro (F0D9C8):
MaxRojo = 255;
MaxVerde = 217;
MaxAzul = 200;
// /////////////////////////////////////////////
// /////////////////// Ship ////////////////////
// /////////////////////////////////////////////
function ControlShip () {
	if (Key.isDown(39)) {
		// Derecha.
		// Para evitar que se vaya demasiado al extremo derecho:
		if (Player._x<722) {
			Player._x = Player._x+PlayerSpeed;
		} else {
			Player._x = 725;
		}
	} else if (Key.isDown(37)) {
		// Izquierda.
		// Para evitar que se vaya demasiado al extremo izquierdo:
		if (Player._x>78) {
			Player._x = Player._x-PlayerSpeed;
		} else {
			Player._x = 75;
		}
	}
	// Si el meteoro va hacia abajo:
	if (MeteorYSpeed>0) {
		// Si aún no se eligió hacia dónde rebotarlo:
		if (Apuntando == 0) {
			if (Key.isDown(65)) {
				Apuntando = -1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 399);
				setProperty ("Mira", _y, 20.5);
			} else if (Key.isDown(83)) {
				Apuntando = 1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 401);
				setProperty ("Mira", _y, 20.5);
			}
		} else if (Apuntando < 0) {
			Apuntando = Apuntando-3;
			if (Apuntando < -400) {
				Apuntando = -400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		} else {
			Apuntando = Apuntando+3;
			if (Apuntando > 400) {
				Apuntando = 400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		}
	}
}
// /////////////////////////////////////////////
// ////////////////////  IA  ///////////////////
// /////////////////////////////////////////////
function IATurn () {
	// Si el meteoro va hacia arriba:
	if (MeteorYSpeed<0) {
		// La IA se moverá hacia él:
		Distancia = IA._x-Meteor._x;
	} else {
		// La IA irá hacia el centro:
		Distancia = IA._x-400;
	}
	if (Distancia < 0) {
		IA._x = IA._x+IASpeed;
		// Para evitar que se vaya demasiado a la derecha:
		if (IA._x > 725) {
			IA._x = 725;
		}
	} else if (Distancia > 0) {
		IA._x = IA._x-IASpeed;
		// Para evitar que se vaya demasiado a la izquierda:
		if (IA._x < 75) {
			IA._x = 75;
		}
	}
}
// /////////////////////////////////////////////
// /////////////////  Meteor  //////////////////
// /////////////////////////////////////////////
function VariarMeteoro () {
	Diametro = 44;
	Radio = Diametro/2;
	// Insertarle imágenes:
	Imagen = 0;
	do {
		Imagen++;
		Name = "Imagen"+Imagen;
		Meteor.attachMovie("sCirculo", Name, Imagen);
		Name = "Meteor."+Name;
		// Para los tamaños y rotación:
		setProperty (Name, _xscale, 400*Math.random());
		setProperty (Name, _yscale, 400*Math.random());
		setProperty (Name, _rotation, 360*Math.random());
		// Para las posiciones:
		X = Math.random()*Diametro - Radio;
		setProperty (Name, _x, X);
		MaxY = Math.sqrt(Radio*Radio - X*X);
		Y = Math.random() * (MaxY*2) - MaxY;
		setProperty (Name, _y, Y);
		// Para los colores:
		ColorDeName = new Color(Name);
		Brillo = 0.2 + 0.8 * Math.random();
		Rojo = Math.round(MaxRojo * Brillo);
		Verde = Math.round(MaxVerde * Brillo);
		Azul = Math.round(MaxAzul * Brillo);
		ColorElegido = (Rojo << 16) | (Verde << 8) | Azul;
		ColorDeName.setRGB(ColorElegido);
	} while (Imagen < 1000);
}
VariarMeteoro ();
function MeteorMoves () {
	MeteorXSpeed = MeteorXSpeed+MeteorRotation/1000*MeteorYDirection;
	MeteorRotation = MeteorRotation/1.01;
	Meteor._x = Meteor._x+MeteorXSpeed;
	Meteor._y = Meteor._y+MeteorYSpeed;
	Meteor._rotation = Meteor._rotation+MeteorRotation;
	// Choque con nave derecha:
	if (Meteor._x > 752.5) {
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	} else if (Meteor._x < 47.5) {
		// Choque con nave izquierda:
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	}
	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		if (Apuntando < -400) {
			Apuntando = -400;
		} else if (Apuntando > 400) {
			Apuntando = 400;
		}
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;
		MeteorRotation = 0;
		// MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = 1;
		trace("MeteorYSpeed: "+MeteorYSpeed);
		trace("Apuntando: "+Apuntando);
		trace("DistanciaY: "+DistanciaY);
		trace("TardanzaY: "+TardanzaY);
		trace("DistanciaX: "+DistanciaX);
		trace("MeteorXSpeed: "+MeteorXSpeed);
		removeMovieclip("Mira");
	} else if (Meteor.hitTest(IA) && MeteorYSpeed<0) {
		MeteorYSpeed = Math.random()*(2+Dificultad)+1;
		MeteorXSpeed = Math.random()*(3+Dificultad)*(2*random(2)-1);
		MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = -1;
		Apuntando = 0;
	} else if (Meteor._y<0) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 55.5);
		PlayerScore++;
		Dificultad++;
		PlayerSpeed = PlayerSpeed+0.1;
		IASpeed = IASpeed+0.11;
		ShowScore();
	} else if (Meteor._y>600) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 544.5);
		IAScore++;
		Dificultad--;
		PlayerSpeed = PlayerSpeed-0.1;
		IASpeed = IASpeed-0.11;
		ShowScore();
	}
}
// 
function ShowScore () {
	attachMovie("sPuntaje", "Mensaje", 4);
	setProperty ("Mensaje", _x, 400);
	setProperty ("Mensaje", _y, 300);
	setProperty ("Player", _x, 400);
	setProperty ("IA", _x, 400);
	gotoAndStop (3);
}
// stop ();

Kung Fu Master de NES es sencillo, ya lo pasé hace mucho, e hice experimentos recientemente, pero quiero hacerlos mejor. Elijo ese juego porque es sencillo y suficientemente bueno.
https://www.youtube.com/watch?v=e7PIr6hpaBY

La idea es empezar también por un experimento sencillo, por ejemplo sólo usar puñetazos normales (no agachado ni saltando). Supongamos que así vencí a 0 jefes. Tengo que anotar datos sobre el resultado:
Usar 1 ataque: 0
Ataque tipo puñetazo: 0
Ataque tipo normal: 0
Puñetazo: 0

El siguiente experimento debe ser lo más distinto posible a ese pero sin complicarme demasiado: 2 ataques, preferentemente que no sean tipo puñetazo, ni normal, y claro que no sean puñetazo.  Por ejemplo patada agachado y patada saltando sin avanzar. Luego pongo los resultados de eso.

Poco a poco se complica comprender cual es el siguiente experimento que conviene hacer, pero mi pregunta es ¿cómo se recomienda que sea la tabla de Excel para anotar los datos o cómo los anotarían? Ciertos datos deben llenarse automáticamente cuando se pone algo en ciertas celdas.

Para empezar pienso en algo así:

Ahí nada se está llenando automáticamente, parece innecesario, es poca cosa.

Luego pienso en algo así:

No sé si tiene sentido tanto dato, creo que es para en el futuro ir viendo qué combinaciones no volver a probar aún, o cuales probar preferentemente, la cosa es que siendo así, ya varios datos se tendrían que llenar automáticamente y probablemente ajustar la tabla para eso o para que quede mejor. Además, si algo tiene puntaje en varias columnas, veo 2 opciones:
A- Crear otra columna que haga un promedio.
B- Que en cada columna se use el nuevo puntaje para promediarlo con el anterior. Creo que esto hace que los últimos puntajes tengan más influencia, no es bueno.

Se va a complicar aún más. El tema es cómo automatizar que se llenen los datos. Lo de las combinaciones lo estoy hablando con GPT.

Pensé en algo así:

Los datos se llenarían así:
Usar 1 ataque: Si en Ataques dice 1, se pone el contenido de Puntaje.
2 ataques: Si en Ataques dice 2, contenido de Puntaje.
Ataque tipo puñetazo: Se busca eso (Ataque tipo puñetazo) en el rango de datos de la columna (hasta donde dice Tipo 2 de Ataque 2). Si se encuentra alguna vez, se pone el Puntaje.
Y así sucesivamente, se busca lo que marca la celda en la fila, y si se encuentra se pone el puntaje.
Entonces llegamos a:
2 ataques   Ataque tipo patada:
Si en Ataques dice 2 y se encuentra "Ataque tipo patada" en el rango de datos, se pone el puntaje.
Más adelante llegamos a:
Ataque tipo patada   Ataque tipo agachado:
Desde ahí se me complica porque lo que se preguntaría es ¿en el experimento se hicieron ataques tipo patada y además otro ataque tipo agachado? Y se se pondría el puntaje si la respuesta es sí, pero no es cuestión de buscar y si aparecen ambas palabras ya está, porque si por ejemplo hubo patadas agachado y puñetazos normales no es que hubo ataques tipo patadas y otro tipo agachado, sino que 1 ataque cumple ambas condiciones, no es lo mismo...
Dicho de otro modo, si es un juego de cartas Pokemon y pongo:
Carta tipo Pokemon   Carta tipo Pokemon tipo planta
lo que se pregunta es ¿hubo una carta Pokemon y otra Pokemon tipo planta? Si hubo un Pokemon tipo planta, eso cumple una condición u otra, no ambas a la vez, para que se cumplan ambas debe haber uno de esos y otro cualquiera.
¿Cómo puedo poner los datos y fórmulas para que se llenen automáticamente la mayoría de datos teniendo en cuenta eso?

No sé qué alternativas tengo.

Consigo en binario la cantidad de dibujos que se van a mostrar en pantalla. DIBUJOS.

Esa cantidad la necesito dividir entre el número de cuadros (o minipantallas), que está en decimal. CUADROS.
Salvo que pudiera hallar alguna regla, que luego comento.

Así que debo convertir el binario en decimal, y luego hacer la división. DIBUJOS/CUADROS.
Una alternativa, trabajar con binarios, lo veo complicado. Supongamos que convierto la cantidad de cuadros, a binario. Luego puedo hacer una división entre binarios, puedo preguntarle a GPT cómo. Pero luego a DIBUJOS tengo que irle restando eso, o sea, hacer restas en binario, y no sé realmente si voy a obtener los números que preciso.
Pero sea como sea, las divisiones van a tener que ser con strings.

Lo de la regla es que los dibujos podrían empezar de cierta forma sin que haya mucho problema. Por ejemplo si hay 4 cuadros de 3*3 cuadraditos cada uno y ponemos que empiecen así:
NNN  NNN
NBB  NBN
NBB  NBB  

NNN  NNN
NBB  NBB
NNB  NBN
Hay que ver si el cuadro inferior derecho queda todo negro (los dibujos van variando) después de que los otros cuadros mostraran todos los dibujos que deben. Si es así y se sigue cumpliendo cuando aumenta la cantidad de cuadros y cuadraditos, bueno, no sería la solución ideal, pero podría ser una solución. Como es difícil saberlo, prefiero hacer una división como se debe. Supongamos que se van a mostrar 512 dibujos. Son menos pero supongamos. Hacemos eso /4, entonces:
512   384
256   128
Me refiero a que un cuadro mostrará el dibujo 512, otro el nro 384, otro el 256, y así. Enseguida, cada uno mostrará el anterior, así:
511  383
255  127
Y así seguirán variando hasta que el inferior derecho llegue a 0 (todo negro), es decir, se muestran todos los dibujos posibles.
Cada número al convertirse a binario se convierte en una representación del dibujo, 0 es negro, 1 blanco.
Más o menos es eso, me puedo haber confundido en algo.
Si los convierto a binario ¿para qué inician como decimales? No sé, me pareció más fácil, lo pensé así, para entender mejor qué estoy haciendo. No creo que sea el problema...

En fin, que yo sepa, para empezar, tengo un binario enorme que debo convertir a decimal pero que sea string. Espero no confundirme en esto.

GPT:

Ahora tengo que intentar entender ese código... Ya había conseguido uno parecido y no pude. Le puedo ir preguntando a GPT lo que no entienda pero... si alguien pudiera hacer un código más comprensible y explicarlo con un ejemplo estaría bueno.

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:

	// 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:

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.

Quizá debería aprender a no prestar atención a asuntos ajenos. Probablemente. Pero mirar temas de foros parece algo normal.

En Quora, gente postea chistes, curiosidades de la historia, respuestas varias a preguntas de los usuarios... En general, nada me parece tonto, nomás bloqueé a uno que daba mensajes "espirituales" crípticos disfrazados de sabiduría y a otro no recuerdo exactamente por qué, algo como que daba información irrelevante o le ponía demasiada opinión suya con la que no estaba de acuerdo.

Acá, El_Andaluz postea, no cualquier cosa sobre guerras, pero muchas cosas sobre guerras ¿demasiadas? Para mí sí, considerando que es un foro de Informática y que en teoría no se puede opinar de política. Lo que postea sobre eso es generalmente casi todo noticias copiadas de otro lado, que quien quiera verlas las podría leer en otro lado, así que no entiendo para qué. Se puede decir que es un tema importante, preocupante, y que cada uno puede postear de lo que se le de la gana, pero a mí me choca que casi siempre se esté hablando de lo mismo, como si te tiraran el tema en la cara, una y otra vez, donde para colmo no se puede opinar casi y no parece que corresponda, por ser un foro de informática, no de guerras ni tan general como otros foros. No entiendo la intención, me parece incomprensible, esa manía de copiar cosas de guerra de un diario hacia un foro de informática.
También de vez en cuando postea videos de cosas paranormales. Que me hacen sentir más o menos lo mismo: ¿Para qué muestra videos random? ¿por qué tengo que leer sobre eso en un foro de informática? Se lee acá:
https://foro.elhacker.net/unread.html;all
y sí entro porque quiero creer que es algo importante, revolucionario, como pareció que fue lo de la esfera de buga, aunque pasó mucho tiempo y no la abrieron, así que quedó en probable farsa, pero ese video que puso sí estuvo bueno.

Por otro lado, Elektro publicó un tema donde casi que dice haber alcanzado la iluminación, la sabiduría, y hace muchas recomendaciones pero parece decir nada, que tienes que ver los videos enteros o leer los libros para poder opinar debidamente. Para mí si alguien tiene algo importante y sabio que decir lo debería poder resumir un poco, pero bueno, no quise creer que fuera una tontería, aunque ese no resumen inspira desconfianza. Leí un resumen, el señor que recomienda cree que la vida es un videojuego, un montaje de la consciencia para evolucionar.

Ante tanta "espiritualidad" en el foro, me pregunté: ¿Esta gente ha experimentado algo paranormal alguna vez o...?
Por eso en parte hice el tema preguntando si alguna vez experimentaron algo paranormal. Y me pareció interesante. Videos probablemente hechos para lucrar, no. Tampoco me gusta asustarme al pedo.

Electro me insultó más o menos, y el tema se desvió.

Ahora, hice este tema que están leyendo porque quería preguntar cómo se supone que evite que se desvíe si me insulta y casi cualquier cosa menos decir lo que más me interesaba. Si él cree que la vida es un videojuego o no sé qué cosa aparentemente paranormal, podría explicar por qué ¿ha tenido alguna experiencia que lo induzca a creer eso? No explicó. ¿Qué debo pensar? Probablemente nada, pero ese tipo de gente me cansa. Si tienen algo importante que decir, que lo digan, sino es como una burla, no sé explicarlo, como si uno tuviese hambre (de sabiduría) y estos tipos nos intentaran hacer ver que están comiendo, pero algo probablemente falso, que probablemente ni ellos se dan cuenta, así que siento una mezcla de rabia y pena.

Más allá de eso, no sé lo que quiero, explicar algunas cosas sí.

Y bueno, no quiero que se prohíban ciertos temas en el foro, ni quiero que la gente se dedique sólo a cosas "inteligentes", pero siento que algo está mal, que no encaja, puede que sea yo, que necesite unas vacaciones de las redes sociales, o de este foro, pero como digo en Quora es muy difícil que te llegue una notificación de un video random de YT de dudosa credibilidad, de cada puñetero ataque en una guerra, o si llegan, como los mensajes espirituales crípticos, se tiene la opción de bloquear, de ignorar.

Quizá, por ejemplo, podrían hacer que los temas del foro libre no aparezcan acá:
https://foro.elhacker.net/unread.html;all
o denme un link donde no aparezcan, aunque igual me siento un poco mal, se me olvida esto: ¿Por qué no hacen algo más importante o relacionado con la Informática? Avances en la IA por ejemplo. No sé, es como que siento que está mal que alguien pierda su tiempo viendo o leyendo "estupideces", no sé, porque lo que siento cambia a veces, me olvido qué era, yo puedo pensar, en teoría, que son unos locos e ignorarlos, pero los temas me aparecen en el link, así que los veo, no puedo ignorarlos... Además a veces me da como rabia que pierdan el tiempo en "estupideces" pudiendo hacer algo mejor, aunque claro no debo obligarlos, pero me molesta ser obligado a ver esos temas.

En mi barrio hay gente durmiendo en la calle, y varios más revisan contenedores de basura, buscando sobras de comida o algo que vender. Yo no me siento tan distinto. Muy cerca se reúnen unos hinchas de políticos a charlar. ¿Debería spamearles una y otra vez lo mal que está el país? No lo hago porque hacer propaganda, joder una y otra vez con lo mismo, me parece mal.

No sé, lamento si soy el problema, demasiado intolerante, intentaré no prestar atención a temas que no sean de informática aquí y no dar importancia a lo "no importante" que hagan otros, pero sería bueno, y quizá importante, que haya una mejora en el foro como para que nos llegue lo que nos interesa, y no lo que no. ¿Qué sentido tiene que se pueda publicar cualquier cosa y que a la gente le llegue cualquier cosa aunque no quieran?

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.

Dijiste que cruzarías la acera para alejarte porque me parece paranormal lo que comenté, que te parece preocupante.
Además me diste otra definición de paranormal, como si la mía hubiera estado demasiado mal.
Y me explicaste que los niños imaginan cosas, como si yo no supiera.
Lo peor es lo 1ero, pero si sumas todo, es como que me trataste como a un idiota.

Este tema no es para debatir, si ya sabés que en este foro no se puede casi. Es para contar experiencias.

Según recuerdo te pedí un video de la lata y no lo hiciste. Acá es Invierno y no compro latas, bueno compré una de conservas, pero son pesadas. Y las botellas tienen como patitas, no sé explicarlo ¿esta imagen la puedes ver?

Yo la veo. No voy a comprar una lata para hacer un experimento en invierno cuando dices que es en verano, y no me sobra como para comprar latas, lo pequeño suele ser poco económico aquí, se compra de a 2l o más.

Me comentaste que no sabes cómo es la llave, y que los "magos" doblan cucharas a escondidas, y que a algunos se les quebraron cosas que parece imposible. No tengo mucho que decir sobre eso, conozco gente a quien se le rompió algún pedacito de llave cuando se le cayó, pero a mí lo que comenté me parece distinto. Lo que podría hacer es preguntarle a mi padre si estaba doblada o no y cómo pudo haberse doblado, pero con este tema no intento comprender los misterios del universo, ni demostrar que fue paranormal, así que no lo tengo pensado hacer, además a mi padre le molesta casi cualquier cosa que le diga, especialmente preguntas, así que prefiero no hablarle en general.

Te pedí que expliques por qué te parecen respetables las creencias de quienes mencionaste y no lo explicaste.

Yo no veo que se pueda decir mucho más de ese post.
No quisiste hacer el video, así que no insistí.
No quisiste explicar por qué son respetables las creencias "religiosas" que mencionaste, idem.
Yo no voy a andar averiguando de qué está hecha la llave, como dije este tema no es para intentar demostrar que algo es paranormal, si no lo crees está bien, no voy a intentar convencerte.

En cuanto al boomerang es más o menos lo mismo.

Tuve la esperanza de que me lo respondieras o hicieras el video. No sólo me importan los ataques.

No tengo problema en discutir pero no creo que este fuera un tema adecuado para eso. Ni la forma en que discutiste.

Bueno, a mí no me parece que haya sido creatividad e imaginación, hubo un caso en que algo había soñadp. posiblemente era más chico, esa vez grité, mis padres vinieron, luego la luz hizo un parpadeo o quizá parapedeé yo y dije "¿ven?", como si eso hubiera sido algo manipulando la eñlectricidad, pero eso no lo mencioné, porque parece claro que fue mi imaginación, lo del boomerang no. No es que yo anduviera "creando" cosas brillantes y ruidosas a esa edad, y en toda mi vida jamás vi ni escuché algo parecido. El ruido fueron 2 veces como comenté. Lo más parecido sería lo de la "anemia", pero fue bastante diferente.
Eso lo digo para que se sepa por qué lo creo, aunque no debería ser necesario. Si alguien no lo cree, está bien.