Sesión 9

Ciclos, patrones iterativos y control de flujo

Unidad 2 · Los ciclos y su utilidad en la escritura de algoritmos

Navegación: ← → · Home / End · F pantalla completa · Táctil: desliza

Qué vas a dominar al final de la sesión

Distinguir con precisión cuándo usar while, do-while y for según la naturaleza del problema.
Diseñar ciclos seguros evitando errores de off-by-one y bucles infinitos involuntarios.
Construir patrones robustos con contadores, acumuladores y banderas lógicas.
Aplicar control de flujo avanzado con break y continue sin generar "código espagueti".
Integrar todo en un ejemplo práctico: sistema de caja registradora con validación fuerte de entradas.

Agenda (180 minutos)

0–20 min · Fundamentos de la iteración y principio DRY.
20–40 min · Scope y ciclo de vida de variables dentro y fuera de bucles.
40–70 min · Tipos de ciclos: while vs do-while vs for (heurística realista).
70–105 min · Patrones de diseño: contadores, acumuladores y banderas.
105–130 min · Anti-patrones, bucles infinitos y control con break/continue.
130–175 min · Ejemplo integrador: caja registradora robusta con TryParse.
175–180 min · Preguntas y aclaraciones focalizadas (dudas de profundidad).

Principio DRY

Don't Repeat Yourself. Cada bloque copiado/pegado es deuda técnica: si cambia la regla, debes buscar y corregir N lugares distintos.

Código duplicado = más probabilidad de inconsistencias.
Los ciclos centralizan la lógica y repiten solo los datos, no el algoritmo.

Analogía mínima

Imagina sumar las ventas de 365 días:

Versión ingenua: 365 líneas total = total + ventaDiaX;
Versión iterativa: 4 líneas con un for que recorre un arreglo de ventas.

Tres componentes indispensables

Inicialización: Estado inicial (contador en 0, acumulador en 0, bandera en true).
Condición: Pregunta lógica que decide si seguimos o detenemos el ciclo.
Actualización: Cambio en las variables que evita que la condición sea true para siempre.

Ejemplo genérico

int i = 0; // Inicialización while (i < 5) // Condición { Console.WriteLine(i); i = i + 1; // Actualización }

Si omites la actualización, i nunca cambia y el ciclo es infinito.

Ciclo de vida en memoria

Las variables declaradas dentro de un bloque { } existen solo mientras se ejecuta ese bloque.

int suma = 0; // Vive en el método completo while (suma < 100) { int parcial = 10; // Se crea y se destruye en cada vuelta suma += parcial; } // Aquí 'suma' existe, 'parcial' NO.

Regla práctica

Declara fuera del ciclo: contadores, acumuladores, banderas.
Declara dentro del ciclo: variables temporales que solo importan en esa vuelta.

Mala práctica

while (true) { int intentos = 0; intentos++; Console.WriteLine(intentos); }

El contador se reinicia a 0 en cada vuelta; el valor impreso será siempre 1.

Buena práctica

int intentos = 0; while (true) { intentos++; Console.WriteLine(intentos); }

El contador persiste fuera del ciclo; se observan 1, 2, 3, ... en la salida.

Características

La condición se evalúa antes del bloque.
Puede ejecutarse 0 veces (si la condición inicial es false).
Ideal cuando no sabes cuántas iteraciones vas a necesitar.

Ejemplo contextual

Console.Write("Ingrese un número positivo: "); int n = int.Parse(Console.ReadLine()); while (n <= 0) { Console.Write("Error. Ingrese un número positivo: "); n = int.Parse(Console.ReadLine()); }

Características

Siempre ejecuta el bloque al menos una vez.
La condición se evalúa al final.
Útil para menús y validaciones que requieren mostrar algo al menos una vez.

Ejemplo menú

int opcion; do { Console.WriteLine("1. Depositar"); Console.WriteLine("2. Retirar"); Console.WriteLine("0. Salir"); Console.Write("Opción: "); opcion = int.Parse(Console.ReadLine()); } while (opcion != 0);

Firma clásica

for (int i = 1; i <= 5; i++) { Console.WriteLine($"Iteración {i}"); }

Tres partes: inicialización · condición · actualización.

Cuándo usar for

Conoce el número exacto de repeticiones desde el inicio.
Recorres estructuras indexadas: arreglos, listas.
Necesitas un índice explícito a cada paso.

Ciclo	Evalúa condición	Iteraciones mínimas	Uso típico
while	Antes del bloque	0	Repetir mientras una condición externa se cumpla (lecturas, búsquedas).
do-while	Después del bloque	1	Menús, validaciones que siempre se muestran al menos una vez.
for	Antes del bloque	0	Recorridos con cantidad de vueltas conocida, estructuras indexadas.

Definición

Variable que registra cuántas veces ocurre algo.

int mayoresDeEdad = 0; for (int i = 0; i < 5; i++) { Console.Write("Edad: "); int edad = int.Parse(Console.ReadLine()); if (edad >= 18) { mayoresDeEdad++; // Contador } }

Errores comunes

No inicializar a 0 → residuos de memoria (en otros lenguajes).
Ubicar el ++ en el lugar equivocado (antes o después de la condición).
Condición mal elegida → Cuenta 4 cuando debió ser 5 (off-by-one).

Definición

Variable que va sumando (o combinando) valores sucesivos.

decimal suma = 0m; int cantidad = 0; for (int i = 0; i < 3; i++) { Console.Write("Nota: "); decimal nota = decimal.Parse(Console.ReadLine()); suma += nota; // Acumulador cantidad++; // Contador } decimal promedio = suma / cantidad;

Precisión numérica

En finanzas: usar decimal en lugar de double.
Las operaciones dentro de un ciclo se repiten muchas veces; pequeños errores flotantes se acumulan.

Definición

Variable bool que representa un estado: activo / inactivo, encontrado / no encontrado, continuar / salir.

bool encontrado = false; int i = 0; while (!encontrado && i < arreglo.Length) { if (arreglo[i] == buscado) { encontrado = true; // Cambia el estado } i++; }

Ventajas frente a múltiples break

La condición del ciclo explica el objetivo (!encontrado).
Evita saltos abruptos de flujo que dificultan leer el código.

Bucle infinito involuntario

int x = 0; while (x < 10) { Console.WriteLine(x); // Falta actualizar x }

La condición siempre es true; el valor de x nunca cambia.

Condición imposible / trivial

while (i > 10 && i < 5) → Nunca entra.
while (true) sin bandera ni break controlado → bloqueo total.

break

for (int i = 0; i < 100; i++) { if (arreglo[i] == buscado) { Console.WriteLine("Encontrado"); break; // Sale del for } }

continue

for (int i = 0; i < 10; i++) { if (i % 2 == 0) { continue; // salta pares } Console.WriteLine(i); // Solo imprime impares }

Requerimiento funcional

Permitir ingresar precios de artículos hasta que el usuario digite 0.
Rechazar entradas no numéricas o negativas y volver a pedir el valor.
Al finalizar, mostrar número de artículos válidos y subtotal.
Usar al menos: while, do-while, TryParse, contador, acumulador y bandera.

decimal subtotal = 0m; // Acumulador int cantidadArticulos = 0; // Contador bool registrarOtro = true; // Bandera Console.WriteLine("=== SISTEMA DE CAJA ==="); while (registrarOtro) { decimal precio = 0m; bool entradaValida = false; // Sub-ciclo de validación estricta do { Console.Write($"\nPrecio del art #{cantidadArticulos + 1} (0 para finalizar): "); string entrada = Console.ReadLine(); if (decimal.TryParse(entrada, out precio) && precio >= 0) { entradaValida = true; } else { Console.WriteLine("Error: ingrese un número válido y >= 0."); } } while (!entradaValida);

// Lógica de negocio después de validar if (precio == 0) { registrarOtro = false; // Cambia la bandera y salimos del while principal } else { subtotal += precio; // Actualiza acumulador cantidadArticulos++; // Actualiza contador } } Console.WriteLine("\n=== RESUMEN COMPRA ==="); Console.WriteLine($"Artículos procesados: {cantidadArticulos}"); Console.WriteLine($"Total a pagar: ${subtotal:N2}");

Observa cómo cada patrón (contador, acumulador, bandera) tiene un rol claro y evita estados inconsistentes.

Lo que debe quedar sólido

Los ciclos son una herramienta para evitar duplicación de lógica y manejar datos de tamaño variable.
El tipo de ciclo adecuado depende de la información disponible (número de vueltas conocido o no) y de la experiencia de usuario requerida.
Patrones de contadores, acumuladores y banderas son la base de casi todos los algoritmos iterativos.
La robustez viene de combinar buena elección de ciclo, correcto scope y validación de entradas.