Cómo programar el juego del ahorcado paso a paso

Qué es el pseudocódigo y para qué sirve

El pseudocódigo no es un lenguaje de programación, sino que es un lenguaje que nos permite definir un algoritmo.

Dentro de las etapas de diseño de una aplicación, en un primer momento tendríamos que analizar el problema que queremos resolver, y en un segundo paso tenemos que diseñar el algoritmo que resuelve el problema.

Una de las técnicas para diseñar ese algoritmo, que son las distintas acciones y los distintos pasos que tenemos que seguir para resolver el problema, es hacerlo mediante un pseudocódigo, el cual es un lenguaje natural que nos permite ir definiendo ese algoritmo.

Pseudocódigo con PSeInt

Tradicionalmente, en programación, el pseudocódigo se hacía con papel y bolígrafo, ya que se escribía el algoritmo pero no había oportunidad de ejecutarlo y ver si funcionaba mismo resolviendo el problema.

Actualmente hay muchos programas para hacerlo. Nosotros vamos a utilizar uno llamado PSeInt, un programa desarrollado por un profesor argentino, que nos permite codificar el algoritmo y el pseudocódigo en un intérprete, y en el que podemos ejecutar el pseudocódigo.

Juego del ahorcado paso a paso

Hay muchas soluciones posibles, pero nosotros la hemos hecho como os indicamos a continuación.

Vamos a hacer que un usuario introduzca una palabra, y el segundo jugador va a tener que adivinar la misma, indicando letras. Si introduce una letra que no está en la palabra secreta, irá apareciendo el típico dibujo del ahorcado para indicar el número de fallos que va teniendo.

Para ello leemos la palabra secreta, utilizando un array de 20 posiciones de valores lógicos, para indicar las letras que hemos descubierto ya. Esa función la llamamos LeerSecreto, y con ella leemos la palabra secreta, que no puede tener más de 20 caracteres, e inicializamos el array de aciertos a falso, ya que al introducir la palabra secreta, aún no hemos acertado ninguna letra.

//################################################################################
//Procedimiento LeerSecreto: Inicializamos la palabra secreta (no más de 20 
//caracteres) y el vector de aciertos a Falso.
//Parámetro de entrada y salida: Palabra que hay que adivinar, y aciertos: vector
//de valores lógicos que se inicializan a falso indicando que no se han acertado 
//ninguna letra.
//################################################################################
Funcion LeerSecreto(secreto Por Referencia,aciertos Por Referencia)
	definir i como Entero;
	Repetir
		Escribir "Introduce la palabra a a adivinar:";
		Leer secreto;
		Si Longitud(secreto)>20 Entonces
			Escribir "No puede tener más de 20 caracteres";
		FinSi
	Hasta Que Longitud(secreto)<=20;
	Para i<-0 hasta 19 Hacer
		aciertos[i]<-Falso;
	FinPara
	Borrar Pantalla;
FinFuncion

Posteriormente ejecutamos un bucle, que terminará cuando hayamos acertado la palabra o cuando hayamos fallado 8 veces y haya aparecido el dibujo completo del ahorcado. En ese bucle vamos a escribir el secreto, mostrando las letras que hayamos acertado y el resto se mostrarán con asteriscos. Después vamos a mostrar el dibujo del ahorcado, dependiendo del número de fallos. A continuación vamos a escribir la lista de letras que ya hemos introducido, y finalmente vamos a leer una nueva letra y comprobamos si la misma está dentro de la palabra secreta.

/################################################################################
//Escribe un programa para jugar al ahorcado.
//################################################################################

Proceso Ahorcado
	Definir secreto,letras,letra como Caracter;
	Definir aciertos como Logico;
	Definir num_fallos como Entero;
	Dimension aciertos[20];
	//Letras: cadena donde se van a ir guardando las letras introducidas
	letras<-"";
	num_fallos<-0;
	//Se introduce por teclado la palabra secreta a adivinar
	LeerSecreto(secreto,aciertos);
	//Se repite hasta que el número de aciertos sea igual a la longitud de la palabra o el número de fallos sea 6
	Repetir
		
		Borrar Pantalla;
		//Se escribe la palabra (* las letras no acertadas)
		EscribirSecreto(secreto,aciertos);
		
		//Se muestra el dibujo del ahorcado, se haya acertado o no.
		MostrarAhorcado(num_fallos);
		
		//Se muestran las letras que se han introducido anteriormente
		Escribir "Letras introducidas: ",letras;
		
		//Se lee una letra y se actualiza las letras leídas
		LeerLetra(letra,letras);
		//Si no hemos acertado la letra mostramos mensaje de error e incrementamos número de fallos.
		Si no ComprobarSecreto(letra,secreto,aciertos) Entonces
			num_fallos<-num_fallos+1;
		FinSi

	Hasta Que NumeroAciertos(aciertos)=Longitud(secreto) o num_fallos=8;
	//Podemos salir del bucle por dos razones
	//Si el número de fallos es 6 hemos perdido
		
	Si num_fallos=8 Entonces
		Borrar Pantalla;
		EscribirSecreto(secreto,aciertos);
		MostrarAhorcado(num_fallos);
		Escribir "Has perdido!!!";
	SiNo //Hemos ganado!!!!
		Escribir "Has ganado!!!";
	FinSi
FinProceso

Y ahora vamos a ver rápidamente el resto de funciones que empleamos en este pseudocódigo

Función NumeroAciertos

Tenemos un contador que va contando el array de aciertos, para ver cuantas letras se han acertado. Si el número de aciertos es igual a la longitud de la palabra secreta, se habrá ganado.

//################################################################################
//Función NumeroAciertos: Recibe el vector de aciertos y devuelve cuantas letras
//se han acertado (valores Verdadero).
//Parámetro de entrada: aciertos: vector de valores lógicos que indica las letras
//que se han acertado.
//Dato devuelto: Número de letras acertadas
//################################################################################

Funcion num <- NumeroAciertos(aciertos)
	Definir num,i Como Entero;
	num<-0;
	Para i<-0 hasta 19 Hacer
		Si aciertos[i] Entonces
			num<-num+1;
		FinSi
	FinPara
FinFuncion

Función EscribirSecreto

Esta función escribe la palabra secreta, dependiendo de si el carácter se ha acertado o no, mostrará el carácter o mostrará un asterisco.

//################################################################################
//Procedimiento EscribirSecreto: Recibe la palabra secreta (no más de 20 
//y el vector de aciertos. Y muestra por pantalla un carácter o un * según la 
//posición del carácter indique en el vector aciertos que se ha acertado la letra 
//(valor Verdadero)
//Parámetro de entrada: Palabra que hay que adivinar, y aciertos: vector de valores 
//lógicos que indica las letras que se han acertado.
//################################################################################

Funcion EscribirSecreto(secreto,aciertos)
	Definir i como Entero;
	//Recorro la cadena de caracteres
	Para i<-0 hasta Longitud(secreto)-1 Hacer
		//Si la posición del vector aciertos igual a la posición de un carácter
		// es verdadero imprimo el carácter
		Si aciertos[i] Entonces
			Escribir sin saltar Subcadena(secreto,i,i);
		SiNo //Sino imprimo un *
			Escribir sin saltar "*";
		FinSi
	FinPara
	Escribir "";
FinFuncion

Función ComprobarSecreto

Esta función comprueba si la letra introducida está en la cadena secreta.

//################################################################################
//Función ComprobarSecreto: Recibe un carácter, la cadena a adivinar y el vector 
//de aciertos y devuelve si el carácter está en la cadena. Además si es así cambia
//en el vector aciertos las posiciones donde se encuentra el carácter de Falso a
//Verdadero.
//Parámetro de entrada: un carácter, la cadena y el vector de aciertos
//Dato devuelto: Valor lógico, Verdadero si el carácter está en la cadena, 
//Falso en caso contrario.
//################################################################################

Funcion acierto <- ComprobarSecreto(letra,secreto,aciertos por Referencia)
	Definir i como Entero;
	Definir acierto como Logico;
	acierto<-Falso;
	Para i<-0 hasta Longitud(secreto)-1 Hacer
		Si Subcadena(secreto,i,i)=letra Entonces
			aciertos[i]<-Verdadero;
			acierto<-Verdadero;
		FinSi
	FinPara
	Escribir "";
FinFuncion

Función LeerLetra

Esta función sirve para pedir la introducción de letras.

//################################################################################
//Procedimiento LeerLetra: Lee un carácter por teclado y lo devuelve. Además 
//devuelve un cadena con las letras que se han leído anteriormente.
//Parámetro de entrada y salida: la letra leída por teclado, y la cadena con todas 
//las letras leídas anteriormente.
//################################################################################

Funcion LeerLetra(letra Por Referencia,letras Por Referencia)
	Repetir
		Escribir Sin Saltar "Introduce una letra:";
		Leer letra;
		Si Longitud(letra)<>1 Entonces
			Escribir "Una sola letra!!!";
		FinSi
	Hasta Que Longitud(letra)=1;
	letras<-Concatenar(letras,Concatenar(letra," "));
FinFuncion

Función MostrarAhorcado

Según el número de fallos que se tengan, se va pintando con caracteres las distintas situaciones de ahorcamiento en el juego.

//################################################################################
//Procedimiento MostarAhorcado: Recibe el número de fallos, y según el valor muestra 
//el nivel de "ahorcamiento" que lleva el jugador.
//Parámetro de entrada: Número de fallos
//################################################################################

Funcion MostrarAhorcado(fallos)
	Escribir "";
	Escribir "La horca!!!";
	Escribir "";
	Segun fallos Hacer
		0:
			Escribir "";
			Escribir "";
			Escribir "";
			Escribir "";
			Escribir "";
			Escribir "";
		1:
			Escribir "";
			Escribir "";
			Escribir "";
			Escribir "";
			Escribir "";
			Escribir "_________";
		2:
			Escribir "|";
			Escribir "|";
			Escribir "|";
			Escribir "|";
			Escribir "|";
			Escribir "_________";
		3:
			Escribir "------";
			Escribir "|";
			Escribir "|";
			Escribir "|";
			Escribir "|";
			Escribir "_________";
		4:
			Escribir "------";
			Escribir "|   |";
			Escribir "|   o";
			Escribir "|  ";
			Escribir "|  ";
			Escribir "_________";
		5:
			Escribir "------";
			Escribir "|   |";
			Escribir "|   o";
			Escribir "|  /|";
			Escribir "|";
			Escribir "_________";
			
		6:
			Escribir "------";
			Escribir "|   |";
			Escribir "|   o";
			Escribir "|  /|\";
			Escribir "|";
			Escribir "_________";
		7:
			Escribir "------";
			Escribir "|   |";
			Escribir "|   o";
			Escribir "|  /|\";
			Escribir "|  / ";
			Escribir "_________";
		8:
			Escribir "------";
			Escribir "|   |";
			Escribir "|   o";
			Escribir "|  /|\";
			Escribir "|  / \";
			Escribir "_________";
	FinSegun
	Escribir "";
FinFuncion

Por último, vamos a ver el programa ejecutándose, ya que tenemos la ventaja de tener este intérprete que nos permite escribir el pseudocódigo y ejecutarlo, para ver cómo funciona. Así comprobamos el funcionamiento del juego que hemos creado.

Si quieres tienes a tu disposición el archivo completo.