c) REPETITIVAS

Principalmente tenemos dos casos, aquellos en los que SI sabemos cuantas veces queremos
repetir algo y aquellos casos en los que NO sabemos cuantas veces queremos repetir ese algo.

i) SI sabemos cuantas veces queremos repetir un proceso, es decir hay algún conjunto
instrucciones o sentencias que queremos que se ejecuten un numero determinado de
veces, se debe usar el bloque Para-FinPara, cuya sintaxis es:

Para VC = VI hasta VF incremento Q

...............
............... cuerpo del para
FinPara

Donde VC es la variable de control, VI es el Valor Inicial de la variable de control, VF

es el Valor Final que debe tomar esta variable de control y Q el valor que se incrementa
al anterior valor de dicha variable de control, cada vez que se ejecuten las sentencias que
están dentro del Para (el cuerpo del para).

por ejemplo:
Para i=1 hasta 50 incremento 1
::::::::::::::
FinPara

Que hace que i funcione como contador, tomando los valores 1,2,3,4,......49 y 50. Es
decir, en este caso se procesan 50 veces las instrucciones que están entre Para y FinPara.

El incremento que en este caso es de 1, puede ser cualquier valor, inclusive decimal, por
ejemplo:

Para i=1 hasta 10 incremento 0.1,

que hará que i tome los valores 1, 1.1, 1.2, 1.3, 1.4, ................9.7, 9.8, 9.9, 10

También puede ser negativo, para lo cual los valores inicial y final deben ser los
apropiados. Ejemplo:
Para i = 10 hasta 1 incremento de -1 .

Todas las instrucciones que se encuentran entre Para y FinPara son ejecutadas (el
cuerpo del Para), a menos que hayan condicionales que lo impidan. Cuando en el
procesamiento Lineal se llega a FinPara, este devuelve el control a Para, a fin de que se
evalúe el valor de la variable de control (i en este caso), si aún no se llego al valor final,
se incrementa en el valor del incremento y luego procede a ejecutar nuevamente el cuerpo
del Para. Una vez que se llega a ejecutar por última vez el cuerpo del Para, el control se
transfiere a la instrucción que sigue a FinPara.

El Para puede escribirse también en forma abreviada:

Ejemplo Para i = 1, 50, 1
Algunos Para nos dan construcciones especiales como ser:
Para k=0, 20, 2 nos da los números pares 0, 2, 4, 6, ...... 20,
Para k=1, 19, 2 nos da los números impares 1, 3, 5, 7, ......19 y,
Para k=7, 100,7 nos da los números múltiplos de 7 que son 7, 14, 21, ...

En algunos casos puede un para no ejecutarse, como en el siguiente caso:

A=20 : B=1
Para i=A hasta B incremento 1
::::::::::::::
FinPara
xxxxxxx

Este bloque Para no se ejecuta debido a que, en la primera evaluación que se efectúe
para determinar el valor inicial y el valor final de la variable de control i, y el incremento
que permitiría llegar desde el valor inicial hasta el valor final se ve que es imposible
llegar desde 20 hasta 1 con un incremento positivo de 1, en consecuencia esta
incongruencia hace que este Para no se ejecute. Dicho de otro modo, se ejecuta 0 veces y
luego entonces se prosigue en la instrucción siguiente a FinPara.

Ejemplo 1.- Leídos 10 números, hallar y mostrar su promedio.

INICIO
suma Å 0
Para k=1, 10, 1
Leer x
suma Å suma + x
FinPara
pro Å suma/10
mostrar suma
FIN

Ejemplo 2.- Generar y mostrar la serie de Fibonacci con los primeros 50 números.
Se muestran 2 soluciones, aunque básicamente las 2 son la misma. La diferencia esta en
el conteo de los 50 números.
Solución a)
INICIO
P Å 0 : U Å 1 : Mostrar P, U // mostramos los 2 primeros
Para k = 3, 50 // contamos desde el 3
N Å P + U : Mostrar N
PÅU : UÅN
FinPara
FIN
 Solución b)
INICIO
P Å 0 : U Å 1 : Mostrar P, U // mostramos los 2 primeros
Para k = 1, 48 // faltan generar 48 numeros
N Å P + U : Mostrar N
PÅU : UÅN
FinPara
FIN

Ejemplo 3.- Leídos 2 números A y B, enteros y positivos, efectuar su multiplicación por

el método de sumas sucesivas.

Obviamente la solución consiste en sumar(acumular) A, B veces. A la inversa también es

posible, es decir sumar(acumular) B pero A veces.
INICIO
Leer A, B // suponemos que son enteros y positivos
suma Å 0
Para k=1, A, 1
suma Å suma + B
FinPara
mostrar suma
FIN

El Para se ejecuta A veces, por lo tanto B se acumula en suma A veces. Pero que pasa si
A es 0 (cero) ??. Cual el resultado ??. Es correcto el resultado ??. Y si B es cero ??.

Un Para puede ser parte del cuerpo de otro Para, en consecuencia tenemos Paras
anidados, cosa que es valida y tampoco hay límite en el número de Paras anidados. Por
ejemplo: Leídos 10 números enteros y positivos, diga cuales son números primos.

INICIO
Para k=1, 10
Leer N // suponemos que es entero y positivo
cont Å 0
Para k=1, N, 1
Si (N MOD k = 0 ) // queremos ver si k es divisor de N
Entonces cont Å cont + 1 // contamos los que son divisores de N
FinSi
i FinPara
i Si (cont = 2) // queremos saber si solo tiene 2 divisores
) Entonces Mostrar N, “Es primo”
FinSI
O FinPara
OFIN
O
otro caso de repetición es aquel en el que NO sabemos cuantas veces se debe repetir algo,
solo sabemos que se debe llegar a una cierta situación (llamada condición de
terminación) o que se debe cumplir alguna condición para parar la repetición. Se dan 2
sub-casos:

a) Cuando queremos repetir 0 (cero) o más veces

Es la sentencia Mientras, cuya sintaxis es:
Mientras ( condicion )
:::::::::::::::::
::::::::::::::::: cuerpo del mientras
FinMientras
Como en el caso del Para, el cuerpo del Mientras (todas las instrucciones que están
entre el Mientras y FinMientras) se ejecutan linealmente hasta llegar a FinMientras,
este devuelve el control a Mientras para que se evalúe la condición, de ser valida todavía
la condición se procesa una vez más el cuerpo del Mientras, de lo contrario se transfiere
el control a la instrucción siguiente al FinMientras. Si no se cumple la condición, no se
ingresa al Mientras en cuyo caso se repitió 0 (cero) veces. Por ejemplo:
BÅ1
Mientras ( B=0 )
:::::::::::::::::
FinMientras

En este caso, al evaluarse la condición B=0 del Mientras se encuentra que esto no es
cierto, por lo tanto no se ejecuta la estructura de control Mientras y luego se transfiere el
control a la línea siguiente a FinMientras, es decir se prosigue en dicha línea.

Una forma de garantizar que se ejecute el Mientras seria que inicialmente se cumpla la
condición del Mientras de la manera siguiente:

BÅ0
Mientras ( B=0 )
:::::::::::::::::
FinMientras

Luego el cuerpo del Mientras se ejecutará hasta que la condición (B=0 en este caso) no
se cumpla, para lo cual se deberá proveer la forma de hacerlo (que cambie de valor) que
puede ser como sigue:

BÅ0
Mientras ( B=0 )
:::::::::::::::::
Si ( condición que queremos que se cumpla para abandonar esta estructura)
L Entonces BÅ 1
u FinSi
:::::::::::::::::
FinMientras
ego solo restaría definir la condición que queremos que se cumpla para abandonar la
estructura Mientras, debido a que en la próxima evaluación que se efectúe, la condición
del Mientras ya no se cumplirá (B ya será 1).

Se deberá hacer uso apropiado de estas estructuras de control, porque si bien ciertas
construcciones pueden ser equivalentes, no siempre el uso es apropiado o denota poco
conocimiento del uso de cada tipo de estructura. Por ejemplo:
BÅ0
Mientras ( B<10 ) Para B=1, 10, 1
BÅB+1 ::::::::::::::::
::::::::::::::::: FinPara
FinMientras

Si bien son equivalentes o hacen lo mismo, en tiempo de proceso del computador el

Mientras demandará mas trabajo al computador que el Para. Además, a simple vista se
puede ver que el uno demanda más líneas de código que el otro. En resumen lo apropiado
en este caso es usar el Para.

Ejemplo 1.- Leídos A y B, dos números enteros y positivos, efectuar la división del
mayor entre el menor mostrando el resultado y el resto.

INICIO
RÅ 0
Leer A, B // suponemos que ambos son enteros y positivos
Mientras ( A>=B )
AÅA–B
RÅR+1
FinMientras
Mostrar “el resultado es =”, R, “con resto”, A
FIN

La solución presentada líneas arriba, resuelve el problema para el caso en que se lea 2
números donde A es mayor o igual a B. Que pasa si B es mayor a A ??. Se ejecuta el
Mientras ??. Cual el resultado que se muestra ??.

Una solución a este problema sería la que se muestra a continuación. Puesto que el
mientras supone que A siempre es el mayor, le resta reiterativamente B a A. Luego
entonces, si A no es mayor que B se da lo contrario y pues solamente corresponde
permutar sus valores y proseguir.
INICIO
RÅ 0
Leer A, B //suponemos por ahora que ambos son enteros y positivos
Si (B > A) // Si A no es mayor a B se deben permutar
Entonces aux Å A : A Å B : B Å aux // efectúa la permutación
FinSi
Mientras ( A>=B ) // En esta línea se supone que A es mayor o igual a B
AÅA–B RÅR+1
FinMientras
Mostrar “el resultado es =”, R, “con resto”, A
FIN

Puede una estructura de control Mientras ser parte del cuerpo de otro Mientras, es decir,
se puede tener 2 Mientras anidados, luego no hay limites en el número de ellos anidados.

Puede también darse situaciones en que un Para este dentro un Mientras o viceversa, es
decir anidamientos entre distintas estructuras de control.

Por ejemplo: Generar la serie de Fibonacci hasta encontrar un número primo de mas de 3
dígitos (debemos recordar que un número es primo si solo tiene 2 divisores).

INICIO
PÅ0: UÅ1 : Mostrar P,U
BÅ1
Mientras (B=1)
NÅU+P : Mostrar N
PÅU:UÅN
cont Å 0
Para k=1, N, 1
Si (N MOD k = 0 )
Entonces cont Å cont + 1 // contamos los que son sus divisores
FinSi
FinPara
Si (cont = 2 y N>99) // si tiene 2 divisores y 3 o más dígitos
Entonces BÅ0 // le cambiamos el estado de la condición
FinSi
FinMientras
FIN
Ejemplo 2.- Generar y mostrar la serie de Fibonacci con números de solamente 1, 2 y 3
dígitos.

Solución 1)
INICIO
P Å 0 : U Å 1 : Mostrar P, U
Mientras ( P+U < 1000 )
N Å P + U : Mostrar N
PÅU : UÅN
FinMientras
FIN

Solución 2)
INICIO
Pen Å 0 : Ult Å 1 : Mostrar Pen, Ult
Nue Å Pen + Ult
Mientras ( Nue < 1000 )
Mostrar Nue
Pen Å Ult : Ult Å Nue
Nue Å Pen + Ult
FinMientras
FIN

Solución 3)
INICIO
Pen Å 0 : Ult Å 1 : Mostrar Pen, Ult
Nue Å 0
Mientras ( Nue < 1000 )
Nue Å Pen + Ult
Si Nue < 1000
Entonces Mostrar Nue
FinSi
Pen Å Ult : Ult Å Nue
FinMientras
FIN

Para poder entender mejor cada solución, será conveniente efectuar la prueba de
escritorio, especialmente en la solución c), para saber del porque del condicional.
Igualmente porque la condición en el Mientras de la solución 1 es (P+U<1000) y no
(N<1000)
Ejemplo 3.- Leída una secuencia de números que termina cuando se lee un cero, contar
cuantos positivos y cuantos negativos hay en dicha secuencia.

Solución 1)
INICIO
cp Å 0 : cn Å 0 : NÅ 1
Mientras (N><0)
Leer N
Si N<>0 // para descartar el cero
Entonces // Solo si es distinto de cero puede ser positivo o negativo
Si N>0
Entonces cp Å cp + 1 // si es positivo
Sino cn Å cn +1 // descartado el cero, solo puede ser negativo
FinSi
FinSi
FinMientras
Mostrar “Hay”, cp, “positivos”
Mostrar “Hay”, cn, “negativos”
FIN

En esta solución,Un condicional se ocupa de descartar el cero, el que esta subrayado.

Solución 2)
INICIO
cp Å 0 : cn Å 0
Leer N
Mientras (N><0)
Si N>0
Entonces cp Å cp + 1
Sino cn Å cn +1
FinSi
Leer N
FinMientras
Mostrar “Hay”, cp, “positivos”, “Hay”, cn, “negativos”
FIN

En esta solución, el Mientras se ocupa de controlar el cero luego el cuerpo del Mientras
solo debe considerar positivos y negativos.
b) Cuando queremos repetir 1 o más veces (al menos 1).- Esta estructura repetitiva
tiene la siguiente sintaxis:

Hacer
:::::::::
:::::::::
Mientras ( condición )

El proceso que se ejecuta es similar al del Para y el Mientras, con la única diferencia de
que el control se evalúa en el Mientras (abajo), en vez de hacerse en la primera línea del
bloque como en los 2 casos anteriores. Si no se cumple la condición del Mientras, el
control se transfiere a la línea que sigue al Mientras pero, de todas maneras el bloque en
cuestión ya se ejecuto una vez

Ejemplo 1.- Generar y mostrar la serie de Fibonacci con números de solamente 1, 2 y 3

dígitos.
INICIO
P Å 0 : U Å 1 : Mostrar P, U
Hacer
N Å P + U : Mostrar N
PÅU : UÅN
Mientras ( P+U < 1000 )
FIN

Ejemplo 2.- Leída una secuencia de números que termina cuando se lee un cero, contar
cuantos positivos y cuantos negativos hay en dicha secuencia.

INICIO
cp Å 0 : cn Å 0
Hacer
Leer N
Si N>0
Entonces cp Å cp + 1
FinSi
Si N<0
Entonces cn Å cn + 1
FinSi
Mientras (n><0) // la condición significa n distinto de 0
Mostrar “Hay”, cp, “positivos”
Mostrar “Hay”, cn, “negativos”
FIN