Lógica de Programación (22) - Estructuras repetitivas anidadas

Así como podemos anidar estructuras de selección, también es posible insertar un ciclo dentro de otro. Las reglas para construir estructuras repetitivas anidadas son las mismas en ambos casos: la estructura interna debe estar incluida totalmente dentro de una estructura externa y no puede haber solapamiento. En esta gráfica vemos algunos ejemplos de cómo deberían verse (estructuralmente) los ciclos anidados:

Las variables de control de los ciclos toman valores de modo tal que por cada valor de la variable de control del ciclo externo se debe ejecutar totalmente el ciclo interno. Es posible anidar cualquier tipo de estructura repetitiva, siempre y cuando se cumplan las condiciones de la figura anterior.

El mejor ejemplo que tenemos de ciclos anidados es el de un reloj, ya que por cada vuelta de la manecilla de las horas (el ciclo externo), la manecilla de los minutos (el ciclo interno) debe dar 60 vueltas; a su vez, por cada vuelta de la manecilla de los minutos, la de los segundos debe completar 60 vueltas también. Un algoritmo para representar el funcionamiento de un reloj se vería algo así:

algoritmo Reloj

var

   entero: hora, minuto, segundo

inicio

   desde hora <- 0 hasta 23 hacer

      desde minuto <- 0 hasta 59 hacer

         desde segundo <- 0 hasta 59 hacer

            escribir (hora + ";" + minuto + ":" + segundo)

         fin_desde

      fin_desde

   fin_desde

fin

En este ejemplo, el ciclo controlado por la variable segundo deberá dar 60 vueltas para que el ciclo controlado por minuto pueda dar una vuelta. A su vez, este último ciclo deberá dar 60 vueltas para que el ciclo más externo, el que es controlado por la variable hora pueda dar una vuelta.

Mira cómo funciona este programa en C#:

Observa que la salida de este programa nos muestra la siguiente secuencia:
0:0:0
0:0:1
0:0:2
0:0:3
0:0:4
0:0:5
0:0:6
0:0:7
...
0:0:59
0:1:0
0:1:1
0:1:2
0:1:3
0:1:4
0:1:5
0:1:6
0:1:7

...

0:1:59
0:2:0
0:2:1
0:2:2
0:2:3
0:2:4
0:2:5
0:2:6
0:2:7

Lo cual concuerda perfectamente con el comportamiento que esperamos para nuestro programa.

En este otro algoritmo, visualizamos las tablas de multiplicar de los números del 1 al 9.

algoritmo Tablas_Multiplicar
var
   entero: i,j, prod
inicio
   desde i<-1 hasta 9 hacer
      desde j<-1 hasta 10 hacer
         escribir(i + "x" + j + "=" + prod)
      fin_desde
   fin_desde
fin

En este algoritmo, el ciclo interno, controlado por j deberá dar 10 vueltas completas antes de que el ciclo exterior, controlado por i, pueda dar una vuelta, dándonos una salida similar a la siguiente:

1x1=1
1x2=2
1x3=3
...
1x10=10
2x1=2
2x2=4
2x3=6
...
2x10=20
3x1=3
3x2=6
3x3=9
...

Mira cómo se ve este programa funcionando en C#



En los dos ejemplos anteriores hemos usado ciclos desde pero, ¿podemos anidar otra clase de estructuras repetitivas? la respuesta es: sí, si podemos. Mira este otro ejemplo. Ahora vamos a hacer un algoritmo que nos permita calcular el promedio de las 5 calificaciones obtenidas por un grupo de alumnos (del cual no sabemos el tamaño) y vamos a ir mostrando en cada iteración el promedio obtenido; al mismo tiempo, vamos a mostrar el promedio general del grupo una vez que se hayan terminado de capturar las calificaciones de todos los alumnos.

algoritmo promedios
var
   entero: i, cal, suma_alum, suma_grupo, num_alumnos
   real: promedio_alum, promedio_grupo
   cadena: respuesta
inicio
   num_alumnos<-1
   suma_grupo<-0
   hacer
      suma_alum<-0
      desde i<-1 hasta 5 hacer
         escribir("Dame la calificación número " + i + " del alumno " + num_alumnos)
         leer(cal)
         suma_alum <- suma_alum + cal
      fin_desde
      promedio_alum = suma_alum / 5
      escribir ("El promedio del alumno número " + i + " es de " + promedio_alum)
      suma_grupo<- suma_grupo + promedio_alum

      escribir ("¿Deseas capturar las calificaciones de otro alumno? S/N")
      leer(respuesta)
      si (respuesta="S") entonces
         num_alumnos++
      fin_si
   fin_hacer
   promedio_grupo = suma_grupo / num_alumnos
   escribir("El promedio total del grupo es " + promedio_grupo)
fin

Prueba el programa en C#:



Como vemos, en este algoritmo anidamos un ciclo desde dentro de un ciclo hacer-mientras, lo cual comprueba que podemos anidar cualquier clase de estructuras haciendo a nuestros programas bastante versátiles y potentes.

Es con esta lección que damos cierre a la tercera sección de nuestro curso de Lógica de Programación. En la siguiente sección aprenderemos todo sobre la creación de subprocedimientos y funciones para ogranizar mejor nuestros programas, especialmente cuando se trata de aplicaciones más extensas y complejas.

Pero por ahora, toca practicar. Resuelve estas actividades propuestas y no dudes en contactarme si tienes alguna duda o comentario al respecto. ¡Hasta la próxima!

ACTIVIDADES DE APRENDIZAJE

1. Escribe un programa que muestre una cuadrícula de m filas por n columnas y un caracter que el usuario desee mostrar. Por ejemplo, si el usuario decide mostrar una cuadrícula de 5 filas por 3 columnas mostrando una letra x, debería verse algo como esto:
xxx
xxx
xxx
xxx
xxx

2. Crea un algoritmo que simule el funcionamiento de una caja registradora. Por cada artículo se debe leer la cantidad, el precio unitario y la descripción. Al final debe mostrarse una lista de los artículos comprados, la cantidad de artículos y el total a pagar, incluyendo además el IVA del 16%.

3. Modifica el ejemplo de los promedios creado en esta lección, pero ahora supón que no conocemos cuántas calificaciones se van a capturar por cada alumno. Es decir, un alumno puede tener 3 calificaciones, otro puede tener 5, otro puede sólo tener 1, etcétera.