El programa genera las combinaciones de 2 letras.

Carga un diccionario en inglés y otro en español.

Anota las combinaciones de 2 letras que hay en las palabras.

Luego anota las combinaciones de 2 letras que ocurren cuando 2 palabras se unen. Así por ejemplo se obtiene zh, por nariz y hoy.

Finalmente, muestra las combinaciones que no ocurrieron, lo hace quitando de la 1er lista (la del inicio) las que anotó.

Eso si funciona bien, no sé.

Lo que quiero es que cuando anote una combinación, me diga cual anotó. Así me entero de cómo se forma qq por ejemplo.

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 ...")

Versión 8.7.5

¿Será porque eso se aplica cuando escribo ahí, no si cargo un archivo hecho con el bloc de notas común?

Sino me serviría que el zoom iniciara siempre con 300% por decir algo ¿cómo soluciono estos obstáculos?

No conseguí la respuesta.

Al abrirlo con el bloc de notas no aparece algo claro, es mucho espacio vacío y caracteres raros.

Es de 2002 dice, aunque quién sabe.

Pesa 22,9 KB (23.530 bytes).

El nombre prefiero no decirlo por las dudas, pero no es algo vergonzoso ni algo así xP

¿Cómo averiguo qué es?

Hace mucho, cuando pegaba una imagen en Paint más grande que la hoja actual, me parecía absurdo que me preguntara si quería agrandar la hoja ¡obvio que sí!

Pero con el tiempo, me empezó a servir poner que no, porque si tomaba una foto pero sólo quería una parte, y luego tomaba otras fotos, porque era un video por ejemplo, me servía que el tamaño de la hoja se mantuviera como lo dejé, para guardar los archivos más rápido, de modo que se viera lo que yo quería y no la foto entera.

Desde que tengo Windows 7, Paint agranda la hoja sin preguntarme, y no veo la opción de modificarle el tamaño (la opción que veo modifica también la imagen, antes creo que no era así, yo no quiero que se agrande/achique la imagen, sólo la hoja), así que ¿con qué programa y cómo podría lograr lo que quiero?

Son varias fotos de un archivo de Flash, que al tomar foto sale el menú y las herramientas, podría modificar algunas cosas pero si cada vez que quiera tomar fotos debo hacer eso no me conviene.

Tomo una foto, supongamos que es así:
xxxx
xAAx
xAAx
xxxx
Yo sólo quiero guardar la parte de las A. Para eso pego la imagen en Paint, la muevo hacia arriba e izquierda para quitar las x de esos sitios, y me queda así:
AAxb
AAxb
xxxb
bbbb
Donde b es blanco, y yo ahora quiero reducir la hoja de modo que sólo queden las A. Debería ser fácil...

El juego es una simplificación del 3 en línea:
- El tablero en vez de ser de 3x3 casilleros es de 2x2.
- Lo que debe formarse, en vez de ser una línea horizontal, vertical o diagonal de 3 signos iguales, debe ser de 2 pero horizontal.

Claro que es menos interesante que el original, es que se me complicó.

Hay a grandes rásgos 3 tipos de IA, díganme otras si me faltan:
A- La que sabe jugar como el programador le dijo, no aprende.
B- La que sabe jugar según lo que entrenó, aprendió todo lo necesario.
C- La que está aprendiendo, aprende mientras juega.

El problema de A es que si el juego es complejo, no hay persona que sepa el modo ideal de jugar, y tampoco es fácil expresarlo.

B requiere más tiempo lograrse entre más complejo sea el juego, por lo que llaman explosión combinatoria o algo así.

C, entre más complejo sea el juego, menos útil es, porque difícilmente llegue a aprender todo lo necesario para jugar bien. El jugador podría hacer cosas distintas hasta el cansancio y en tales casos la IA sería como si recién empezara.

Supongo que pueden pulirse de distintos modos, pero no sé bien cómo.

A, en este caso simple sería así creo:

Sobre C no pensé mucho.

B es más difícil de lo que creí, a ver si me dan ideas.

Mi idea es algo así:
- En la situación inicial (tablero todo vacío), se prueban las acciones posibles y si se llega a una situación que no está en la lista de situaciones no resueltas, se agrega. Al principio esa lista está vacía, ahora habrá 4 porque 4 son las posibles consecuencias de las 4 posibles acciones.
- Se genera una de las situaciones de la lista. Probamos las posibles acciones, ahora el signo es 0 en vez de X. Si obtenemos situaciones que no estén en la lista, de nuevo, las anotamos.
- Repetimos eso con cada situación, el signo a poner depende de cuales sean, y llegará un punto en que poner un signo causará una victoria, por ejemplo en esta:
XV
0V
(V es vacío)
La acción nro 2 (casillero 1_2, al lado de la X) causa victoria. Cuando eso ocurre, creamos unas variables cuyos nombres implican la situación anterior a la victoria, en el ejemplo sería XV0V, y ponemos una S delante para menos lío, sabemos que S significa situación. Bueno, las variables van a ser por ejemplo:
SXV0VBestAction = 2
SXV0VDistanciaDeVictoria = 1
Significa que en esa situación conviene la acción 2 y que hace falta sólo 1 acción para llegar a la victoria.
Eliminamos esa acción de la lista de situaciones sin resolver.
- Cuando hayamos recorrido la lista de situaciones, comenzamos a recorrerla de nuevo, pero no sé bien qué debería hacerse ahora específicamente.

En programas "similares" que había hecho, lo que se hacía era que si se llega a una situación cuya DistanciaDeVictoria fuese 1, a la anterior situación se le asignaba que DistanciaDeVictoria fuese 2, y así se repite realizar acciones, asignar "puntajes" a las situaciones, eliminarlas de la lista, y en cada nueva repetición aumentar el número asignado a DistanciaDeVictoria, hasta que ya no queden situaciones a investigar.

Pero en este caso no se puede porque hay turnos, hay rivales, a ver:

Si sólo hubiera X, sería así:
Comenzamos investigando la situación
VV
VV
Probamos una acción
XV
VV
Anotamos esa situación en la lista de no resueltas.
Probamos otra acción en la situación que estamos investigando, nos queda:
VX
VV
En fin, en cierto punto vamos a investigar esta:
XV
VV
Realizamos una acción que causa victoria
XX
VV
Entonces definimos:
SXVVVBestAction=2
SXV0VDistanciaDeVictoria = 1
Y en otro punto, cuando volvamos a investigar situaciones aún no resueltas, como esta:
VV
VV
Cuando hagamos esto:
XV
VV
Llegamos a una que la tenemos evaluada como 1, entonces a la anterior (la que puse arriba, todo V) le vamos a poner 2. Está clarísimo, se requieren 2 acciones para ganar desde el inicio.

Pero hay 0, así que luego de hallar todas las victorias posibles, cuando volvamos a investigar situaciones aún no resueltas, como esta:
XV
VV
Sabemos que es turno del 0, que si pone en 2_1 o 2_2 se llegará a una situación cuya DistanciaDeVictoria es 1, pero para X, para 0 es 1 de la derrota, así que el programa no puede ponerle 2, eso se interpretaría como que a 0 le hacen falta 2 acciones para ganar, que es segurto que ganará, lo cual no es así.

¿La solución es crear otra variable? ¿que exista DistanciaDeVictoriaDeX y DistanciaDeVictoriaDe0? Hay que tener en cuenta la explosión combinatoria, no conviene crear variables en lo posibñe, además no veo bien cómo eso lo resolvería.
A ver, si no llega a una situación cuya DistanciaDeVictoriaDe0 sea 1 (cosa imposible, 0 no puede ganar), nada se anota al respecto. Y cuando la distancia de X es 1, se anota que de 0 es -1, es decir que está a 1 acción de ser derrotado. La distancia ideal es positiva y en 2nda instancia lo más cercana a 0 posible.
Bueno... cuando en una búsqueda no se anoten cosas, es decir no se llegue a situaciones resueltas, se comenzaría a anotar las que lleguen a distancias -1, luego a -2, y así, podría ser que se llegue a resolver todas las situaciones.

¿Creen que eso funcionará? ¿no, por qué?

¿Es posible usar sólo una distancia? ¿sí, cómo?

¿Cómo sería un método más rápido y eficiente? Imagino que deduciendo en base a rotar el tablero o considerar simetría, pero creo que debe haber algo como aprender la regla, aprender un código a seguir, no esto de aprender qué hacer en la situación 1, 2, 3... Cuando juegue, sería bueno que siga un código como el que puse al inicio, en vez de "llamar a la función SXVVV" (o sea, cargar los datos de esa situación a ver qué acción conviene en ella), porque cuando sean MUCHAS posibles situaciones, es un disparate hacerlo así, por la explosión ¿no? Imagina un 5 en línea en un tablero de 25x25 con 5 jugadores, por decir algo.

A esto:
https://foro.elhacker.net/programacion_general/iquestque_metodo_es_recomendado_para_ordenar_al_azar_un_array-t522940.0.html
...quería agregarle eficientemente que el nuevo array pudiera tener menos elementos que el original. Como no se me ocurrió bien cómo, consulté a GPT:

En Macromedia Flash 5 tengo un array de 3 elementos y quiero que se genere otro array con 2 de esos elementos al azar, y ordenados al azar ¿cómo?


¿por qué pones
var tempArray = array.slice(0);
en vez de
tempArray = array;
?


Poner un nombre, luego = y luego un valor, es crear una variable cuyo nombre es el indicado en nombre y su valor es indicado luego del signo =, no es una referencia ¿o estoy equivocado?


¿Por qué lo hicieron así?


No le veo sentido, si quiero crear una copia debería poder hacerlo normalmente no con "slice", si consume mucho entonces el programador debería saberlo y no usarlo salvo que sea útil ¿por qué limitarnos?

Claro que no entendí todos los motivos que dice ahí, que una variable tenga 2 nombres puede ser útil pero... Si fuese así, debería poder hacerse con variables simples, y sobretodo debería poder hacerse de otro modo. Que una misma expresión, tan básica, haga cosas distintas según el tipo de variable parece absurdo.

¿Qué opinan?

Edit: Sabía que había excepciones a eso, tenemos por ejemplo que Número+Número es una suma pero si alguno de esos números es cadena entonces el + es concatenar. Pero vamos, no es lo mismo el + que el =. El = es sagrado xP

Edit2: Es como si al copiar un archivo en Windows, este en vez de eso copiara un acceso directo. Joder, si quiero una copia porque voy a modificar una, dejame copiar tranquilo 

Conocen el juego 3 en línea, tic tac toe, tateti, etc.

Yo estoy haciendo un S en línea, es decir, que el juego permita elegir cuántos signos debe haber en la línea (y qué tan grande es el tablero).

Anduve pensando cual es el método más eficiente de ver si alguien ganó.

Se me ocurrieron 2 métodos.

El 1ero es bastante bruto, más o menos así:
No es necesario que los ifs se repitan, sólo que al escribirlo así nomás quedaba más claro.

El otro método intentaba usar menos repeticiones o variaciones de variables, pero a medida que lo analicé llegó un punto en que me parecía igual. En la misma repetición, se apunta a 2 casilleros (al principio son el mismo), y en cada repetición se varía a cual se apunta (y analiza como puse arriba), el 1ero es cada vez más hacia la derecha y el 2ndo hacia abajo. Cuando no quedan, se apunta al diagonal derecho-abajo y se repite el proceso hasta que el apuntado sea el inferior derecho.

Empecé a aplicar el método 1:

// Por practicidad al calcular, las filas se cuentan desde 0:
Fila = -1;
// Las columnas no, desde 1:
Columna = 0;
do {
	Fila++;
	SemiReferenciaAlCas = "Casillero"+Fila+"_";
	do {
		Columna++;
		// Si el casillero no está vacío:
		if (eval(SemiReferenciaAlCas+Columna != 2)) {
			// Esto va variando qué siguientes...
			// casilleros se analizan:
			Extra = 0;
			do {
				Extra++;
				// 

Ahí iría lo de analizar hacia la diagonal arriba-derecha, y el resto de las cosas. Pero siento que es tan poco eficiente que prefiero que me digan algo mejor, que probablemente haya. Sino, más adelante le pregunto a GPT.

Por cierto, tengo pensado que la máquina aprenda a jugar experimentando, por eso los valores de los casilleros están grabados de 2 formas, por ejemplo el superior izquierdo:
// 2 es vacío, 1 es cruz, 0 es 0.
Casillero1 = 2;
Casillero1_1 = 2;
Porque al hacer referencia a una situación es más fácil variar sólo una variable (no fila y columna).
Lo necesito para hacer árboles, no sé cómo lo hacen uds, hablaremos en otra ocasión de eso.

Mientras hacía el tema me di cuenta que alcanza con analizar solamente las líneas que impliquen al casillero recién modificado   así que intentaré eso y podría borrar todo esto, pero igual puede ser interesante, luego pongo lo que logre.

Probablemente los lenguajes modernos tienen una función que lo hace, no busco eso.

Yo había pensado algo así:

Colores = ["Azul", "Rojo", "Verde", "Blanco", "Negro"];
// Esto habría que hacerlo con loop pero no es lo relevante:
PesoDeElementos = [Math.random(), Math.random(), Math.random(), Math.random(), Math.random()];
Elemento1aReubicarse = -1;
ReordenarHasta = 4;
do {
	Elemento1aReubicarse++;
	Elemento2aReubicarse = Elemento1aReubicarse+1;
	if (PesoDeElementos[Elemento1aReubicarse] > PesoDeElementos[Elemento2aReubicarse]) {
		// Intercambiar esos 2 elementos:
		SaveDeElemento1 = Colores[Elemento1aReubicarse];
		Colores[Elemento1aReubicarse] = Colores[Elemento2aReubicarse];
		Colores[Elemento1aReubicarse] = SaveDeElemento1;
	}
	if (Elemento2aReubicarse == ReordenarHasta) {
		// Hacia la derecha ya está reordenado, volver a la izquierda:
		Elemento1aReubicarse = -1;
		ReordenarHasta--;
	}
} while (ReordenarHasta > 0);

Pero suponiendo que podía haber algo más sencillo (esa cosa la acabo de hacer, no sé si funciona), le pregunté a GPT. Me dijo un método de Fisher o algo así que no entendí. En Wikipedia tampoco. Pero se me ocurrió (o puede ser igual a lo que no entendí) un método que recorra los elementos, hasta el central, intercambiando los de un lado con los de otro, y luego el central con cualquiera, pero tenía dudas de cómo sería exactamente y ahora noto que no sería justo, es decir, el 1er elemento nunca quedaría 2ndo (salvo que fuesen menos de 4), y además:
- Si siempre hay intercambio, nunca podrían quedar en el lugar original, lo cual debería poder suceder.
- Si puede no haber intercambio, la probabilidad de que queden igual varios de ellos es muy alta.
Así que eso no sirve ¿pero cual es entonces un buen método?

Copio la conversación que tuve con GPT:

quisiera que el índice vaya subiendo en vez de bajando y que uses while en vez de for


Intenté imitarlo pero como no sé exacto cómo funciona y esos nombres j e i me entreveran, decidí buscar en Wikipedia.
https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

Creo que ahora entiendo, va desde derecha a izquierda y "rolled" significa que eligió intercambiar con ese, el elemento posible de intercambiarse era el 4 y "rolled" un 1, yo interpretaba que había elegido por azar el 1 y no sabía de dónde había sacado el 4.

¿Es así? ¿hay otro mejor?

Aunque sale ese tema y usuario, pudo haber sido acá:
https://foro.elhacker.net/desarrollo_web/cual_es_el_mejor_hostingservidor_dedicado_para_proyectos-t522776.0.html;msg2282159#msg2282159

La otra página es Youtube. Estaba viendo mis temas para responder, incluido el otro por curiosidad, y me saltó ese cartel.

Al otro tema, ese del link, creo que es la 1era vez que entro. Otra cosa que no suelo hacer es entrar a 2 temas a la vez digamos, pero no debería ser un problema.

EDIT:
No sé si en el otro, pero acá:
https://foro.elhacker.net/programacion_general/generar_funciones-t522899.0.html;msg2282600;topicseen#msg2282600
me acaba de salir de nuevo el cartel.

Para ver todos los dibujos posibles uno a uno, hice un programa que los genera así, aunque por ahora sólo son en blanco y negro, de esos 2 colores nada más.

Luego indiqué que no mostrara dibujos que no cumplieran ciertas características.

A:
Luego empecé a indicar cómo pasar de uno aceptable al siguiente aceptable, para evitar generar los que no van a mostrarse. Por si no se entiende:
Supongamos que quieres ver todos los números divisibles entre 3. Puedes generar todos los enteros y mostrar sólo los divisibles entre 3 (se genera el 1 pero no se muestra, luego el 2 pero tampoco, el 3 sí, luego el 4 pero no...), o puedes simplemente indicar que se generen sólo los necesarios (3, 6...). Pero no en todo contexto es simple.
Noté una falla en eso que hice. Tengo una idea sobre cómo corregirlo pero, si lo que hice antes estuvo mal ¿por qué creer que ahora estará bien? Tampoco es que deba creer que estará mal, no se debe creer que se puede prever el futuro tanto, es cuestión de probar, pero me tiene un poco cansado, no sé, me pregunto hasta qué punto tiene sentido fallar, fallar, fallar y cuando no se notan errores no estar seguro de si no hay o uno está fallando en detectarlos. Es como "Mejor que lo haga otro, alguien que no falle tanto".

Había concluido que lo mejor era dejar de intentar hacer A, pero eso en última instancia es como creer que no tiene sentido intentar programar, es dejar de programar. Por eso estoy un poco confuso, el programa en sí tampoco tiene mucho sentido, los dibujos que muestra es como que son nada, grandes cuadrados cerca, así o asá. Una IA o como se llame, hoy en día hace dibujos bastante bien de lo que se le pida, así que pa qué. En parte era porque quería demostrar que los dibujos no son una creación, que deba tener dueño, es algo que puede ser generado pintando ciertos puntos de ciertos colores, duh, y se puede lograr probando combinaciones. Y por ver dibujos interesantes, no sé. Ah, y era una práctica para otras cosas, no puedo generar películas o representaciones de cerebros, si no puedo generar dibujos... Mejor empezar por lo más fácil. No sé si es un error dejar esto o no. Y la cuestión es más profunda que eso, quizá debería dejar la programación misma, pero para hacer qué, no sé, si igual la cuestión de que puedo fallar sigue.

Probablemente no es un tema de programación entonces, pero aquí lo dejo, como "testimonio" de lo que es programar sin saber hacerlo bien, o el problema que sea.


Recientemente vi este video:
https://www.youtube.com/watch?v=4zk6uodm7tY
Yo no entendí Matrix y no recordaba tanto, aparentemente el programador comete fallas que no sabe corregir.