Diseño de algoritmos entendibles: del objetivo a instrucciones sin ambigüedad

Del objetivo a un algoritmo sin ambigüedad: método de diseño

Un algoritmo entendible es una lista de instrucciones que otra persona (o una computadora) puede ejecutar sin interpretar “intenciones”. La meta no es que suene bonito, sino que sea ejecutable: que indique qué hacer, con qué datos, en qué orden, y qué ocurre en cada caso.

Método práctico en 5 pasos

Usa este método cada vez que pases de una idea a instrucciones precisas. La clave es convertir frases generales en reglas medibles y decisiones explícitas.

1) Definir entradas, salidas y restricciones

Antes de escribir pasos, fija el contrato del algoritmo.

• Entradas: datos que recibes (con formato y unidades). Ej.: lista de tramos con duración (min) y costo (€), hora de salida, hora límite, presupuesto.
• Salida: resultado esperado (con formato). Ej.: ruta seleccionada (secuencia de tramos) y métricas (tiempo total, costo total).
• Restricciones: condiciones que deben cumplirse. Ej.: llegar antes de 09:00 y gastar ≤ 8€.
• Criterio de preferencia (si hay varias soluciones): qué optimizas y cómo desempatas. Ej.: minimizar costo; si empatan, minimizar tiempo; si empatan, elegir menos transbordos.

Regla útil: si no defines desempates, el algoritmo puede producir salidas distintas con la misma entrada (y eso complica probarlo).

2) Convertir términos vagos en reglas medibles

Reemplaza palabras interpretables por umbrales, fórmulas o listas cerradas.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

3) Elegir representaciones: variables y estructuras

Un algoritmo entendible usa nombres que describen el propósito, no letras sueltas. Define también cómo representar listas, opciones y resultados.

• Variables: hora_salida, hora_limite, presupuesto_max, costo_total, tiempo_total.
• Estructuras: una ruta como lista de tramos; cada tramo con origen, destino, duracion_min, costo_eur.
• Estados: “ruta parcial” mientras construyes una solución; “mejor ruta” como la mejor encontrada hasta ahora.

Si una variable no tiene unidad o significado claro, es una fuente típica de errores y ambigüedad.

4) Construir pasos con control de flujo explícito

Escribe acciones en imperativo y decide dónde necesitas:

• Secuencia: acciones en orden fijo.
• Decisión: condiciones con SI/SINO que cubran todos los casos relevantes.
• Repetición: recorrer opciones, intentar alternativas, o refinar una solución.

Haz visibles los “puntos de decisión”: qué condición se evalúa, qué ocurre si se cumple y qué ocurre si no se cumple.

5) Verificar con casos de prueba y trazas

Antes de “dar por terminado” el algoritmo, pruébalo con entradas concretas. Una traza es anotar cómo cambian las variables paso a paso.

• Casos normales: hay soluciones que cumplen restricciones.
• Casos límite: presupuesto exacto, llegada justo a la hora límite, lista vacía, un solo tramo.
• Casos sin solución: ninguna ruta cumple; define qué salida produce (por ejemplo, NINGUNA_RUTA).

Criterios de calidad de un algoritmo entendible

Claridad

• Usa verbos de acción: “calcular”, “comparar”, “seleccionar”, “agregar”.
• Evita pronombres sin referente: “eso”, “lo”, “aquello”.
• Define unidades y formatos: minutos, euros, hora en formato 24h.

Determinismo (misma entrada → misma salida)

• Define orden de evaluación y desempates.
• Evita “elige cualquiera” si necesitas reproducibilidad.
• Si hay aleatoriedad, declárala y fija una semilla o regla.

Completitud

• Cubre todos los casos: ¿qué pasa si no hay rutas?, ¿si hay datos inválidos?, ¿si hay empate?
• Incluye validación mínima de entradas (por ejemplo, costos no negativos).

Verificabilidad

• Cada paso debe poder comprobarse: “calcular costo_total” es verificable; “asegurar que sea conveniente” no.
• Incluye condiciones medibles y resultados intermedios que se puedan inspeccionar.

Formato recomendado de pseudocódigo en español

Este formato prioriza legibilidad. Mantén verbos en imperativo y nombres significativos.

ALGORITMO NombreDelAlgoritmo(entradas...): salida...  DEFINIR variables con unidades y significado  VALIDAR entradas (si aplica)  INICIALIZAR valores  PARA cada elemento en una lista HACER    SI condicion ENTONCES      ejecutar acciones    SINO SI otra_condicion ENTONCES      ejecutar acciones    SINO      ejecutar acciones por defecto    FIN SI  FIN PARA  MIENTRAS condicion HACER    ejecutar acciones    ACTUALIZAR condicion  FIN MIENTRAS  DEVOLVER salida  (o DEVOLVER NINGUNA_SOLUCION)

Convenciones útiles:

• Mayúsculas para palabras clave: SI, PARA, MIENTRAS, DEVOLVER.
• Comentarios breves solo cuando aclaran una decisión: // desempate por tiempo.
• Evita pasos “mágicos”: si dices “calcular mejor ruta”, define cómo.

Ejemplo completo: planificar una ruta con restricciones de tiempo y costo

Planteamiento

Quieres ir desde origen hasta destino. Tienes varias rutas candidatas ya enumeradas (por ejemplo, propuestas por un mapa o por una lista previa). Debes elegir una ruta que cumpla:

• Llegar antes o a la hora límite.
• No superar el presupuesto máximo.

Si hay varias rutas válidas, eliges la de menor costo. Si empatan en costo, eliges la de menor tiempo. Si empatan, eliges la de menos tramos.

Entradas y salida

• Entrada: rutas_candidatas (lista de rutas; cada ruta es lista de tramos con duracion_min y costo_eur), hora_salida, hora_limite, presupuesto_max_eur.
• Salida: mejor_ruta (ruta seleccionada) o NINGUNA_RUTA.

Pseudocódigo

ALGORITMO SeleccionarRutaConRestricciones(rutas_candidatas, hora_salida, hora_limite, presupuesto_max_eur): ruta_o_ninguna  SI rutas_candidatas está vacía ENTONCES    DEVOLVER NINGUNA_RUTA  FIN SI  DEFINIR mejor_ruta COMO NINGUNA_RUTA  DEFINIR mejor_costo_eur COMO INFINITO  DEFINIR mejor_tiempo_min COMO INFINITO  DEFINIR mejor_num_tramos COMO INFINITO  PARA cada ruta en rutas_candidatas HACER    DEFINIR costo_total_eur COMO 0    DEFINIR tiempo_total_min COMO 0    PARA cada tramo en ruta HACER      SI tramo.costo_eur < 0 O tramo.duracion_min <= 0 ENTONCES        CONTINUAR con la siguiente ruta  // datos inválidos en esta ruta      FIN SI      costo_total_eur <- costo_total_eur + tramo.costo_eur      tiempo_total_min <- tiempo_total_min + tramo.duracion_min    FIN PARA    DEFINIR hora_llegada COMO hora_salida + tiempo_total_min minutos    SI costo_total_eur <= presupuesto_max_eur Y hora_llegada <= hora_limite ENTONCES      DEFINIR num_tramos COMO cantidad de tramos en ruta      SI (costo_total_eur < mejor_costo_eur) ENTONCES        mejor_ruta <- ruta        mejor_costo_eur <- costo_total_eur        mejor_tiempo_min <- tiempo_total_min        mejor_num_tramos <- num_tramos      SINO SI (costo_total_eur = mejor_costo_eur) Y (tiempo_total_min < mejor_tiempo_min) ENTONCES        mejor_ruta <- ruta        mejor_tiempo_min <- tiempo_total_min        mejor_num_tramos <- num_tramos      SINO SI (costo_total_eur = mejor_costo_eur) Y (tiempo_total_min = mejor_tiempo_min) Y (num_tramos < mejor_num_tramos) ENTONCES        mejor_ruta <- ruta        mejor_num_tramos <- num_tramos      FIN SI    FIN SI  FIN PARA  DEVOLVER mejor_ruta

Mini-ejemplo de datos para probar (y qué deberías observar)

Supón:

• hora_salida = 08:00, hora_limite = 09:00, presupuesto_max_eur = 8
• Ruta A: tramos (20 min, 3€) + (25 min, 4€) → 45 min, 7€ (llega 08:45)
• Ruta B: tramos (35 min, 8€) → 35 min, 8€ (llega 08:35)
• Ruta C: tramos (50 min, 2€) → 50 min, 2€ (llega 08:50)

Con el criterio “menor costo”, la ruta C gana (2€) aunque no sea la más rápida, porque cumple restricciones. Si quisieras priorizar rapidez, tendrías que cambiar explícitamente el criterio de selección.

Lista de comprobación para detectar y eliminar ambigüedades

• ¿Hay palabras vagas? Marca términos como “rápido”, “barato”, “cerca”, “suficiente”, “mejor”, “normal”, “pronto”, “seguro”.
• ¿Cada palabra vaga tiene una regla medible? Umbral, fórmula, lista cerrada o criterio de optimización.
• ¿Las unidades están definidas? minutos vs horas, € vs $, formato de hora, redondeos.
• ¿Hay desempates definidos? Si dos opciones cumplen igual, ¿cuál eliges y por qué?
• ¿Qué pasa si no hay solución? Define salida y comportamiento (por ejemplo, devolver NINGUNA_RUTA).
• ¿Qué pasa con entradas inválidas? Costos negativos, duraciones cero, campos faltantes: ¿rechazas, corriges o ignoras esa opción?
• ¿Cada paso es ejecutable? Evita “optimizar”, “asegurar”, “verificar que esté bien” sin detallar cómo.
• ¿Puedes probarlo con ejemplos? Incluye al menos un caso normal, uno límite y uno sin solución.
• ¿El algoritmo es determinista? Misma entrada produce misma salida gracias a reglas y desempates.