PRACTICA PROGRAMACION 2022-23

*****
.....

Programación – Informática I
Grupo 15
Antonio Medarde Payeras
2. Introducción
La práctica del curso 2022-23 de la asignatura programación consiste en realizar un
“WORDLE”.

El juego WORDLE tiene como objetivo descubrir una palabra oculta en 6 intentos de
entre 1 y 23 letras. Para descubrir la palabra oculta se irán introduciendo palabras y
después el juego mostrará un resultado en función de la palabra introducida. Este
resultado será útil para ir descubriendo las letras que tiene la palabra y así descubrir cuál
es.

Para jugar a “WORDLE” se debe tener en cuenta que:

- Se deben introducir palabras que existan en el diccionario
- Los plurales no se tienen en cuenta
- La ñ i la ç no existen
- Al principio se indica el tamaño de la palabra, y las futuras palabras introducidas
deben tener ese tamaño.
- Se deben introducir palabras en minúsculas
- Los acentos de las palabras no se tienen en cuenta
- Cuando se introduce una palabra válida se mostrará un resultado por pantalla en
las posiciones de la palabra introducida:
o Se mostrará ‘*’ si la letra no existe
o Se mostrará ‘.’ si la letra existe en otra posición
o Se mostrará la letra si se ha acertado la posición
- Existen varias ayudas para descubrir la palabra oculta más fácilmente:
o ‘@acertadas’: mostrará en una palabra todas las letras acertadas, lo otro
será ‘*’
o ‘@duplicados’: indicará si hay alguna letra duplicada
o ‘@pista’: en las posiciones donde @acertadas indique ‘*’ se mostrará para
cada letra de la a-z las posibles palabras que hay en el diccionario, teniendo
en cuenta las letras acertadas
o ‘@ayuda’: se mostrará por pantalla una explicación del juego
- Si el usuario se rinde podrá introducir ‘@rendicion’ y se mostrará la palabra oculta
y acabará el juego
- Si el usuario quiere finalizar el programa deberá introducir ‘@salir’
- Cada vez que se introduzca una palabra al juego, a excepción de los comandos de
ayuda, se podrá escuchar un sonido
o Si se pierde el juego se escuchará un sonido descendente
o Si se gana el juego se escuchará un sonido ascendente
o Si se falla la palabra, se escucharán dos sonidos seguidos
A continuación, hay ejemplos de como se debería comportar el programa cuando se
introducen palabras:
Palabra oculta: tarro
Palabra introducida: gorra
Se debe mostrar: *.rr.

----------------------------------------------------------------------------------------------------------

Palabra oculta ganar

Palabra introducida gorra
g*.*.

Palabra introducida venda

**n*.
@acertadas g*n**
@pista
En la posición 2:
Letra a: existen 8 palabras
Letra b: existen 2 palabras
…

En la posición 4:
Letra a: 2 palabras
Letra b: 0 palabras
…

En la posición 5:
Letra a: 10 palabras
Letra b: 3 palabras
3. Diseño

Para realizar esta práctica he hecho un programa de un total de 358 líneas. Ahora
procederé a explicar cómo he realizado el WORDLE. Iré explicando desde el principio
del main y si hay algún subprograma saltaré a este para explicarlo.

Lo primero que hago en el programa es preguntarle al usuario con cuantas letras quiere
jugar al WORDLE y declaro en una variable TAM_PALABRA el tamaño de esta. Acto
seguido lo que hago es abrir el diccionario que contiene las palabras con tamaño de 1 a
23 letras. Después de abrir el archivo, si todo sale correctamente, se irá avanzando línea
a línea del documento de texto (en cada línea hay una palabra) y si la palabra de la línea
tiene un tamaño igual al de TAM_PALABRA, la palabra se guardará en un vector de
strings mediante el método push_back().

Cuando se llega al final del documento, el vector será el diccionario con el que se
comprobará si las palabras introducidas existen. Después de completar el diccionario, se
obtendrá una palabra aleatoria y será la palabra oculta, así cada vez que se juegue nadie
sabrá qué palabra es la oculta. Para obtener la palabra oculta ha sido necesaria la librería
“random”. Con esta, hacemos que saque un numero aleatorio entre 0 y el tamaño del
vector después declaramos un string con la posición del numero aleatorio del vector,
que será una palabra.

A continuación, declaramos tres strings; el primero para la palabra del intento, el

segundo para mostrar por pantalla el resultado del intento y el ultimo el de las letras
acertadas. Este ultimo lo igualamos a un array que se formará en un subprograma
(rellenar) donde le pasamos TAM_PALABRA y devuelve un string de este tamaño con
todo ‘*’. Esto es porque el usuario todavía no ha introducido nada y mostraremos todo
como equivocado.

Después de esto empieza un bucle for muy extenso donde se iran evaluando las
palabras. Este bucle se inicializa con la variable intento = 6 y en el avance se le quita
uno; si intento llega a 0 entonces el usuario pierde y mostraría la palabra oculta y el
programa acabaría.

Lo primero que se hace en el bucle es pedir al usuario que introduzca por teclado la
palabra del intento y esta se evaluará. Si es @salir, el programa acaba; si es @rendición
se muestra la palabra oculta y acaba el programa, si la palabra es igual a la palabra
oculta, se muestra un mensaje de enhorabuena y acaba el programa; si la palabra es
@ayuda, se da una explicación breve del juego y sus ayudas y si la palabra es
@acertadas se mostrara el resultado de todas las letras acertadas.
Si la palabra es @pista, el programa deberá seguir un for donde para cada posición de la
palabra, si en @acertadas es ‘*’ , se meterá en el subprograma pista. Allí, primeramente
se declara un vector donde se guardaran todas la palabras que tienen las letras ya
acertadas por el usuario y gracias a la librería “map”, se podrá evaluar fácilmente para
cada letra cuantas posible palabras hay. El subprograma deberá mostrar por pantalla
cuantas palabras posibles hay con cada letra, aunque sea 0. Para que muestre 0 primero,
he tenido que inicializar cada letra a 0 para que después con iteradores muestre todo el
contenido del map.

Si la palabra introducida no tiene un tamaño de TAM_PALABRA, se le indicará al

usuario y se restará un intento. Si la palabra introducida no existe en el diccionario de
palabras con TAM_PALABRA, se le indicará al usuario y se restará un intento. Para
ver si la palabra existe en el diccionario, se llama a un subprograma (verificar), con el
que recorrerá todo el vector (el diccionario) y si encuentra la palabra devolverá cierto.

Si no pasa nada de lo anterior, entonces es que la palabra existe en el diccionario y es

del tamaño que toca. Por eso, comprobaremos la palabra letra a letra y mostraremos el
resultado. Para hacer esto, usamos el subprograma “comprobar”, al que le pasamos la
palabra del intento, la palabra oculta y el tamaño de la palabra. Lo primero que hace el
programa es crear un array de caracteres con el tamaño de TAM_PALABRA+1 para
después convertirlo a un string. Después hace un recorrido de la palabra oculta y si en
alguna posición, la letra de la palabra del intento es igual a la de la oculta, entonces en
esta posición se guardara la letra en el array. Después se realiza otro recorrido, donde se
buscan las diferentes letras de la palabra del intento y si no se encuentran, en la posición
de la letra no encontrada se pondrá ‘*’.
Finalmente, queda lo más complicado, que son las letras acertadas pero que se
encuentran en una posición errónea. Para esto, si en el array hay una posición donde no
hay nada querrá decir que la letra de esta posición del intento se encuentra en alguna
posición de la palabra oculta. Aquí podríamos pensar que bastaría con poner un punto
pero no, porque se tiene que tener en cuenta si las letras en la palabra oculta se repiten.
Por eso miraremos en un while cuantas letras como la de la posición que se mira tiene la
palabra oculta. Después miraremos si se repite en la palabra del intento y si es así, le
pondremos ‘.’ si el numero de repetición es menor a la cantidad del de la palabra oculta.
Cuando se acabe el bucle ya tendremos la palabra completa y la mostraremos por
pantalla.

Tras mostrar por pantalla el resultado, se mirarán las letras acertadas. Esto se hace ahora
para que se actualicen las letras acertadas después de introducir cada palabra.

Al final del programa cerraremos el fichero de las palabras para liberar la memoria.
4. Juegos de prueba

Con la palabra ocula “ancla”:

Funcionamiento de @acertadas:
Funcionamiento de @pista, con @acertadas de **nta:
Funcionamiento de algunas ayudas:

Funcionamiento de @rendicion y @salir

5. Conclusiones
Durante la realización de esta práctica me he podido dar cuenta de lo complicado, pero a
su vez entretenido que puede llegar a ser programar.

Lo más tedioso de esta practica no ha sido tener la idea de cómo hacerla, sino comó
trasladar la idea a lenguaje de programación. En mi opinión lo más difícil ha sido la
pista, ya que no entendía cómo se debía usar la clase “map”.

Sin embargo, esta práctica me ha servido para acercarme al mundo de la programación

y además he aprendido bastante. He podido añadir algún extra a mi práctica, como es
que haya sonido o que se pueda jugar con cualquier tamaño de palabra. También he
hecho el extra que el usuario pueda saber si hay letras duplicadas, o el de que se pueda
rendir.