Comenzando a programar: 8b - Repetición condicional con WHILE...DO

[Kyshuo]

LECCIÓN 8 - Parte b: Repetición condicional con WHILE...DO

Este programa está totalmente comentado, por lo cual deberían entenderlo completamente. Les dejo aquí, la versión sin comentarios para que el código resulte más entendible:

Código Pascal:

PROGRAM AdivinadorSimple;
 
CONST
   MAX_INTENTOS= 10;
   TOPE= 30; 
 
VAR
   numero_a_adivinar, numero_leido: INTEGER;
   adivinado: BOOLEAN;
   intento_actual: INTEGER;
 
BEGIN
   randomize; 
   numero_a_adivinar:= Random(TOPE) + 1;
 
   adivinado:= FALSE; 
 
   intento_actual:= 0; 
 
   WriteLn('Ingrese números para intentar adivinar:');
   WriteLn;
 
   WHILE (NOT adivinado) AND (intento_actual< MAX_INTENTOS) DO
   BEGIN
      intento_actual:= intento_actual + 1;
      Write(intento_actual,' --> ');  
      ReadLn(numero_leido);  
 
      IF numero_leido= numero_a_adivinar THEN
         adivinado:= TRUE;
   END;
 
   IF adivinado THEN
      WriteLn('Felicitaciones ¡¡¡GANASTE!!!')
   ELSE
     WriteLn('Lamentablemente has perdido.');
 
   ReadLn; 
END.
 

Como pueden ver uso dos constantes en este programa, MAX_INTENTOS y TOPE. Simplemente son para que el código sea más entendible y fácilmente modificable. Si yo quiero que ahora mi programa genere números entre 1 y 100 solo voy y modifico el valor de TOPE. Si quiero que el número máximo de intentos sea 20 y no 10, modifico el valor de MAX_INTENTOS y listo.


En este ejemplo vemos por primera vez uno de los usos de las variables booblean. En este caso declaré una adivinado que indicará el momento en el cual el usuario adivine el número.
Comenzamos generándonos un número al azar y asignando ese valor a la variable numero_a_adivinar , para luego inicializar nuestro booleano con el valor false ya que el usuario no ha adivinado nada todavía porque ni siquiera ha intentado. También inicializamos la variable intento_actual con el valor 0 ya que el usuario aún no ha comenzado.

Es importante siempre inicializar las variables con los valores apropiados y no asumir que ya lo tienen. Es común que uno suponga que el valor de intento_actual sea 0 al inicio ya que no se le asignó nada hasta el momento, pero esto no es así, depende mucho del compilador que se use. Cuando uno declara una variable de algún tipo, esta puede tomar un valor cualquiera al azar que es desconocido por el usuario (basura). Hay compiladores que las inicializan con algún valor específico. Sin embargo, al crear un software, nunca sabemos en el futuro cuando deberemos modificarlo o si debemos pasarle nuestro código a algún otro programador para que él trabaje con él. Si la otra persona usa un compilador diferente entonces el programa probablemente no funcione como debe.

¡¡¡SIEMPRE INICIALIZAR LAS VARIABLES!!!

Veamos el encabezado del WHILE ya que allí las condiciones están dadas por el booleano y por una comparación.

Código:

WHILE (NOT adivinado) AND (intento_actual< MAX_INTENTOS) DO

es equivalente a decir

Código:

WHILE (adivino=FALSE) AND (intento_actual< MAX_INTENTOS) DO

Aquí vemos por primera vez el uso del operador NOT. Vean que lo que hace es preguntar por la falsedad de una variable booleana, o sea, la condición es verdadera mientras el valor de la variable sea FALSE. Si no se antepone el operador NOT y solo aparece el nombre de la variable booleana, estamos preguntando por la veracidad de la misma, o sea, si esta vale TRUE. Notar que la condición es una condición compuesta y que será verdadera en tanto ambas condiciones comprendidas entre el operador AND sean verdaderas, o sea, la condición es verdadera si el booleano es FALSO y la variable intento_actual es menor que MAX_INTENTOS. Si falla alguna de estas cosas el AND es FALSO y el WHILE terminará su iteración.

Usar el nombre de un booleano en una condición ya es preguntar por si es TRUE. Del mismo modo si uno quiere preguntar por si es FALSE, como en nuestro programa, debe anteponer el operador NOT antes del nombre del booleano. Por ejemplo:

Código:

IF adivinado THEN
   Instruccion;

Es lo mismo que decir

Código:

IF adivinado=TRUE THEN
   Instruccion;

Ya saben que si ponen NOT es justamente lo contrario.

Bien, nuestro WHILE funcionará en tanto se cumplan las condiciones dadas, basta que una falle para que no se ejecute el WHILE. Como nosotros inicializamos nuestro booleano en FALSE y le dimos a intento_actual el valor 0, sabemos que la primera vez que el programa llegue al WHILE su condición AND será verdadera y por tanto se ejecutará al menos una vez. Esto es porque nosotros hemos dado a propósito las condiciones necesarias.

Lo primero que hacemos dentro del bloque del WHILE es la asignación:

Código:

intento_actual:= intento_actual + 1;

o sea, estamos asignando a una variable su valor anterior más 1. Esto se conoce como acumulador porque es una variable que acumula valores y va aumentando. ¿Se dan cuenta de eso? En la primera ejecución del WHILE intento_actual pasa a valer 1.
En cada iteración del WHILE estaremos aumentando esta variable en 1, por lo tanto nos aseguramos de que en algún momento alcanzará el número máximo de intentos disponibles.

Luego leemos el número que el usuario ingresa para pasar a esta instrucción:

Código:

 IF numero_leido= numero_a_adivinar THEN
         adivinado:= TRUE;

Lo que hace este IF es cambiar el valor de adivinado a TRUE si el usuario a adivinado el número. Si esto sucede, cuando el WHILE vuelva a mirar su encabezado se encontrará conque el booleano es TRUE y por lo tanto ya no iterará más y seguiremos de largo.

Esta asignación con IF, se puede hacer así:

Código:

adivinado:= numero_leido= numero_a_adivinar;

Como ven, es posible asignar a un booleano la condición que debe cumplirse para que sea TRUE, si esto no sucede se le asigna el valor FALSE. Esa sería la forma más correcta en vez de hacerlo con IF. Yo lo hice así primero para que a ustedes les quede bien claro lo que se está haciendo.

El uso que dimos aquí de la variable booleana es conocido como Bandera Booleana ya que nuestra variable se encenderá cuando se cumpla alguna condición y nos avisará algo. Sería como levantar una bandera para indicarle algo a alguien. El uso de banderas booleanas es muy común aunque en principio uno no lo crea. A medida que la práctica en programar es mayor se comprende mejor a los booleanos y su uso aumenta. Yo en particular hago mucho uso de ellos, llegando incluso a abusarme un poco, cosa que no es aconsejable ya que el código puede volverse muy confuso.

Una vez fuera del WHILE debemos verificar por qué es que salimos de él. Eso hace el último IF, si salimos porque adivinado se volvió TRUE entonces será porque el usuario ganó, en caso contrario salimos porque el usuario se pasó de intentos posibles y perdió.

Muy bien, ahora que ya conocen el uso de WHILE es hora de darle práctica. Quiero que modifiquen el programa del triángulo para que cuando el usuario ingrese base o altura con un valor nulo o negativo el programa le notifique su error y vuelva a pedírselo. Asuman que el usuario siempre ingresa números reales en la entrada, no se preocupen todavía por si ingresa otros caracteres.

También modifiquen el programa que efectuaba una división entre dos números de modo que si el usuario ingresa el valor del cociente como 0 el programa se lo indique y vuelva a pedírselo.
Hagan lo mismo con el programa que desglosaba un número de cuatro cifras. Si el usuario ingresa un número inválido vuelvan a pedírselo hasta que sea válido.

===============================================

Un pequeño juego:

Los tres ejercicios anteriores corresponden a modificar códigos ya hechos por mí y a remodificar lo que ya habían hecho en los ejercicios anteriores, que aunque no es del todo fácil es más sencillo que diseñar un programa desde 0. Ahora les plantearé un pequeño juego para que lo hagan. Piensen en esto como en su primer proyecto de programación. Podrán usar todo lo que hemos visto hasta el momento. Este juego se centrará en el uso del WHILE. El problema es el siguiente:

Un jugador deberá adivinar en un máximo de 15 intentos un número entre 1 y 100. Si el jugador adivina, el programa se lo notificará y terminará su ejecución, en caso contrario el jugador recibirá una pista para volver a intentar adivinar. El juego le dirá si el número que debe adivinar es mayor o menor que el que ha ingresado y el jugador volverá intentarlo.

En cada caso el juego deberá mostrar al jugador el número de intento actual y cuantos restantes le quedan. Cuando el usuario pierda, el programa deberá mostrar cuál era el número que debía adivinar. Siempre asumiremos que recibiremos un entero desde la entrada estándar.
El número a ser adivinado será generado al azar por el juego.

Ejemplos de ejecución:
Ejemplo 1:
Dispones de 15 intentos para adivinar.
1)--> 98
¡¡¡Muy bien!!! ¡¡¡Has adivinado!!!

Ejemplo 2:
Dispones de 15 intentos para adivinar.
1)--> 99
Lo siento, no has acertado.
El número que debes adivinar es menor.

Dispones de 14 intentos para adivinar.
2)--> 80
Lo siento, no has acertado.
El número que debes adivinar es mayor.

Dispones de 13 intentos para adivinar.
3)--> 85
¡¡¡Muy bien!!! ¡¡¡Has adivinado!!!

Ejemplo 3:
Dispones de 15 intentos para adivinar.
1)--> 60
Lo siento, no has acertado.
El número que debes adivinar es menor.
. . .
Dispones de 1 intentos para adivinar.
15)--> 13
Lo siento, no has acertado.
Lamentablemente has perdido. El número era 10.

Mucha suerte. Espero que esto les guste. Un saludo, y como siempre, estaré a las órdenes.