Sentencias de repetición

Unidad 4: Acciones
Tema: Sentencias de repetición

Hay quien opina que la programación es una actividad que nunca puede resultar tediosa o repetitiva, ya que todo aquello ha de hacerse repetidamente puede programarse en una instrucción simple para que sea la computadora quien lo haga repetidas veces. De hecho, las sentencias de repetición son generalmente las responsables de la utilidad de la computadora. Se trata de instrucciones que controlan la realización de tareas repetitivas mientras sea cierta una condición.

En Pascal existen tres estructuras de repetición que son las sentencias For -Do, Repeat -Until, y While -Do.

La primera de ellas, la instrucción For -Do, tiene la siguiente sintaxis:

For identificador := principio To final Do
   accion

donde identificador es una variable que puede almacenar un dato ordinario, principio es el valor que se le asigna a la variable antes de realizar la acción, final es el valor máximo que puede alcanzar la variable antes de finalizar la acción, y accion es la instrucción, simple o compuesta, de Pascal que se repetirá incrementando en uno cada vez el valor de idetificador- Si se trata de una sentencia compuesta, tendrá que utilizarse la estructura Begin-End para identificar el principio y el fin.

Existe también otra opción equivalente

For identificador := principio Downto final Do
   accion

en la que el valor del identificador se decrementa en uno cada vez que se realiza la acción.

En el programa Catorce se tiene la aplicación de esta estructura para el calculo del factorial dado un número.

Program Catorce;
Var
   z : Real;
   n, i : Integer;
Begin
   Write('Calculo del factorial (introducir el numero): ');
   Readln(z);
   n := Round(z);
   If(n > 33)
   Then
      Writeln('Solo se puede calcular hasta 33!')
   Else
      Begin
         z := 1.;
         For i := 1 to n do
            z := z * i;
         Writeln('El factorial de ', n:2, ' es: ');
         Wrtieln(z:40:0)
      End;
End.

La limitación básica de la instrucción For-Do es que la acción que implícitamente se realiza cada vez simplemente el aumento o decremento de una variable ordinaria. No obstante, hay que tener presente que variables ordinarias no son solamente los Integer. En el programa Quince vemos como se puede utilizar la estructura con una variable Char.

Program Quince;
Var
   i : Char;
Begin
   (* Programa que escribe el abecedario al reves *)
   Writeln('');
   For i := 'Z' Downto 'A' do
      Write(' ', i);
End.

La variable que se utiliza como contador en la instrucción For-Do puede modificarse también en la acción que se repite, pero hay que ser extremadamente cuidadoso porque de lo contrario se puede generar un ciclo infinito. Si en el siguiente programa no se realiza la modificación a un múltiplo de tres, se podría caer en un ciclo infinito (con probabilidad 0.33333).

Program Dieciseis;
Var
   i, n : Integer;
Begin
   Writeln('Escribo los numeros de dos en dos');
   Write('Empezando en 1 y acabando en ?: ');
   Readln(n);
   
   n := n - (n Mod 3);
   For i:1 to n do
      Begin
         Writeln(i);
         i := i + 2
      End;
End.

Aceptando que el programa anterior es siempre correcto, es fácil deducir que la comprobación sobre el estado del índice se realiza antes o después de incrementar el índice.

Una estructura muy similar a la For-Do pero más versátil es la Repeat-Until. Su sintaxis es:

Repeat
   accion1;
   accion2;
   .  .  .
Until DatoBoolean

y con ella se especifica el conjunto de acciones situado entre el Repeat y el Until mientras que no sea True el valor de DatoBoolean. Las acciones se realizan al menos una vez porque la verificación sobre el dato Boolean se hace después de las acciones. Así, en el siguiente programa el juego no se interrumpe inmediatamente después de escribir el 0. Por el contrario la jugada se repite y luego termina.

Program Diecisiete;
Var
 n, i : Integer;
Begin
   Writeln('Adivina el numero que he generado (del 1 al 9)');
   Writeln('Teclea 0 para terminar ');
   
   Randomize;
   Repeat
      i := Random(8);
      Write('Dime un numero: ');
      Readln(n);
      If i + 1 <> n
         Then
            Writeln('No adivinaste, era el ' i+1)
         Else
            Writeln('Adivinaste!);
   Until n = 0;
End.

Sin embargo, en la instrucción While-Do se realiza la comprobación de la condición que ha de finalizar la repetición antes de ejecutarse la acción. Su sintaxis es:

While DatoBoolean Do
   accion

donde DatoBoolean es una expresión cuyo resultado es un dato de tipo Boolean, y accion es una instrucción de Pascal (sencilla o compuesta) que se repetirá mientras DatoBoolean sea verdadero (true).

El programa Dieciocho es una modificación del Diecisiete en el que con el uso de la instrucción While-Do se verifica la condición de fin del juego antes de generar el número.

Program Dieciocho;
Var
   n, i : Integer;
Begin
   Writeln('Adivina el numero que he generado (del 1 al 9)');
   Writeln('Teclea 0 para terminar ');
   Randomize;
   Write('Dime un numero: ');
   Readln(n);
   While n <> 0 do
      Begin
         i := Random(8);
         If i + 1 <> n
            Then
               Writeln('No adivinaste, era el ' i+1)
            Else
               Writeln('Adivinaste!);
         Write('Dime un numero: ');
         Readln(n);
   End; { endwhile }
End.

Cuando se ha de programar un procedimiento repetitivo, la elección de una de las tres estructuras se hará siempre considerando la claridad y facilidad de programación.

En Pascal también existe la sentencia de control no estructurado Goto, pero no se considerará pues en este curso de presente que ejercitar la programación estructurada. Sin embargo si se considerará la función Exit cuyo efecto es interrumpir la ejecución del bloque en que se encuentra. Si se trata del programa principal, producirá una interrupción en la ejecución del programa. En el programa Diecinueve se modifica el Diecisiete para interrumpir el juego haciendo uso de la función Exit.

Program Diecinueve;
Var
 n, i : Integer;
Begin
   Writeln('Adivina el numero que he generado (del 1 al 9)');
   Writeln('Teclea 0 para terminar ');
   
   Randomize;
   Repeat
      i := Random(8);
      Write('Dime un numero: ');
      Readln(n);
      If n = 0 Then Exit
      If i + 1 <> n
         Then
            Writeln('No adivinaste, era el ' i+1)
         Else
            Writeln('Adivinaste!);
   Until n = 0;
End.
SHARE

Manuel Soto

Programar es una artesanía, cualquiera puede hacerlo, con la práctica y constancia adecuada no se necesita ninguna carrera, como toda artesanía, el producto depende del empeño que le ponga el artesano.

  • Image
  • Image
    Blogger Comment
    Facebook Comment