UNIDAD
3
ESTRUCTURAS
ITERATIVAS
Tal como
dijimos en el apunte anterior, todo algoritmo de solución a un problema
informático puede escribirse en base a tres estructuras básicas. Ya hemos visto
dos de ellas: la estructura secuencial y la estructura selectiva.
La tercera y
última de estas estructuras es la estructura
iterativa o repetitiva.
Esta
estructura permite que una determinada cantidad de instrucciones se repita
varias veces.
Existen
cuatro tipos de estructuras iterativas. La primera que veremos es la estructura
iterativa determinada por programa.
Supongamos el
siguiente ejercicio: se leen dos números enteros, mostrar la suma de ambos.
Claramente el algoritmo de solución es el siguiente:
Program Dosnumeros;
Uses wincrt;
Var
N1:
integer;
N2: integer;
SUMA:
integer;
Begin
Readln (N1);
Readln (N2);
SUMA := N1 +
N2;
Writeln
(SUMA);
End.
Pero si el
ejercicio dijera “se leen tres pares de números enteros; informar la suma de
cada par”, lo mismo que escribimos más arriba habría que repetirlo tres veces.
Program
Trespares;
Uses
wincrt;
Var
N1:
integer;
N2:
integer;
SUMA:
integer;
Begin
Readln
(N1);
Readln
(N2);
SUMA
:= N1 + N2;
Writeln
(SUMA);
Readln
(N1);
Readln
(N2);
SUMA := N1 + N2;
Writeln
(SUMA);
Readln
(N1);
Readln
(N2);
SUMA := N1 + N2;
Writeln
(SUMA);
End.
Hasta ahora
no parece haber problemas, pero ¿si quisiéramos leer mil pares de números?
¿tendríamos que repetir mil veces lo mismo?
No; justamente
para esto existen estas estructuras.
Si el
programador sabe cuántas veces tiene que repetir una serie de instrucciones, le
aclara al compilador que lo haga introduciendo una variable entera que se la
denomina contador y que va contando las vueltas de la repetición. Para nuestro
ejemplo, tendríamos que decirle que tiene que leer dos variables enteras e
imprimir su suma mil veces, es decir, desde la vez 1 hasta la vez 1000. Esta
estructura se denomina iterativa
determinada por programa. Así es como nos queda el programa:
Program
Milpares;
Uses
wincrt;
Var
|
N1:
integer;
N2: integer;
SUMA:
integer;
I:
integer;
Begin
For I:=1
to 1000 do
Begin
|
Readln (N1);
Readln (N2);
SUMA
:= N1 + N2;
Writeln
(SUMA);
End;
End.
Otro ejemplo:
Se leen las tres notas de la materia “Programación” de 30 alumnos de un curso.
Se desea imprimir el promedio de cada alumno.
Como cada
alumno tiene tres notas y tenemos treinta alumnos, deberemos leer 30 veces un
grupo de tres notas, y de cada grupo obtener el promedio y mostrarlo. Es decir,
se trata de una estructura iterativa determinada por programa con un contador
que va a controlar desde 1 hasta 30, y dentro de esta estructura se leerán tres
variables reales (las notas pueden tener decimales) y se calculará y mostrará
el promedio.
Program Promedios;
Uses wincrt;
Var
NOTA1: real;
NOTA2: real;
NOTA3: real;
PROMEDIO:
real;
I: integer;
Begin
For I:= 1 to
30 do
Begin
Readln (NOTA1);
Readln
(NOTA2);
Readln
(NOTA3);
PROMEDIO
:= (NOTA1 + NOTA2 + NOTA3) / 3;
Writeln
(PROMEDIO);
End;
End.
Ejercicio: ¿cómo habría que modificar
el ejercicio anterior si además de mostrar el promedio de cada alumno, quisiera
mostrar un cartel que diga si aprobó o no la materia (considerando que aprueba
con 6 o más)?
Siguiendo el
último ejemplo, podría darse el caso de que el mismo programa tuviera que
utilizarlo para cualquier curso, independientemente de la cantidad de alumnos
que tenga. El programador no sabe cuántos alumnos tiene un curso para poder
decidir hasta qué valor llegará el contador, pero la persona que va a cargar
los datos sí lo sabe. Por lo tanto, una solución a ese problema sería que el
programa le pregunte al usuario cuántas veces va a repetir la estructura, y
guardar ese valor en una variable entera que va a determinar el tope superior
de la estructura. A este tipo de estructura se la denomina estructura iterativa determinada por usuario. El algoritmo ahora
es:
Program Promedios2;
Uses wincrt;
Var
NOTA1: real;
NOTA2: real;
NOTA3: real;
PROMEDIO:
real;
|
I:
integer;
FINAL:
integer;
Begin
Readln
(FINAL);
For I:= 1 to FINAL do
Begin
Readln (NOTA1);
Readln
(NOTA2);
Readln
(NOTA3);
PROMEDIO
:= (NOTA1 + NOTA2 + NOTA3) / 3;
Writeln
(PROMEDIO);
End;
End.
Pero puede suceder incluso que ni siquiera el
usuario sepa cuántas veces se va a repetir una estructura. Por ejemplo, si
estamos en un consultorio médico y vamos recorriendo las fichas de los
pacientes y calculamos para cada paciente el aumento (o disminución) de peso
entre la primera y la última visita. La persona que va cargando los datos no
tiene por qué saber de antemano cuántas fichas hay; simplemente va a introducir
valores hasta que se terminen las fichas. En este caso, tenemos dos variables
para guardar los dos valores del peso y una tercera para guardar y mostrar la
diferencia entre ambas. Deberemos leer los pesos, hacer la resta y mostrarla. Y
eso lo haremos… ¿cuántas veces? No sabemos, sólo sabemos que lo repetiremos
hasta que se terminen las fichas. El usuario podría indicar al programa que las
fichas se terminaron cuando ambos valores de entrada sean cero; es decir, el
usuario ingresará valores hasta que ingrese dos ceros. Esto requiere de una
nueva estructura llamada estructura
iterativa con condición de salida, es decir, la repito hasta que se cumple
una condición que me indica que debo salir de ella, pero no puedo saber cuántas
veces será eso. En este caso, no hay ningún contador que controle la cantidad
de veces que se hace, sino que se le pregunta al usuario si desea continuar o
no. El algoritmo que soluciona el ejemplo es el siguiente:
Program Pesos;
Uses wincrt;
Var
PRIMERA:
real;
ULTIMA: real;
DIFERENCIA:
real;
|
CONTINUAR:
char;
Begin
Repeat
Readln
(PRIMERA);
Readln
(ULTIMA);
DIFERENCIA
:= ULTIMA - PRIMERA;
Writeln
(DIFERENCIA);
Writeln
(‘Presione “S” para seguir, “T” para terminar’);
Readln
(CONTINUAR)
Until CONTINUAR
= ‘T’;
End.
|
Otro ejemplo: en un vivero se controla la floración
de los rosales. Cada rosal tiene una ficha en la que se consignan semanalmente
la cantidad de pimpollos que nacen. Un programa informa si el rosal es apto
para la venta, lo cual sucede cuando de una semana para la otra el rosal tiene
al menos cinco pimpollos más. Los rosales se encuentran codificados R-1, R-2…,
R-n. Se lee el código de cada rosal, los pimpollos que contenía la semana
anterior y los que contiene esta semana. Se desea mostrar los códigos de los
rosales con un cartel que indique “APTO” o “NO APTO” según corresponda.
Program Rosales;
Uses wincrt;
Const
CARTELAPTO =
‘El rosal se encuentra apto para la venta’;
CARTELNOAPTO
= ‘El rosal no se encuentra apto para la venta’;
Var
CODIGO:
string;
SEMANA1: integer;
SEMANA2:
integer;
AUMENTO:
integer;
FIN: char;
Begin
Repeat
Readln
(CODIGO);
Readln
(SEMANA1);
Readln
(SEMANA2);
AUMENTO
:= SEMANA2 – SEMANA1;
If
AUMENTO >= 5 then
Begin
Writeln
(CODIGO);
Writeln (CARTELAPTO);
End
Else
Begin
Writeln
(CODIGO);
Writeln (CARTELNOAPTO);
End;
Writeln
(‘Desea terminar? (“S” o “N”): ‘);
Readln
(FIN);
Until FIN = ‘S’;
End.
Este programa lee los valores, calcula el aumento, y
luego se fija si corresponde imprimir un cartel o el otro; todo esto, dentro de
la estructura iterativa que se repetirá hasta que el usuario ingrese una “S”
para indicar que “Sí” desea terminar.
Por último, existe otro tipo de estructuras que
permiten ingresar datos una cierta cantidad de veces que no se sabe cuántas
serán, que se denominan estructuras
iterativas con condición de entrada. Es decir, en lugar de repetir las
instrucciones hasta que decido salir de la estructura, voy a repetir las
instrucciones mientras que le permita ingresar a la estructura. En este caso,
la condición de repetición la pongo al principio y no al final. Podríamos
considerar que ingresamos valores mientras que el código no sea la palabra
‘FIN’. En cuanto la variable CODIGO tenga el valor ‘FIN’, voy a dejar de entrar
en la estructura.
Supongamos que Veamos cómo queda:
Program Rosales2;
Uses wincrt;
Const
CARTELAPTO =
‘El rosal se encuentra apto para la venta’;
CARTELNOAPTO
= ‘El rosal no se encuentra apto para la venta’;
Var
CODIGO:
string;
SEMANA1: integer;
SEMANA2:
integer;
AUMENTO:
integer;
Begin
Readln (CODIGO);
While
CODIGO <> ‘FIN’ do
Begin
Readln
(SEMANA1);
Readln
(SEMANA2);
AUMENTO := SEMANA2 – SEMANA1;
If
AUMENTO >= 5 then
|
Begin
Writeln
(CODIGO);
Writeln (CARTELAPTO);
End
Else
Begin
Writeln
(CODIGO);
Writeln (CARTELNOAPTO);
End;
Readln (CODIGO);
End;
End.
La diferencia fundamental entre estas dos últimas
estructuras iterativas, es que en el caso de tener una condición de salida, las
instrucciones se ejecutan al menos una vez; cuando hay una condición de
entrada, es posible que nunca se ejecuten las sentencias que están dentro de la
estructura. Por eso, cuando no sabemos cuántas veces se repite una estructura,
y tampoco se lo podemos preguntar al usuario, utilizaremos una estructura
repetitiva con condición de entrada si es posible que no exista ningún dato
para procesar, y con condición de salida en caso contrario. Por ejemplo, si
tengo que controlar personas que se vienen a anotar a un curso por día,
utilizaré una estructura iterativa con condición de entrada, porque puede ser
que nadie venga a anotarse; pero cuando quiero calcular sueldos de empleados en
una empresa, utilizaré una estructura iterativa con condición de salida, porque
al menos un empleado debe haber.
PRÁCTICA
3
ESTRUCTURAS
DE PROGRAMACIÓN
¡¡¡¡NO
INTENTES HACER ESTOS EJERCICIOS SIN HABER LEÍDO ANTES EL APUNTE QUE LOS
PRECEDE!!!!
Los siguientes ejercicios están
ordenados según el grado de dificultad. Por lo tanto, hacélos respetando el
orden. Si te trabás en alguno, INMEDIATAMENTE consultámelo así puedo aclararte
en qué te equivocás para que puedas seguir adelante.
En principio, vamos a hacer todos los
ejercicios en Pascal. Luego los haremos todos en Visual Basic.
- Se leen cien pares de números.
Para cada par de números leídos, imprimir el resultado de su
multiplicación.
- Para cada uno de los días de un
mes, se leen las temperaturas máxima y mínima. Mostrar la temperatura
máxima promedio y la temperatura mínima promedio de ese mes.
- Calcular y mostrar el cuadrado y
la raíz (en Pascal, la raíz de N se escribe SQRT(N)) de todos los números
que se ingresan por teclado, hasta que se indique el fin.
- En un jardín botánico se desea
realizar una estadística con los siguientes datos: NOMBRE DEL EJEMPLAR,
ALTURA ACTUAL, ALTURA MEDIDA EN EL CONTROL ANTERIOR, FLORACIÓN (completa o
incompleta). Para ello se ingresan los datos en una computadora. Informar
el crecimiento de todos los ejemplares y cuáles son los que han completado
su floración.
- Este año han ingresado a
- Dados cien números enteros,
imprimir la mitad de la raíz cuadrada de los que son mayores que 28.
- Ingresar números hasta que se
ingrese el 0. Mostrar sólo los números múltiplos de 3 (en Pascal, “NUM es
múltiplo de tres” se escribe “NUM MOD 3 =
- Se leen los datos de los
ciudadanos de
- Se ingresan 100 pares de números.
Se debe obtener lo siguiente: si ambos números son positivos, imprimir los
dos números y su suma; si ambos son negativos, mostrar los dos números y
su resta; si sólo uno es positivo, mostrar los dos números y su producto.
- Se desea obtener, para cada
empleado, el monto a pagar en concepto de horas extras. Para ello se
ingresarán: APELLIDO Y NOMBRE DEL EMPLEADO, CANTIDAD DE HORAS EXTRAS y
TIPO DE HORAS EXTRAS (diurna, nocturna o feriado). El valor de la hora
extra depende del tipo de hora: diurna, $10.-, nocturna, $15.-, y feriado,
$20.-.
- En un curso se han tomado tres
exámenes y se obtiene la siguiente información: ALUMNO, NOTA1, NOTA2, y
NOTA3. Leer los datos y calcular el promedio de cada alumno, informado si
aprobó (6 o más), si debe recuperar (
- En una fábrica de rulemanes, por
cada producto realizado se registra el número de máquina en que se realizó
(de
- Los 300 obreros de una empresa
cobran $ 5.- por hora de trabajo y $ 8.- por hora extra. Si trabajan más
de 200 horas mensuales, a las excedentes se las considera extra. Se debe
tener presente que del valor total del sueldo se le debe descontar un 20%
en concepto de jubilación y obra social. Dados el NOMBRE Y APELLIDO,
DESAFÍO:
Se ingresan cien
números. Determinar e informar cuál de ellos es el mayor.
