Mientras más automatizado mejor, hasta cierto punto, así que opto por la solución 2, no quiero ordenar la tabla cada vez que agregue datos, pero me diste una idea: ¿No se puede hacer un batch que busque los valores, o haga que Excel ordene esos valores de la tabla?
Doble clic es más fácil que seleccionar datos, hacer clic, esperar a que aparezca el menú...

No sabía eso de insertar una tabla en la tabla xD ¿seguro que no se ordenan automáticamente una vez lo indicas? En la imagen aparece una flechita hacia abajo.

No entiendo cómo funciona esto:
Supongo que pones la fórmula más adelante.

Idem...

Ya veo, pero ni idea cómo lo despejas.

No me funciona bien esto:
=CONTAR.SI($L$131:$L$137;">"&L132)+1

Decidí ampliar el rango, puse:
=CONTAR.SI($L$124:$L$137;">"&L125)+1

Pero supongo que no es el problema.

Te muestro:


La fila de Ataque tipo puñetazo es la 124.

Puse:
=CONTAR.SI($L$124:$L$137;">"&L125)+1
en la celda M124.
En la M125 la copié, quedó:
=CONTAR.SI($L$124:$L$137;">"&L126)+1
¿está bien que se cambie el 125?

Creo que había un error, cambié L125 por 124 y se arregló. Entiendo que la fórmula cuenta las veces que hay un valor mayor que el correspondiente a esa fila, no en la siguiente como estanba.

Ok.

¿Por qué se pone ">"&L124 en vez de >L124?

A ver, en el rango $L$124:$L$137 contar los valores si son >124. Luego sumar 1. No entiendo por qué las cosas raras...
CONTAR.SI(rango;condición para que se cuente)+1


Le pedí a GPT que explique la 2nda fórmula que pones:
(...)
CONTAR.SI.CONJUNTO($L$131:$L$137;L131;$B$131:$B$137;"<"&B131)
Aquí se manejan empates.
Cuenta cuántas filas tienen:
El mismo valor en L que L131 (empate en la métrica principal), y
Un valor en B estrictamente menor que B131.
Es decir, entre los empatados en L, cuenta cuántos “van antes” de L131 según un criterio secundario: B más pequeño.
No entiendo bien cómo es que hace eso...
CONTAR.SI.CONJUNTO(rango;valor;rango 2;condición a cumplir)
no lo capto...
La sintaxis de CONTAR.SI.CONJUNTO en español es:

CONTAR.SI.CONJUNTO(rango_criterios1; criterio1; [rango_criterios2; criterio2]; ...)

Cómo funciona:

rango_criterios1: el rango donde se evaluará el criterio1.
criterio1: la condición que deben cumplir las celdas de rango_criterios1 (puede ser un valor, una referencia, o una cadena con operadores como ">5", "<="&A1, etc.).
Puedes añadir más pares rango_criteriosN; criterioN. Excel solo contará la fila si TODAS las condiciones se cumplen simultáneamente (AND lógico, por filas).
No es “primero cuenta en el rango1 y luego en el rango2”. Más bien:

Recorre las filas en paralelo.
Para cada fila i, verifica: ¿la celda de rango_criterios1 cumple criterio1 Y la celda de rango_criterios2 cumple criterio2 Y ...?
Si sí, suma 1. Si no, no.

Aplicado a tu caso:
CONTAR.SI.CONJUNTO($L$131:$L$137; L131; $B$131:$B$137; "<"&B131)

rango_criterios1 = $L$131:$L$137
criterio1 = L131 (equivale a “igual a L131”)
rango_criterios2 = $B$131:$B$137
criterio2 = "<"&B131 (equivale a “estrictamente menor que B131”)
Cuenta cuántas filas, entre las 131–137, cumplen simultáneamente:

En la columna L: valor igual al de L131
Y en la columna B: valor menor que B131


Bien, pensé que CONJUNTO era como conjunto de datos, es más bien conjunto de condiciones que deben cumplirse.

Parece que funciona bien, pongo la tabla entera para descargar:
https://docs.google.com/spreadsheets/d/1xp_RAVCm3FwYSdTmqJWxRudvgQsqCrgQ/edit?usp=sharing&ouid=109273743447273895658&rtpof=true&sd=true

¿Podría ponerse que el 2ndo criterio en vez de orden alfabético sea órden de aparición? O sea, si está una fila antes, va antes.

Ahora no pero supongo que voy a leer más sobre fórmulas matriciales, por curiosidad.

Lo vi en varios videos de YT y no vi que en comentarios dijeran que es falso, salvo en un caso que decían que era en una ciudad y era en otra.

Me lo dijeron:

Yo hacía:
DistanciaX = Meteor._x-400+Apuntando;

y lo correcto es:
DistanciaX = Apuntando+400-Meteor._x;

Solved 

Tengo unas celdas así:

y otras así:


Quiero que en las que puse 1ero aparezca, en una lo de fondo rojo que tenga mejor promedio, y en la otra lo de fondo rojo que tenga el 2ndo mejor promedio, pudiendo ser igual, o sea, el 2ndo máximo que encuentre.

Le dije a GPT el problema:
esto
=INDICE(B131:B138; COINCIDIR(MAX(L131:L138); L131:L138; 0))
y esto
=INDICE(B131:B138; COINCIDIR(K.ESIMO.MAYOR(L131:L138;2); L131:L138; 0))
me están dando el mismo resultado, no debería ¿qué pasa?

Vean que en la 1er imagen los resultados son los mismos, pero el 2ndo debería ser Patada agachado.


Creo que entiendo el problema "por diseño, COINCIDIR(...;0) devuelve la primera aparición del valor en el rango"
pero las soluciones me parecen bastante raras, aunque le pedí una más simple ¿se les ocurre?

Básicamente es:
- Buscar 2ndo máximo valor en un rango.
- Anotar en qué celda está.
- Restar columnas a esa posición.

Pero nada tiene que ver con hackers....

Recientemente vi un video de una onlyfan que mató al novio. Parece que espiando los fiscales descubrieron que los padres de ella estaban intentando hackear la notebook o algo del asesinado para modificar los mensajes, pero como eso fue espionaje el juez no aprobó la prueba. En fin, es lo más parecido que se me viene a la mente a que hacer las cosas bien, sin hackear ni espiar, es recomendable, pero si los fiscales no hubieran espiado y el hackeo hubiera salido bien entonces la historia sería otra...

Por otro lado en YT hay un tío que postea videos donde supuestamente actúa como caza estafadores y se burla de ellos o similares. Yo no lo sé Rick...

Y por lo que tengo entendido hay muchos extrangeros ocupando ciudades enteras de Europa, así que está bravísimo el tema.

Más que un programador necesitas un hacker o experto en seguridad informática. Un programador es algo más general, como si dijeras médico general, no es experto en ojos, ni en pulmones, etc. Un programador, en general, tampoco es experto en averiguar direcciones de gente.
También podría ser un detective privado, él capaz que conoce a gente que sepa.

Pero dudo que te sirva de mucho conseguir su dirección...

+1.

Estás viendo un video, quieres que no te aparezcan más de ese canal.

Si te aparecen en la lista de recomendados, puedes hacer clic en los 3 puntitos y poner la opción ahí.

¿Y si no te aparecen? ¿si sólo viste 1? No sé... Cuando te aparezcan de nuevo los bloqueas, tendrás que hacer una lista de los que quieres bloquear o memorizarlos, pero parece medio tedioso...

Otro método es que cuando vas a ver un video de un canal sospechosamente malo, lo abras en una nueva pestaña, así tienes en la otra el video en la lista y la opción de bloquearlo, pero esto tampoco está bueno, porque en mi caso se pone lento, y si pasa mucho tiempo la pestaña anterior se recarga, los recomendados cambian y ya no puedo bloquearlo. Además no todos los videos son sospechosamente malos, yo que sé, uno me dice "A sus 90 años, X revela lo que le pasó en..." y luego es el youtuber contando la biografía de esa persona, no habla la persona que crei que iba a hablar (parece) y tiene más relleno que Naruto, yo que iba a saber.

¿No se puede entrar al jodido canal y poner ahí no recomendarmelo? Que yo sepa no...

¿Habrá algún código que se le pueda enviar a YT? ¿algún javascript? ¿o sí hay una forma fácil de bloquear que no conozco?

Flamer:
Hice lo que dijiste, puse
1111111011111110111111101111111011111110111111101111111000000000
y el resultado fue
18374403900871474688

pero al hacerlo aquí:
https://masterplc.com/calculadora/convertir-binario-a-decimal/
fue
18374403900871475000

Y GPT dijo
18,446,744,066,181,791,744

Yo no sé


Ahora en un rato voy a hablar con él sobre el código que me dió porque no lo entendí. Luego actualizo.

Edit: Hablado hasta que me quedé sin puntos.

Resumen:
qué significa Saltar ceros líderes

explica esto
  while (i < n && bin.charAt(i) == "0") { i++; }
  if (i >= n) return "0";

no sé si el while ha terminado, etc. Lo veo así:
while (i < n && bin.charAt(i) == "0") {
   i++;
}
if (i >= n) return "0";
y sigue ¿es así?


cambié los i por NroDeCaracteraMirar:
(código)
¿tengo que cambiar los siguientes i o son independientes? Este:
  for (; i < n; i++) {


la variable n es el largo del binario, siempre?


var para qué es, qué diferencia hay entre definir una variable con var y sin var


No sabía o me había olvidado, a veces creaba variables y luego las eliminaba, de esta forma se eliminan solas.

cómo este if no tiene el { ?
  if (NroDeCaracteraMirar >= LargoDelBinario) return "0";
normalmente se pone
si (condición) {
   efecto


¿es posible que NroDeCaracteraMirar quede mayor que LargoDelBinario?
  // Ignorar ceros al inicio del binario:
  var NroDeCaracteraMirar = 0;
  var LargoDelBinario = bin.length;
  // Para eso mira caracteres desde la izquierda hasta que no haya caracteres o hasta que no sea 0:
  while (NroDeCaracteraMirar < LargoDelBinario && bin.charAt(NroDeCaracteraMirar) == "0") {
    NroDeCaracteraMirar++;
  }
  if (NroDeCaracteraMirar >= LargoDelBinario) {
   return "0";
  }

el incremento de NroDeCaracteraMirar ocurre sólo si es menor que LargoDelBinario, por lo que en cierto punto quedará igual y luego ya no aumentará, por lo tanto NroDeCaracteraMirar nunca será mayor que LargoDelBinario ¿correcto?


Código más claro (aún falta aclararlo más):

// Convierte un string binario (p.ej. "1101") a string decimal exacto (p.ej. "13")
// No usa Number para representar el valor completo, solo dígitos individuales.
function binToDecString(bin) {
  // Ignorar ceros al inicio del binario:
  var NroDeCaracteraMirar = 0;
  var LargoDelBinario = bin.length;
  // Para eso mira caracteres desde la izquierda hasta que no haya caracteres o hasta que no sea 0:
  while (NroDeCaracteraMirar < LargoDelBinario && bin.charAt(NroDeCaracteraMirar) == "0") {
    NroDeCaracteraMirar++;
  }
  // Si miró todos los caracteres:
  if (NroDeCaracteraMirar == LargoDelBinario) {
	return "0";
  }
 
  // digits almacena el número decimal en dígitos base 10, LSB primero (digits[0] es las unidades)
  var digits = [0];
 
  // Recorremos desde el primer '1' encontrado
  for (; NroDeCaracteraMirar < LargoDelBinario; NroDeCaracteraMirar++) {
    var c = bin.charAt(NroDeCaracteraMirar);
    if (c != "0" && c != "1") {
      continue; // o maneja error si prefieres
    }
 
    // decimal *= 2
    var carry = 0;
    var j;
    for (j = 0; j < digits.length; j++) {
      var x = digits[j] * 2 + carry;
      digits[j] = x % 10;
      carry = Math.floor(x / 10);
    }
    while (carry > 0) {
      digits[digits.length] = carry % 10;
      carry = Math.floor(carry / 10);
    }
 
    // decimal += bit
    if (c == "1") {
      var k = 0;
      var add = 1;
      while (add > 0) {
        if (k >= digits.length) digits[digits.length] = 0;
        var y = digits[k] + add;
        digits[k] = y % 10;
        add = Math.floor(y / 10);
        k++;
      }
    }
  }
 
  // Construir string (invertir los dígitos)
  var s = "";
  for (var t = digits.length - 1; t >= 0; t--) {
    s += digits[t];
  }
  return s;
}

EdePC te respondo otro día porque por hoy este tema me cansó/aburrió, pero a simple vista, sí, voy a tener que poner que el programa opere así, pero eso es un problema a resolver más adelante.

Se refiere al 3 en raya pero con la configuración que se ponga: En vez de 3 puede ser otro número y en vez de un tablero de 3*3 puede ser otro número independiente del anterior. Lo pensé para tableros cuadrados, pero quizá funcione para rectangulares. De momento está configurado para revisar sólo rayas horizontales, pero basta quitar un par de rayas // para que revise todas las posibilidades, es sólo que para pruebas me pareció mejor así.
Aún no lo probé, acabo de terminarlo, llevo bastante tiempo con esto... Disfrútenlo, analícenlo si quieren a ver qué tal:

// Signos en línea en tableros cuadrados:
// Este programa tiene básicamente 3 etapas,
// que se pueden resumir así:
// Nota: La situación inicial, en que hay 0 signos colocados,
// estará guardada en la lista nro 0.      
// 1:
// Probar acciones en cada situación de la lista nro 0,
// guardando en una nueva lista las nuevas situaciones (que no...
// sean victoria ni empate). Repetir con cada nueva lista hasta...
// la que tenga situaciones en que sólo 1 acción es posible
// (por ejemplo en el 3 en línea es la 8).
// 2:
// Probar acciones en cada situación de la última lista,
// guardando datos sobre las consecuencias (victoria o empate)
// de realizar la única acción posible.
// 3:
// En las situaciones no resueltas, empezando por las...
// penúltimas listas, probar las acciones.
// Guardar cuántas acciones causan victoria de uno, de otro y...
// de empate. Averiguar la mejor acción en cada situación,
// basado en el mejor resultado seguro que causa (asumiendo...
// que el rival juega bien), y en 2nda instancia el más probable
// (asumiendo que el rival juegue al azar).
// Repetir hasta resolver la lista 0.
JuntosRequeridos = 2;
CasillerosPorFila = 2;
// Contando desde 0:
MaxColumna = CasillerosPorFila-1;
Casilleros = CasillerosPorFila*CasillerosPorFila;
// Están numerados así:
// 0 1
// 2 3
MaxCasillero = Casilleros-1;
// En las listas L_SaE se irán poniendo las situaciones a...
// experimentar que tengan _ signos colocados.
// En la lista 0 se agregará una situación:
L0SaE1 = [];
// A continuación se especifica cual, agregando v
// (que significa vacío) en lo que serían los casilleros,
// los elementos del array:
ValoraAgregar = -1;
do {
	ValoraAgregar++;
	L0SaE1.push("v");
} while (ValoraAgregar < MaxCasillero);
delete ValoraAgregar;
// Los datos de las situaciones no están en las listas,
// se crean aparte. Con esta variable se evita repetidamente...
// convertir en texto y concatenar:
S_ = "S"+(L0SaE1.join(""));
// Datos de la situación:
// Usada para fácilmente saber de qué signo es turno:
set (S_+"Turno", "X");
// En otros casos usada para evitar probar acciones...
// innecesarias y con LastAPosible para saber si sólo queda 1:
set (S_+"FirstAPosible", 0);
set (S_+"LastAPosible", MaxCasillero);
NroDeListaRevisandose = -1;
// Última lista que se revisará en la etapa 1:
// LastListaDeEt1 = Casilleros;
// /////////////////////////////////////////////
// /////////////////  Etapa 1  /////////////////
// /////////////////////////////////////////////
// Consiste en llegar a nuevas situaciones y guardarlas,
// si no son victoria. Termina antes de que pueda haber empates.
//
// Usada a continuación y durante la etapa 1 (Et1)...
// cuando no hay más situaciones en la lista revisándose:
function BuscarOtraListaEt1 () {
	trace("Ejecutando BuscarOtraListaEt1");
	NroDeListaRevisandose++;
	PrepararUsoDeLista();
	PrepararSaE();
	// Si las situaciones de la lista tienen más de 1 opción:
	if (NroDeListaRevisandose < MaxCasillero) {
		// Para evitar concatenar cosas al guardar datos de situaciones nuevas:
		NextL_SaE = "L"+(NroDeListaRevisandose+1)+"SaE";
		trace("NextL_SaE: "+NextL_SaE);
		// Usado en EvaluarConocimientoSobreSEt1 para...
		// nombrar las situaciones nuevas que se logren:
		SituacionesNuevas = 0;
	} else {
		trace(	"La lista actual tiene situaciones de sólo 1 opción; inicia la etapa 2.");
		// Iniciar Etapa 2:
		gotoAndStop(3);
	}
}
BuscarOtraListaEt1();
// Usada cuando se cambia de lista, en BuscarOtraListaEt1,
// al comenzar Et2 y en Et3:
function PrepararUsoDeLista () {
	trace("Ejecutando PrepararUsoDeLista");
	// Para evitar concatenar repetidamente:
	L_SaE = "L"+NroDeListaRevisandose+"SaE";
	trace("L_SaE: "+L_SaE);
	NroDeSExperimentandose = 1;
	// También para evitar concatenar repetidamente:
	// L_SaE_ = L_SaE+NroDeSExperimentandose;
	L_SaE_ = L_SaE+"1";
	trace("L_SaE_: "+L_SaE_);
	trace("Comienzan experimentos en una nueva lista, la "+NroDeListaRevisandose);
}
// Usada cuando se elige una SaE, en BuscarOtraListaEt1,
// BuscarOtraSituacionEt1, BuscarOtraSituacionEt2 y PrepararSaEEt3:
function PrepararSaE () {
	trace("Ejecutando PrepararSaE");
	trace("Se inician experimentos en otra situación de la lista, la nro "+NroDeSExperimentandose);
	SituacionBase = eval(L_SaE_).slice();
	S_ = "S"+(SituacionBase.join(""));
	Turno = eval(S_+"Turno");
	FirstActionPosible = eval(S_+"FirstAPosible");
	LastActionPosible = eval(S_+"LastAPosible");
	Action = FirstActionPosible;
}
// Usada en frame 2 (o etapa 1) repetidamente:
function ResetearSituacionEt1 () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	EvaluarAplicabilidadEt1();
}
// Usada luego de que cambia la SaE y/o la acción, en Et1:
function EvaluarAplicabilidadEt1 () {
	trace("Ejecutando EvaluarAplicabilidadEt1");
	if (Situacion[Action] == "v") {
		trace("La acción "+Action+" es realizable.");
		AplicarAccionEt1();
	} else {
		trace("La acción "+Action+" no es realizable.");
		SinResetBuscarOtraAccionEt1();
	}
}
// Usada luego de EvaluarAplicabilidadEt1,
// si una acción es realizable:
function AplicarAccionEt1 () {
	trace("Ejecutando AplicarAccionEt1");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	if (Win == "No") {
		EvaluarConocimientoSobreSEt1();
	}
	// ¿Queda alguna acción sin probar en la situación?
	BuscarOtraAccionEt1();
}
// Usada en EvaluarAplicabilidadEt1 cuando una acción no es...
// realizable:
function SinResetBuscarOtraAccionEt1 () {
	trace("Ejecutando SinResetBuscarOtraAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		EvaluarAplicabilidadEt1();
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada luego de AplicarAccionEt1:
function BuscarOtraAccionEt1 () {
	trace("Ejecutando BuscarOtraAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará ResetearSituacionEt1.
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada en AplicarAccionEt1 cuando no hay victoria (ni empate,
// aunque por ahora no ocurren):
function EvaluarConocimientoSobreSEt1 () {
	trace("Ejecutando EvaluarConocimientoSobreSEt1");
	// Estas 3 variables son para evitar reconcatenar:
	SituacionJoined = Situacion.join("");
	NewS_ = "S"+SituacionJoined;
	NewS_BestAction = NewS_+"BestAction";
	// ¿Se ha llegado antes a la situación?
	if (eval(NewS_BestAction) == undefined) {
		// No, anotar que debe investigarse:
		SituacionesNuevas++; 
		// Copiar array (porque no se puede normalmente):
		trace("Situación a copiar a "+NextL_SaE+SituacionesNuevas+" es "+Situacion);
		set (NextL_SaE+SituacionesNuevas, Situacion.slice());
		trace("Esa situación no está anotada; se anota como nro "+SituacionesNuevas);
		set(NewS_BestAction, "Desconocida");
		if (Turno == "X") {
			set (NewS_+"Turno", "0");
		} else {
			set (NewS_+"Turno", "X");
		}
		// Averiguar cual es su 1er acción posible:
		AccionRevisandose = -1;
		do {
			AccionRevisandose++;
			if (Situacion[AccionRevisandose] == "v") {
				set (NewS_+"FirstAPosible", AccionRevisandose);
				break;
			}
		} while (true);
		// Averiguar cual es su última acción posible:
		AccionRevisandose = Casilleros;
		do {
			AccionRevisandose--;
			if (Situacion[AccionRevisandose] == "v") {
				set (NewS_+"LastAPosible", AccionRevisandose);
				break;
			}
		} while (true);
	}
}
// Usada en BuscarOtraAccionEt1 cuando no hay más acciones posibles,
// y en SinResetBuscarOtraAccionEt1:
function BuscarOtraSituacionEt1 () {
	trace("Ejecutando BuscarOtraSituacionEt1");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaE();
	} else {
		trace("No hay más situaciones a experimentar en la lista actual, se mirará otra.");
		BuscarOtraListaEt1();
	}
}
// /////////////////////////////////////////////
// /////////////////  Etapa 2  /////////////////
// /////////////////////////////////////////////
// Consiste en guardar el resultado de las situaciones en que...
// sólo 1 acción es posible. Puede ser victoria o empate.
//
// Usada en frame 3 (o etapa 2) repetidamente:
function ResetearSituacionEt2 () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	AplicarAccionEt2();
}
// Usada luego de ResetearSituacionEt2, parece innecesario que sea función:
function AplicarAccionEt2 () {
	trace("Ejecutando AplicarAccionEt2");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	set(S_+"BestAction", Action);
	if (Win == "Sí") {
		trace("Victoria conseguida, guardando datos.");
		if (Turno == "X") {
			// Estas son las chances de que gane...
			// X, 0 o que haya empate:
			set(S_+"VictoriasDeX", 1);
			set(S_+"VictoriasDe0", 0);
			set(S_+"ResultadoEsperado", "X");
		} else {
			set(S_+"VictoriasDeX", 0);
			set(S_+"VictoriasDe0", 1);
			set(S_+"ResultadoEsperado", "0");
		}
		set(S_+"DistanciaaGanar", 1);
		set(S_+"Empates", 0);
	} else {
		trace("Empate conseguido, guardando datos.");
		set(S_+"VictoriasDeX", 0);
		set(S_+"VictoriasDe0", 0);
		set(S_+"Empates", 1);
		set(S_+"ResultadoEsperado", "E");
	}
	// ¿Queda alguna situación en la lista experimentándose?
	BuscarOtraSituacionEt2();
}
// Usada luego de AplicarAccionEt2, parece innecesario que sea función:
function BuscarOtraSituacionEt2 () {
	trace("Ejecutando BuscarOtraSituacionEt2");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaE();
	} else {
		trace("No hay más situaciones a experimentar en la lista actual, inicia la etapa 3.");
		BuscarOtraListaEt3();
		gotoAndStop(4);
	}
}
// /////////////////////////////////////////////
// /////////////////  Etapa 3  /////////////////
// /////////////////////////////////////////////
// Consiste en guardar los resultados de las acciones en...
// situaciones en que más de 1 acción es posible.
// Particularmente se guarda la mejor acción.
// El resultado de las acciones puede ser victoria,
// una situación con posibles resultados,
// y en la penúltima lista una situación con un único posible...
// resultado.
//
// Usada antes y durante esta etapa...
// cuando no hay más situaciones en la lista revisándose:
function BuscarOtraListaEt3 () {
	trace("Ejecutando BuscarOtraListaEt3");
	NroDeListaRevisandose--;
	if (NroDeListaRevisandose > -1) {
		// Si se halla una lista:
		PrepararUsoDeLista();
		PrepararSaEEt3();
	} else {
		trace("No hay más listas a revisar; programa terminado.");
		// En este frame nada hay, es sólo para mostrar el mensaje:
		gotoAndStop(5);
	}
}
// Casi como PrepararSaE. Usada cuando se elige una SaE,
// en BuscarOtraListaEt3 y BuscarOtraSituacionEt3:
function PrepararSaEEt3 () {
	trace("Ejecutando PrepararSaEEt3");
	PrepararSaE();
	// Para evitar evals y concatenaciones repetidamente:
	BestAction = "";
	VictoriasDeX = 0;
	VictoriasDe0 = 0;
	Empates = 0;
	// Establecer que hasta ahora los resultados hallados...
	// son peores que lo posible, para que se sustituyan por...
	// cualquier acción:
	if (Turno == "X") {
		// La E antes de Obtenido es Esperado:
		BestResultadoEObtenido = "0";
	} else {
		BestResultadoEObtenido = "X";
	}
	// Si 2 acciones causan victoria segura,
	// esto sirve para elegir la mejor de ellas:
	BestDistanciaaGanar = Casilleros;
	// Si 2 acciones causan empate seguro,
	// esto sirve para elegir la mejor de ellas:
	BestChanceDeGanarEnE = -1;
	BestChanceDeEmpatarEnE = -1;
	// Si 2 acciones causan derrota segura,
	// esto sirve para elegir la mejor de ellas:
	LowestChanceDePerderEnD = -1;
	BestChanceDeGanarEnD = -1;
}
// Usada en frame 4 (o etapa 3) repetidamente:
function ResetearSituacionEt3 () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	EvaluarAplicabilidadEt3();
}
// Usada luego de que cambia la SaE y/o la acción, en Et3:
function EvaluarAplicabilidadEt3 () {
	trace("Ejecutando EvaluarAplicabilidadEt3");
	if (Situacion[Action] == "v") {
		trace("La acción "+Action+" es realizable.");
		AplicarAccionEt3();
	} else {
		trace("La acción "+Action+" no es realizable.");
		SinResetBuscarOtraAccionEt3();
	}
}
// Usada luego de EvaluarAplicabilidadEt3,
// si una acción es realizable:
function AplicarAccionEt3 () {
	// Los datos se guardarán bien en GuardarDatosEt3.
	// Por ahora varios se están guardando en variables más simples de nombrar.
	// Además algunos no se pueden guardar aún (VictoriasDeX, NewVictoriasDe0...).
	// Y DistanciaaGanar se está guardando como -1 de lo que debe, para no tener que estar sumando.
	trace("Ejecutando AplicarAccionEt3");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	if (Win == "No") {
		// Agregar los posibles resultados de la...
		// situación obtenida:
		// Estas 5 variables son para evitar reconcatenar:
		SituacionJoined = Situacion.join("");
		NewS_ = "S"+SituacionJoined;
		NewVictoriasDeX = eval(NewS_+"VictoriasDeX");
		NewVictoriasDe0 = eval(NewS_+"VictoriasDe0");
		NewEmpates = eval(NewS_+"Empates");
		VictoriasDeX = VictoriasDeX+NewVictoriasDeX;
		VictoriasDe0 = VictoriasDe0+NewVictoriasDe0;
		Empates = Empates+NewEmpates;
		// Si en la SaE ya se halló una acción que...
		// causa victoria segura: 
		if (BestResultadoEObtenido == Turn) {
			// Si la acción recién usada también causa eso:
			if (eval(NewS_+"ResultadoEsperado") == Turn) {
				// Si dicha acción la causa faster:
				if (eval(NewS_+"DistanciaaGanar") < BestDistanciaaGanar) {
					// Sustituir datos:
					BestDistanciaaGanar = eval(NewS_+"DistanciaaGanar");
					BestAction = Action;
				}
				// SINO SI LA CAUSA IGUAL DE RÁPIDO HABRÍA QUE AVERIGUAR CHANCES, pero se gana igual...
				// sino dicha acción es peor, no prestarle más atención.
			}
			// idem.
		// sino si el mejor resultado esperado hallado...
		// en esta SaE es empate:
		} else if (BestResultadoEObtenido == "E") {
			// Si la acción recién usada causa que...
			// el resultado esperado sea victoria:
			if (eval(NewS_+"ResultadoEsperado") == Turn) {
				// Sustituir datos:
				BestResultadoEObtenido = Turn;
				BestDistanciaaGanar = eval(NewS_+"DistanciaaGanar");
				BestAction = Action;
			// sino si es empate:
			} else if (eval(NewS_+"ResultadoEsperado") == "E") {
				// Averiguar chance de victoria:
				Posibilidades = NewVictoriasDeX+NewVictoriasDe0+NewEmpates;
				ChanceDeGanar = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
				// Si es mejor que la hallada antes:
				if (ChanceDeGanar > BestChanceDeGanarEnE) {
					// Sustituir datos:
					BestChanceDeGanarEnE = ChanceDeGanar;
					BestChanceDeEmpatarEnE = NewEmpates*100/Posibilidades;
					BestAction = Action;
				// sino si la chance es igual:
				} else if (ChanceDeGanar == BestChanceDeGanarEnE) {
					// Averiguar chance de empate:
					ChanceDeEmpatar = NewEmpates*100/Posibilidades;
					// Si es mejor que la hallada antes:
					if (ChanceDeEmpatar > BestChanceDeEmpatarEnE) {
						// Sustituir datos:
						BestChanceDeGanarEnE = ChanceDeGanar;
						BestChanceDeEmpatarEnE = ChanceDeEmpatar;
						BestAction = Action;
					}
				}
				// SINO SI LAS CHANCES SON LAS MISMAS HABRÍA QUE DECIDIR SI SE PREFIERE LA QUE LO CAUSA MÁS RÁPIDO O NO.
				// sino dicha acción no es mejor, no prestarle más atención.
			// idem.
			}
		// El resultado esperado es derrota:
		} else {
			// Si la acción recién usada causa que...
			// el resultado esperado sea victoria:
			if (eval(NewS_+"ResultadoEsperado") == Turn) {
				// Sustituir datos:
				BestResultadoEObtenido = Turn;
				BestDistanciaaGanar = eval(NewS_+"DistanciaaGanar");
				BestAction = Action;
			// sino si es empate:
			} else if (eval(NewS_+"ResultadoEsperado") == "E") {
 				// Averiguar chances y sustituir datos:
				Posibilidades = NewVictoriasDeX+NewVictoriasDe0+NewEmpates;
				BestChanceDeGanarEnE = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
				BestChanceDeEmpatarEnE = NewEmpatesDeX*100/Posibilidades;
				BestResultadoEObtenido = "E";
				BestAction = Action;
			// sino es derrota:
			} else {
				// Averiguar chance de perder:
				Posibilidades = NewVictoriasDeX+NewVictoriasDe0+NewEmpates;
				ChanceDePerder = (Posibilidades-eval("NewVictoriasDe"+Turno)*100/Posibilidades;
				// Si es más baja (mejor) que la hallada antes:
				if (ChanceDePerder < LowestChanceDePerderEnD) {
					// Sustituir datos:
					LowestChanceDePerderEnD = ChanceDePerder;
					BestChanceDeGanarEnD = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
					BestAction = Action;
				// sino si la chance es igual:
				} else if (ChanceDePerder == LowestChanceDePerderEnD) {
					// Averiguar chance de victoria:
					ChanceDeGanar = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
					// Si es mejor que la hallada antes:
					if (ChanceDeGanar > BestChanceDeGanarEnD) {
						// Sustituir datos:
						LowestChanceDePerderEnD = ChanceDePerder;
						BestChanceDeGanarEnD = ChanceDeGanar;
						BestAction = Action;
					}
				}
			}
		}
	// sino la acción causa una victoria inmediata:
	} else {
		// Incrementar victorias:
		// Esta es para evitar reconcatenar:
		VariableaIncrementar = "VictoriasDe"+Turno;
		set (VariableaIncrementar, eval(VariableaIncrementar)+1);
		if (BestDistanciaaGanar > 0) {
			// Sustituir datos:
			BestResultadoEObtenido = Turn;
			BestDistanciaaGanar = 0;
			BestAction = Action;
		}
	}
	// ¿Queda alguna acción sin probar en la situación?
	BuscarOtraAccionEt3();
}
// Usada en EvaluarAplicabilidadEt3 cuando una acción no es...
// realizable:
function SinResetBuscarOtraAccionEt3 () {
	trace("Ejecutando SinResetBuscarOtraAccionEt3");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		EvaluarAplicabilidadEt3();
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt3();
	}
}
// Usada luego de AplicarAccionEt3:
function BuscarOtraAccionEt3 () {
	trace("Ejecutando BuscarOtraAccionEt3");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará ResetearSituacionEt3.
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt3();
	}
}
// Usada cuando no hay más acciones posibles:
function GuardarDatosEt3 () {
	trace("Ejecutando GuardarDatosEt3");
	set(S_+"VictoriasDeX", VictoriasDeX);
	set(S_+"VictoriasDe0", VictoriasDe0);
	set(S_+"Empates", Empates);
	set(S_+"BestAction", BestAction);
	set(S_+"DistanciaaGanar", BestDistanciaaGanar+1);
	set(S_+"ResultadoEsperado", BestResultadoEObtenido);
}
// Usada en BuscarOtraAccionEt3 cuando no hay más acciones posibles,
// y en SinResetBuscarOtraAccionEt3:
function BuscarOtraSituacionEt3 () {
	trace("Ejecutando BuscarOtraSituacionEt3");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaEEt3();
	} else {
		trace("No hay más situaciones a experimentar en la lista actual, se mirará otra.");
		BuscarOtraListaEt3();
	}
}
// /////////////////////////////////////////////
// /////////////////  Chequeos  ////////////////
// /////////////////////////////////////////////
// Usada en ChequeoHorizontal y requerida en otros casos:
function ObtenerColumnayFilaDelMarcado () {
	FilaDelMarcado = Math.floor(Action/CasillerosPorFila);
	ColumnaDelMarcado = Action%CasillerosPorFila;
}
function ChequearVertical () {
	// trace ("Ejecutando ChequearVertical");
	// 
	// SOLO FUNCIONA SI CasillerosPorFila >= JuntosRequeridos.
	// 
	// Se revisará la vertical. Desde el casillero más arriba...
	// que pueda estar incluído en la línea,
	// hasta el casillero marcado. Si se halla alguno que no...
	// tenga la marca requerida, se repite el proceso mirando...
	// desde uno más abajo del fallado, y mirando ahora hasta...
	// más abajo, según corresponda:
	Desde = Action-CasillerosPorFila*(JuntosRequeridos-1);
	// Mientras el casillero no exista:
	while (Desde<0) {
		// trace ("Desde es "+Desde+", se aumentará");
		// Indicar que se empiece a mirar desde más abajo:
		Desde = Desde+CasillerosPorFila;
	}
	do {
		Hasta = Desde+CasillerosPorFila*(JuntosRequeridos-1);
		if (Hasta>MaxCasillero) {
			// Para ganar se necesitaría más casilleros hacia...
			// abajo de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos abajo");
			break;
		}
		Puntero = Desde;
		// trace ("Comenzando chequeo desde "+Desde+" hasta "+Hasta);
		// Puede cambiar:
		Win = "Sí";
		do {
			// trace ("Chequando el casillero "+Puntero);
			if (Situacion[Action] != Situacion[Puntero]) {
				Win = "No";
				Desde = Puntero+CasillerosPorFila;
				break;
			}
			Puntero = Puntero+CasillerosPorFila;
		} while (Puntero<=Hasta);
	} while (Desde<=Action && Win == "No");
	if (Win == "No") {
		// ChequearHorizontal();
	}
}
function ChequearHorizontal () {
	// trace ("Ejecutando ChequearHorizontal");
	// Es similar al chequeo vertical, pero aquí no sirve...
	// sumar o restar a un puntero que marque el casillero...
	// porque puede existir ese casillero pero no estar en...
	// un costado. En vez de eso, se obtiene su columna y...
	// fila, se modifica la columna si es posible,
	// y se calcula cual es el casillero a mirar:
	ObtenerColumnayFilaDelMarcado();
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// Para que no mire cuadraditos inexistentes en la izq:
	if (DesdeColumna<0) {
		DesdeColumna = 0;
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		Puntero = DesdeColumna;
		// trace ("Comenzando chequeo desde "+DesdeColumna+" hasta "+HastaColumna);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = FilaDelMarcado*CasillerosPorFila+Puntero;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = Puntero+1;
				break;
			}
			Puntero++;
		} while (Puntero<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	if (Win == "No") {
		ChequearDesdeUpIzq();
	}
}
// La diagonal así \
function ChequearDesdeUpIzq () {
	// trace ("Ejecutando ChequearDesdeUpIzq");
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeColumna: "+DesdeColumna);
	DesdeFila = FilaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeFila: "+DesdeFila);
	// Para que no mire cuadraditos inexistentes:
	if (DesdeColumna<DesdeFila) {
		Sumar = DesdeColumna;
	} else {
		Sumar = DesdeFila;
	}
	// trace("Sumar: "+Sumar);
	if (Sumar<0) {
		// trace("Sumando.");
		DesdeColumna = DesdeColumna-Sumar;
		// trace("DesdeColumna: "+DesdeColumna);
		DesdeFila = DesdeFila-Sumar;
		// trace("DesdeFila: "+DesdeFila);
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		HastaFila = DesdeFila+JuntosRequeridos-1;
		// Sirve usar MaxColumna en vez de crear MaxFila...
		// porque como el tablero es cuadrado serían iguales:
		if (HastaFila>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// abajo de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos abajo");
			break;
		}
		PunteroDeColumna = DesdeColumna;
		PunteroDeFila = DesdeFila;
		// trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
		// trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = PunteroDeColumna+1;
				DesdeFila = PunteroDeFila+1;
				break;
			}
			PunteroDeColumna++;
			PunteroDeFila++;
		} while (PunteroDeColumna<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	if (Win == "No") {
		ChequearDesdeDownIzq();
	}
}
// La diagonal así /
function ChequearDesdeDownIzq () {
	// trace ("Ejecutando ChequearDesdeDownIzq");
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeColumna: "+DesdeColumna);
	DesdeFila = FilaDelMarcado+JuntosRequeridos-1;
	// trace("DesdeFila: "+DesdeFila);
	// Para que no mire cuadraditos inexistentes:
	ColumnasInexistentes = 0;
	if (DesdeColumna<0) {
		ColumnasInexistentes = DesdeColumna*-1;
	}
	FilasInexistentes = 0;
	// Está bien usar MaxColumna porque MaxFila sería igual:
	if (DesdeFila>MaxColumna) {
		FilasInexistentes = DesdeFila-MaxColumna;
	}
	if (ColumnasInexistentes>=FilasInexistentes) {
		Ajuste = ColumnasInexistentes;
	} else {
		Ajuste = FilasInexistentes;
	}
	// trace("Ajuste: "+Ajuste);
	if (Ajuste>0) {
		// trace("Ajustando.");
		DesdeColumna = DesdeColumna+Ajuste;
		// trace("DesdeColumna: "+DesdeColumna);
		DesdeFila = DesdeFila-Ajuste;
		// trace("DesdeFila: "+DesdeFila);
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		HastaFila = DesdeFila-JuntosRequeridos+1;
		if (HastaFila<0) {
			// Para ganar se necesitaría más casilleros hacia...
			// arriba de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos arriba");
			break;
		}
		PunteroDeColumna = DesdeColumna;
		PunteroDeFila = DesdeFila;
		// trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
		// trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = PunteroDeColumna+1;
				DesdeFila = PunteroDeFila-1;
				break;
			}
			PunteroDeColumna++;
			PunteroDeFila--;
		} while (PunteroDeColumna<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	// trace("Win: "+Win);
}

El 1ero se usa como sinónimo de "encuentra".

El 2ndo es como un pasado de haber.

https://www.rae.es/duda-linguistica/es-haya-o-haya

Hasta el nombre del link se cambia