Algoritmos: lógica, pseudocódigo y ejemplos

Un algoritmo en programación es un conjunto finito y ordenado de pasos que transforma una entrada en un resultado. Buscar un nombre, ordenar precios, validar una contraseña, calcular una ruta o recomendar un producto son tareas que dependen de algoritmos.

El algoritmo describe el método antes de que un lenguaje concreto se encargue de la sintaxis. En esta guía aprenderás a reconocer entradas, procesos y salidas, escribir pseudocódigo, traducirlo a Python, analizar casos límite, comprobar corrección y comparar eficiencia.

Qué significa algoritmo

El Dictionary of Algorithms and Data Structures del NIST define un algoritmo como un conjunto computable de pasos para alcanzar un resultado. En términos sencillos, es una receta precisa que una persona o una máquina puede seguir.

Un algoritmo no es lo mismo que el código fuente. El algoritmo es el procedimiento; el código es una implementación. El mismo método de búsqueda puede escribirse en Python, JavaScript o cualquier otro lenguaje.

Ejemplo cotidiano

Preparar una taza de té puede describirse con pasos:

1. Llenar el hervidor.
2. Calentar el agua.
3. Colocar el té en una taza.
4. Verter el agua.
5. Esperar cuatro minutos.
6. Retirar el té y servir.

La secuencia tiene entrada, acciones y resultado. Una instrucción como “espera un poco” es ambigua para un programa; “espera cuatro minutos” es medible.

Propiedades de un algoritmo útil

• Claro: cada paso tiene un significado comprensible.
• Finito: termina.
• Correcto: produce el resultado esperado.
• Definido: entradas, salidas y supuestos están descritos.
• Ejecutable: cada operación puede realizarse.
• General: resuelve una clase de casos, no un ejemplo fijo.

Un algoritmo correcto puede ser lento y uno rápido puede fallar en un caso límite. El diseño debe considerar ambas dimensiones.

Entrada, proceso y salida

• Entrada: datos de una persona, archivo, sensor, API o función.
• Proceso: cálculos, comparaciones, repeticiones y transformaciones.
• Salida: un valor, mensaje, archivo, registro o acción.

La guía de lógica de programación con Python explica estas estructuras con ejemplos.

Escribir pseudocódigo

El pseudocódigo expresa la lógica sin depender de una sintaxis exacta:

LEER precio
LEER porcentaje_descuento

SI precio es negativo
    MOSTRAR error
SINO SI el porcentaje está fuera de 0 a 100
    MOSTRAR error
SINO
    descuento = precio * porcentaje / 100
    precio_final = precio - descuento
    MOSTRAR precio_final
FIN SI

El pseudocódigo permite revisar decisiones y secuencia antes de preocuparse por paréntesis o nombres de funciones.

Traducirlo a Python

def calcular_precio_final(
    precio: float,
    porcentaje: float,
) -> float:
    if precio < 0:
        raise ValueError("El precio no puede ser negativo")
    if not 0 <= porcentaje <= 100:
        raise ValueError("Descuento fuera de rango")

    descuento = precio * porcentaje / 100
    return precio - descuento


print(calcular_precio_final(200, 15))

La implementación añade tipos, validación y una salida reutilizable.

Representar con un diagrama de flujo

Los diagramas de flujo usan formas convencionales:

• óvalo para inicio y fin;
• paralelogramo para entrada o salida;
• rectángulo para proceso;
• rombo para decisión;
• flechas para el flujo.

Son útiles para discutir procesos con personas técnicas y no técnicas. En sistemas grandes, mantén el diagrama a un nivel comprensible.

Secuencia, selección y repetición

Secuencia

subtotal = 100
envio = 12
total = subtotal + envio
print(total)

Selección

edad = 20

if edad >= 18:
    print("Mayor de edad")
else:
    print("Menor de edad")

Repetición

total = 0

for numero in range(1, 6):
    total += numero

print(total)

Consulta la guía de bucles en Python y la de range() para patrones de repetición.

Encontrar el número mayor

Problema: encontrar el mayor valor de una lista no vacía sin usar max().

def encontrar_mayor(numeros):
    if not numeros:
        raise ValueError("La lista no puede estar vacía")

    mayor = numeros[0]

    for numero in numeros[1:]:
        if numero > mayor:
            mayor = numero

    return mayor

La lista vacía es un caso límite. La guía de excepciones en Python explica cómo señalar entradas inválidas.

Búsqueda lineal

def buscar_lineal(elementos, objetivo):
    for indice, elemento in enumerate(elementos):
        if elemento == objetivo:
            return indice
    return None

La búsqueda lineal revisa elementos uno por uno. Funciona con datos no ordenados y suele ser suficiente para colecciones pequeñas.

Búsqueda binaria

def buscar_binaria(elementos_ordenados, objetivo):
    inferior = 0
    superior = len(elementos_ordenados) - 1

    while inferior <= superior:
        medio = (inferior + superior) // 2
        valor = elementos_ordenados[medio]

        if valor == objetivo:
            return medio
        if valor < objetivo:
            inferior = medio + 1
        else:
            superior = medio - 1

    return None

Este algoritmo elimina la mitad del espacio en cada paso, pero requiere una secuencia ordenada. Aplicarlo a datos sin ordenar produce resultados incorrectos.

Corrección y casos límite

Antes de confiar en una solución, pregunta:

• ¿Qué ocurre con la entrada mínima?
• ¿Y con una colección vacía?
• ¿Se permiten duplicados?
• ¿Existen valores negativos o ausentes?
• ¿El bucle progresa y termina?
• ¿El resultado cumple el requisito original?

Trabajar manualmente con ejemplos suele revelar requisitos ambiguos.

Probar un algoritmo

def test_busqueda_encuentra_primero():
    assert buscar_lineal([4, 8, 8, 10], 8) == 1


def test_busqueda_devuelve_none():
    assert buscar_lineal([4, 8, 10], 7) is None

La guía de Pytest explica organización y aserciones.

Complejidad temporal

La complejidad describe cómo crece el trabajo al aumentar la entrada. La referencia sobre complejidad temporal resume las clases más conocidas:

• O(1): trabajo constante.
• O(log n): reducción repetida del espacio.
• O(n): recorrido completo.
• O(n log n): comportamiento común de ordenaciones eficientes.
• O(n²): comparaciones anidadas sobre datos crecientes.

No mide segundos exactos. Sirve para comparar el crecimiento de alternativas.

Complejidad espacial y estructuras

Una solución puede usar memoria adicional para acelerar búsquedas:

permitidos = {101, 203, 407, 509}

if 407 in permitidos:
    print("Permitido")

La guía de sets en Python explica unicidad y pertenencia. La comparación de colecciones de Python ayuda a elegir la estructura adecuada.

Proceso práctico de diseño

1. Define el problema y sus límites.
2. Especifica entradas y salidas.
3. Resuelve ejemplos manualmente.
4. Elige estructuras de datos.
5. Escribe pseudocódigo.
6. Comprueba terminación y casos límite.
7. Implementa una versión clara.
8. Automatiza pruebas.
9. Mide antes de optimizar.
10. Documenta supuestos.

Errores frecuentes

• Programar antes de entender el problema.
• Ignorar entradas inválidas.
• Crear bucles sin progreso.
• Optimizar demasiado pronto.
• Probar un único ejemplo.
• Confundir conocer sintaxis con diseñar soluciones.

Proyecto práctico: promedio validado

def calcular_promedio(notas):
    if not notas:
        raise ValueError("Se necesita al menos una nota")

    for nota in notas:
        if not 0 <= nota <= 100:
            raise ValueError(f"Nota inválida: {nota}")

    return sum(notas) / len(notas)

El algoritmo tiene entrada, validación, proceso, salida y reglas de error claramente separadas.

Conclusión

Un algoritmo en programación es un método preciso para transformar entradas en resultados. Una buena solución define el problema, termina, maneja casos límite, utiliza estructuras apropiadas y puede comprobarse con pruebas. Practica escribiendo pseudocódigo, convirtiéndolo en funciones pequeñas y comparando alternativas antes de buscar optimizaciones complejas.