2.01 · Estructuras Selectivas Simples: `if`, `if-else`

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Explicar qué es una estructura selectiva y por qué es fundamental para cualquier programa no trivial.
2. Escribir condiciones simples usando operadores relacionales y lógicos.
3. Usar la estructura if (sin else) para ejecutar código condicionalmente.
4. Usar la estructura if-else para elegir entre dos caminos.
5. Anidar varias estructuras if-else para decisiones más complejas.
6. Reconocer y evitar los 5 errores más comunes: usar = en vez de ==, omitir las llaves, "else colgante", condiciones ambiguas, no cubrir todos los casos.
7. Aplicar las estructuras selectivas a problemas reales de la vida cotidiana (validación, clasificación, menús).

Este es el primer tema del Capítulo 2: estructuras de control. A partir de aquí, tus programas van a poder tomar decisiones, no solo ejecutar instrucciones secuenciales.

🧠 Teoría y conceptos — 2.1.1 — Por qué los programas necesitan tomar decisiones

El problema de los programas secuenciales

En el Capítulo 1 escribiste programas secuenciales: una instrucción tras otra, sin desviaciones. Pero la vida real no es secuencial:

• En un cajero automático, si el PIN es correcto, das acceso; si no, lo rechazas.
• En una tienda en línea, si el total es mayor a $500, aplicas envío gratis; si no, cobras envío.
• En un juego, si el jugador tiene 0 vidas, termina el juego; si no, sigue jugando.

Estas decisiones son estructuras selectivas (o condicionales): ejecutan un bloque de código solo si se cumple una condición.

Definición formal

Una estructura selectiva permite que un programa elija entre uno o varios caminos de ejecución, basándose en una condición (verdadero o falso).

Las 3 formas de selectiva

2.1.2 — La estructura if: sintaxis, semántica, flujo

Sintaxis en C++

if (condición) {

// bloque de código que se ejecuta SOLO si la condición es verdadera

instrucción1;

instrucción2;

// ...

}

Anatomía:

El ejemplo clásico: validar edad

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

int edad;

cout << "¿Cuántos años tienes? ";
cin >> edad;
if (edad >= 18) {
cout << "Eres mayor de edad." << endl;
cout << "Puedes votar y tener licencia de conducir." << endl;

}

cout << "Programa terminado." << endl;
return 0;

}

Traza con edad = 25:

• Lee 25.
• Evalúa 25 >= 18 → true.
• Ejecuta el bloque: imprime los 2 mensajes.
• Imprime "Programa terminado".

Traza con edad = 15:

• Lee 15.
• Evalúa 15 >= 18 → false.
• NO ejecuta el bloque.
• Imprime solo "Programa terminado".

La forma abreviada: sin llaves (solo 1 instrucción)

Si el bloque tiene UNA SOLA instrucción, las llaves son opcionales:

if (edad >= 18)
cout << "Eres mayor de edad" << endl;

PERO: no se recomienda usar esta forma porque es propensa a errores. Mira esto:

if (edad >= 18)
cout << "Eres mayor de edad" << endl;
cout << "Puedes votar" << endl;  // ¡Esto SIEMPRE se imprime!

La indentación miente: la segunda línea NO está dentro del if, aunque parezca que sí. Con llaves, esto no pasa:

if (edad >= 18) {
cout << "Eres mayor de edad" << endl;
cout << "Puedes votar" << endl;

}

Regla de oro: SIEMPRE usa llaves, incluso con una sola instrucción. Te salva de bugs futuros.

El flujo visual (diagrama de flujo clásico)

Representación con la simbología clásica ANSI/ISO:

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

│ INICIO │ ⬭

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

│

▼

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

╱ LEER edad ╲ ▱

╲ ╱

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

│

▼

◆─────────────◆ ◇

╱ ╲

edad >= 18? Si la condición

─────── es FALSA, el

│ │ flujo continúa

Sí │ │ No SIN hacer nada

│ │ │

▼ │ │

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

╱ ESCRIBIR ╲ │

╲ "Eres mayor ╱ │

╲ de edad" ╱ │

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

│ │

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

│

▼

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

╱ ESCRIBIR "Fin" ╲ ▱

╲ ╱

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

│

▼

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

│ FIN │ ⬭

└─────────────┘

2.1.3 — La estructura if-else: dos caminos exclusivos

Sintaxis

if (condición) {

// bloque 1: se ejecuta si la condición es verdadera

} else {

// bloque 2: se ejecuta si la condición es falsa

}

Siempre se ejecuta UNO de los dos bloques, nunca ambos, nunca ninguno.

Ejemplo: par o impar

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

int numero;

cout << "Ingresa un número entero: ";
cin >> numero;
if (numero % 2 == 0) {
cout << numero << " es PAR" << endl;
} else {
cout << numero << " es IMPAR" << endl;

}

return 0;

}

Traza con numero = 7:

• Lee 7.
• 7 % 2 == 0 → 7 % 2 = 1 → 1 == 0 → false.
• Ejecuta el bloque else: imprime "7 es IMPAR".

Traza con numero = 10:

• 10 % 2 == 0 → 10 % 2 = 0 → 0 == 0 → true.
• Ejecuta el bloque if: imprime "10 es PAR".

Ejemplo real: validar acceso

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

string usuarioCorrecto = "admin";

string passwordCorrecto = "12345";

string usuario, password;

cout << "Usuario: ";
cin >> usuario;
cout << "Contraseña: ";
cin >> password;
if (usuario == usuarioCorrecto && password == passwordCorrecto) {
cout << "Acceso permitido. Bienvenido." << endl;
} else {
cout << "Acceso denegado. Usuario o contraseña incorrectos." << endl;

}

return 0;

}

Diagrama de flujo clásico del if-else (simbología ANSI/ISO)

Este es el ejemplo del "validar acceso" representado con la simbología clásica de diagramas de flujo (estándar ANSI/ISO 5807). Los símbolos tradicionales son:

• Óvalo ⬭ → Inicio o Fin del algoritmo
• Paralelogramo ▱ → Entrada o Salida de datos
• Rombo ◇ → Decisión (condición con dos caminos)
• Rectángulo ▭ → Proceso o instrucción
• Flecha → → Flujo de ejecución (sentido del recorrido)

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

│ INICIO │ ⬭ (terminal)

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

│

▼

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

╱ LEER usuario ╲ ▱ (entrada)

╲ y password ╱

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

│

▼

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

╱ ╲

usuario Y Si la condición

password son es FALSA

correctos? ─────────────►

─────── │

│ │ ▼

Sí │ │ No ╱─────────────╲

│ │ ╱ ESCRIBIR ╲ ▱ (salida)

│ │ ╲ "Acceso ╱

│ │ ╲ denegado" ╱

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

│ │ │

▼ │ │

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

╱ ESCRIBIR ╲ │

╲ "Acceso ╱ │

╲ permitido" ╱ │

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

│ │

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

│

▼

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

│ FIN │ ⬭ (terminal)

└─────────────┘

Herramienta recomendada: Para crear diagramas de flujo profesionales en tus prácticas, usa [draw.io (diagrams.net)](https://app.diagrams.net/) — es gratis, sin registro, funciona en el navegador o de escritorio, y exporta a PNG, PDF y SVG. Tiene plantillas de diagramas de flujo con la simbología ANSI/ISO lista para usar. Encuéntrala en `General → Flowchart`.

Regla nemotécnica: el else es el "plan B"

Si la condición se cumple → plan A (lo que está en `if`). Si la condición NO se cumple → plan B (lo que está en `else`). **Uno de los dos se ejecuta SIEMPRE.**

2.1.4 — Anidación de if-else: decisiones jerárquicas

Cuándo anidar

Cuando tienes 3 o más caminos posibles, necesitas anidar if-else o usar else if (que veremos en el Tema 2.2). Veamos la versión anidada primero porque es la más explícita.

Ejemplo: clasificar por edad

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

int edad;

cout << "¿Cuántos años tienes? ";
cin >> edad;
if (edad < 0) {
cout << "Edad inválida (no puede ser negativa)" << endl;
} else {
if (edad < 12) {
cout << "Eres un niño" << endl;
} else {
if (edad < 18) {
cout << "Eres un adolescente" << endl;
} else {
if (edad < 65) {
cout << "Eres un adulto" << endl;
} else {
cout << "Eres un adulto mayor" << endl;

}

}

}

}

return 0;

}

Traza con edad = 30:

• 30 < 0 → false. Va al else.
• 30 < 12 → false. Va al else.
• 30 < 18 → false. Va al else.
• 30 < 65 → true. Imprime "Eres un adulto".

La indentación es CRUCIAL

Con tantos niveles de anidación, es fácil perderse. La indentación debe ser CONSISTENTE:

if (edad < 0) {

// nivel 1

} else {
if (edad < 12) {

// nivel 2

} else {

// nivel 2

}

}

Cada nivel de anidación = 4 espacios (o 1 tab).

El problema de la "pirámide de Doom"

Si anidas muchos if, el código se vuelve ilegible (la indentación se va muy a la derecha). Por eso existe else if, que vamos a ver en el Tema 2.2. Por ahora, con 3-4 niveles máximo, está bien la anidación.

Alternativa con else if (introducción)

C++ (y Java) tienen una sintaxis más limpia para encadenar decisiones:

if (edad < 0) {
cout << "Edad inválida" << endl;
} else if (edad < 12) {
cout << "Eres un niño" << endl;
} else if (edad < 18) {
cout << "Eres un adolescente" << endl;
} else if (edad < 65) {
cout << "Eres un adulto" << endl;
} else {
cout << "Eres un adulto mayor" << endl;

}

else if es equivalente a anidar if-else, pero más legible. La diferencia: cada else if está al mismo nivel de indentación. En este tema usamos la versión anidada para entender; en el Tema 2.2 usamos `else if` como estándar.

Diagrama de flujo clásico de la cadena if-else if-else

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

│ INICIO │ ⬭

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

│

▼

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

╱ LEER edad ╲ ▱

╲ ╱

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

│

▼

◆─────────────◆ ◇

╱ ╲

edad < 0? No

─────── │

│ │ │

Sí │ │ No ▼

│ │ ◆─────────────◆ ◇

│ │ ╱ ╲

▼ │ edad < 12? No

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

╱ ESCRIBIR ╲ │ │ │ │

╲ "Edad inválida" ╱ │ Sí │ │ No ▼

╲───────────────╱ │ │ │ ◆─────────────◆ ◇

│ │ │ ╱ ╲

▼ │ ▼ edad < 18? No

(continúa │ ╱─────── │

con las │ │ │ │ ▼

otras │ Sí│ │ │No ◆─────────────◆ ◇

ramas) │ │ │ │ ╱ ╲

│ ▼ │ │ edad < 65? No

│ ... │ │ ────── │

│ │ │ │ │ │

│ ▼ │ │Sí │ │ No ▼

│ (continúa)│ │ │ │ ╱─────────────╲

│ │ │ │ ▼ ╱ ESCRIBIR ╲

│ ▼ │ ▼ ╲ "Adulto mayor" ╱

│ ... │ (continúa)╲──────────────╱

│ │

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

│

▼

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

│ FIN │ ⬭

└─────────────┘

Nota sobre el diagrama: para no hacerlo ilegible, solo se muestran las 2 primeras decisiones con detalle. En la práctica, cuando dibujes esto en draw.io, cada `◆` (decisión) se conecta con flechas claras hacia su bloque correspondiente. La herramienta te permite arrastrar, conectar y alinear mucho más fácil que hacerlo a mano.

2.1.5 — Los 5 errores clásicos y cómo evitarlos

Error 1: Usar = en vez de ==

// ❌ MAL: asigna, no compara

if (edad = 18) {  // Asigna 18 a edad, luego evalúa 18 (que es true)
cout << "Tienes 18" << endl;

}

// ✅ BIEN: compara

if (edad == 18) {  // Compara edad con 18
cout << "Tienes 18" << endl;

}

Por qué pasa: porque = y == se ven parecidos.

Cómo evitarlo:

1. Lee el código en voz alta: "si edad es igual a 18" → usas ==. "si edad recibe 18" → usas =.
2. Muchos compiladores dan un warning: suggest parentheses around assignment used as truth value. Atiéndelo.
3. Truco: pon la constante primero. if (18 == edad) → si te equivocas y pones =, el compilador da error (no puedes asignar a una constante).

Error 2: Omitir las llaves

// ❌ MAL: parece que las 2 líneas están dentro del if

if (edad >= 18)
cout << "Mayor de edad" << endl;
cout << "Puedes votar" << endl;  // Esta línea SIEMPRE se ejecuta

// ✅ BIEN: ambas líneas dentro del if

if (edad >= 18) {
cout << "Mayor de edad" << endl;
cout << "Puedes votar" << endl;

}

Por qué pasa: porque la indentación engaña al ojo. El compilador solo respeta las llaves, no la indentación.

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

Error 3: El "else colgante" (dangling else)

// ❌ MAL: el else pertenece al if de adentro, no al de afuera

if (edad >= 18)
if (edad < 65)
cout << "Adulto" << endl;

else

cout << "Adulto mayor" << endl;  // Este else es del if (edad < 65)!

// ✅ BIEN: con llaves, no hay ambigüedad

if (edad >= 18) {
if (edad < 65) {
cout << "Adulto" << endl;
} else {
cout << "Adulto mayor" << endl;

}

}

Por qué pasa: sin llaves, el else se asocia al if más cercano que no tenga ya un else.

Cómo evitarlo: llaves SIEMPRE. Y aún con else if, no te confíes.

Error 4: Condiciones ambiguas

// ❌ MAL: ¿es válido entre 18 y 65 inclusive?

if (18 < edad < 65) {  // Esto se evalúa como (18 < edad) < 65
cout << "Edad laboral" << endl;

}

// ✅ BIEN: usar && explícitamente

if (edad > 18 && edad < 65) {
cout << "Edad laboral" << endl;

}

Por qué pasa: en C++ (y Java, C, Python con and/or), la expresión 18 < edad < 65 se evalúa como (18 < edad) < 65. Primero ve si 18 < edad (true/false = 1/0), luego compara con 65. Casi siempre es true, así que la condición no filtra nada.

Cómo evitarlo: siempre usa && y || para combinar comparaciones. Lo veremos en detalle en el Tema 2.3.

Error 5: No cubrir todos los casos

// ❌ MAL: si la nota no está en 0-10, no imprime nada

if (nota >= 7) {
cout << "Aprobado" << endl;
} else if (nota < 7) {
cout << "Reprobado" << endl;

}

// ¿Qué pasa si nota = -5 o 15? El programa no dice nada

// ✅ BIEN: con un else final, todo queda cubierto

if (nota >= 7) {
cout << "Aprobado" << endl;
} else if (nota < 7) {
cout << "Reprobado" << endl;
} else {
cout << "Nota inválida" << endl;  // Captura el caso no esperado

}

Por qué pasa: porque se asume que los datos siempre van a ser correctos. En la realidad, no lo son.

Cómo evitarlo: valida SIEMPRE la entrada del usuario (Tema 1.7) y usa else final como "red de seguridad".

2.1.6 — Condiciones compuestas: usando &&, ||, !

Cuándo las necesitas

A veces una sola condición no es suficiente. Necesitas combinar varias condiciones:

• "Acceso permitido si el usuario es admin Y la contraseña es correcta" → dos condiciones con &&.
• "Descuento si eres estudiante O adulto mayor" → dos condiciones con ||.
• "Si NO estás autenticado, redirige al login" → una condición con !.

Los 3 operadores lógicos en C++/Java

(En Python son and, or, not.)

Ejemplo: validación completa con &&

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

int edad;

bool tieneLicencia;

char tieneLicenciaChar;

cout << "¿Cuántos años tienes? ";
cin >> edad;
cout << "¿Tienes licencia de conducir? (s/n): ";
cin >> tieneLicenciaChar;

tieneLicencia = (tieneLicenciaChar == 's' || tieneLicenciaChar == 'S');

if (edad >= 18 && tieneLicencia) {
cout << "Puedes conducir." << endl;
} else {
cout << "No puedes conducir." << endl;
if (edad < 18) {
cout << "  Razón: eres menor de edad." << endl;

}

if (!tieneLicencia) {
cout << "  Razón: no tienes licencia." << endl;

}

}

return 0;

}

Cortocircuito (importante)

Los operadores && y || usan evaluación de cortocircuito: si el resultado ya se conoce, no evalúan el resto.

• En A && B: si A es false, B no se evalúa.
• En A || B: si A es true, B no se evalúa.

Esto importa cuando el segundo operando es "peligroso" (puede fallar):

if (edad >= 18 && validarLicencia(numeroLicencia)) {  // Solo valida si edad es 18+

// ...

}

Si edad < 18, la segunda condición no se evalúa y no hay riesgo de error.

Combinación de && y || con paréntesis

Cuando mezclas && y ||, usa paréntesis para evitar ambigüedad:

if (edad >= 18 && (tieneLicencia || esExtranjero)) {

// Mayor de edad Y (con licencia O es extranjero)

}

Sin paréntesis, el && tiene mayor precedencia que ||, así que se evalúa primero, pero mejor ser explícito.

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

Error 1: "Si la condición es complicada, mejor pongo muchos if separados"

Idea equivocada: "Para validar muchas cosas, mejor pongo un if para cada cosa, así no se me complica."

Realidad: poner muchos if separados ejecuta TODAS las validaciones, incluso si la primera ya falló. Eso puede causar errores en cascada. Usa else (o else if) para que sean mutuamente excluyentes.

Cómo evitarlo: piensa si los casos son excluyentes (solo uno puede pasar) o independientes (varios pueden pasar). Si son excluyentes, usa if-else if-else. Si son independientes, usa if separados.

Error 2: "El else es opcional, mejor lo quito para que el código sea más corto"

Idea equivocada: "Si ya tengo el if, ¿para qué el else? Lo quito."

Realidad: sin else, tu programa NO HACE NADA en el caso "falso". Si eso es lo que quieres (por ejemplo, validar algo sin acción), está bien. Pero si quieres mostrar un mensaje de error o un valor por defecto, necesitas el else.

Cómo evitarlo: pregúntate: "¿qué quiero que pase cuando la condición es falsa?". Si la respuesta es "nada", omite el else. Si la respuesta es "otra cosa", ponlo.

Error 3: "Las condiciones se evalúan en orden, así que da igual dónde ponga el if más restrictivo"

Idea equivocada: "Da igual poner if (edad > 18) antes que if (edad > 65), ¿no?"

Realidad: en una cadena de if-else if, el ORDEN IMPORTA. Si pones edad > 18 primero, una persona de 70 años va a entrar en ese if y nunca va a llegar a edad > 65. Siempre pon primero la condición más específica.

Cómo evitarlo: ordena de más específico a más general. O usa rangos con &&: if (edad >= 18 && edad < 65).

Error 4: "Si el código compila, las condiciones están bien"

Idea equivocada: "El compilador no dio error, las condiciones son correctas."

Realidad: el compilador verifica que la SINTAXIS sea válida (que uses == en vez de =, que pongas paréntesis, etc.). NO verifica que la SEMÁNTICA sea correcta (que la condición realmente signifique lo que tú crees). Un if (edad >= 18) puede compilar y ejecutarse, pero si la variable edad contiene otra cosa, el resultado no es el que esperas.

Cómo evitarlo: traza con datos de prueba. Siempre.

Error 5: "Las condiciones son lógica, no se equivocan"

Idea equivocada: "Si yo escribí if (x > 0), eso es exactamente lo que hace."

Realidad: la computadora hace EXACTAMENTE lo que escribiste, no lo que quisiste decir. Si querías decir "x es positivo o cero" pero escribiste x > 0, el cero no entra. Si querías decir "x es distinto de 0" pero escribiste x > 0, los negativos no entran. La ambigüedad entre lo que piensas y lo que escribes es la fuente #1 de bugs lógicos.

Cómo evitarlo: antes de escribir la condición, escribe en tu cuaderno: "Si [condición en español], entonces [acción]". Luego tradúcelo a código. La traducción debe ser 1:1.

🤖 IA como copiloto — 🤖 AI Mission 2.1 — Condiciones con IA

Regla de los 3 minutos (obligatoria): primero intenta resolver por tu cuenta. Si después de 3 minutos no avanzas, primero relee la teoría, luego consulta tu cuaderno, luego la IA con los prompts sugeridos.

Lo que la IA NO debe hacer

• ❌ No debe escribir tus ejercicios del LAB.
• ❌ No debe inventar la respuesta del Quest.
• ❌ No debe corregir tu código completo.

Lo que SÍ debe hacer

• ✅ Explicarte por qué una condición no funciona como esperas.
• ✅ Ayudarte a encontrar el error lógico en una condición.
• ✅ Sugerir mejores formas de escribir una condición compleja.

Prompts sugeridos

Prompt 1 — Explicar una condición:

"Te voy a pegar una condición en C++: '[condición]'. Explica con palabras qué hace esta condición, qué valores la hacen verdadera y cuáles la hacen falsa. NO uses código, máximo 100 palabras."

Prompt 2 — Encontrar el error lógico:

"Mi programa debería hacer X si la condición se cumple, pero siempre hace Y. Te pego la condición: '[condición]'. NO me la corrijas. Solo dime: (1) qué hace exactamente, (2) por qué no funciona como espero. Máximo 100 palabras."

Prompt 3 — Simplificar una condición:

"Te voy a pegar una condición larga en C++. NO me la corrijas. Solo dime: (1) qué hace, (2) si se puede simplificar, (3) qué buena práctica no estoy siguiendo. Máximo 100 palabras."

Prompt 4 — Comparar 2 condiciones:

"Te voy a pegar 2 condiciones en C++ que creo que hacen lo mismo. NO me digas si son equivalentes. Solo dime qué hace cada una paso a paso. Después yo decido. Máximo 150 palabras."

🧪 Laboratorio — 🧪 LAB 2.1 — 6 ejercicios de toma de decisiones

Tiempo total: 1 h 30 min | Entregable: 6 programas funcionando, con capturas de pantalla y datos de prueba.

🛠️ 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 (menciona la que prefieras): - [Mermaid](https://mermaid.live/) — diagramas desde código Markdown. Ideal si quieres diagramas versionados en 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 — Mayoría de edad (básico, 15 min)

Enunciado. Crea un programa que pida la edad del usuario y muestre:

• "Eres mayor de edad" si edad >= 18.
• "Eres menor de edad" si edad < 18.
• "Edad inválida" si edad < 0.

Hazlo en los 3 lenguajes.

Criterio de éxito: los 3 casos (negativa, menor, mayor) funcionan correctamente.

Rúbrica (10 pts): 3 pts por cada versión correcta + 1 pt por el caso de edad inválida.

Ejercicio 2 — Par o impar con validación (básico, 20 min)

Enunciado. Crea un programa que pida un número entero al usuario y determine si es par o impar. Si el número es negativo, muestra "Número inválido". Si es 0, muestra "Cero es neutro (ni par ni impar)".

Criterio de éxito: maneja correctamente los 3 casos: negativo, 0, positivo par, positivo impar.

Rúbrica (10 pts): 4 casos (negativo, cero, par positivo, impar positivo) × 2 pts + 2 pts por mensajes claros.

Ejercicio 3 — Calificaciones con letras (intermedio, 25 min)

Enunciado. Crea un programa que pida una calificación numérica (0-10) y la convierta a letra:

• 9-10: A (Excelente)
• 8-8.9: B (Muy bien)
• 7-7.9: C (Bien)
• 6-6.9: D (Suficiente)
• 0-5.9: F (No suficiente)
• Cualquier otro valor: "Calificación inválida"

Criterio de éxito: los 6 casos se clasifican correctamente.

Rúbrica (10 pts): 6 casos × 1.5 pts + 1 pt por formato.

Ejercicio 4 — Login con 3 intentos (intermedio, 25 min)

Enunciado. Crea un programa que simule un sistema de login. El usuario y contraseña correctos están hardcodeados (por ejemplo, admin y 12345). El usuario tiene 3 intentos. Si acierta, muestra "Acceso permitido" y termina. Si falla los 3, muestra "Cuenta bloqueada" y termina. Después de cada intento, muestra cuántos intentos le quedan.

Criterio de éxito: los 3 intentos funcionan, el contador decrementa, y el mensaje de "Cuenta bloqueada" aparece exactamente al tercer fallo.

Rúbrica (10 pts): login correcto (3 pts) + contador de intentos (3 pts) + mensajes claros (2 pts) + caso de bloqueo (2 pts).

Ejercicio 5 — Calculadora de descuento (avanzado, 30 min)

Enunciado. Crea un programa que pida el monto de una compra y aplique un descuento según estas reglas:

• Si el monto es mayor a $5,000: 15% de descuento.
• Si el monto está entre $1,000 y $5,000: 10% de descuento.
• Si el monto está entre $500 y $999: 5% de descuento.
• Si el monto es menor a $500: sin descuento.

Muestra el monto original, el descuento aplicado y el monto final.

Criterio de éxito: las 4 categorías de monto se calculan correctamente. Verifica con: $400 (sin descuento), $800 (5%), $3,000 (10%), $6,000 (15%).

Rúbrica (10 pts): 4 categorías × 2 pts + 2 pts por formato de salida con 2 decimales.

Ejercicio 6 — Clasificador de triángulos (avanzado, 30 min)

Enunciado. Crea un programa que pida los 3 lados de un triángulo y determine:

• Si NO es un triángulo válido (algún lado <= 0, o la suma de 2 lados no es mayor al tercero).
• Si es equilátero (3 lados iguales).
• Si es isósceles (2 lados iguales).
• Si es escaleno (3 lados diferentes).
• Si es rectángulo (cumple el teorema de Pitágoras: a² + b² = c², donde c es el lado mayor).

Criterio de éxito: maneja los 5 casos correctamente. Verifica con: (3,4,5) → rectángulo, (5,5,5) → equilátero, (3,3,5) → isósceles, (3,4,6) → escaleno, (1,2,5) → no es triángulo.

Rúbrica (10 pts): 5 casos × 1.5 pts + 2.5 pts por validación inicial.

Ejercicio bonus — Validador de CURP (avanzado, opcional, 30 min)

Enunciado. Crea un programa que pida una CURP al usuario (18 caracteres) y valide su formato:

• Posiciones 1-4: 4 letras mayúsculas.
• Posiciones 5-10: 6 dígitos (fecha de nacimiento YYMMDD).
• Posiciones 11-16: 6 letras mayúsculas.
• Posición 17: 1 carácter (H o M para sexo).
• Posición 18: 1 carácter (estado).

Si la CURP no cumple el formato, muestra en qué posición está el error.

Criterio de éxito: detecta correctamente los 3 errores de formato más comunes (longitud, dígitos en posiciones incorrectas, minúsculas en lugar de mayúsculas).

Rúbrica bonus (5 pts): 2 pts por longitud + 2 pts por tipo de carácter en cada posición + 1 pt por mensaje de error específico.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Qué es una estructura selectiva y por qué es fundamental.
• La sintaxis y semántica de if y if-else.
• Cómo anidar if-else para decisiones complejas.
• Los 5 errores clásicos (= vs ==, llaves omitidas, else colgante, condición ambigua, casos no cubiertos).
• Condiciones compuestas con &&, ||, !.
• El mismo programa escrito en C++, Java y Python.

Lo que sigue: en el Tema 2.2 — Selectivas Anidadas y `switch` (8h), vas a usar else if para escribir cadenas de decisión más limpias, y vas a aprender la estructura switch/case para decisiones con muchos casos discretos. También verás los menús interactivos profesionales, que son la base de cualquier programa de consola.

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

• [ ] 6 programas del LAB 2.1 funcionando.
• [ ] Tabla comparativa de "if" en C++/Java/Python.
• [ ] Los 5 errores clásicos con ejemplos propios.
• [ ] Glosario con: if, if-else, anidación, else if, condición, cortocircuito, &&, ||, !, dangling else.

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: Decision Maker (parcial).

*"Un programa sin decisiones es una receta. Un programa con decisiones es una herramienta. La diferencia es el `if`."* — De la introducción de este manual.

Fin del Tema 2.1

📝 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 un if en C++?
   • Repite
   • Ejecuta código solo si la condición es verdadera
   • Define función
   • Termina el programa
2. ¿Cuál es la sintaxis correcta de if?
   • if condicion { }
   • if (condicion) { }
   • if [condicion] { }
   • if: condicion { }
3. ¿Qué pasa si la condición es falsa y no hay else?
   • Error
   • Se omite el bloque
   • Se ejecuta 2 veces
   • El programa termina
4. ¿Cuál es la diferencia entre if e if-else?
   • Son iguales
   • if-else tiene alternativa para el caso falso
   • if es para números
   • if-else no compila
5. ¿Puedes anidar if dentro de otro if?
   • No
   • Sí, se llama if anidados
   • Solo en Python
   • Solo en C++
6. ¿Qué operador lógico representa "Y" (AND)?
   • ||
   • &&
   • !
   • ==
7. ¿Qué operador lógico representa "O" (OR)?
   • &&
   • ||
   • !
   • ==
8. ¿Qué operador lógico representa "NO" (NOT)?
   • &&
   • !
   • ||
   • ==
9. Si edad=20, ¿qué imprime if(edad>=18 && edad<65)?
   • Nada
   • "Adulto" (si imprime dentro)
   • Error
   • "Joven"
10. ¿Por qué se usan llaves {} en if?
    • Decoración
    • Delimitar el bloque de código condicional
    • Obligatorio en C++
    • Para comentarios

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 if simple, if-else, if-else if-else. Da un ejemplo de cuándo usar cada uno.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. Diseña un algoritmo con if-else que clasifique una edad: niño (0-12), adolescente (13-17), adulto (18-64), adulto mayor (65+).
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. ¿Por qué es importante usar llaves {} aunque el if tenga una sola línea?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…