Programando desde 0: 07- Secuencia de repetición FOR.

[Vlady_18]

Lección 7: Secuencia de repetición FOR:


Introducción:

Antes que nada les diré que intentaré hacer estas lecciones un tanto menos densas que las anteriores porque se que han sido largas y esto puede desanimar un poco. Sin embargo, ir tirando temas que no se terminen de dar no es mi estilo porque sino el conocimiento no se termina de arraigar. Lo mejor es, dado un tema, comenzarlo y terminarlo de entrada, excepto si este está constituido por muchos temas diferentes, en ese caso es mejor dar cada temita por separado para luego unir lo que haga falta. En esta lección tratamos el tema Repetición, sin embargo este abarca tres estructuras, en esta lección solo veremos una de ellas.

Hemos visto hasta ahora lo básico de la programación, como los tipos, las variables, las constantes y demás. Todos estos, aspectos necesarios para hacer funcionar un código. Ahora bien, lo que nos falta es controlar ese código a nuestro gusto, pudiendo optar por distintos caminos, ir y venir, etc.

La selección nos permite elegir un camino u otro en base a condiciones booleanas (verdaderas o faltas), las cuales pueden ser sumamente complejas. Esto lo permite la sentencia IF en todas sus variantes. Sin embargo no basta con solo elegir un camino u otro, sino que a veces necesitamos repetir tareas, entrando entonces en la repetición.

Por ejemplo, en nuestro programa que resuelve polinomios de segundo grado sería conveniente que si el usuario ingresa el coeficiente a nulo, además de mostrar el mensaje de error, el programa vuelva a pedir que se ingresen los coeficientes, o si en nuestro programa de la instrucción CASE el usuario ingresara una opción que no está en el menú además de notificárselo sería correcto volver a pedir que ingrese una.
Estas repeticiones son indefinidas, o sea, no sabemos cuando terminaremos de repetir lo mismo una y otra vez porque no sabemos cuantas veces se equivocarán los usuarios.

Para ser un poco más claro, una repetición consta justamente de repetir la ejecución de cierta parte de nuestro código fuente, o de todo el mismo. O sea, si nuestro programa debe volver a hacer exactamente lo mismo que ya hizo ¿por qué no usar el código ya escrito?
Aquí entramos entonces en los bucles de repetición. Un bucle es un bloque de código que, por lo general, delimitamos entre Begin y End tal como ya he explicado. Estos bloques de código están pensados para ejecutarse más de una vez para la realización de ciertas tareas que lo requieren.

Existen tres estructuras de repetición; la que vamos a ver a continuación llamada FOR, y otras dos que veremos luego llamadas WHILE…DO y REPEAT…UNTIL.

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

Sentencia FOR:

En los ejemplos que dí, como ya dije, hablé de repeticiones indefinidas, o sea que no sabíamos a priori cuántas veces debíamos repetir una misma tarea. Un ejemplo más común es este:
Un teléfono celular normalmente contiene un código PIN de 4 dígitos, el cual se ingresa al encender el teléfono. Por lo general tenemos 3 intentos posibles de ingreso del PIN, o sea, podemos equivocarnos un máximo de tres veces. Si eso sucede el chip SIM se bloquea y nos solicita el código PUK que es larguísimo y además rara vez funciona, pero eso no nos importa. Centrémonos en el hecho del ingreso sel PIN.

Si lo ingresamos bien de entrada, el teléfono inicia su sistema y listo. Si nos equivocamos, vuelve a solicitar el PIN además demostrarnos los intentos restantes que nos quedan. Si lo ingresamos bien, se inicia el sistema y sino, vuelve a solicitar.

Esta es un claro ejemplo de repetición indefinida, porque podemos repetir la misma tarea un máximo de 4 veces o ninguna. Entonces hay dos condiciones de salida: O ingresamos bien el código, o fallamos todas las veces posibles.
Este tipo de repeticiones es muy útil pero no la veremos todavía.

FOR (que en inglés significa PARA o POR) repite una tarea una cantidad específica de veces, ni mas ni menos. O sea que, una vez iniciada, repetirá el código tantas veces como se le haya estipulado, no pudiendo salirse antes. Entonces, esta estructura no sirve para el ingreso del PIN.

Veamos un ejemplo donde escribiremos en pantalla el número 1 diez veces seguidas, primero sin FOR, y luego con:

PROGRAM sinFOR;

BEGIN
   write(1);
   write(1);
   write(1);
   write(1);
   write(1);
   write(1);
   write(1);
   write(1);
   write(1);
   write(1);

   readln;
END.

Este es un programa super básico, casi tan básico como el "Hola mundo". He agregado al final un procedimiento readln; para que el programa quede a la espera de un ENTER, así vemos el resultado de su salida.

Aquí hemos repetido lo mismo 10 veces. Entonces, veamos como utilizar FOR para lograrlo:

PROGRAM conFOR;

VAR
   i: integer;

BEGIN
   For i:=1 to 10 do
      write(1);

   readln;
END.

Como pueden ver, lo primero que hice a diferencia del ejemplo anterior ha sido declarar una variable i. Ahora veamos la siguiente línea

For i:=1 to 10 do

Esto es lo que llamamos encabezado del FOR. Comenzamos con la palabra reservada FOR. Luego indicamos una variable que debe estar declarada junto con todas las demás. Esta variable debe de ser de un tipo ordinal, por ejemplo, integer o char. Luego le asignamos el valor inicial desde el cual comenzaremos a contar las repeticiones a realizar, en este caso es el número entero 1 porque i es del tipo integer. Luego va la palabra reservada TO y luego el valor final de la variable que usamos antes. En este caso el entero 10. Finalmente va la palabra reservada DO seguida de la instrucción a realizar.

La variable i comenzará valiendo 1 (así lo asignamos nosotros), luego aumentará su valor a 2, luego a 3, a 4, y así hasta llegar a 10, donde terminará la ejecución del FOR.
Esta variable es llamada variable de control justamente porque controla al FOR indicando el tiempo de vida del mismo. Cada vez que la variable de control modifica su valor se sucede lo que se conoce como iteración.

En cada iteración el FOR realiza la instrucción que está luego de su encabezado (luego de DO), en este caso, write(1);
Noten que luego de la palabra DO no va punto y coma ya que esto quebraría el FOR y el compilador chillaría por no encontrar una instrucción a realizar.

Entonces, dado el FOR tal como lo escribí en este ejemplo:

For i:=1 to 10 do
      write(1);

la ejecución se sucede así:

Primero i comienza valiendo 1, entonces el FOR mira su instrucción y la realiza, en este caso, imprime un 1 en la salida.
Hecho esto el FOR vuelve a su encabezado y aumenta el valor de la variable de control en 1, o sea que ahora i vale 2. Se realiza nuevamente la instrucción, o sea, volvemos a imprimir un 1 en pantalla.
Volvemos al encabezado y el FOR aumenta en 1 la variable de control, o sea que ahora i vale 3. Realizamos la instrucción y repetimos esto.
Cuando i valga 10, el FOR terminará de iterar y pues, el programa continuará su curso.

La sintaxis general de un FOR es la siguiente:

FOR variable:= valor_inicial TO valor_final DO
Instrucción;

Por ejemplo, si quisiéramos imprimir la letra A unas 10 veces la declaración del FOR sería algo así:

For i:=1 to 10 do
   Write(‘A’);

En este caso veríamos una salida como esta: AAAAAAAAAA

NOTA: El valor final del encabezado del FOR debe ser del mismo tipo que el inicial, o sea, del mismo tipo que la variable de control (por ejemplo puede ser for i:= ‘a’ to ‘z’ do).

¿Resulta realmente útil poder repetir solo una única instrucción? Realmente NO, por lo tanto, si dentro de un FOR queremos realizar más de una cosa, debemos delimitar el bloque por Begin y End.
De este modo, la verdadera forma general de un FOR sería así:

FOR variable:= valor_inicial TO valor_final DO
Begin
   Instruccion1;
   Instruccion2;
   . . .
   InstruccionN;
End;

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

Uso de la variable de control:

Como he explicado, en cada iteración la variable de control va tomando valores, por lo tanto, muchas veces (y en general) se utiliza esta variable para realizar tareas dentro de un FOR, no solo para aumentar o disminuir. Veremos un ejemplo entonces donde, usando la variable de control del FOR imprimimos en pantalla los números del 1 al 10 separados por un espacio:

PROGRAM Del1al10;

VAR
   i: integer;

BEGIN
   FOR i:= 1 to 10 DO
      write(i,' ');

   readln;
END.

¿Se entiende? Esto no es nada complicado. Podemos usar la variable de control dentro del FOR para realizar cualquier tarea, incluso modificar su valor, sin embargo les diré esto

¡¡¡NUNCA MODIFICAR LA VARIABLE DE CONTROL DE UN FOR!!!

Si me hacen caso, se ahorrarán cientos de miles de dolores de cabeza.

Ahora veamos un ejemplo en el que imprimimos en pantalla los 10 primeros números pares. Por si no lo saben, decimos que un número es par si es divisible entre 2, o sea, si el resto de la división entera es igual a 0, lo que en Pascal equivale a decir que VALOR MOD 2= 0.

Imprimiremos en pantalla los 10 primeros número pares a partir del 0 sin incluir a este:

1 PROGRAM pares;
2
3 Var
4     i: integer;
5
6   BEGIN
7   write('Los 10 primeros pares son: ');
8
9   For i:=1 to 20 do
10     If i mod 2= 0 then
11        write(i,' ');
12 END.

En la línea 7 mostramos al usuario un mensaje. En la novena línea comienza la declaración del FOR donde inicializamos i en 1 y continuaremos hasta que valga 20. El IF en la línea 10 se encarga de ver si el valor actual de i es par, o sea si el resto de dividirlo entre 2 es igual a 0. En ese caso imprimimos su valor y un espacio, sino no hacemos nada y esperamos la siguiente iteración.

Vuelvo a repetirles que al proceso de repetir varias veces un mismo segmento de código se lo llama iteración. Nuestro FOR iterará 20 veces.
Es importante jamás modificar la variable de control mientras se está ejecutando el FOR, o sea, no hacer por ejemplo i:= 10 dentro del FOR ya que eso produce errores muy inesperados y dependen mucho del compilador usado para crear el programa. Puede usarse el valor de la variable de control para todo lo que se necesite, incluso incluirlo en expresiones y condiciones tal como en nuestro ejemplo, pero nunca modificarlo (¿se los tengo que gritar nuevamente jeje?.

Ahora veamos el mismo programa, pero solo que esta vez le pediremos al usuario que ingrese cuantos números pares quiere visualizar:

1  PROGRAM PrimerosPares;
2
3  Var
4      i, pares: integer;
6   BEGIN
7
8   write('¿Cuantos pares quieres visualizar? ');
9   readln(pares);
10
11 writeln;
12 write('Los primeros ',pares,' pares son: ');
13
14 pares:= pares*2;
15
16 For i:=1 to pares do
17    If i mod 2= 0 then
18       write(i,' ');
19 END.

En la línea 8 mostramos el mensaje al usuario para, en la siguiente línea, pedirle que ingrese cuántos pares desea ver.
En la línea 11 usamos el procedimiento writeln sin parámetros para que imprima una línea en blanco. En la línea 12 mostramos un mensaje al usuario.

En la línea 14 hay algo nuevo. A la variable pares le asignamos su propio valor multiplicado por 2 ya que si el usuario desea ver, por ejemplo, los diez primeros pares nosotros deberíamos iterar del 1 al 20. Esto de asignar a una variable un valor que depende de su valor anterior es muy común en la programación. A dichas variables se las conoce como acumuladores. Esto lo veremos en más detalle cuando trabajemos con WHILE y REPEAT.

En la línea 16 cambiamos el valor final del encabezado del FOR por la variable pares. Esto es lo más común en el uso de esta instrucción. No hace falta indicar un valor nosotros mismos, sino que podemos colocar nombres de variables, constantes o incluso expresiones matemáticas siempre y cuando el tipo de la variable de control y el del valor final sean el mismo y a su vez estos sean ordinales.

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

Veamos otro ejemplo sencillo, solo que ahora le diremos al usuario que indique el rango de números entre los cuales desea ver los pares, o sea, por ejemplo, si quiere ver los pares entre el 10 y el 30, que lo indique él mismo:

1  PROGRAM RangoDePares;
2
3  Var
4      i, inico, fin: integer;
6   BEGIN
7
8   write('Ingrese el rango numérico para visualizar pares: ');
9   readln(inicio,fin);
10
11 writeln;
12 write('Los pares en el rango del ',inicio,' al ',fin,' son: ');
13
14 For i:=inicio to fin do
15    If i mod 2= 0 then
16       write(i,' ');
17
18 radln;
19 END.

En este caso vemos que hemos puesto variables como valor_inicial y como valor_final. Es posible colocar funciones, expresiones y demás.

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

Anidación de FOR:

Veamos un ejemplo donde el usuario ingresará un número que indicará el largo del lado de un cuadrado y dibujaremos este con el carácter * (asterisco):

1  PROGRAM Cuadrado;
2
3  Const
4     caracter= '*';
5
6  Var
7     i, j, lado: integer;
8
9  BEGIN
10 write('Ingresa el largo del lado: ');
11 readln(lado);
12
13 writeln;
14
15 For i:=1 to lado do
16 begin
17    For j:=1 to lado do
18       write(caracter);
19
20    writeln;
21 end;
22END.

Lo interesante en este programa es analizar lo que sucede desde la línea 15 en adelante. Tenemos dos FOR, uno dentro de otro. Lo primero a resaltar es el uso de dos variables de control diferentes, una para cada FOR. Si usáramos la misma variable para ambos uno modificaría la del otro y se ocasionaría un caos. Si quieren prueben este programa así como está y luego con la misma variable de control. Es probable que el compilador los regañe por eso y se produzca un error en tiempo de compilación.

Veamos, cuando i vale 1 entramos al FOR principal. Allí tenemos otro FOR el cual se ejecutará hasta el final antes de volver al primer FOR. Cuando j vale 1 imprimimos un * (está definido en la constante caracter). Luego j vale 2 y se imprime un segundo * en la misma línea ya que estamos usando un procedimiento write. Así continuamos hasta que se imprimen tantos * en una línea como lo indique la variable largo. Ahora pasamos a la línea 20 del programa donde está writeln para escribir una línea en blanco, o sea, para bajar un renglón.
Hemos vuelto al encabezado del FOR principal, ahora i vale 2.
Volvemos a entrar en el FOR principal y el FOR de dentro vuelve a comenzar con j en 1. Imprime los *, se baja un renglón y así hasta que i sea igual al valor de la variable lado.

Notar que la instrucción writeln de la línea 20 está dentro del FOR principal pero no forma parte del FOR interno.

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

FOR decreciente:

Otra forma del FOR es la siguiente:

For variable:=valor_inicial downto valor_final do
   Instrucción;

Esto funciona exactamente igual a la forma anterior del FOR con la diferencia de que valor_inicial es mayor que valor_final. O sea que la variable de control irá decreciendo en vez de aumentando. Por ejemplo:

For i:=20 downto 1 do
Instruccion;

En este caso i comenzará valiendo 20, luego 19, luego 18, y así hasta llegar al 1.

NOTAS: Nunca asuman el valor que tendrá la variable de control una vez finalizado el FOR. En este ejemplo de FOR que va de 20 a 1 uno podría decir que i vale 1 al final, pero esto puede no ser así, depende del compilador.

Si van a volver a usar esta variable deberán inicializarla ustedes mismos con el valor apropiado.

A continuación les planteo una serie de ejercicios de aplicación del FOR y algunos temas ya vistos. Por favor, no continúen si no son capaces de resolver estos ejercicios. Todas las dudas postéenlas aquí.

P.D: Díganme si estoy yendo muy rápido.

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

Ejercicio 1: Determinen cuáles de los siguientes fragmentos de código producen la misma salida:
a)

FOR i:=1 TO 3 DO
   FOR j:= i+1 TO 3 DO
      write(i,j)

b)

FOR i:=1 TO 3 DO
   write (i, i+1)

c)

FOR i:=1 TO 4 DO
   IF (i=1) OR (i=4) THEN
      write(i)
   ELSE
      write(i,i)

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

Ejercicio 2: Escriban un programa que lea desde el teclado un valor entero n. A continuación, el programa deberá leer n enteros y luego desplegar el mayor y el menor de ellos.
Ejemplo de entrada:
n=8

Ingrese 8 enteros: 5 12 36 4 21 95 12 18

Ejemplo de salida:

El mayor entero ingresado es: 95
El menor entero ingresado es: 4

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

Ejercicio 3: Escriban un programa que lea de la entrada estándar 5 valores positivos, todos menores que 60 y produzca una gráfica de barras horizontales similar a la que se muestra en el ejemplo para estos datos:

Ejemplo de entrada:

Ingrese 5 valores: 5 12 17 35 8

Ejemplo de salida:

*****
************
*****************
***********************************
********

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

Ejercicio 4: Escriban un programa que lea de la entrada estándar un carácter c y un entero n. El programa debe desplegar un triángulo de n líneas formado por el carácter c según se muestra en el siguiente ejemplo:

Ejemplo de entrada:

n=8
c=$

Ejemplo de salida:

$$$$$$$$
$$$$$$$
$$$$$$
$$$$$
$$$$
$$$
$$
$

Mucha suete.

[raulexploit]

Buenas
hacia mucho que no me pasaba

no consigo realizar el ejerciocio 2

no se como indicar al programa que lea tantas cifras como las que ponga el usuario

salu2
y a ver ahora que he terminado examenes si retomo el curso

[Vlady_18]

Estimado, te dejo aquí un código que soluciona el problema:

PROGRAM Leccion7Ejercicio2; 
 
VAR 
   n: INTEGER; //El entero n leído inicialmente. 
   (*Leeremos luego n enteros, llamaremos actual al entero que leemos 
   en el momento*) 
   actual: INTEGER; 
   mayor, menor: INTEGER; 
   i: INTEGER; //Variable de control del FOR que usaré. 
 
BEGIN 
    Write('Ingresa un entero positivo: '); 
    ReadLn(n); 
    WriteLn; 
 
    Write('Ingresa ',n,' enteros separados por espacios: '); 
    Read(actual); //Leo el primero de los n enteros ingresados. 
    (*Como solo leí un número asumo que es el mayor y el menor a la vez*) 
    mayor:= actual; 
    menor:= actual; 
 
    (*Este FOR iterará n-1 veces ya que de los n enteros ingresados hemos leído 
    uno, por lo tanto quedan n-1 números por leer.*) 
    FOR i:= 1 to n-1 DO 
    Begin 
       Read(actual); 
       IF actual>mayor THEN 
          mayor:= actual 
       ELSE 
       IF actual 

Saludos.

[raulexploit]

de nuevo muchas gracias
aunque voy a practicar más este apartado para un mejor dominio
:P

[antonio_3_13]

Excelente los tutoriales, pero sucede un problema en el codigo que pusiste de los numeros mayores y menores, cual es la funcion del "read(actual) despues del begin? y al ejecutar no funciona toma los numeros pero se cierra. Saludos

[Vlady_18]

Pásame el código a ver que error tenemos...

[danteolivetti]

Muy bien!!!, super entendible, gracias. Ya termine los ejercicios satisfactoriamente, solo me quedo una duda en el de los números para saber cual es mayor y cual menor, al momento de ejecutarlo, si ingreso X número de valores a teclear me pide de más por ej: si pongo 4, no corre el programa, sin embargo si pondo por decir otros 3 ya corre el programa y no me da el resultado que quiero...cabe mencionar que es el codigo que posteaste. Un saludo y ya estoy empezando la lección siguiente, ya con nuevas dudas jeje.

[Vlady_18]

¿Cual ejercicio amigo???

[danteolivetti]

El ejercicio número 2

---------- Mensaje agregado a las 23:57 ---------- Mensaje anterior a las 23:47 ----------

Ya lo resolvi solo herá un error de sintaxis jeje suele pasar...ya sabes