2.04 · Repetitivas: `while` (precondición)

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Explicar qué es una estructura repetitiva y por qué es la base de toda la programación real.
2. Escribir bucles while simples que repitan un bloque mientras una condición sea verdadera.
3. Identificar la precondición del bucle y evitar los bucles infinitos (el error #1 de los programadores junior).
4. Combinar while con contadores, acumuladores y centinelas para resolver problemas clásicos.
5. Diferenciar entre while, do-while y for (los 3 tipos de bucles) y saber cuándo usar cada uno.
6. Validar entradas del usuario con while + reintentos hasta que sean correctas.
7. Trazar bucles manualmente para entender su comportamiento con datos específicos.

Este es el primer tema donde tus programas pueden **repetir acciones**. Con `while`, una calculadora puede pedir números hasta que el usuario quiera salir; un sistema de login puede pedir la contraseña hasta que sea correcta; un juego puede pedir acciones hasta que el jugador pierda.

🧠 Teoría y conceptos — 2.4.1 — El problema: programas que necesitan repetir

El límite de los programas secuenciales y selectivos

Hasta ahora, tus programas pueden:

• Ejecutar instrucciones una tras otra (secuencial).
• Tomar decisiones (selectiva: if, switch).

Pero hay programas que necesitan repetir una acción muchas veces:

• Pedir al usuario números hasta que escriba 0.
• Sumar las calificaciones de un grupo de 30 alumnos.
• Preguntar la contraseña hasta que sea correcta (máximo 3 intentos).
• Mostrar un menú hasta que el usuario elija "Salir".
• Buscar un elemento en una lista de 1 millón.

Sin estructuras repetitivas, tendrías que escribir el mismo código 30, 100, 1000 veces. Imposible. Las estructuras repetitivas resuelven esto.

Definición formal

Una estructura repetitiva (o bucle) permite ejecutar un bloque de código múltiples veces, controlando la repetición mediante una condición.

Los 3 tipos de bucles

Este tema cubre `while`. Los otros dos vienen en los Temas 2.5 y 2.6.

2.4.2 — La estructura while: sintaxis, semántica, flujo

Sintaxis en C++

while (condición) {

// cuerpo del bucle: instrucciones que se repiten

// ...

}

Anatomía:

Cómo funciona (paso a paso)

1. Se evalúa la condición.
2. Si es verdadera (true / distinto de 0), se ejecuta el cuerpo.
3. Al terminar el cuerpo, se vuelve al paso 1 (se re-evalúa la condición).
4. Si la condición es falsa (false / 0), el bucle termina y se continúa con lo que sigue.

Clave: la condición se evalúa ANTES de cada iteración. Si desde el inicio es falsa, el cuerpo nunca se ejecuta.

El ejemplo clásico: contar del 1 al 5

#include <iostream>
using namespace std;
int main() {

int contador = 1; // Inicialización: variable de control

while (contador <= 5) {  // Condición: continuar mientras contador <= 5
cout << contador << endl;  // Cuerpo: imprimir el contador

contador = contador + 1; // Actualización: incrementar el contador

}

cout << "Fin del bucle" << endl;
return 0;

}

Traza:

Salida:

1

2

3

4

5

Fin del bucle

Las 3 partes de un while correcto

Para que un while funcione bien, necesitas las 3 partes:

1. Inicialización (antes del bucle): la variable de control tiene un valor inicial.
2. Condición (en el while): decide si se sigue iterando.
3. Actualización (dentro del cuerpo): cambia la variable de control para que la condición eventualmente sea falsa.

int contador = 1; // 1. Inicialización

while (contador <= 5) {    // 2. Condición
cout << contador << endl;

contador++; // 3. Actualización

}

Si te falta CUALQUIERA de las 3 partes, el bucle se comporta mal. (Por ejemplo, sin actualización, se vuelve infinito.)

Diagrama de flujo clásico del while (simbología ANSI/ISO)

┌─────────────┐

│ INICIO │ ⬭

└──────┬──────┘

│

▼

╱─────────────╲

║ INICIALIZAR ║ ▭ (proceso)

║ contador = 1 ║

╲ ╱

╲─────────────╱

│

▼

◆─────────────◆ ◇ (decisión: precondición)

╱ ╲

contador <= 5? No ─────────►

──────── │

│ │ │

Sí │ │ No │

│ │ │

▼ │ ▼

╱──────────────╲ ┌─────────────┐

║ CUERPO: ║ │ [después │ ▭

║ imprimir y ║ │ del bucle] │

║ incrementar ║ └──────┬──────┘

╲ ╱ │

╲────────────────╱ │

│ │

└───────────┬───────────┘

│

└───► (vuelve al rombo de decisión)

Lo que muestra el diagrama: la flecha "No" del rombo lleva DIRECTAMENTE al final del bucle. La flecha "Sí" ejecuta el cuerpo y vuelve al rombo (no a INICIO). Esto es lo que hace único al `while`: la condición se evalúa al inicio, y el bucle puede NO ejecutarse nunca si la condición es falsa desde el principio.

2.4.3 — La precondición: la clave del while

Qué es la precondición

La precondición del while es la condición que se evalúa antes de cada iteración. Es el "filtro" que decide si el cuerpo se ejecuta.

La precondición garantiza que el bucle se detenga cuando la condición sea falsa. Si la precondición nunca se vuelve falsa, el bucle se ejecuta para siempre (bucle infinito).

La regla de oro: la precondición debe ser modificable DENTRO del cuerpo

// ✅ BIEN: la variable de control (i) cambia dentro del cuerpo

int i = 1;

while (i <= 5) {
cout << i << endl;

i++; // <-- Esto hace que eventualmente i > 5, terminando el bucle

}

// ❌ MAL: la variable de control (x) NO cambia, bucle infinito

int x = 1;

while (x <= 5) {
cout << x << endl;

// Falta x++; aquí

}

Ejemplo: leer números hasta que el usuario ingrese 0

#include <iostream>
using namespace std;
int main() {

int numero;

int suma = 0;

int contador = 0;

cout << "Ingresa números (0 para terminar):" << endl;
cin >> numero;
while (numero != 0) {

suma = suma + numero;

contador++;

cin >> numero;

}

if (contador > 0) {
cout << "Suma: " << suma << endl;
cout << "Promedio: " << (double)suma / contador << endl;
cout << "Cantidad: " << contador << endl;
} else {
cout << "No ingresaste números." << endl;

}

return 0;

}

Traza con entrada: 10, 5, 3, 0:

Salida:

Suma: 18

Promedio: 6

Cantidad: 3

Variación: leer el primer número ANTES del bucle

Fíjate en la estructura del ejemplo anterior: el primer cin >> numero está fuera del bucle. Esto es porque la precondición (numero != 0) se evalúa ANTES de entrar al bucle, así que necesitamos tener un valor para comparar desde el principio.

El patrón "priming read":

// 1. Leer el primer valor (antes del bucle)

cin >> numero;

// 2. Mientras no sea el valor de salida, procesarlo

while (numero != 0) {

// ... hacer algo con numero

cin >> numero;  // 3. Leer el siguiente

}

2.4.4 — Bucles infinitos: el error #1 y cómo evitarlo

Qué es un bucle infinito

Un bucle infinito es un bucle cuya condición nunca se vuelve falsa, por lo que se ejecuta eternamente (hasta que cierres el programa a la fuerza).

Es el error #1 de los programadores junior. Todos lo cometemos alguna vez. La diferencia entre junior y senior es que el senior lo detecta y corrige rápido.

Las 3 causas más comunes

Causa 1: Olvidaste la actualización.

// ❌ MAL: i nunca cambia, siempre será 1

int i = 1;

while (i <= 5) {
cout << i << endl;

// Falta i++

}

Solución: siempre incluir la actualización.

Causa 2: La condición siempre es verdadera por error.

// ❌ MAL: x siempre será 5, no se decrementa

int x = 5;

while (x != 0) {
cout << x << endl;

// x no se modifica

}

Solución: verificar la lógica de la condición.

Causa 3: La variable de control se resetea dentro del bucle.

// ❌ MAL: i se resetea a 0 cada iteración

int i = 0;

while (i < 5) {
cout << i << endl;

i = 0; // <-- Esto borra el progreso

}

Solución: nunca resetees la variable de control dentro del bucle.

Cómo interrumpir un bucle infinito en C++

Si tu programa entra en bucle infinito, no entres en pánico:

Aprende este atajo de memoria: `Ctrl + C` mata cualquier programa que esté en bucle infinito.

Cómo evitar bucles infinitos (5 reglas)

1. Inicializa la variable de control antes del bucle.
2. Asegúrate de que la condición se vuelve falsa en algún momento.
3. Actualiza la variable de control DENTRO del cuerpo.
4. No resetees la variable de control dentro del bucle.
5. Traza el bucle con 2-3 datos de prueba para verificar que termina.

La técnica del "bucle con tope de seguridad"

A veces, por bug, un bucle podría volverse infinito. Para protegerte, agrega un contador de iteraciones que rompa el bucle si pasa de un máximo razonable:

int intentos = 0;

while (condicionUsuario && intentos < 1000) {

// cuerpo del bucle

intentos++;

}

Es una red de seguridad. En producción, no debería activarse, pero si la lógica tiene un bug, evita que tu programa se cuelgue para siempre.

2.4.5 — Patrones básicos: contadores y acumuladores dentro de while

Patrón 1: Contador

Un contador es una variable entera que se incrementa (o decrementa) en cada iteración. Sirve para contar cuántas veces pasó algo.

int contador = 0; // Inicialización

while (/* condición */) {

// ... cuerpo ...

contador++; // Actualización

}

// Al final, `contador` tiene el número de iteraciones

Ejemplo: contar cuántos números positivos ingresaste.

int contadorPositivos = 0;

int numero = 0;

cout << "Ingresa números (0 para terminar):" << endl;
cin >> numero;
while (numero != 0) {
if (numero > 0) {

contadorPositivos++;

}

cin >> numero;

}

cout << "Positivos: " << contadorPositivos << endl;

Patrón 2: Acumulador

Un acumulador es una variable (entera o flotante) que suma valores en cada iteración. Sirve para calcular un total.

double acumulador = 0; // Inicialización (en 0)

while (/* condición */) {

// ... cuerpo que calcula un valor ...

acumulador = acumulador + valor; // Acumulación

}

// Al final, `acumulador` tiene la suma de todos los valores

Ejemplo: sumar números hasta que el usuario ingrese 0.

double suma = 0;

int numero = 0;

cout << "Ingresa números (0 para terminar):" << endl;
cin >> numero;
while (numero != 0) {

suma = suma + numero; // suma += numero es equivalente

cin >> numero;

}

cout << "Suma: " << suma << endl;

Patrón 3: Bandera (flag)

Una bandera o flag es una variable booleana que indica si algo pasó. Sirve para detectar eventos dentro del bucle.

bool encontrado = false; // Inicialización (false)

while (/* condición */ && !encontrado) {
if (/* algo pasó */) {

encontrado = true;

}

}

Ejemplo: buscar un número en una secuencia.

int numero, objetivo;

bool encontrado = false;

int contador = 0;

cout << "Número a buscar: "; cin >> objetivo;
cout << "Ingresa números (0 para terminar):" << endl;
cin >> numero;
while (numero != 0 && !encontrado) {

contador++;

if (numero == objetivo) {

encontrado = true;

} else {
cin >> numero;

}

}

if (encontrado) {
cout << "Encontrado en el intento " << contador << endl;
} else {
cout << "No encontrado" << endl;

}

Patrón 4: Centinela

Un centinela es un valor especial que indica el fin de la entrada de datos. Es lo que usamos en los ejemplos anteriores con el 0 o -1 como señal de parada.

Regla del centinela:

• Elige un valor que nunca sea un dato válido (por ejemplo, -1 para edades, "" para nombres, 0 para calificaciones).
• El bucle se repite hasta que el usuario ingrese el centinela.
• El centinela NO se procesa como dato válido.

Diagrama de flujo clásico del patrón "centinela"

┌─────────────┐

│ INICIO │ ⬭

└──────┬──────┘

│

▼

╱─────────────╲

║ LEER numero ║ ▱ (PRIMING READ)

╲ ╱

╲─────────────╱

│

▼

◆─────────────◆ ◇ (precondición)

╱ ╲

numero != 0? No (centinela) ─────►

──────── │

│ │ │

Sí │ │ No │

│ │ │

▼ │ ▼

╱───────────────╲ ┌──────────────┐

║ PROCESAR numero ║ │ Mostrar │ ▭

║ (sumar, contar) ║ │ resultados │

║ ║ └──────┬───────┘

╲ ╱ │

╲───────────────╱ │

│ │

▼ │

╱───────────╲ │

║ LEER numero ║ ▱ │

╲ ╱ │

╲────────────╱ │

│ │

└──────►─────────┘

│

└───► (vuelve al rombo de decisión)

2.4.6 — Validación de entradas con while + reintentos

El patrón fundamental

En todos los programas interactivos, necesitas validar que el usuario ingrese datos correctos. El patrón es:

// 1. Pedir el dato

cout << "Dato: ";
cin >> dato;

// 2. Mientras el dato sea inválido, pedirlo de nuevo

while (/* dato inválido */) {
cout << "Dato inválido. Intenta de nuevo: ";
cin >> dato;

}

// 3. Continuar con el dato válido

Ejemplo: pedir una edad válida (entre 0 y 150)

#include <iostream>
using namespace std;
int main() {

int edad;

cout << "Ingresa tu edad: ";
cin >> edad;
while (edad < 0 || edad > 150) {
cout << "Edad inválida. Debe estar entre 0 y 150." << endl;
cout << "Ingresa tu edad: ";
cin >> edad;

}

cout << "Tu edad es: " << edad << endl;
return 0;

}

Ejemplo: login con 3 intentos

#include <iostream>
#include <string>
using namespace std;
int main() {

string usuarioCorrecto = "admin";

string passwordCorrecto = "12345";

string usuario, password;

int intentos = 0;

const int MAX_INTENTOS = 3;

bool accesoPermitido = false;

while (intentos < MAX_INTENTOS && !accesoPermitido) {
cout << "\nUsuario: "; cin >> usuario;
cout << "Contraseña: "; cin >> password;

intentos++;

if (usuario == usuarioCorrecto && password == passwordCorrecto) {

accesoPermitido = true;

} else {
cout << "Credenciales incorrectas. Intentos restantes: "

<< (MAX_INTENTOS - intentos) << endl;

}

}

if (accesoPermitido) {
cout << "Acceso permitido. Bienvenido." << endl;
} else {
cout << "Cuenta bloqueada tras " << MAX_INTENTOS << " intentos." << endl;

}

return 0;

}

Traza con usuario="admin", password="0000", "1234", "12345":

⚠️ Errores típicos — ❌ Errores típicos del razonamiento

Error 1: "Si funciona, no importa que sea feo"

Idea equivocada: "Mi while hace lo que quiero, ¿para qué refactorizarlo?"

Realidad: un while con la actualización mezclada con la lógica de negocio es difícil de leer y mantener. Siempre separa las 3 partes (inicialización, condición, actualización) cuando sea posible.

Cómo evitarlo: aplica la regla de las 3 partes en cada bucle que escribas.

Error 2: "El bucle infinito no me va a pasar a mí"

Idea equivocada: "Ya revisé la lógica, mi bucle termina."

Realidad: los bucles infinitos pasan a TODOS, incluso a programadores con 20 años de experiencia. La diferencia es que ellos los detectan y corrigen rápido porque siempre trazan antes de ejecutar.

Cómo evitarlo: traza SIEMPRE tus bucles con 2-3 datos de prueba antes de ejecutarlos. Si la traza muestra que termina, el código también.

Error 3: "El priming read es opcional, mejor leo dentro del bucle"

Idea equivocada: "Mejor meto el cin dentro del bucle, más limpio."

Realidad: sin priming read, la condición no tiene con qué comparar en la primera iteración. La variable tendría un valor basura. Resultado: comportamiento indefinido o bucle infinito.

Cómo evitarlo: SIEMPRE lee el primer valor fuera del bucle cuando uses centinela. Memorízalo: priming read ANTES del while.

Error 4: "Las llaves en el while son opcionales, el código se ve más limpio sin ellas"

Idea equivocada: "Si el cuerpo es una sola línea, no necesito {}."

Realidad: sin llaves, el cuerpo del while es SOLO la primera instrucción. Si agregas una segunda, NO entra al bucle. Es un bug sutil.

Cómo evitarlo: SIEMPRE usa {}, aunque sea una sola línea.

Error 5: "Mi bucle cuenta del 1 al 5, pero la condición es i < 5 así que cuenta hasta 4"

Idea equivocada: "< y <= se confunden, no importa cuál use."

Realidad: importa. Con i <= 5 y i empezando en 1, cuenta 1, 2, 3, 4, 5. Con i < 5, cuenta 1, 2, 3, 4 (5 no entra). Elige el operador correcto para tu intención.

Cómo evitarlo: traza con datos. Si tu intención es contar hasta 5, verifica que el último valor impreso sea 5.

🤖 IA como copiloto — 🤖 AI Mission 2.4 — Bucles con IA

Regla de los 3 minutos (obligatoria): primero intenta por tu cuenta.

Prompts sugeridos

Prompt 1 — Detectar bucle infinito:

"Te voy a pegar un bucle `while` en C++ que se queda ejecutándose para siempre. NO me lo corrijas. Solo dime: (1) qué hace línea por línea, (2) por qué no termina, (3) qué falta. Máximo 100 palabras."

Prompt 2 — Optimizar bucle:

"Te voy a pegar un bucle `while` en C++ que funciona pero creo que se puede mejorar. NO me lo reescribas. Solo dime: (1) qué hace, (2) si hay un patrón conocido (contador, acumulador, centinela), (3) cómo se podría hacer más claro. Máximo 100 palabras."

Prompt 3 — Convertir while a for:

"Te voy a pegar un `while` en C++. NO me lo conviertas. Solo dime: (1) qué hace, (2) si se puede convertir a `for`, (3) en qué casos sí y en qué casos no. Máximo 100 palabras."

Prompt 4 — Validar entrada con while:

"Necesito pedir al usuario una edad entre 0 y 150. Si ingresa algo inválido, vuelve a pedir. Dame el código C++ que use `while` para la validación. Explícame la lógica paso a paso. Máximo 200 palabras."

🧪 Laboratorio — 🧪 LAB 2.4 — 6 ejercicios de repetición

Tiempo total: 1 h 30 min | Entregable: 6 programas funcionando.

🛠️ Herramienta recomendada para los diagramas de flujo de este LAB: Para los ejercicios que pidan un diagrama de flujo, usa [draw.io (diagrams.net)](https://app.diagrams.net/) — herramienta gratis, sin registro, que funciona en el navegador. Tiene plantillas con la simbología ANSI/ISO lista (en `General → Flowchart`). Exporta tus diagramas como PNG e insértalos en tu cuaderno digital o entrégalos junto con el código. Otras opciones libres: - [Mermaid](https://mermaid.live/) — diagramas desde código Markdown. Ideal para Git. - [Excalidraw](https://excalidraw.com/) — estilo "dibujado a mano", muy intuitivo. - Dibujar a mano en tu cuaderno — siempre válido, especialmente para trazar el razonamiento.

Ejercicio 1 — Contar del 1 al 10 (básico, 10 min)

Enunciado. Crea un programa que cuente del 1 al 10 usando while, e imprima cada número. Luego cuenta del 10 al 1 (descendente). Hazlo en los 3 lenguajes.

Criterio de éxito: cuenta ascendente y descendente correctas.

Rúbrica (10 pts): 3 pts por versión + 1 pt por descendente.

Ejercicio 2 — Suma de N números (básico, 15 min)

Enunciado. Crea un programa que pida N al usuario y luego pida N números. Calcula y muestra la suma y el promedio.

Criterio de éxito: con N=5 y números 10, 20, 30, 40, 50, la suma debe ser 150 y el promedio 30.

Rúbrica (10 pts): suma correcta (4 pts) + promedio (3 pts) + uso de while (3 pts).

Ejercicio 3 — Centinela: promedio hasta 0 (básico, 15 min)

Enunciado. Crea un programa que pida números hasta que el usuario ingrese 0 (centinela). Calcula el promedio, la cantidad de números y el mayor.

Criterio de éxito: con entrada 5, 10, 15, 0, debe mostrar promedio 10, cantidad 3, mayor 15.

Rúbrica (10 pts): promedio (3 pts) + cantidad (3 pts) + mayor (2 pts) + centinela correcto (2 pts).

Ejercicio 4 — Validación de edad (intermedio, 20 min)

Enunciado. Crea un programa que pida la edad al usuario. Si está fuera del rango [0, 150], muestra error y vuelve a pedir. Al final, muestra un mensaje según la edad (niño, adolescente, adulto, adulto mayor) usando else if.

Criterio de éxito: con entrada 200, debe pedir de nuevo; con entrada 25, debe decir "Eres adulto".

Rúbrica (10 pts): validación (5 pts) + clasificación (3 pts) + mensajes (2 pts).

Ejercicio 5 — Suma de dígitos (intermedio, 25 min)

Enunciado. Crea un programa que pida un número entero positivo al usuario y calcule la suma de sus dígitos. Ejemplo: 472 → 4+7+2 = 13. Usa while para extraer los dígitos con el operador módulo (% 10).

Criterio de éxito: con entrada 472, debe dar 13; con 1000, debe dar 1; con 5, debe dar 5.

Rúbrica (10 pts): algoritmo correcto (5 pts) + manejo de 0 (2 pts) + pruebas (3 pts).

Ejercicio 6 — Cajero automático simplificado (avanzado, 30 min)

Enunciado. Crea un programa que simule un cajero automático. Saldo inicial $1000. Menú con 4 opciones: consultar saldo, depositar, retirar, salir. Valida que el monto a retirar no exceda el saldo. El menú se repite hasta que el usuario elija "Salir".

Criterio de éxito: las 4 opciones funcionan, retiro valida saldo insuficiente, el bucle termina con "Salir".

Rúbrica (10 pts): menú con while (3 pts) + 4 opciones (4 pts) + validación (2 pts) + salida limpia (1 pt).

Ejercicio bonus — Número primo (opcional, 30 min)

Enunciado. Crea un programa que pida un número entero positivo al usuario y determine si es primo. Un primo solo es divisible entre 1 y sí mismo. Usa while para probar divisores del 2 al n/2.

Criterio de éxito: con entrada 7, debe decir "Es primo"; con 8, "No es primo"; con 1, caso especial.

Rúbrica bonus (5 pts): algoritmo correcto (3 pts) + caso especial de 1 (1 pt) + eficiencia (1 pt).

🎯 Cierre del tema

Lo que aprendiste hoy:

• Qué es una estructura repetitiva y por qué es fundamental.
• La sintaxis y semántica del while con precondición.
• Las 3 partes de un while correcto (inicialización, condición, actualización).
• Cómo evitar bucles infinitos y cómo interrumpirlos (Ctrl + C).
• Los 4 patrones: contador, acumulador, bandera, centinela.
• Validación de entradas con while + reintentos.
• Diagrama de flujo clásico del while con simbología ANSI/ISO.

Lo que sigue: en el Tema 2.5 — `do-while` (5h), vas a aprender el bucle de postcondición: el cuerpo se ejecuta AL MENOS una vez antes de evaluar la condición. Es el bucle ideal para menús interactivos (que vimos en el Tema 2.2) y para validaciones que sabes que se ejecutan al menos una vez.

Antes de seguir, asegúrate de tener en tu cuaderno:

• [ ] 6 programas del LAB 2.4 funcionando.
• [ ] Tabla comparativa de while en C++/Java/Python.
• [ ] Diagrama de flujo clásico del while dibujado a mano.
• [ ] Glosario con: while, precondición, bucle infinito, contador, acumulador, bandera, centinela, priming read, validación con reintentos.

XP obtenida al completar este tema: 100 base + 30 por LAB (6 ejercicios) + 20 por Quest = 150 XP. Insignia desbloqueada al cerrar el capítulo: Loop Master (parcial).

*"Un programa sin bucles es una calculadora. Un programa con bucles es una herramienta. La diferencia es la capacidad de hacer mil veces lo mismo sin cansarse."* — De la introducción de este manual.

Fin del Tema 2.4

📝 Quest · Cuestionario — 📝 Quest — Reactivos para autoevaluación

Sección A · Opción múltiple

Elige la opción correcta (A, B, C o D). Las respuestas están en la sección Respuestas modelo.

1. ¿Qué hace while?
   • Ejecuta una vez
   • Repite mientras la condición sea verdadera
   • Define función
   • Termina
2. Si la condición de while es false desde el inicio, ¿cuántas veces se ejecuta?
   • 1
   • 0
   • infinito
   • depende
3. while(true) genera:
   • Un error
   • Bucle infinito (a menos que haya break)
   • 1 iteración
   • Compila pero no corre
4. ¿Cómo evitar un bucle infinito en while?
   • No se puede
   • Modificar la variable de control y/o usar break
   • Cambiar el nombre
   • Recompilar
5. while vs do-while: diferencia clave:
   • Son iguales
   • do-while ejecuta el bloque al menos una vez
   • while es más rápido
   • do-while no tiene condición
6. ¿Cuál es la sintaxis de while?
   • while (cond) { }
   • while { } cond
   • while: cond { }
   • do while (cond) { }
7. Si i=0, while(i<5) { i++; }, ¿cuántas iteraciones?
   • 4
   • 5
   • 6
   • infinito
8. Un while dentro de otro while se llama:
   • Doble bucle
   • while anidado
   • loop loop
   • bucle doble
9. break en while:
   • Reinicia
   • Sale del bucle inmediatamente
   • Salta a la siguiente iteración
   • Duerme
10. continue en while:
    • Termina
    • Salta a la siguiente iteración
    • Duerme
    • Recompila

Sección B · Preguntas abiertas

Desarrolla tu respuesta en al menos 3 líneas. Compara con la respuesta modelo después de escribir.

1. Explica la diferencia entre while y for. ¿Cuándo es mejor cada uno?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. ¿Por qué es importante evitar bucles infinitos? Da un ejemplo real de un bug causado.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. Diseña un while que valide que el usuario ingrese un número entre 1 y 10.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…