Qué es un algoritmo y cómo pensar como programador

Si llevas algún tiempo aprendiendo a programar, habrás escuchado la palabra "algoritmo" decenas de veces. Pero más allá de la definición técnica, hay una habilidad que separa a los programadores que resuelven problemas de los que se quedan bloqueados: saber cómo pensar antes de escribir código. En esta guía aprenderás qué es un algoritmo, cómo diseñar uno desde cero y cómo desarrollar la mentalidad que usa un programador para descomponer y resolver problemas.

Qué es un algoritmo

Un algoritmo es una secuencia finita de pasos bien definidos que resuelve un problema o realiza una tarea. Tres palabras clave en esa definición:

• Finita: el algoritmo debe terminar. Una secuencia de pasos que se repite infinitamente sin llegar a ningún resultado no es un algoritmo.
• Bien definida: cada paso debe ser claro y sin ambigüedad. "Busca algo en internet" no es un paso bien definido. "Abre el navegador, escribe la URL en la barra de direcciones y pulsa Enter" sí lo es.
• Resuelve un problema: el algoritmo tiene un objetivo y, cuando termina, ese objetivo se ha cumplido.

Los algoritmos no son exclusivos de la informática. Ya los usas todos los días sin darte cuenta:

• La receta de una tortilla es un algoritmo: una serie de pasos en orden que, si los sigues correctamente, producen una tortilla.
• Las instrucciones para montar un mueble de IKEA son un algoritmo.
• El proceso de buscar un número en una agenda telefónica es un algoritmo.

En programación, un algoritmo es lo mismo: una secuencia de pasos que el ordenador puede ejecutar para llegar a un resultado.

Tu primer algoritmo: buscar el número más grande

Supongamos que tienes una lista de números y quieres encontrar el más grande. Antes de escribir código, piensa cómo lo harías tú a mano con un papel.

Si te dieran esta lista: [34, 7, 89, 12, 55, 3], ¿cómo encontrarías el mayor?

Probablemente harías algo así:

1. Miras el primer número (34) y lo recuerdas como "el más grande que he visto hasta ahora".
2. Miras el siguiente (7). ¿Es mayor que 34? No. Sigues recordando 34.
3. Miras el siguiente (89). ¿Es mayor que 34? Sí. Ahora recuerdas 89.
4. Miras el siguiente (12). ¿Es mayor que 89? No. Sigues recordando 89.
5. Miras el siguiente (55). ¿Es mayor que 89? No. Sigues recordando 89.
6. Miras el siguiente (3). ¿Es mayor que 89? No.
7. Has recorrido toda la lista. El más grande es 89.

Acabas de describir un algoritmo. Ahora puedes traducirlo a código:

# Python
def encontrar_maximo(numeros):
    if not numeros:
        return None   # caso especial: lista vacía

    maximo = numeros[0]   # paso 1: el primero es el máximo provisional

    for numero in numeros[1:]:       # paso 2: recorrer el resto
        if numero > maximo:          # paso 3: comparar
            maximo = numero          # paso 4: actualizar si encontramos uno mayor

    return maximo   # paso 5: devolver el resultado

lista = [34, 7, 89, 12, 55, 3]
print(encontrar_maximo(lista))   # 89

// JavaScript
function encontrarMaximo(numeros) {
  if (numeros.length === 0) return null;

  let maximo = numeros[0];

  for (let i = 1; i < numeros.length; i++) {
    if (numeros[i] > maximo) {
      maximo = numeros[i];
    }
  }

  return maximo;
}

const lista = [34, 7, 89, 12, 55, 3];
console.log(encontrarMaximo(lista));   // 89

El proceso que seguiste mentalmente y el código que lo implementa son exactamente la misma cosa: un algoritmo. La programación es traducir ese proceso mental a un lenguaje que el ordenador entiende.

Pseudocódigo: pensar antes de escribir

El pseudocódigo es una forma de escribir algoritmos en lenguaje natural estructurado, a mitad de camino entre el español normal y el código real. No tiene una sintaxis fija ni sigue las reglas de ningún lenguaje de programación. Su único objetivo es ayudarte a pensar el algoritmo antes de preocuparte por los detalles del código.

# Pseudocódigo: encontrar el número mayor
FUNCIÓN encontrar_máximo(lista de números)
    SI la lista está vacía
        DEVOLVER ningún valor

    máximo ← primer elemento de la lista

    PARA CADA número en el resto de la lista
        SI número es mayor que máximo
            máximo ← número

    DEVOLVER máximo
FIN FUNCIÓN

# Pseudocódigo: verificar si una palabra es un palíndromo
FUNCIÓN es_palíndromo(palabra)
    palabra_limpia ← palabra en minúsculas, sin espacios
    palabra_inversa ← palabra_limpia al revés

    SI palabra_limpia es igual a palabra_inversa
        DEVOLVER verdadero
    SI NO
        DEVOLVER falso
FIN FUNCIÓN

El pseudocódigo te permite detectar problemas en tu lógica sin perder tiempo en errores de sintaxis. Es especialmente útil cuando un problema es complejo: diseña primero, codifica después.

Las cuatro habilidades del pensamiento algorítmico

Pensar como programador no significa saber de memoria las funciones de un lenguaje. Es una forma de abordar problemas que se puede aprender y practicar. Se basa en cuatro habilidades:

1. Descomposición: partir el problema en trozos pequeños

Los problemas grandes abruman. Los problemas pequeños se resuelven. La descomposición es el arte de dividir un problema complejo en subproblemas más simples que puedas resolver uno a uno.

# Problema: construir un sistema de registro de usuarios
# En lugar de intentar resolverlo todo de golpe, descompones:

# Subproblema 1: validar que el email tiene formato correcto
# Subproblema 2: verificar que el email no está ya registrado
# Subproblema 3: validar que la contraseña cumple los requisitos
# Subproblema 4: guardar los datos del usuario en la base de datos
# Subproblema 5: enviar un email de confirmación

# Cada subproblema es manejable por sí solo.
# Cuando resuelves todos, has resuelto el problema grande.

2. Reconocimiento de patrones: ver lo que se repite

Los programadores aprenden a reconocer cuando un problema es similar a otro que ya han resuelto. No tienes que reinventar la rueda cada vez: si reconoces el patrón, puedes adaptar una solución conocida.

# Patrón: "recorrer una lista y quedarse con los elementos que cumplen una condición"
# Lo has visto en: filtrar usuarios activos, buscar productos por precio,
# seleccionar pedidos del último mes, encontrar errores en un log...

# Todos siguen el mismo patrón:
def filtrar(lista, condicion):
    resultado = []
    for elemento in lista:
        if condicion(elemento):
            resultado.append(elemento)
    return resultado

# Adaptas el patrón al contexto concreto:
usuarios_activos    = filtrar(usuarios,  lambda u: u["activo"])
productos_baratos   = filtrar(productos, lambda p: p["precio"] < 20)
pedidos_recientes   = filtrar(pedidos,   lambda p: p["fecha"] > hace_30_dias)

3. Abstracción: quedarse con lo esencial

La abstracción consiste en ignorar los detalles irrelevantes y centrarte en lo que importa para resolver el problema. Cuando diseñas un algoritmo para ordenar una lista, no te importa si la lista contiene nombres de frutas o temperaturas: el proceso de ordenar es el mismo.

# Sin abstracción: código específico y difícil de reutilizar
def calcular_precio_manzana(cantidad, precio_por_kilo):
    return cantidad * precio_por_kilo

def calcular_precio_naranjas(cantidad, precio_por_kilo):
    return cantidad * precio_por_kilo

# Con abstracción: función general que funciona para cualquier producto
def calcular_precio(cantidad, precio_por_unidad):
    return cantidad * precio_por_unidad

# Ahora una sola función resuelve todos los casos
print(calcular_precio(2, 1.50))   # manzanas: 3.0€
print(calcular_precio(5, 0.80))   # naranjas: 4.0€
print(calcular_precio(1, 15.00))  # libro: 15.0€

4. Diseño de algoritmos: planificar los pasos

Con el problema descompuesto, los patrones identificados y los detalles irrelevantes eliminados, puedes diseñar el algoritmo concreto para cada subproblema. En esta fase decides la secuencia exacta de pasos, las condiciones y las repeticiones.

Las tres estructuras de control de todo algoritmo

Todo algoritmo, sin importar lo complejo que sea, se puede expresar combinando solo tres estructuras:

Secuencia: pasos que se ejecutan en orden

# Los pasos se ejecutan uno tras otro, de arriba a abajo
def hacer_cafe():
    calentar_agua()
    poner_cafe_en_el_filtro()
    verter_agua_caliente()
    esperar_3_minutos()
    retirar_filtro()
    servir_en_taza()

Condicional: tomar decisiones según una condición

# El algoritmo toma caminos diferentes según si la condición es verdadera o falsa
def clasificar_temperatura(grados):
    if grados < 0:
        return "bajo cero"
    elif grados < 15:
        return "frío"
    elif grados < 25:
        return "templado"
    else:
        return "caluroso"

print(clasificar_temperatura(-5))   # "bajo cero"
print(clasificar_temperatura(22))   # "templado"
print(clasificar_temperatura(35))   # "caluroso"

Repetición: hacer algo varias veces

# Repetir un proceso hasta que se cumpla una condición o un número de veces
def contar_hacia_atras(desde):
    while desde > 0:
        print(desde)
        desde -= 1
    print("¡Despegue!")

contar_hacia_atras(5)
# 5
# 4
# 3
# 2
# 1
# ¡Despegue!

# Repetir un número fijo de veces
def tabla_de_multiplicar(numero):
    for i in range(1, 11):
        print(f"{numero} × {i} = {numero * i}")

tabla_de_multiplicar(7)

Cómo resolver un problema como programador: el proceso

Cuando te enfrentas a un problema de programación, sigue estos pasos en orden. La tendencia de los principiantes es saltar directamente a escribir código. Los programadores con experiencia dedican más tiempo a pensar que a escribir.

Paso 1: entiende el problema antes de tocar el teclado

Lee el enunciado varias veces. Asegúrate de que entiendes qué se pide, cuáles son las entradas y cuál debe ser la salida. Si tienes dudas, aclára​las antes de empezar.

# Problema: "Dada una lista de palabras, devolver solo las que tienen más de 5 letras"

# Entradas: una lista de palabras → ["hola", "programación", "sol", "mundo", "increíble"]
# Salida:   lista de palabras de más de 5 letras → ["programación", "increíble"]
# Condición: longitud > 5 (¿o >= 5? Aclarar si el límite es inclusivo o exclusivo)

Paso 2: trabaja con ejemplos concretos

Antes de pensar en el algoritmo general, trabaja con ejemplos específicos. ¿Qué debería devolver el algoritmo con esta entrada? ¿Y con esta otra? Los casos límite (lista vacía, un solo elemento, todos iguales) son especialmente importantes.

# Ejemplos normales:
# ["hola", "programación", "sol"] → ["programación"]

# Casos límite:
# []                             → []  (lista vacía)
# ["abcdef"]                     → ["abcdef"]  (exactamente 6 letras, ¿se incluye?)
# ["a", "b", "c"]                → []  (ninguna cumple la condición)
# ["python", "código", "data"]   → ["python", "código"] (todas de más de 5)

Paso 3: describe el algoritmo en palabras

# Algoritmo en lenguaje natural:
# 1. Crear una lista vacía para los resultados
# 2. Recorrer cada palabra de la lista original
# 3. Si la palabra tiene más de 5 letras, añadirla a los resultados
# 4. Devolver la lista de resultados

Paso 4: traduce a código

# Python
def palabras_largas(palabras):
    resultado = []
    for palabra in palabras:
        if len(palabra) > 5:
            resultado.append(palabra)
    return resultado

# Versión más concisa con comprensión de listas:
def palabras_largas(palabras):
    return [p for p in palabras if len(p) > 5]

# Prueba con los ejemplos del paso 2
print(palabras_largas(["hola", "programación", "sol"]))   # ["programación"]
print(palabras_largas([]))                                 # []
print(palabras_largas(["a", "b", "c"]))                    # []

Paso 5: verifica y mejora

Comprueba que el código funciona con todos tus ejemplos, incluyendo los casos límite. Si algo falla, vuelve al paso 3 y revisa el algoritmo, no intentes arreglar el código a ciegas.

Una vez que funciona correctamente, pregúntate si se puede mejorar. ¿Es claro? ¿Hay una forma más simple de expresarlo? ¿Es eficiente si la lista tuviera un millón de elementos?

Errores de lógica: cuando el código funciona pero el algoritmo está mal

Uno de los tipos de errores más difíciles de detectar son los errores de lógica: el código se ejecuta sin mensajes de error, pero el resultado no es el correcto. Esto ocurre cuando el algoritmo está mal planteado.

# Error de lógica: calcular el promedio de una lista
def promedio_incorrecto(numeros):
    suma = 0
    for n in numeros:
        suma = suma + n
        promedio = suma / len(numeros)   # ❌ calcula el promedio en cada iteración
    return promedio                       # devuelve el resultado de la última iteración

# El código funciona (no da error) pero el resultado es el mismo que el correcto
# por casualidad. Si el algoritmo fuera diferente, el resultado sería incorrecto.

def promedio_correcto(numeros):
    if not numeros:
        return None
    suma = sum(numeros)
    return suma / len(numeros)   # ✅ calcula el promedio al final, una sola vez

print(promedio_correcto([10, 20, 30]))   # 20.0

# Error de lógica clásico: condición equivocada
def es_par_incorrecto(numero):
    if numero % 2 == 1:   # ❌ condición de número impar, no par
        return True
    return False

def es_par_correcto(numero):
    return numero % 2 == 0   # ✅

print(es_par_incorrecto(4))   # False ← incorrecto (4 sí es par)
print(es_par_correcto(4))     # True  ← correcto

Tres algoritmos clásicos para practicar el pensamiento

Invertir una cadena de texto

# Antes de ver la solución, piensa: ¿cómo lo harías tú a mano?
# Si tienes "hola", ¿cómo obtienes "aloh"?

# Algoritmo manual:
# 1. Tomar el último carácter → "a"
# 2. Tomar el penúltimo      → "l"
# 3. Tomar el anterior       → "o"
# 4. Tomar el primero        → "h"
# 5. Unirlos: "aloh"

# Implementación en Python
def invertir(texto):
    resultado = ""
    for i in range(len(texto) - 1, -1, -1):   # recorrer de atrás hacia adelante
        resultado += texto[i]
    return resultado

print(invertir("hola"))        # "aloh"
print(invertir("algoritmo"))   # "omtirogla"

# Python tiene una forma más corta (slicing con paso -1):
print("hola"[::-1])   # "aloh"

Comprobar si un número es primo

# Un número primo es el que solo se puede dividir entre 1 y él mismo.

# Algoritmo:
# 1. Si el número es menor que 2, no es primo
# 2. Probar si es divisible por algún número del 2 hasta su raíz cuadrada
#    (si no tiene divisores hasta la raíz cuadrada, tampoco los tiene después)
# 3. Si encontramos un divisor, no es primo
# 4. Si no encontramos ninguno, es primo

import math

def es_primo(n):
    if n < 2:
        return False

    for divisor in range(2, int(math.sqrt(n)) + 1):
        if n % divisor == 0:
            return False   # encontramos un divisor: no es primo

    return True   # no encontramos ningún divisor: es primo

print(es_primo(2))    # True
print(es_primo(7))    # True
print(es_primo(10))   # False (10 = 2 × 5)
print(es_primo(13))   # True
print(es_primo(1))    # False

Contar las ocurrencias de cada elemento

# Dada una lista, contar cuántas veces aparece cada elemento.
# Por ejemplo: ["a", "b", "a", "c", "b", "a"] → {"a": 3, "b": 2, "c": 1}

# Algoritmo:
# 1. Crear un diccionario vacío para los contadores
# 2. Recorrer cada elemento de la lista
# 3. Si el elemento ya está en el diccionario, sumarle 1
# 4. Si no está, añadirlo con contador 1
# 5. Devolver el diccionario

def contar_ocurrencias(lista):
    contador = {}
    for elemento in lista:
        if elemento in contador:
            contador[elemento] += 1
        else:
            contador[elemento] = 1
    return contador

letras = ["a", "b", "a", "c", "b", "a"]
print(contar_ocurrencias(letras))   # {"a": 3, "b": 2, "c": 1}

# Python tiene una herramienta específica para esto:
from collections import Counter
print(Counter(letras))   # Counter({"a": 3, "b": 2, "c": 1})

Cómo mejorar el pensamiento algorítmico

El pensamiento algorítmico es una habilidad y, como toda habilidad, mejora con la práctica deliberada. Estas son las formas más efectivas de desarrollarla:

Resuelve problemas de programación regularmente. Plataformas como LeetCode, HackerRank, Codewars o Exercism tienen cientos de problemas organizados por dificultad. Empieza por los más fáciles y sube el nivel gradualmente. Lo importante no es resolver el mayor número posible, sino entender bien los que resuelves.

Explica tu solución en voz alta. La técnica del "pato de goma" consiste en explicar tu código línea a línea a un objeto inanimado (o a otra persona). Al verbalizar lo que hace tu código, a menudo detectas los errores de lógica que no veías leyéndolo.

Lee código de otros. Cuando resuelves un problema, busca cómo lo resolvieron otras personas. A menudo hay enfoques más elegantes o eficientes que el tuyo, y analizarlos amplía tu repertorio de patrones.

Trabaja hacia atrás desde la solución. Si no sabes por dónde empezar, pregúntate: "¿Qué necesito tener justo antes del resultado final?" y así sucesivamente hasta llegar a los datos de entrada. Este proceso inverso a veces revela el algoritmo de forma más natural.

Resumen

• Un algoritmo es una secuencia finita y bien definida de pasos que resuelve un problema. No es exclusivo de la informática: los usamos en el día a día.
• El pensamiento algorítmico se basa en cuatro habilidades: descomposición (dividir el problema), reconocimiento de patrones (ver lo que se repite), abstracción (quedarse con lo esencial) y diseño de pasos concretos.
• Todo algoritmo se expresa combinando tres estructuras: secuencia (pasos en orden), condicional (decisiones) y repetición (bucles).
• El proceso correcto para resolver un problema es: entender → trabajar con ejemplos → diseñar el algoritmo en palabras → traducir a código → verificar. La tentación de empezar a codificar sin pensar es el error más habitual.
• El pseudocódigo es una herramienta valiosa para diseñar el algoritmo sin preocuparse por la sintaxis del lenguaje.
• Los errores de lógica son los más difíciles: el código funciona pero el resultado es incorrecto. La única cura es trabajar con ejemplos concretos y casos límite.
• El pensamiento algorítmico mejora con la práctica: resuelve problemas regularmente, explica tu código en voz alta y lee soluciones de otras personas.