CICLOS, LAZOS O BUCLES

**IV.- Ciclos, Lazos o Bucles**

Las computadoras están especialmente diseñadas para ejecutar tareas repetidamente. Los cálculos simples o la manipulación de pequeños conjuntos de datos se pueden realizar fácilmente a mano, pero las tareas grandes o repetitivas son realizadas con mayor eficiencia por una computadora. Las estructuras de control repetitivas son aquellas en las que una sentencia o grupos de sentencias se repiten muchas veces. Este conjunto de sentencias se denomina bucle o lazo, y puede presentarse de varias formas, una de las formas es el lazo condicionado, en el cual el proceso de repetición se controla mediante una condición previamente establecida.

Los pasos especificados en el enunciado de repetición se conocen como ámbito del lazo, (es decir, los pasos comprendidos en éste ámbito deben repetirse en tanto la condición sea verdadera). La condición debe evaluarse antes de cada pasada por el lazo (ciclo), si es verdadera el lazo debe ejecutarse una vez más; si es falsa, se ejecutará en seguida el paso siguiente al último del intervalo del lazo. Si la condición es falsa en la primera entrada del lazo, deberá saltarse el lazo completo y dejarse sin ejecutar todos sus enunciados.

Por ejemplo: Suponga que se desea sumar una lista de números escritos desde el teclado. El medio conocido hasta ahora es leer los número y añadir sus valores a una variable SUMA que contenga las sucesivas sumas parciales. La variable SUMA se hace igual a cero y a continuación se incrementa el valor del número cada vez que uno de ellos se lea. El algoritmo sería el siguiente:

inicio
SUMA <--- 0
leer número
SUMA <--- SUMA + número
leer número
SUMA <--- SUMA + número
leer número
fin
star
SUMA <--- 0
read número
SUMA <--- SUMA + número
read número
SUMA <--- SUMA + número
read número
end

y así sucesivamente para cada número de la lista. En otras palabras, el algoritmo repite muchas veces las acciones:

leer número

SUMA <--- SUMA + número

A dichas opciones repetidas se les llama bucles o ciclos, y a la acción (o acciones) que se repite en un bucle se denomina iteración. Lo principal a realizar en el diseño de un bucle es: el contenido de dicho bucle y las veces que debe repetirse.

En el ejemplo anterior necesitamos saber cuantos números se van a sumar, para ello debemos conocer algún medio para detener el ciclo, daremos a una variable N el número que deseamos. Para contar el número de iteraciones usaremos una variable TOTAL que se inicializa a la cantidad de números que se desea y a continuación se decrementa en uno cada vez que el ciclo se repite (este procedimiento añade una acción mas al cuerpo del bucle: TOTAL <--- TOTAL - 1), o bien inicializar la variable TOTAL en 0 o en 1, e ir incrementando en uno a cada iteración hasta llegar al número deseado:

algoritmo suma\_número

inicio

{leer número total en variable N}

TOTAL <--- N {también podría "leer N"}

SUMA <--- 0

{inicio del bucle}

hacer lo siguiente mientras que TOTAL sea mayor que cero

leer número

SUMA <--- SUMA + número

SUMA <--- TOTAL - 1

{fin del bucle}

escribir ‘la suma de los’, N, ‘números es’. SUMA

fin

Como se ha visto, por medio de un lazo apropiado es posible leer grupos adicionales de datos y leer un algoritmo. El problema de leer datos adicionales no constituye una dificultad ya que se conoce el mecanismo de los lazos. La dificultad se presenta en el momento de la detención. Existen varias formas de detener la ejecución de un lazo, una de ellas es agregar un dato que indica el número de veces que debe recorrerse el lazo por completo. Esto se denomina entrada controlada por contador. Para detener la ejecución de los bucles se utiliza una condición de parada. El pseudocódigo de una estructura repetitiva tendrá siempre este formato:

inicio

{inicialización de variables}

repetir

acciones S1, S2, ...

acciones Sn, Sn+1...

salir según condición

fin\_repetir
fin

Hay tres estructuras de control para especificar la repetición: while (mientras), do-while (hacer\_mientras/repetir, repeat) y for (desde).

El algoritmo de suma anterior podría expresarse en pseudocódigo estándar así:

algoritmo SUMA\_números

inicio

leer N

SUMA <-- 0

repetir

salir si TOTAL <= 0

leer número

SUMA <--- SUMA+1

TOTAL <--- TOTAL-1

fin\_repetir

escribir "la suma es", SUMA

fin

Los tres casos generales de estructuras repetitivas dependen de la situación y modo de la condición. La condición se evalúa tan pronto se encuentra en el algoritmo y su resultado producirá los tres tipos de estructuras citadas.

**4.1 Estructura mientras (while)**

La estructura repetitiva mientras (en ingles WHILE) es aquella en que el cuerpo del bucle se repite mientras se cumple una determinada condición. La representación gráfica es:

Pseudocódigo en español

mientras condición hacer

acción S1

acción S2

. .

. .

acción Sn

fin\_mientras

Cuando se ejecuta la instrucción hacer- mientras (while, do-while), se repite mientras el valor de la expresión de la condición sea verdadera.

Ejemplo:

algoritmo SUMA\_números

inicio

{leer número total N}

leer N

TOTAL <--- N

SUMA <--- 0

mientras N > 0 hacer

leer número

SUMA <--- SUMA+número

TOTAL <--- TOTAL+1

fin\_mientras

escribir "la suma de los ",N,"número es", SUMA

fin

En el caso anterior, como la variable TOTAL se va decrementando y su valor inicial era N, cuando tome el valor 0, significará que se han realizado N iteraciones, o, lo que es igual, se han sumado N números y el bucle se debe parar o terminar.

Ejemplo:

Contar los números enteros positivos introducidos por el teclado. Se consideran dos variables enteras NÚMERO y CONTADOR (contará el número de enteros positivos). Se supone que se leen números positivos y se detiene el bucle cuando se lee un número negativo o cero.

inicio

contador <--- 0

leer números

mientras número > 0 hacer

contador <--- contador + 1

leer número

fin\_mientras

escribir "el número de enteros positivos es ", contador

fin

Diagrama de flujo:

**4.2 Bucles infinitos**

Algunos bucles no exigen fin y otros no encuentran el fin por error en su diseño.

Un bucle que nunca se termina se denomina bucle infinito o sin fin. Los bucles sin fin no intencionados son perjudiciales para la programación y se deben evitar siempre.

Por ejemplo: el siguiente bucle visualiza el interés producido por un capital a las tasa de interés comprendidos en el rango desde 10 a 20%.

leer capital

tasa <--- 10

mientras tasa <> 20 hacer

interés <--- tasa \* 0.01 \* capital {tasa\*capital/100=tasa\*0.01\*capital}

escribir "interés producido", interés

tasa <---ß tasa + 2

fin\_mientras

escribir "continuación"

Los sucesivos valores de la tasa serán 10, 12, 14, 16, 18, 20, de modo que al tomar tasa el valor 20 se detendrá el bucle y se escribirá el mensaje "continuación".

Supongamos que se cambia la línea última del bucle por

Tasa <--- tasa + 3

El problema es que el valor de la tasa salta ahora de 19 a 22 y nunca será igual a 20 (10, 13, 16, 19, 22,..). El bucle sería infinito, la expresión booleana para terminar el bucle será:

tasa < 20 o bien tasa > 20

Las pruebas o test en las expresiones booleanas es conveniente que sean mayor o menor que en lugar de pruebas de igualdad o desigualdad.

Existen muchas situaciones en las que se desea que un bucle se ejecute al menos una vez antes de comprobar la condición de repetición. En la estructura mientras si el valor de la expresión booleana es inicialmente falso, el cuerpo del bucle no se ejecutará; por ello se necesitan otros tipos de estructuras repetitivas.

La estructura repetir (repeat) se ejecutara hasta que se cumpla una condición determinada que se comprueba al final del bucle.

Pseudocódigo

Repetir repeat

<acciones> <acciones>

. .

. .

hasta\_que <condicion> until <condicion>

Diagrama de flujo:

El bucle repetir-hasta\_que se repite mientras el valor de la expresión booleana de la condición sea falsa, justo la opuesta de la sentencia mientras.

inicio

contador <--- 1

repetir

leer número

contador <--- contador + 1

hasta\_que contador > 30

escribir "números leídos 30"

fin

En el ejemplo anterior el bucle se repite hasta que el valor de variable contador exceda a 30, lo que sucederá después de 30 ejecuciones del cuerpo del bucle.

Ejemplo:

Desarrolle un algoritmo que calcule el factorial de un número N que responda a la formula:

N! = N \* (N-1) \* (N-2), . . . , 3 \* 2 \* 1

Inicio

leer N

Factorial <--- 1

I <--- I - 1

repetir

Factorial <--- Factorial \* I

I <--- I - 1

Hasta\_que I = N - 1

Escribir "el factorial del número", N, "es", Factorial

fin

Diferencias de las estructuras mientras y repetir

La estructura mientras termina cuando la condición es falsa, mientras que repetir termina cuando la condición es verdadera.

En la estructura repetir el cuerpo del bucle se ejecuta siempre al menos una vez; por el contrario, mientras es más general y permite la posibilidad de que el bucle pueda no ser ejecutado. Para usar la estructura repetir debe estar seguro de que el cuerpo del bucle (bajo cualquier circunstancia) se repetirá al menos una vez.

Ejemplo: Encontrar el entero positivo más pequeño (num) para el cual la suma 1+2+3,...,+num es menor que limite.

1.- introducir limite

2.- inicializar num y suma a 0

3.- repetir las acciones siguientes hasta que suma>limite

\* incrementar num en 1
\* añadir num a suma
4.- visualizar num y suma

inicio

leer limite

num <--- 0

suma <--- 0

repetir

num <--- num+1

suma <--- suma+num

hasta\_que suma > limite

escribir num, suma

Ejemplo:

Escribir los numeros 1 a 100

Num <--- 1

Repetir

escribir num

num <--- num+1

hasta\_que num = 101

**4.3 Estructura desde/para (for)**

En muchas ocasiones se conoce de antemano el número de veces que se desean ejecutar las acciones de un bucle. En estos casos en el que el número de iteraciones es fija, se debe usar la estructura desde o para (for en inglés).

La estructura desde ejecuta las acciones del cuerpo del bucle un número especificado de veces y de modo automatico controla el número de iteraciones o pasos a través del cuerpo del bucle.

Pseudocódigo

Desde variable (v) =vi hasta vf hacer para v desde vi hasta vf hacer

<acciones> <acciones>

. .

. .

. .

fin\_desde fin\_desde

v: variable indice

vi:, vf: valores inicial y final d ela variable.

Calcular la suma de los N primeros enteros

Inicio

Leer I, S, N

S <--- 0

desde I = 1 hasta N hacer

S = S + 1

fin\_desde

escribir "suma = ", S

fin

Ejemplo:

Calcular el factorial de un número N utilizando la estructura desde

El factorial de N responde a la fórmula:

N! = N \* (N-1) \* (N-2) \* (N-3), . . . , 3 \* 2 \* 1

Inicio

leer N

Factorial <--- 1

I <--- I - 1

Desde J = 1 hasta N hacer

Factorial <--- Factorial \* J

fin\_desde

Escribir "el factorial de ", N, "es", Factorial

fin

**4.4 Lazos anidados**

De la misma manera en que es posible incluir dentro de una estructura if-then-else, también es posible incluir un segundo lazo en el interior del intervalo de un lazo cualquiera. Las reglas de anidamiento son similares en los dos casos. La estructura interna debe estar por completo dentro de la estructura externa y no deben existir traslapes.