Pseudocódigo y diagramas de flujo
Imagina que un arquitecto empieza a construir un edificio sin planos. Suena absurdo, ¿verdad? Pues eso es exactamente lo que hace un programador novato cuando se sienta a escribir código sin haber pensado la solución antes. El pseudocódigo y los diagramas de flujo son tus planos: te permiten diseñar la solución antes de pelearte con la sintaxis de un lenguaje.
¿Por qué escribir soluciones antes de programar?
Cuando piensas directo en código, tu cerebro tiene que hacer dos cosas a la vez: resolver el problema Y recordar la sintaxis. Es como intentar escribir una novela en un idioma que apenas hablas. Si primero escribes la historia en tu idioma (pseudocódigo), luego traducirla es mucho más fácil.
Ventajas de planificar antes de codificar:
- Detectas errores de lógica antes de escribir una sola línea de código
- Puedes explicar tu solución a otra persona sin que sepa programar
- No dependes de ningún lenguaje: el pseudocódigo sirve para JavaScript, Python, Java o cualquier otro
- Ahorras tiempo: es más rápido borrar una línea de pseudocódigo que depurar un bug
Convenciones de pseudocódigo
El pseudocódigo no tiene una sintaxis estricta como un lenguaje de programación, pero usamos convenciones para que cualquier persona lo entienda. Estas son las palabras clave que hemos usado a lo largo del curso:
// Estructura general
INICIO // Empieza el programa
FIN // Termina el programa
// Entrada y salida
LEER variable // Pedir un dato al usuario
MOSTRAR "mensaje" // Mostrar algo en pantalla
// Variables
nombre = "Ana" // Asignar un valor
contador = contador + 1 // Modificar una variable
// Condicionales
SI condición ENTONCES // Si se cumple la condición...
// instrucciones
SINO SI otraCondición ENTONCES // Otra opción
// instrucciones
SINO // Si nada se cumple
// instrucciones
FIN SI
// Bucles
MIENTRAS condición HACER // Repetir mientras se cumpla
// instrucciones
FIN MIENTRAS
PARA i = 1 HASTA 10 HACER // Repetir un número fijo de veces
// instrucciones
FIN PARA
PARA CADA elemento EN lista HACER // Recorrer una lista
// instrucciones
FIN PARA CADA
// Funciones
FUNCION nombre(parámetros) // Definir una función
// instrucciones
DEVOLVER resultado // Devolver un valor
FIN FUNCIONLa regla de oro: si alguien que no sabe programar puede leer tu pseudocódigo y entenderlo, está bien escrito. No te preocupes por ser "perfecto" con la sintaxis. Lo importante es que la lógica sea clara.
Símbolos de diagramas de flujo
Un diagrama de flujo es la versión visual de tu pseudocódigo. Usa formas geométricas conectadas por flechas para mostrar el flujo del programa. Estos son los símbolos estándar:
- Óvalo = Inicio / Fin del programa
- Rectángulo = Proceso (una acción: calcular, asignar, etc.)
- Rombo (diamante) = Decisión (una pregunta con Sí/No)
- Paralelogramo = Entrada/Salida (leer datos o mostrar resultados)
- Flechas = Dirección del flujo (qué paso viene después)
Veamos un diagrama sencillo en formato texto. Este programa pregunta tu edad y te dice si puedes votar:
┌───────────┐
│ INICIO │
└─────┬─────┘
│
▼
┌──────────────┐
│ LEER edad │
└──────┬───────┘
│
▼
┌──────────┐
╱ edad ╲ Sí ┌──────────────────────┐
╱ >= 18 ╲──────────────│ MOSTRAR "Puedes │
╲ ? ╱ │ votar" │
╲──────────╱ └──────────┬───────────┘
│ No │
▼ │
┌──────────────────────┐ │
│ MOSTRAR "Aún no │ │
│ puedes votar" │ │
└──────────┬───────────┘ │
│ │
└──────────┬─────────────────┘
▼
┌───────────┐
│ FIN │
└───────────┘Ejemplo: convertir un problema real a pseudocódigo
Vamos con un problema real: el proceso de compra en una tienda online. Cuando le das a "Comprar" en una web, por detrás pasan muchas cosas. Vamos a convertir ese proceso en pseudocódigo:
FUNCION procesarCompra(carrito, usuario)
// Paso 1: Verificar que el carrito no está vacío
SI LONGITUD(carrito) == 0 ENTONCES
MOSTRAR "Tu carrito está vacío"
DEVOLVER FALSO
FIN SI
// Paso 2: Calcular el total
total = 0
PARA CADA producto EN carrito HACER
total = total + (producto.precio * producto.cantidad)
FIN PARA CADA
// Paso 3: Aplicar descuento si tiene cupón
SI usuario.tieneCupon == VERDADERO ENTONCES
descuento = total * 0.10
total = total - descuento
MOSTRAR "Descuento aplicado: -" + descuento + "€"
FIN SI
// Paso 4: Verificar que el usuario tiene dirección de envío
SI usuario.direccion == "" ENTONCES
MOSTRAR "Necesitas añadir una dirección de envío"
DEVOLVER FALSO
FIN SI
// Paso 5: Procesar el pago
pagoExitoso = procesarPago(usuario.tarjeta, total)
SI pagoExitoso == VERDADERO ENTONCES
// Paso 6: Confirmar el pedido
MOSTRAR "Pedido confirmado. Total: " + total + "€"
enviarEmailConfirmacion(usuario.email)
vaciarCarrito(carrito)
DEVOLVER VERDADERO
SINO
MOSTRAR "Error en el pago. Revisa los datos de tu tarjeta"
DEVOLVER FALSO
FIN SI
FIN FUNCIONFíjate cómo este pseudocódigo te cuenta la historia completa del proceso. Un programador de JavaScript, Python o cualquier lenguaje podría leerlo e implementarlo sin ambigüedad.
Ejemplo: trazar la ejecución paso a paso (dry run)
Un dry run (ejecución en seco) es seguir tu pseudocódigo línea por línea con datos de ejemplo, anotando cómo cambian las variables. Es como ser el ordenador tú mismo, con papel y boli. Esto es CRUCIAL para encontrar errores antes de programar.
Vamos a trazar este algoritmo que busca el número mayor de una lista:
FUNCION encontrarMayor(numeros)
mayor = numeros[1]
PARA i = 2 HASTA LONGITUD(numeros) HACER
SI numeros[i] > mayor ENTONCES
mayor = numeros[i]
FIN SI
FIN PARA
DEVOLVER mayor
FIN FUNCION
// Ejecutamos con: numeros = [3, 7, 2, 9, 4]Ahora hagamos el dry run. Seguimos cada paso y anotamos los valores:
Datos: numeros = [3, 7, 2, 9, 4]
Paso 1: mayor = numeros[1] = 3
mayor = 3
Paso 2: i = 2, numeros[2] = 7
¿7 > 3? SÍ → mayor = 7
Paso 3: i = 3, numeros[3] = 2
¿2 > 7? NO → mayor sigue siendo 7
Paso 4: i = 4, numeros[4] = 9
¿9 > 7? SÍ → mayor = 9
Paso 5: i = 5, numeros[5] = 4
¿4 > 9? NO → mayor sigue siendo 9
Fin del bucle. DEVOLVER 9
✓ Resultado correcto: el mayor de [3, 7, 2, 9, 4] es 9Hacer dry runs es como los ensayos antes de una obra de teatro. Te aseguras de que todo funciona antes del estreno. Si algo falla, lo ves en el papel y lo corriges sin tocar un ordenador.
Diagrama de flujo: proceso de compra
Vamos a representar el proceso de compra que escribimos antes como diagrama de flujo:
┌───────────┐
│ INICIO │
└─────┬─────┘
│
▼
┌──────────────┐
│ LEER carrito │
└──────┬───────┘
│
▼
┌──────────┐
╱ ¿Carrito ╲ Sí ┌─────────────────┐
╱ vacío? ╲──────────│ MOSTRAR "Carrito │
╲ ╱ │ vacío" │──── FIN
╲──────────╱ └─────────────────┘
│ No
▼
┌─────────────────┐
│ Calcular total │
└────────┬────────┘
│
▼
┌──────────┐
╱ ¿Tiene ╲ Sí ┌─────────────────┐
╱ cupón? ╲──────────│ Aplicar 10% │
╲ ╱ │ descuento │
╲──────────╱ └────────┬─────────┘
│ No │
└────────┬──────────────────┘
▼
┌──────────┐
╱ ¿Tiene ╲ No ┌───────────────────┐
╱ dirección? ╲─────────│ MOSTRAR "Falta │
╲ ╱ │ dirección" │──── FIN
╲──────────╱ └───────────────────┘
│ Sí
▼
┌──────────────┐
│ Procesar pago│
└──────┬───────┘
│
▼
┌──────────┐
╱ ¿Pago ╲ No ┌──────────────────┐
╱ exitoso? ╲──────────│ MOSTRAR "Error │
╲ ╱ │ en el pago" │──── FIN
╲──────────╱ └──────────────────┘
│ Sí
▼
┌──────────────────┐
│ Confirmar pedido │
│ Enviar email │
│ Vaciar carrito │
└────────┬─────────┘
│
▼
┌───────────┐
│ FIN │
└───────────┘El diagrama hace algo que el pseudocódigo no puede: te muestra visualmente todos los caminos posibles. Ves de un vistazo que hay 3 formas de terminar con error (carrito vacío, sin dirección, fallo en el pago) y solo 1 camino exitoso.
Cuándo usar pseudocódigo vs. diagramas
- Pseudocódigo: cuando el problema es secuencial y necesitas detalle (fórmulas, operaciones con datos, lógica compleja)
- Diagramas de flujo: cuando hay muchas decisiones y bifurcaciones, y quieres ver todos los caminos posibles
- Ambos juntos: para problemas complejos, primero el diagrama para el flujo general y luego pseudocódigo para los detalles de cada paso
Resumen
- El pseudocódigo es tu herramienta para diseñar soluciones sin pelearte con la sintaxis de ningún lenguaje.
- Usa convenciones claras: INICIO/FIN, SI/SINO, MIENTRAS, PARA CADA, FUNCION/DEVOLVER.
- Los diagramas de flujo son la versión visual: óvalos (inicio/fin), rectángulos (procesos), rombos (decisiones) y paralelogramos (entrada/salida).
- Un dry run (ejecución en seco) te permite verificar tu lógica paso a paso con datos reales antes de programar.
- La regla de oro: si alguien que no sabe programar puede leer tu pseudocódigo y entenderlo, está bien escrito.
En la siguiente lección aprenderemos a resolver problemas como un programador: un método de 4 pasos para enfrentarte a cualquier problema, por complejo que sea.
Sistema de login con máximo 3 intentos
Con papel y bolígrafo, diseña un sistema de login que funcione así:
- El usuario correcto es "admin" y la contraseña correcta es "1234"
- El sistema pide usuario y contraseña
- Si son correctos, muestra "Bienvenido" y termina
- Si son incorrectos, muestra "Datos incorrectos" y deja intentar de nuevo
- Si falla 3 veces, muestra "Cuenta bloqueada" y termina
Debes entregar:
- Pseudocódigo completo usando las convenciones aprendidas (INICIO, FIN, MIENTRAS, SI, LEER, MOSTRAR...)
- Diagrama de flujo en ASCII con los símbolos correctos (óvalo, rectángulo, rombo, paralelogramo)
- Un dry run con este escenario: el usuario falla 2 veces y acierta a la tercera
lightbulb Pistas
Necesitas una variable intentos que empiece en 0 y un bucle MIENTRAS intentos < 3. Dentro del bucle, lee usuario y contraseña, comprueba si coinciden y, si no, incrementa intentos. Después del bucle, comprueba si saliste porque acertaste o porque se agotaron los intentos. Para el dry run, haz una tabla con columnas: paso, intentos, usuario, contraseña, resultado.
