Estructuras Repetitivas

Se solicita al operador que ingrese tres nmeros enteros cualesquiera.

En base a estos nmeros, mostrar por pantalla cual es el mayor de todos.
Diag. De Flujos

Pseudocdigo

Matlab

Inicio
Variable1=0
Variable2=0
Imprimir Ingrese tres nmeros enteros

v1=0;
v2=0;
disp(Ingrese tres nmeros enteros);

Desde 1 a 3
{
variable1=leer desde teclado
si (variable1>variable 2) entonces
{
variable2=variable1
}
sino
{
no hacer nada
}
fin si
}
imprimir El mayor valor ingresado es
imprimir variable2
Fin

for i=[1..3]
v1=input(ingrese un entero );
if (v1 > v2)
v2=v1;
end
end

disp(El mayor valor es);

disp(v2);

Estructuras Repetitivas
La estructura repetitiva se utiliza cuando se
quiere que un conjunto de instrucciones se
ejecuten un cierto nmero finito de veces.
Llamamos bucle o ciclo al proceso que se
repite.

Estructuras Repetitivas
Existen dos tipos de estructuras repetitivas:
Aquella en donde se tiene perfectamente
establecido el nmero de veces que un grupo
de acciones se van a ejecutar .
Aquella en la que el nmero de repeticiones
es desconocido y se har hasta que se cumpla
o no cierta condicin.

Estructuras Repetitivas
Desde o Para
Cuando conocemos de antemano el nmero
de veces en que se desea ejecutar una accin
o grupo de acciones.
Esta estructura ejecuta las acciones del cuerpo
del bucle un nmero especificado de veces.
Controla en modo automtico el valor de una
variable que cuenta la cantidad de ciclos
ejecutados.

Estructuras Repetitivas
Desde o Para - SINTAXIS
desde variable= Vi hasta Vf [incremento]
accin o acciones
fin-desde
variable: variable ndice
Vi: valor inicial de la variable indice
Vf: valor final de la variable indice
[incremento]: el nmero que se
incrementa (o decrementa) a la
variable indice en cada iteracin del
bucle, si se omite es 1.

Estructuras Repetitivas
Desde o Para - EJEMPLO
Imprimir todos los nmeros del 1 al 100.

Inicio
desde I = 1 hasta 100
imprimir I
fin-desde
fin

for l=1:100,
disp(l);
end

1) I es la variable ndice con un valor inicial de 1, se incrementa uno en cada paso hasta 100.
2) La estructura desde comienza con un valor inicial de la variable indice y las acciones se
ejecutan hasta que su valor sea MAYOR que el que el Valor final.
3) La variable indice se incremente en uno y si este nuevo valor del indice no es mayor que
el valor final, se ejecuta de nuevo la accin imprimir.
En este caso se visualizar los nmeros 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ....97, 98, 99, 100

Estructuras Repetitivas
Desde o Para - EJEMPLO
Imprimir todos los nmeros pares desde 2 hasta 300.

Inicio
desde I = 2 hasta 300 incremento 2
imprimir I
fin-desde
fin

for l=2:2:300,
disp(l);
end

1) La variable indice comienza en 2, se imprime 2 y en el siguiente paso se incrementa en 2

2) l pasa a valer 4; se imprime el 4 y como 4 es menor que 300 (valor final) , se pasa a una
nueva iteracin incrementando nuevamente l en 2, que ahora vale 6; y as
sucesivamente...
3) Aqu se visualiza: 2, 4, 6, 8, 10, 12, 14, 16, 18, ..... 296, 298, 300

Estructuras Repetitivas
Desde o Para - EJEMPLO
Imprimir todos los nmeros IMPARES desde 1 hasta 300.

Inicio
desde I = 1 hasta 300 incremento 2
imprimir I
fin-desde
fin

for l=1:2:300,
disp(l);
end

1) Vemos los valores: 1, 3, 5, 7, 9, 11, 13, .... , 299

2) El ciclo termina mostrando 299 puesto que en el siguiente paso, la variable I valdra 301 y
es mayor al lmite establecido de 300.
3) I pasa a valer realmente 301 en el ltimo paso, solo que la instruccin de imprimir no se
ejecuta.
4) Si diramos la instruccin de imprimir el valor de I, inmediatamente despus del findesde, veramos 301.

Estructuras Repetitivas
Desde o Para - EJEMPLO
Imprimir los valores comprendidos entre el 460 y 500 en orden inverso.

Inicio
desde I = 500 hasta 460 incremento -1
imprimir I
fin-desde
fin

for l=500:-1:460,
disp(l);
end

Como salida tenemos, entonces:

500, 499, 498, 497, 496, 495, 494, .... 464, 463, 462, 461, 460.

Ciclos con Numero Indeterminado de Iteraciones

Se diferencia de la PARA/DESDE en que no se
conoce el nmero de repeticiones o iteraciones
en que se va a ejecutar una instruccin o un
bloque de instrucciones.
Estas estructuras son bsicamente dos:
mientras....fin-mientras
repetir.... hasta.

Estas dos se diferencian en que la verificacin de

la condicin para repetir el ciclo se hace al inicio
con mientras y al final con repetir.

HACER-MIENTRAS
El cuerpo del bucle se cumple mientras se cumple una determinada
condicin. Por esta razn se los denomina BUCLES CONDICIONALES.

mientras {condicin}
accin 1
accin 2
accin 3
.....
accin n
fin mientras
instruccin X

while condicin,
comando;

end

HACER-MIENTRAS
Lo primero que el computador hace es examinar la condicin, lo que
puede dar como resultado dos posibilidades:
La condicin se cumple: Se ejecutan accin 1, accin 2, accin 3, ...,
accin n.
Las estar repitiendo hasta que la condicin no se cumpla, entonces
se sale del ciclo y se siguen ejecutando la o las instrucciones que
vienen a continuacin y estn fuera del bucle; instruccin X.

La condicin no se cumple: No entrar en el ciclo. Se ejecutan las

instrucciones que vienen despus del bucle, instruccin X, por
ejemplo.
De esto se deduce que el cuerpo del bucle de una estructura
mientras puede repetirse cero o ms veces.

Pseudocdigo

leer contrasea
mientras contrasea < > "josua"
imprimir "La contrasea es incorrecta !
leer contrasea
fin-mientras
imprimir "Ha ingresado la contrasea correcta

Matlab

HACER-MIENTRAS
(EJEMPLO)

contrasea=input(Ingrese su contrasea );
while(contrasea <> josua),
disp(contrasea incorrecta);
contrasea=input(Ingrese su contrasea );
End
disp(Ha ingresado la contrasea correcta);

REPETIR-HASTA
La estructura repetir cumple la misma funcin
que la estructura mientras. La diferencia est
en que la estructura mientras comprueba la
condicin al inicio y repetir lo hace al final; por
eso la estructura repetir se ejecuta por lo
menos una vez.

REPETIR-HASTA
SINTAXIS

repetir
intruccin 1
instruccin 2
instruccin 3
......
hasta {condicin}
instrucin X

Lo que la computadora hace al ejecutar la estructura repetir es:

1) Se ejecutan: instruccin 1, instruccin 2, instruccin 3, ......
2) Se evala la condicin.

Si esta es FALSA se vuelve a repetir el ciclo y se

ejecutan instruccin 1, instruccin 2, instruccin 3, .

Si la condicin es VERDADERA se sale del ciclo y se

ejecuta instruccin X.

Comparacin
mientras - repetir
MIENTRAS
Comprobacin de la condicin al inicio,
antes de entrar al bucle

REPETIR
Comprobacin de la condicin al
final, despus de haber ingresado
una vez al bucle

Las instrucciones del cuerpo del bucle se

Las instrucciones del cuerpo del

ejecutan en forma repetitiva si la

bucle se ejecutan si la condicin es

condicin es verdadera

falsa

Las acciones del bucle se pueden

Las acciones del bucle se ejecutan

ejecutar 0 o ms veces

por lo menos una vez

PROBLEMAS DE ESTRUCTURAS
CCLICAS
Calcular el promedio de un alumno que tiene 7 calificaciones en una materia.
HACER PARA
HACER MIENTRAS
Inicio
Inicio
Sum=0
Sum=0
Hacer para c desde 1 hasta 7 c=1
Leer calif
Mientras (c<=7) hacer
Sum = sum + calif
Leer calif
Fin-para
Sum = sum + calif
prom = sum /7
c= c+1
Imprimir prom
Fin-mientras
Fin.
prom = sum /7
Imprimir prom
Fin.

REPETIR HASTA
Inicio
Sum=0
c=1
Repetir
Leer calif
Sum = sum + calif
c= c+1
Hasta (c>7)
prom = sum /7
Imprimir prom
Fin.

PROBLEMAS DE ESTRUCTURAS
CCLICAS
Leer 10 nmeros y obtener su cubo y su cuarta potencia

HACER PARA
Inicio
Hacer para n desde 1 hasta 10
Leer num
cubo = num * num * num
cuarta = cubo * num
Imprimir cubo, cuarta
Fin-para
Fin.

HACER MIENTRAS
Inicio
C=1
Mientras (c<=10) hacer
Leer num
cubo = num * num * num
cuarta = cubo * num
Imprimir cubo, cuarta
C= c+1
Fin-mientras
Fin.

REPETIR HASTA
Inicio
C=1
Repetir
Leer num
cubo = num * num * num
cuarta = cubo * num
Imprimir cubo, cuarta
C= c+1
Hasta (c>10)
Fin.

PROBLEMAS DE ESTRUCTURAS
CCLICAS
Calcular la suma y el promedio de nmeros ingresados . La cantidad de nmeros a ingresar es
desconocida al momento de ejecutar el algoritmo y todos los nmeros a ingresar se encuentran
en el entorno [0,100]. La carga finaliza cuando se ingresa un nmero fuera de rango.
HACER MIENTRAS
Inicio
HACER PARA
No puede resolverse con esta Sum=0
estructura NO se conoce el Cuenta=0
Leer Num
nmero de iteraciones.
Mientras Num>=0 y
Num<=100 hacer
Sum=Sum+Num
Leer Num
cuenta= cuenta+1
Fin-mientras
Si cuenta>0 entonces
Prom= sum/cuenta
Imprimir Sum, Prom
Fin-Si
Fin.

REPETIR HASTA
No puede resolverse con
esta estructura ya que si el
primer nmero ingresado
se encuentra fuera de
rango igual ejecutara el
bucle, ya que en el Repetirhasta al menos una vez se
ejecuta el bucle.

CUANDO EMPLEAR CADA

ESTRUCTURA REPETITIVA?

Modularizacin
(Funciones y Procedimientos)
En general un problema complejo puede ser resuelto de manera ms fcil
y eficiente si se divide en problemas ms pequeos y concentrndonos en
cada etapa en la solucin de ese "subproblema".
Esto implica que el gran problema original ser resuelto por medio de
varios mdulos, cada uno de los cuales se encarga de resolver un
subproblema determinado. Esos mdulos, se conocen con el nombre de
subalgoritmos.
Los subalgoritmos se escriben slo una vez, luego es posible hacer
referencia a ellos ("llamarlos") desde diferentes puntos de un pseudo
cdigo. La ventaja obvia es que nos permite reutilizacin y evita la
duplicacin de cdigos.
Los subalgoritmos son independientes entre si, en el sentido de que se
puede escribir y verificar cada mdulo en forma separada sin preocuparse
por los dems mdulos. Por ello, es menos complicado localizar un error y
tambin se puede modificar el cdigo sin tener que tocar o rehacer varias
partes del mismo.
Los subalgoritmos pueden ser dos tipos: Funciones y Procedimientos
(tambin llamadas subrutinas o subprogramas).

Modularizacin
(Funciones y Procedimientos)
Notemos que al utilizar procedimientos y funciones se
establece un lmite para el alcance de las variables, unas
tendrn efecto y valor slo en el subalgoritmo y otras en el
algoritmo principal, tambin es posible especificar que una
variable tenga efecto en el algoritmo principal y todos los
subalgoritmos.
Los subalgoritmos pueden recibir valores del algoritmo
principal (parmetros), trabajar con ellos y devolver un
resultado al algoritmo principal: No existen limitaciones en
cuanto a las acciones que pueda ejecutar un subalgoritmo.
Un subprograma puede, a su vez, invocar o llamar a otros o
a sus propios subprogramas, inclusive puede llamarse a s
mismo (esto se conoce como recursividad).

Modularizacin
(Funciones y Procedimientos)
Cada mdulo debe tener un nombre que lo identifique.
Puede tener una serie de parmetros asociados.
El nombre del mdulo es utilizado para la invocacin
del mismo.
Cuando se invoca a un subprograma se transfiere el
control al mismo y una vez finalizada la ltima
instruccin del mdulo el control retornar a la
siguiente instruccin del programa o subprograma que
lo llam.

Modularizacin - Ejemplo
Calcular el factorial de un numero, mediante subprogramas.

PROGRAMA factorial
ENTORNO:
res <- "S"
ALGORITMO:
MIENTRAS res = "S" HACER
Borrar_pantalla( )
factorial <- 1
ESCRIBIR "Numero: "
LEER numero
SI numero < 0 ENTONCES
ESCRIBIR "No tiene factorial"
SINO
HACER Calculos
FINSI
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------

SUBPROGRAMA Calculos
MIENTRAS numero > 1 HACER
factorial <- factorial * numero
numero <- numero - 1
FINMIENTRAS
HACER Imprimir
FINSUBPROGRAMA
-----------------------------SUBPROGRAMA Mas
res <- " "
MIENTRAS res <> "S" Y res <> "N" HACER
ESCRIBIR "Desea calcular ms factoriales (S/N): "
LEER res
res <- Convertir_maysculas( res )
FINMIENTRAS
FINSUBPROGRAMA
-----------------------------SUBPROGRAMA Imprimir
ESCRIBIR "Su factorial es: "
ESCRIBIR factorial
FINSUBPROGRAMA