// Signos en línea en tablero de Lado*Lado:
// Este programa tiene básicamente 2 etapas,
// que se pueden resumir así:
// 1:
// Desde la situación inicial probar las acciones,
// guardando las situaciones nuevas,
// y probando acciones en ellas también.
// Guardar las situación-acción que causan una victoria,
// y las que causan un empate. Es el RE de esa situación,
// resultado esperado (porque en otros casos es el que...
// se espera o supone si el rival juega bien).
// 2:		ACTUALIZAR ESTA
// En las situaciones no resueltas, probar las acciones.
// Si las consecuencias tienen RE, anotar cuantas de ellas...
// son victoria de X, 0 o empate y anotar la acción que...
// cause la RE más favorable, considerando secundariamente...
// las cantidades.
//
JuntosRequeridos = 2;
CasillerosPorFila = 2;
// Contando desde 0:
MaxColumna = CasillerosPorFila-1;
// Los casilleros están numerados así:
// 0 1 2
// 3 4 5
// 6 7 8
Casilleros = CasillerosPorFila*CasillerosPorFila;
MaxCasillero = Casilleros-1;
// Uso arrays porque es más fácil así modificar partes...
// de los valores de variables (los casilleros):
// Situación a experimentar nro 1, signo en los casilleros
// (a este array se le agregarán valores):
SaE1 = [];
ValoraAgregar = -1;
do {
	ValoraAgregar++;
	// v significa vacío
	SaE1.push("v");
	// trace("ValoraAgregar es "+ValoraAgregar);
} while (ValoraAgregar < MaxCasillero);
delete (ValoraAgregar);
// Situaciones a experimentar (cuántas son):
SaE = 1;
NroDeSExperimentandose = 0;
NoEvaluedSaE = "SaE1";
SaEEvaluedyJoined = "S"+(eval(NoEvaluedSaE).join(""));
// Usada para fácilmente saber de qué signo es turno:
set (SaEEvaluedyJoined+"Turno", "X");
// Con LastAPosible, usada para evitar probar...
// acciones innecesarias y saber si sólo queda 1:
set (SaEEvaluedyJoined+"FirstAPosible", 0);
set (SaEEvaluedyJoined+"LastAPosible", MaxCasillero);
// Usada a continuación y en varios casos:
function PrepararExperimentosEnOtraS () {
	// trace("Ejecutando PrepararExperimentosEnOtraS");
	NroDeSExperimentandose++;
	trace("Se inician experimentos en otra situación, la anotada nro "+NroDeSExperimentandose);
	// Usada para evitar concatenar repetidamente:
	NoEvaluedSaE = "SaE"+NroDeSExperimentandose;
	SituacionBase = eval(NoEvaluedSaE);
	SaEEvaluedyJoined = "S"+(SituacionBase.join(""));
	Turno = eval(SaEEvaluedyJoined+"Turno");
	FirstActionPosible = eval(SaEEvaluedyJoined+"FirstAPosible");
	LastActionPosible = eval(SaEEvaluedyJoined+"LastAPosible");
	Action = FirstActionPosible;
}
PrepararExperimentosEnOtraS();
// Usada en frame 2 repetidamente:
function BuscarBuenasSituacionesEt1 () {
	// 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:
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.");
		BuscarAccionEt1();
	}
}
// 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 == "Sí") {
		// Sí, crear datos sobre eso:
		// trace("Ganó, ahora se sabe que en la situación "+SituacionBase+" se gana usando la acción "+Action);
		set (SaEEvaluedyJoined+"BestAction", Action);
		set (SaEEvaluedyJoined+"RE", Turno);
		// Se borra la situación de la lista a experimentar,
		// pues ya se halló la mejor acción en ella:
		BorrarSaE();
		BuscarOtraSituacionEt1();
	} else if (FirstActionPosible == LastActionPosible) {
		// sino si es empate (no hay más acciones posibles):
		// Parecido, crear datos sobre eso:
		// trace("Empató, ahora se sabe que en la situación "+SituacionBase+" se empata usando la acción "+Action);
		// (y es la mejor acción porque no hay otra)
		set (SaEEvaluedyJoined+"BestAction", Action);
		set (SaEEvaluedyJoined+"RE", "Empate");
		// Se borra la situación de la lista a experimentar,
		// pues ya se halló la mejor acción en ella:
		BorrarSaE();
		BuscarOtraSituacionEt1();
	} else {
		EvaluarConocimientoSobreSEt1();
		// ¿Queda alguna acción sin probar...
		// en la situación?
		BuscarAccionEt1();
	}
}
// Usada luego de AplicarAccionEt1,
// si causa victoria o empate:
function BorrarSaE () {
	// La última SaE ponerla en la actual:
	// trace("ATENCIÓN: "+NoEvaluedSaE+", que es "+SaEEvaluedyJoined);
	set (NoEvaluedSaE, eval("SaE"+SaE).slice());
	// trace("...ahora es: "+eval(NoEvaluedSaE));
	// Borrar la última:
	delete (eval("SaE"+SaE));
	// Indicar que hay una menos:
	SaE--;
	// También se borran datos prácticos que ya no se usarán:
	// trace("SaEEvaluedyJoined: "+SaEEvaluedyJoined);
	// trace("SaEEvaluedyJoined+Turno: "+eval(SaEEvaluedyJoined+"Turno"));
	delete (eval(SaEEvaluedyJoined+"Turno"));
	// trace("SaEEvaluedyJoined+Turno: "+eval(SaEEvaluedyJoined+"Turno"));
	delete (eval(SaEEvaluedyJoined+"FirstAPosible"));
	delete (eval(SaEEvaluedyJoined+"LastAPosible"));
	// Indicar que vuelva a invertigarse la del número actual,
	// pues ahora es otra:
	NroDeSExperimentandose--;
}
// Usada luego de EvaluarAplicabilidadEt1,
// cuando una acción no es realizable:
function BuscarAccionEt1 () {
	// trace("Ejecutando BuscarAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará BuscarBuenasSituaciones.
	} else {
		// trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada luego de que hay victoria, empate o si no hay más acciones posibles:
function BuscarOtraSituacionEt1 () {
	// trace("Ejecutando BuscarOtraSituacionEt1");
	if (SaE > NroDeSExperimentandose) {
		PrepararExperimentosEnOtraS();
	} else {
		trace(	"No hay más situaciones a experimentar; inicia la etapa 2.");
		// IniciarEtapa2();
		gotoAndStop(4);
	}
}
// Usada en AplicarAccionEt1 cuando no hay victoria ni empate:
function EvaluarConocimientoSobreSEt1 () {
	// trace("Ejecutando EvaluarConocimientoSobreSEt1");
	SituacionJoined = Situacion.join("");
	NombreDeSituacion = "S"+SituacionJoined;
	ResumenDeBest = NombreDeSituacion+"BestAction";
	// ¿Se ha llegado antes a la situación?
	if (eval(ResumenDeBest) == undefined) {
		// No, anotar que debe investigarse:
		SaE++;
		// Copiar array (porque no se puede normalmente):
		set ("SaE"+SaE, Situacion.slice());
		// trace("Esa situación no está anotada; se anota como nro "+SaE);
		set(ResumenDeBest, "Desconocida");
		if (Turno == "X") {
			set (NombreDeSituacion+"Turno", "0");
		} else {
			set (NombreDeSituacion+"Turno", "X");
		}
		// Averiguar cual es su 1er acción posible:
		AccionRevisandose = -1;
		do {
			AccionRevisandose++;
			if (Situacion[AccionRevisandose] == "v") {
				set (NombreDeSituacion+"FirstAPosible", AccionRevisandose);
				break;
			}
		} while (true);
		// Averiguar cual es su última acción posible:
		AccionRevisandose = Casilleros;
		do {
			AccionRevisandose--;
			if (Situacion[AccionRevisandose] == "v") {
				set (NombreDeSituacion+"LastAPosible", AccionRevisandose);
				break;
			}
		} while (true);
	}
}
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);
}

if (Situacion[Action] == "v") {
   // Es realizable, realizarla...
sino
   // No, ver si hay otra...

// 2 en línea horizontal, en tablero de 2x2, sólo X:
// 
// Uso arrays porque es más fácil así modificar los nombres...
// de variables:
// 
// Los casilleros están numerados así:
// 0 1
// 2 3
// Situación inicial (v es casillero vacío):
SituacionBase = ["v", "v", "v", "v"];
// Ponerla en la lista de situaciones a experimentar:
SaE1 = SituacionBase.slice();
// Situaciones a experimentar (cuántas son):
SaE = 1;
NroDeSExperimentandose = 1;
NombreDeSE = "S"+(SaE1.join(""));
// Acción a realizarse (casillero a marcar):
Action = 0;
function BuscarAccionesGanadoras () {
	PlantearSyActuar();
	// ¿Ganó?
	// Para averiguarlo, calcular fila (contando desde 0):
	Fila = Math.floor(Action/2);
	// trace("	Fila: "+Fila);
	if (Situacion[Fila*2] == Situacion[Fila*2+1]) {
		// trace("Situacion[Fila*2] == Situacion[Fila*2+1]: "+Situacion[Fila*2]+" == "+Situacion[Fila*2+1]);
		// Sí, crear datos sobre eso:
		// En la situación base conviene la acción realizada:
		set (NombreDeSE+"BestAction", Action);
		// En esa situación se requiere 1 acción para ganar:
		set (NombreDeSE+"DistanciaaGanar", 1);
		trace("Ganó, ahora se sabe que en la situación "+SituacionBase+" se gana usando la acción "+Action);
		// ¿Aún hay situaciones a experimentar?
		if (SaE > NroDeSExperimentandose) {
			IniciarExperimentosEnOtraS();
		} else {
			// Comenzar la etapa 2.
			IniciarEtapa2();
		}
	} else {
		EvaluarConocimientoSobreSyEtc();
	}
}
function PlantearSyActuar () {
	// 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);
	// Aplicación de la acción:
	Situacion[Action] = "X";
	trace("	Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
}
function IniciarExperimentosEnOtraS () {
	NroDeSExperimentandose++;
	SituacionBase = eval("SaE"+NroDeSExperimentandose);
	// trace("SituacionBase: "+SituacionBase);
	// Reset de la acción a probar:
	Action = 0;
	trace("Se inician experimentos en otra situación");
}
function IniciarEtapa2 () {
	DistanciaaGanarAceptada = 1;
	trace("Se experimentaron todas las situaciones; se reexperimentarán buscando resultados menos óptimos");
	trace("Son "+SaE+" situaciones; se acepta que la distancia a la victoria sea "+DistanciaaGanarAceptada);
	gotoAndStop (3);
}
function EvaluarConocimientoSobreSyEtc () {
	SituacionHechaTexto = Situacion.join("");
	NombreDeSituacion = "S"+SituacionHechaTexto;
	Resumen = NombreDeSituacion+"BestAction";
	if (eval(Resumen) == undefined) {
		// No, anotar que debe investigarse:
		SaE++;
		set ("SaE"+SaE, Situacion.slice());
		trace("Esa situación no está anotada; se anota como nro "+SaE);
		// Esto para saber que está anotada:
		set (Resumen, "Desconocida");
	}
	// ¿Queda alguna acción sin probar?
	if (Action < 3) {
		// Sí, probar otra:
		Action++;
	} else if (SaE > NroDeSExperimentandose) {
		// Sino si aún hay situaciones a experimentar:
		trace("No hay más acciones posibles en la situación");
		IniciarExperimentosEnOtraS();
	} else {
		// Comenzar la etapa 2.
		IniciarEtapa2();
	}
}

function HacerTablero () {
	MaxCasillero = CasillerosPorFila*CasillerosPorFila;
	LargoDeCasilleros = 384/CasillerosPorFila;
	CasillerosColocados = 0;
	// Sus columnas y filas se cuentan desde 0,
	// sirven para posicionarlos más fácil:
	Columna = 0;
	Fila = 0;
	do {
		CasillerosColocados++;
		CasilleroaColocar = "Casillero"+CasillerosColocados;
		// v es vacío.
		set ("SignoEn"+CasilleroaColocar, "v");
		// sCasillero tiene código.
		attachMovie("sCasillero", CasilleroaColocar, CasillerosColocados);
		setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
		setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
		setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
		setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
		Columna = Columna+1;
		if (Columna == CasillerosPorFila) {
			Columna = 0;
			Fila = Fila+1;
		}
		// Para que al presionar el botón se sepa qué modificar:
		set (CasilleroaColocar+".CasilleroAsociado", CasillerosColocados);
	} while (CasillerosColocados<MaxCasillero);
}

function HacerTablero () {
	// Esto se irá especificando en el while:
	Situacion = [];
	PosiblesAcciones = [];
	// Los casilleros se cuentan desde 0:
	MaxCasillero = CasillerosPorFila*CasillerosPorFila-1;
	LargoDeCasilleros = 384/CasillerosPorFila;
	NroDeCasillerosaColocar = -1;
	// Sus columnas y filas se cuentan desde 0,
	// sirven para posicionarlos más fácil:
	Columna = 0;
	Fila = 0;
	do {
		NroDeCasilleroaColocar++;
		// v es vacío:
		Situacion.push("v");
		PosiblesAcciones.push(NroDeCasilleroaColocar);
		CasilleroaColocar = "Casillero"+NroDeCasilleroaColocar;
		// set ("SignoEn"+CasilleroaColocar, "v");
		// sCasillero tiene código.
		attachMovie("sCasillero", CasilleroaColocar, NroDeCasilleroaColocar);
		setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
		setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
		setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
		setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
		Columna = Columna+1;
		if (Columna == CasillerosPorFila) {
			Columna = 0;
			Fila = Fila+1;
		}
		// Para que al presionar el botón se sepa qué modificar:
		set (CasilleroaColocar+".CasilleroAsociado", NroDeCasilleroaColocar);
		trace("Colocado el "+NroDeCasilleroaColocar);
	} while (NroDeCasilleroaColocar<MaxCasillero);
}

import itertools
 
def cargar_diccionario(ruta):
    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
    with open(ruta, 'r', encoding='utf-8') as archivo:
        return set(palabra.strip().lower() for palabra in archivo)
 
def generar_combinaciones(alfabeto):
    """Genera todas las combinaciones posibles de dos letras del alfabeto."""
    return {a + b for a, b in itertools.product(alfabeto, repeat=2)}
 
def buscar_combinaciones(diccionario, combinaciones):
    """Busca combinaciones dentro de las palabras del diccionario."""
    presentes = set()
 
    # Buscar combinaciones dentro de palabras individuales
    for palabra in diccionario:
        for i in range(len(palabra) - 1):
            presentes.add(palabra[i:i+2])
 
    # Buscar combinaciones entre palabras consecutivas
    lista_palabras = sorted(diccionario)  # Ordenar las palabras
    for i in range(len(lista_palabras) - 1):
        ultima_letra = lista_palabras[-1]
        primera_letra = lista_palabras[i + 1][0]
        presentes.add(ultima_letra + primera_letra)
 
    return combinaciones - presentes
 
# Paso 1: Cargar diccionarios
diccionario_es = cargar_diccionario('diccionario_es.txt')
diccionario_en = cargar_diccionario('diccionario_en.txt')
 
# Paso 2: Generar combinaciones posibles
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyz'
alfabeto_en = 'abcdefghijklmnopqrstuvwxyz'
combinaciones_es = generar_combinaciones(alfabeto_es)
combinaciones_en = generar_combinaciones(alfabeto_en)
 
# Paso 3: Buscar combinaciones inexistentes en cada diccionario
inexistentes_es = buscar_combinaciones(diccionario_es, combinaciones_es)
inexistentes_en = buscar_combinaciones(diccionario_en, combinaciones_en)
 
# Paso 4: Combinar resultados y mostrar combinaciones inexistentes en ambos idiomas
inexistentes_totales = inexistentes_es.intersection(inexistentes_en)
 
print(f"Combinaciones inexistentes en ambos idiomas ({len(inexistentes_totales)}):")
print(sorted(inexistentes_totales))
input("Presione Enter para continuar ...")