1.03 · Algoritmos: Concepto, Características, Tipos y Diseño

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Definir formalmente qué es un algoritmo y reconocer las 5 propiedades obligatorias en ejemplos reales.
2. Distinguir los 3 tipos de algoritmos (secuencial, condicional, repetitivo) y dar 3 ejemplos de cada uno.
3. Identificar los 3 elementos de un algoritmo (entrada, proceso, salida) en problemas nuevos.
4. Aplicar 4 técnicas de diseño de algoritmos (divide y vencerás, top-down, bottom-up, fuerza bruta) a problemas reales.
5. Diseñar 10 algoritmos propios siguiendo el proceso 4P y trazarlos con datos de prueba en tu cuaderno.
6. Conocer 5 algoritmos clásicos de la historia de la computación (Euclides, burbuja, búsqueda lineal, factorial, Fibonacci) y explicar su lógica sin código.

Este tema es donde dejas de pensar sobre programación y empiezas a programar con la cabeza. El código viene después.

🧠 Teoría y conceptos — 1.3.1 — Algoritmo: definición formal y las 5 propiedades obligatorias

Repaso y profundización

En el Tema 1.2 vimos que un algoritmo es "una secuencia finita, ordenada y no ambigua de instrucciones". Ahora vamos a profundizar en cada una de las 5 propiedades que lo definen, porque no basta con hacer un procedimiento: tiene que cumplir TODAS para ser algoritmo.

Las 5 propiedades en detalle

1. Finito (Finitud) El algoritmo debe terminar después de ejecutar un número finito de pasos. No puede quedarse corriendo eternamente.

Ejemplo que cumple: un programa que suma 10 números y termina. ✅ Ejemplo que NO cumple: un programa que imprime "Hola" una y otra vez sin condición de salida. ❌

Analogía: una receta de cocina siempre termina cuando el platillo está listo. Si la receta te dice "agrega sal hasta que sepa bien", y nunca te dice cuándo parar, no es un algoritmo completo. Falta una condición de salida (por ejemplo, "agrega sal hasta que tenga 1 gramo total").

1. Definido (Determinismo) Cada paso del algoritmo debe estar claro. Si dos personas ejecutan el mismo algoritmo con los mismos datos, deben obtener el mismo resultado.

Ejemplo que cumple: "suma el número A con el número B". ✅ Ejemplo que NO cumple: "agrega sal al gusto". ❌ (¿cuánto es "al gusto"?)

1. Entrada (Input) Tiene cero o más datos de entrada. Los datos son los valores que el algoritmo recibe del exterior para trabajar.

Ejemplo: en "calcular el promedio de 3 calificaciones", las entradas son las 3 calificaciones. Los datos de entrada pueden venir del usuario, de un archivo, de un sensor, etc.

1. Salida (Output) Tiene al menos un dato de salida. Si tu algoritmo no produce nada, no es un algoritmo, es un cálculo perdido.

Ejemplo: en "calcular el promedio de 3 calificaciones", la salida es el promedio. Sin salida, ¿para qué calcularlo?

1. Efectivo (Eficacia) Cada paso debe ser ejecutable. No puede haber pasos que nadie sabe cómo hacer, o que requieren información no disponible.

Ejemplo que cumple: "suma A + B". ✅ (cualquier persona con una calculadora puede hacerlo) Ejemplo que NO cumple: "predice el futuro". ❌ (no hay un método efectivo para hacerlo)

Verificador de las 5 propiedades

Cuando diseñes un algoritmo, pregúntate por cada propiedad:

Si falla alguna, no es un algoritmo completo. Hay que revisar.

Caso especial: programas que nunca terminan

Existen programas legítimos que parecen no terminar, como un servidor web que escucha peticiones todo el día. Pero cada iteración individual del programa sí termina (atiende una petición y vuelve a esperar). El programa principal es un bucle con condición de salida explícita (cuando se apaga el servidor). Eso sí es un algoritmo.

En cambio, un while (true) { } sin condición de salida es un bug, no un algoritmo. La diferencia: el bug no tiene salida controlada; el servidor sí.

1.3.2 — Los 3 elementos de un algoritmo: entrada, proceso, salida

El esquema E-P-S

Todo algoritmo, por simple o complejo que sea, tiene tres bloques fundamentales:

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

│ ENTRADA(S) │ ← Datos que recibe del exterior

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

↓

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

│ PROCESO │ ← Transformación: cálculos, decisiones, repeticiones

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

↓

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

│ SALIDA(S) │ ← Resultado(s) que entrega al exterior

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

Esta es la columna vertebral de cualquier algoritmo. Si identificas estos tres bloques en un problema, ya tienes el 70% del algoritmo diseñado.

Ejemplo 1: sumar dos números

ENTRADA: dos números A y B

PROCESO: resultado = A + B

SALIDA: resultado

Pseudocódigo:

INICIO

ESCRIBIR "Ingresa el primer número:"

LEER A

ESCRIBIR "Ingresa el segundo número:"

LEER B

resultado = A + B

ESCRIBIR "La suma es: " + resultado

FIN

Ejemplo 2: determinar si un número es par o impar

ENTRADA: un número entero N

PROCESO: calcular N módulo 2. Si el residuo es 0, es par; si no, impar.

SALIDA: "par" o "impar"

Pseudocódigo:

INICIO

ESCRIBIR "Ingresa un número entero:"

LEER N

residuo = N % 2

SI residuo == 0 ENTONCES

ESCRIBIR N + " es par"

SINO

ESCRIBIR N + " es impar"

FIN SI

FIN

Ejemplo 3: convertir grados Celsius a Fahrenheit

ENTRADA: temperatura en Celsius

PROCESO: aplicar la fórmula F = (C * 9/5) + 32

SALIDA: temperatura en Fahrenheit

Pseudocódigo:

INICIO

ESCRIBIR "Temperatura en Celsius:"

LEER C

F = (C * 9 / 5) + 32

ESCRIBIR "Temperatura en Fahrenheit: " + F

FIN

La trampa de saltarse el E-P-S

Un error muy común de los principiantes es lanzarse a escribir código sin definir explícitamente las entradas, el proceso y las salidas. Terminan con código que compila pero no hace lo que se necesita.

Antídoto: antes de escribir cualquier línea de código (ni siquiera pseudocódigo), escribe en tu cuaderno:

PROBLEMA: [descripción en una frase]

ENTRADAS: [lista de datos que necesito]

PROCESO: [en lenguaje natural, qué voy a hacer con esos datos]

SALIDAS: [qué resultado entrego al usuario]

CASOS BORDE: [qué pasa si los datos son raros]

1.3.3 — Los 3 tipos de algoritmos: secuencial, condicional, repetitivo

Tipo 1: Algoritmo secuencial

Los pasos se ejecutan uno tras otro, en orden, sinSaltarse ninguno. Es el tipo más simple y el más común para problemas directos.

INICIO

// Paso 1

LEER base

// Paso 2

LEER altura

// Paso 3

area = (base * altura) / 2

// Paso 4

ESCRIBIR area

FIN

3 ejemplos de la vida real:

1. Cepillarse los dientes (pasta → cepillar → enjuagar).
2. Preparar un sándwich (pan → jamón → queso → pan).
3. Sacar dinero del cajero (insertar tarjeta → escribir PIN → elegir monto → confirmar → retirar).

Tipo 2: Algoritmo condicional

Uno o más pasos se ejecutan solo si una condición se cumple. Esto le da al algoritmo la capacidad de "tomar decisiones".

INICIO

LEER edad

SI edad >= 18 ENTONCES

ESCRIBIR "Eres mayor de edad"

SINO

ESCRIBIR "Eres menor de edad"

FIN SI

FIN

Las 3 formas de condicional:

3 ejemplos de la vida real:

1. Cruzar la calle: SI el semáforo está en verde ENTONCES cruza SINO espera.
2. Estudiar para examen: SI el examen es mañana ENTONCES estudia toda la noche SINO descansa.
3. Elegir ropa: SI llueve ENTONCES lleva impermeable SINO lleva chamarra ligera.

Tipo 3: Algoritmo repetitivo (iterativo)

Uno o más pasos se ejecutan varias veces según una condición o un contador. Le da al algoritmo la capacidad de "trabajar en volumen".

Las 3 formas de repetición:

INICIO

// Sumar los números del 1 al 10

suma = 0

PARA i DESDE 1 HASTA 10 HACER

suma = suma + i

FIN PARA

ESCRIBIR "La suma es: " + suma  // Imprime 55

FIN

3 ejemplos de la vida real:

1. Subir escaleras: PARA cada escalón DESDE 1 HASTA N, sube un escalón.
2. Llenar una jarra: MIENTRAS la jarra no esté llena, vierte agua.
3. Cambiar de canal: HAZ clic en "siguiente canal", MIENTRAS no encuentres uno que te guste.

Los 3 tipos se combinan

En la práctica, los algoritmos reales combinan los 3 tipos. Un programa que calcula el promedio de N calificaciones tiene:

• Secuencial: pedir N, calcular suma, dividir, imprimir.
• Condicional: validar que N > 0, validar que cada calificación esté entre 0 y 10.
• Repetitivo: pedir las N calificaciones una por una.

Esto se llama programación estructurada y la vamos a ver en detalle en el Capítulo 2.

1.3.4 — Técnicas de diseño de algoritmos

Por qué necesitas técnicas

Cuando el problema es complejo (decenas de variables, cientos de casos, optimización), no basta con sentarse a escribir. Necesitas un método para abordar el problema. Hay 4 técnicas clásicas que se siguen usando 50 años después.

Técnica 1: Top-Down (de arriba hacia abajo)

Qué es: empiezas por el problema general y vas descomponiendo en subproblemas cada vez más pequeños, hasta llegar a problemas triviales.

Cuándo se usa: en problemas grandes, mal definidos al inicio, donde necesitas entender la estructura general antes de entrar en detalles.

Analogía: planificar una empresa. Primero defines la misión y la estructura general (áreas), luego defines los departamentos de cada área, luego los puestos de cada departamento, luego las tareas de cada puesto.

Pseudocódigo de un diseño top-down para "vender un producto en línea":

Vender un producto en línea

├── 1. Publicar el producto

│ ├── 1.1. Tomar fotos

│ ├── 1.2. Escribir descripción

│ └── 1.3. Subir a la plataforma

├── 2. Atender al cliente

│ ├── 2.1. Responder preguntas

│ └── 2.2. Procesar el pago

├── 3. Enviar el producto

│ ├── 3.1. Empacar

│ ├── 3.2. Etiquetar

│ └── 3.3. Entregar al servicio de paquetería

└── 4. Seguimiento post-venta

├── 4.1. Confirmar recepción

└── 4.2. Pedir reseña

Técnica 2: Bottom-Up (de abajo hacia arriba)

Qué es: empiezas por los componentes más pequeños (funciones auxiliares, tipos de datos) y los vas combinando hasta construir el sistema completo.

Cuándo se usa: cuando ya tienes claras las piezas básicas (por ejemplo, porque reusarás código de otro proyecto) y solo necesitas ensamblarlas.

Analogía: construir una casa con bloques LEGO. Empiezas por los bloques pequeños (puertas, ventanas), luego los combinas en paredes, luego en habitaciones, luego en la casa completa.

Técnica 3: Divide y Vencerás

Qué es: divides el problema en subproblemas del mismo tipo (generalmente la mitad), resuelves cada uno por separado, y combinas las soluciones.

Cuándo se usa: en problemas donde el "tamaño" del problema se puede reducir, como ordenar, buscar o buscar en árboles.

Analogía: buscar una palabra en el diccionario. No empiezas en la página 1; abres por la mitad, decides si tu palabra está antes o después, y repites con la mitad correspondiente. Pasas de revisar 1,000 páginas a revisar 10.

Ejemplo clásico: MergeSort para ordenar una lista.

Ordenar [5, 2, 8, 1, 9, 3]:

├── Dividir en dos: [5, 2, 8] y [1, 9, 3]

├── Ordenar cada mitad:

│ ├── Ordenar [5, 2, 8]:

│ │ ├── Dividir: [5] y [2, 8]

│ │ ├── Ordenar [2, 8]:

│ │ │ ├── Dividir: [2] y [8]

│ │ │ ├── Combinar: [2, 8] (ordenados)

│ │ └── Combinar: [2, 5, 8]

│ └── Ordenar [1, 9, 3]:

│ ├── Dividir: [1] y [9, 3]

│ ├── Ordenar [9, 3]:

│ │ ├── Dividir: [9] y [3]

│ │ └── Combinar: [3, 9]

│ └── Combinar: [1, 3, 9]

└── Combinar: [1, 2, 3, 5, 8, 9] (ordenados)

Técnica 4: Fuerza Bruta

Qué es: probar todas las posibles soluciones hasta encontrar la correcta.

Cuándo se usa: cuando no hay una estrategia más inteligente y el espacio de búsqueda es pequeño. En problemas grandes, suele ser muy lenta (o imposible).

Analogía: probar todas las llaves de un llavero hasta que una abra la puerta. Funciona si tienes pocas llaves; es inviable si tienes 10,000.

Ejemplo clásico: encontrar la contraseña de 4 dígitos probando desde 0000 hasta 9999. Son 10,000 intentos. Para una contraseña de 8 caracteres alfanuméricos, son 2.8 * 10^14 intentos: imposible en la vida del universo con fuerza bruta.

Cuándo usar cada técnica

En la vida real, los problemas grandes usan combinaciones de técnicas. Un sistema de ventas online probablemente usa top-down para la arquitectura general, divide y vencerás para los algoritmos de recomendación, y fuerza bruta para validar contraseñas en un diccionario pequeño.

1.3.5 — Algoritmos clásicos de la historia

Por qué importan los algoritmos clásicos

Los algoritmos clásicos son los "abuelos" de la computación. Los resolvió gente como Euclides (300 a.C.), Al-Juarismi (s. IX), o los pioneros de la computación del siglo XX. Conocerlos no es por nostalgia: siguen siendo la base de los algoritmos que usan los sistemas modernos.

Vamos a ver 5 algoritmos que tienes que poder explicar sin código y trazar con datos en tu cuaderno.

Algoritmo 1: MCD de Euclides (Máximo Común Divisor)

Problema: dados dos números A y B, encontrar el número más grande que divide a ambos sin dejar residuo.

Por qué importa: se usa en criptografía (RSA), en simplificación de fracciones, y en problemas de teoría de números.

Pseudocódigo:

INICIO

LEER A

LEER B

MIENTRAS B != 0 HACER

temporal = B

B = A MOD B

A = temporal

FIN MIENTRAS

ESCRIBIR "El MCD es: " + A

FIN

Traza con A = 48, B = 18:

Resultado: MCD(48, 18) = 6.

¡Verifica: 6 divide a 48 (48/6=8) y divide a 18 (18/6=3). Es el más grande! ✅

Algoritmo 2: Factorial de un número

Problema: dado un número N, calcular N! = N × (N-1) × (N-2) × ... × 1. Por definición, 0! = 1.

Por qué importa: se usa en combinatoria, en probabilidad, en series matemáticas. Aparece en toda la matemática de conteo.

Pseudocódigo:

INICIO

LEER N

SI N < 0 ENTONCES

ESCRIBIR "No existe el factorial de negativos"

SINO

factorial = 1

PARA i DESDE 1 HASTA N HACER

factorial = factorial * i

FIN PARA

ESCRIBIR N + "! = " + factorial

FIN SI

FIN

Traza con N = 5:

Resultado: 5! = 120.

Algoritmo 3: Sucesión de Fibonacci

Problema: generar los primeros N números de la sucesión 1, 1, 2, 3, 5, 8, 13, 21, ... donde cada número es la suma de los dos anteriores.

Por qué importa: aparece en la naturaleza (distribución de hojas, conchas), en el análisis de algoritmos, en finanzas.

Pseudocódigo:

INICIO

LEER N

SI N == 0 ENTONCES

ESCRIBIR "Sin números"

SINO SI N == 1 ENTONCES

ESCRIBIR "1"

SINO

anterior = 1

actual = 1

ESCRIBIR anterior

ESCRIBIR actual

PARA i DESDE 3 HASTA N HACER

siguiente = anterior + actual

ESCRIBIR siguiente

anterior = actual

actual = siguiente

FIN PARA

FIN SI

FIN

Traza con N = 6:

Resultado: 1, 1, 2, 3, 5, 8.

Algoritmo 4: Búsqueda Lineal

Problema: dada una lista de N elementos y un valor X, decir si X está en la lista. Si está, decir en qué posición.

Por qué importa: es el algoritmo de búsqueda más simple. Se usa cuando la lista es pequeña o no está ordenada. Si la lista está ordenada, se usa la búsqueda binaria (Tema 3.5).

Pseudocódigo:

INICIO

LEER N  // tamaño de la lista

PARA i DESDE 1 HASTA N HACER

LEER lista[i]

FIN PARA

LEER X  // valor a buscar

posicion = -1 // -1 significa "no encontrado"

PARA i DESDE 1 HASTA N HACER

SI lista[i] == X ENTONCES

posicion = i

SALIR DEL BUCLE

FIN SI

FIN PARA

SI posicion == -1 ENTONCES

ESCRIBIR X + " no está en la lista"

SINO

ESCRIBIR X + " está en la posición " + posicion

FIN SI

FIN

Traza con lista = [10, 25, 7, 40, 15], X = 7:

Resultado: 7 está en la posición 3.

Algoritmo 5: Ordenamiento por Burbuja (introducción)

Problema: dada una lista de N números, ordenarlos de menor a mayor.

Por qué importa: es el algoritmo de ordenamiento más simple de entender. No es eficiente para listas grandes (eso lo verá el Tema 3.6), pero es perfecto para aprender la lógica.

Pseudocódigo:

INICIO

LEER N

PARA i DESDE 1 HASTA N HACER

LEER lista[i]

FIN PARA

// Burbuja: comparamos pares adyacentes y los intercambiamos si están en mal orden

PARA i DESDE 1 HASTA N-1 HACER

PARA j DESDE 1 HASTA N-i HACER

SI lista[j] > lista[j+1] ENTONCES

temporal = lista[j]

lista[j] = lista[j+1]

lista[j+1] = temporal

FIN SI

FIN PARA

FIN PARA

// Imprimir lista ordenada

PARA i DESDE 1 HASTA N HACER

ESCRIBIR lista[i]

FIN PARA

FIN

Traza con lista = [5, 2, 8, 1]:

Resultado: [1, 2, 5, 8] (ordenada).

1.3.6 — Traza de algoritmos: cómo verificar que un algoritmo funciona

Qué es la traza

La traza (o prueba de escritorio) es el proceso de ejecutar un algoritmo paso a paso, con datos concretos, anotando en una tabla el estado de cada variable en cada paso.

Es la herramienta más importante de un programador antes de codificar. Una traza correcta garantiza que el algoritmo funciona. Si tu traza falla, el código también fallará.

Cómo hacer una buena traza

Reglas:

1. Elige datos pequeños y manejables (no N = 1,000,000).
2. Haz una tabla con columnas para cada variable y una fila por cada paso.
3. Anota el estado de las variables DESPUÉS de cada operación, no antes.
4. Incluye todas las variables, no solo las que "parecen importantes".
5. Verifica que el resultado final coincida con lo esperado.

Ejemplo completo: algoritmo para encontrar el mayor de 3 números

Pseudocódigo:

INICIO

LEER A

LEER B

LEER C

mayor = A

SI B > mayor ENTONCES

mayor = B

FIN SI

SI C > mayor ENTONCES

mayor = C

FIN SI

ESCRIBIR "El mayor es: " + mayor

FIN

Traza con A = 7, B = 12, C = 3:

Resultado: El mayor es 12. ✅

La traza como depurador mental

Cuando un programa no funciona, el primer paso NO es correr el código en la IDE. Es hacer la traza en papel con los mismos datos que estás probando. Casi siempre el error lógico se hace visible en la traza antes de tocar una línea de código.

Esto es lo que hacen los programadores senior. Y es lo que la IA no puede hacer por ti, porque requiere que tú entiendas qué debería pasar.

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

Error 1: "Diseñar el algoritmo y programarlo al mismo tiempo"

Idea equivocada: "Voy a hacer las dos cosas en paralelo. Mientras pienso el algoritmo, ya voy escribiendo el código."

Realidad: el código y el algoritmo viven en niveles de abstracción distintos. Mezclarlos genera bugs que son difíciles de detectar porque no sabes si el error está en la idea o en la sintaxis.

Cómo evitarlo: siempre algoritmo primero, código después. Cuando el algoritmo esté trazado y verificado en papel, recién entonces pasas al IDE.

Error 2: "Más variables = mejor algoritmo"

Idea equivocada: "Voy a usar muchas variables para que el algoritmo quede más claro."

Realidad: cada variable adicional es una oportunidad de error. El mejor algoritmo usa el mínimo de variables necesario para resolver el problema. Si tu algoritmo tiene 15 variables, probablemente estás guardando cosas que no necesitas.

Cómo evitarlo: pregúntate por cada variable "¿realmente la necesito o puedo calcular su valor cuando lo necesite?".

Error 3: "Si compila, está bien"

Idea equivocada: "El algoritmo funcionó en mi cabeza, lo pasé a código, el IDE lo compiló, entonces está bien."

Realidad: el compilador solo verifica SINTAXIS. No verifica que el algoritmo resuelva el problema correctamente. Un programa que compila puede tener la lógica completamente mal.

Cómo evitarlo: la traza en papel es la verificación. Si no trazaste, no verificaste.

Error 4: "Las trazas son una pérdida de tiempo"

Idea equivocada: "Llevo 5 minutos trazando y el algoritmo parece correcto, voy a codificar directo."

Realidad: 5 minutos de traza ahorran 50 minutos de debugging. Las trazas parecen lentas al principio, pero con práctica se vuelven rápidas y son la inversión más rentable que hace un programador.

Cómo evitarlo: trazar siempre, sin excepción. Es un hábito que te va a distinguir de los programadores promedio.

Error 5: "Reconocer un algoritmo clásico es trampa"

Idea equivocada: "Si uso Euclides en mi problema, no estoy pensando, solo copiando."

Realidad: un programador profesional conoce y reutiliza los algoritmos clásicos. No reinventar la rueda es una habilidad. La clave es entender CÓMO funciona el algoritmo (por eso los trazamos a mano), no solo memorizar la fórmula.

Cómo evitarlo: siempre que uses un algoritmo clásico, traza un ejemplo a mano. Así lo entiendes de verdad, no solo lo memorizas.

🤖 IA como copiloto — 🤖 AI Mission 1.3 — Validación de algoritmos con prompts sugeridos

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

Lo que la IA NO debe hacer por ti en este tema

• ❌ No debe diseñar los algoritmos de tu LAB.
• ❌ No debe inventar las trazas de tus algoritmos.
• ❌ No debe darte la respuesta del Quest.
• ❌ No debe corregir tu cuaderno.

Lo que SÍ debe hacer

• ✅ Explicarte un algoritmo clásico con analogías.
• ✅ Ayudarte a detectar errores LÓGICOS (no de sintaxis) en tu pseudocódigo.
• ✅ Darte más ejemplos de un tipo de algoritmo.
• ✅ Críticar tu descomposición sin darte la solución.

Prompts sugeridos

Prompt 1 — Explicar un algoritmo clásico con analogía:

"Explícame el algoritmo de Euclides para encontrar el MCD con una analogía de la vida real (que no sea de matemáticas). No me des código. Máximo 150 palabras."

Prompt 2 — Verificar una traza:

"Te voy a pegar la traza que hice de un algoritmo. NO me corrijas el algoritmo. Solo dime: (1) ¿la traza está bien hecha? (2) ¿el resultado final es el esperado? (3) ¿hay algún paso que me faltó anotar? Sé concreto, máximo 100 palabras."

Prompt 3 — Identificar el tipo de algoritmo:

"Te voy a describir un problema. NO me des la solución. Solo dime: ¿es un algoritmo secuencial, condicional o repetitivo? ¿O combina varios? ¿Qué técnica de diseño usarías? Máximo 100 palabras."

Prompt 4 — Comparar algoritmos:

"Compáreme los algoritmos de búsqueda lineal y búsqueda binaria: (1) ¿cuál es más rápido? (2) ¿en qué caso usarías cada uno? (3) ¿qué precondición tiene cada uno? No me des código. Máximo 200 palabras."

🧪 Laboratorio — 🧪 LAB 1.3 — Diseña 10 algoritmos propios en tu cuaderno

Tiempo total: 3 h | Entregable: cuaderno con 10 algoritmos diseñados con proceso 4P y trazados.

Regla de oro: no abras la computadora. Todo a mano, en el cuaderno. La computadora viene en el Tema 1.7.

Ejercicio 1 — Calculadora de área de figuras (básico, 30 min)

Enunciado. Diseña un algoritmo que pida al usuario qué figura quiere calcular (1 = triángulo, 2 = cuadrado, 3 = círculo) y luego pida los datos necesarios para calcular su área.

Aplica proceso 4P:

• PR: ¿cuáles son las entradas? ¿cuáles son las salidas?
• DE: descompón en subproblemas.
• PA: identifica el patrón (decisión múltiple + cálculo).
• AL: pseudocódigo + traza con datos.

Criterio de éxito: el pseudocódigo maneja los 3 casos y traza correctamente.

Rúbrica (10 pts): 3 pts por cada figura con pseudocódigo correcto + 1 pt por la traza.

Ejercicio 2 — Validador de contraseñas (básico, 30 min)

Enunciado. Diseña un algoritmo que pida una contraseña al usuario y la valide según estas reglas: mínimo 8 caracteres, al menos una mayúscula, al menos un dígito, al menos un carácter especial (!@#$%).

Aplica proceso 4P y al final escribe el pseudocódigo.

Criterio de éxito: el pseudocódigo verifica las 4 reglas y dice "válida" o "inválida" con la razón.

Rúbrica (10 pts): 2.5 pts por cada regla verificada en el pseudocódigo.

Ejercicio 3 — Generador de tabla de multiplicar (intermedio, 30 min)

Enunciado. Diseña un algoritmo que pida un número N al usuario e imprima la tabla de multiplicar de N del 1 al 10.

Criterio de éxito: el pseudocódigo es general (funciona para cualquier N, no solo para uno específico).

Rúbrica (10 pts): generalización correcta (5 pts) + pseudocódigo claro (3 pts) + traza con N=7 (2 pts).

Ejercicio 4 — Encontrar el número más grande de N números (intermedio, 40 min)

Enunciado. Diseña un algoritmo que pida N al usuario, luego pida N números, y al final imprima cuál fue el más grande. No puedes usar arreglos (eso lo veremos en el Capítulo 3). Solo variables simples.

Pista: vas a necesitar una variable "el más grande hasta ahora" que se actualiza en cada iteración.

Criterio de éxito: el algoritmo funciona con cualquier cantidad de números (no solo con N=5).

Rúbrica (10 pts): generalización (4 pts) + pseudocódigo claro (3 pts) + traza con 5 números (3 pts).

Ejercicio 5 — Sumar dígitos de un número (intermedio, 30 min)

Enunciado. Diseña un algoritmo que pida un número entero positivo al usuario y sume todos sus dígitos. Ejemplo: si el usuario ingresa 472, el resultado es 4 + 7 + 2 = 13.

Criterio de éxito: el pseudocódigo funciona con números de cualquier cantidad de dígitos.

Rúbrica (10 pts): generalización (5 pts) + pseudocódigo (3 pts) + traza con 472 y 9032 (2 pts).

Ejercicio 6 — Invertir una palabra (avanzado, 30 min)

Enunciado. Diseña un algoritmo que pida una palabra al usuario e imprima la palabra invertida. Ejemplo: "Hola" → "aloH".

Pista: cada carácter tiene una posición. El primero va al final, el segundo al penúltimo, etc.

Criterio de éxito: el pseudocódigo funciona con palabras de cualquier longitud.

Rúbrica (10 pts): generalización (4 pts) + pseudocódigo (3 pts) + traza con "Hola" y "Programar" (3 pts).

Ejercicio 7 — Contar vocales en una frase (avanzado, 30 min)

Enunciado. Diseña un algoritmo que pida una frase al usuario y cuente cuántas vocales (a, e, i, o, u) tiene, considerando mayúsculas y minúsculas.

Criterio de éxito: cuenta correctamente, incluyendo acentos si los hay.

Rúbrica (10 pts): manejo de mayúsculas y acentos (4 pts) + pseudocódigo (3 pts) + traza con "Hola Mundo" (3 pts).

Ejercicio 8 — MCD de dos números (avanzado, 30 min)

Enunciado. Diseña el algoritmo de Euclides (MCD) en pseudocódigo y traza con dos pares de números: (48, 18) y (1071, 462).

Criterio de éxito: las trazas coinciden con los resultados esperados (MCD(48,18) = 6, MCD(1071, 462) = 21).

Rúbrica (10 pts): pseudocódigo correcto (5 pts) + 2 trazas correctas (5 pts).

Ejercicio 9 — Detección de palíndromo (avanzado, 30 min)

Enunciado. Diseña un algoritmo que pida una palabra al usuario y determine si es palíndromo (se lee igual al derecho y al revés). Ejemplos: "ana" es palíndromo, "Hola" no lo es, "oso" sí.

Criterio de éxito: funciona con palabras de cualquier longitud y maneja correctamente las mayúsculas.

Rúbrica (10 pts): generalización (4 pts) + manejo de mayúsculas (2 pts) + pseudocódigo (2 pts) + traza con 3 palabras (2 pts).

Ejercicio 10 — Suma de los primeros N números naturales (avanzado, 30 min)

Enunciado. Diseña un algoritmo que pida un número N al usuario y calcule la suma de los números del 1 al N. Aplícalo de dos formas:

• Con un bucle (sumando uno a uno).
• Con la fórmula matemática N*(N+1)/2.

Criterio de éxito: ambos diseños funcionan y traza correctamente con N=10 (resultado: 55).

Rúbrica (10 pts): 5 pts por cada versión (pseudocódigo + traza).

Entregable final del LAB: 10 algoritmos con su proceso 4P y traza. Sello del cuaderno para acreditar el Boss 1.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Las 5 propiedades obligatorias de un algoritmo.
• El esquema E-P-S como columna vertebral de todo algoritmo.
• Los 3 tipos de algoritmos y cómo combinarlos.
• 4 técnicas de diseño (top-down, bottom-up, divide y vencerás, fuerza bruta).
• 5 algoritmos clásicos de la historia (Euclides, factorial, Fibonacci, búsqueda lineal, burbuja).
• La traza como herramienta de verificación antes de codificar.

Lo que sigue: en el Tema 1.4 — Pseudocódigo y Diagramas de Flujo (PSeInt + draw.io), vas a aprender a representar los algoritmos visualmente. El pseudocódigo es la forma textual; los diagramas de flujo son la forma gráfica. Vas a usar PSeInt (un editor gratuito que ejecuta pseudocódigo) y draw.io (un editor gratuito de diagramas). Este tema es la antesala al primer código real (que viene en el Tema 1.7).

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

• [ ] 10 algoritmos diseñados (LAB 1.3).
• [ ] Trazas de al menos 5 algoritmos.
• [ ] Tabla con los 4 algoritmos clásicos trazados.
• [ ] Glosario con los términos: finito, definido, efectivo, E-P-S, top-down, bottom-up, divide y vencerás, fuerza bruta, MCD, factorial, Fibonacci, búsqueda lineal, burbuja, traza.

XP obtenida al completar este tema: 100 base + 30 por LAB (10 algoritmos) + 20 por Quest = 150 XP. Insignia desbloqueada al cerrar el capítulo: Algorithm Architect (parcial).

*"Un algoritmo bien diseñado es como un mapa: si está bien trazado, te lleva al destino sin perderte. Si está mal hecho, te lleva al lado equivocado de la montaña."* — De la introducción de este manual.

Fin del Tema 1.3

📝 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é es un algoritmo?
   • Un lenguaje de programación
   • Una secuencia finita y ordenada de pasos para resolver un problema
   • Un editor de código
   • Un tipo de variable
2. ¿Cuál NO es una característica de un buen algoritmo?
   • Finitud
   • Ambigüedad
   • Definibilidad
   • Eficacia
3. ¿Qué es la complejidad algorítmica O(n)?
   • El algoritmo es lento
   • El tiempo crece linealmente con el tamaño de la entrada
   • El algoritmo es óptimo
   • El algoritmo no termina
4. Big-O se enfoca en:
   • El mejor caso
   • El caso promedio
   • El peor caso
   • El caso constante
5. O(1) significa:
   • Un segundo
   • Tiempo constante independientemente del tamaño
   • Una operación
   • Un ciclo
6. O(log n) es típico de:
   • Búsqueda lineal
   • Búsqueda binaria
   • Ordenamiento burbuja
   • Sumar elementos
7. Un algoritmo O(n²) con n=100 tarda:
   • 100 ops
   • 1,000 ops
   • 10,000 ops
   • 1,000,000 ops
8. La diferencia entre while y do-while es:
   • Son iguales
   • while evalúa antes, do-while después
   • do-while es más rápido
   • do-while no usa condición
9. Un diagrama de flujo usa rombos para:
   • Inicio
   • Proceso
   • Decisión
   • Salida
10. ¿Qué es pseudocódigo?
    • Código real
    • Descripción en lenguaje natural estructurado
    • Un compilador
    • Un depurador

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 Big-O, Omega y Theta. Da un ejemplo de cada uno con un algoritmo.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. ¿Por qué O(n log n) es mejor que O(n²) para n grande? Calcula para n=1,000,000.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. Diseña un algoritmo para encontrar el segundo número más grande de un arreglo de n elementos. Calcula su complejidad.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…