Coding interview en Python — patrones para resolver casi cualquier ejercicio

La mayoría de la gente prepara los coding interviews mal: hace 200 ejercicios sueltos en LeetCode esperando que “salga”. El problema es que sin un mapa, cada ejercicio parece nuevo.

La realidad es que la gran mayoría de ejercicios de entrevista se resuelven con un puñado de patrones. Si los reconoces, dejas de empezar de cero cada vez. En esta entrada te enseño los 6 que más cubren, con código Python real y, sobre todo, cuándo usar cada uno — que es lo que de verdad cuesta.

Si todavía no controlas las preguntas teóricas (mutabilidad, is vs ==, GIL…), empieza por las 20 preguntas de entrevista de Python. Aquí vamos a la parte de resolver código en vivo.

Antes de los patrones: cómo abordar el ejercicio

El error que más descarta no es fallar el algoritmo: es lanzarse a teclear sin pensar. El guion que esperan los entrevistadores:

1. Repite el problema con tus palabras y pregunta lo que no esté claro (¿hay duplicados? ¿está ordenado? ¿qué hago si la entrada está vacía?).
2. Pon un ejemplo pequeño a mano antes de codificar.
3. Di tu plan en voz alta (“voy a usar un diccionario para…”) antes de escribir.
4. Empieza por la fuerza bruta si no ves la óptima. Una solución que funciona vale más que una elegante a medias.
5. Optimiza y comenta la complejidad.

Esto se entrena aparte y pesa tanto como el código: lo desarrollo en cómo explicar tu código en una entrevista técnica.

Patrón 1 — Hashmap (diccionario) para buscar en O(1)

Cuando necesitas “¿he visto antes este valor / su complemento?”, un diccionario te quita un bucle de encima. El clásico: encontrar dos números que sumen un objetivo.

def dos_suman(numeros, objetivo):
    vistos = {}                      # valor -> índice
    for i, n in enumerate(numeros):
        complemento = objetivo - n
        if complemento in vistos:    # O(1)
            return [vistos[complemento], i]
        vistos[n] = i
    return None

print(dos_suman([2, 7, 11, 15], 9))   # [0, 1]

Fuerza bruta: dos bucles, O(n²). Con diccionario: O(n). Señal para usarlo: “para cada elemento, ¿existe otro que cumpla X?”.

Patrón 2 — Dos punteros

Dos índices que recorren la secuencia, normalmente desde los extremos hacia el centro. Funciona muy bien con datos ordenados o para comparar inicio/fin.

def es_palindromo(texto):
    izq, der = 0, len(texto) - 1
    while izq < der:
        if texto[izq] != texto[der]:
            return False
        izq += 1
        der -= 1
    return True

print(es_palindromo("reconocer"))   # True

Señal para usarlo: comparar elementos de los dos extremos, o buscar un par en una lista ordenada sin bucle anidado.

Patrón 3 — Sliding window (ventana deslizante)

Para subcadenas o subarrays contiguos: en vez de recalcular cada ventana desde cero, mueves un borde y ajustas. El ejemplo típico: la subcadena más larga sin caracteres repetidos.

def subcadena_sin_repetir(s):
    vistos = {}            # caracter -> última posición
    inicio = mejor = 0
    for fin, c in enumerate(s):
        if c in vistos and vistos[c] >= inicio:
            inicio = vistos[c] + 1     # encoge la ventana
        vistos[c] = fin
        mejor = max(mejor, fin - inicio + 1)
    return mejor

print(subcadena_sin_repetir("abcabcbb"))   # 3  ("abc")

Señal para usarlo: “la subsecuencia contigua más larga/corta que cumple X”. Convierte un O(n²) en O(n).

Patrón 4 — Conteo de frecuencias con Counter

Muchos ejercicios de strings se reducen a “¿qué aparece y cuántas veces?”. collections.Counter lo resuelve en una línea. Detectar anagramas:

from collections import Counter

def son_anagramas(a, b):
    return Counter(a) == Counter(b)

print(son_anagramas("roma", "amor"))   # True

Señal para usarlo: anagramas, “el elemento que más se repite”, “¿se puede formar X con las letras de Y?”.

Patrón 5 — Pila (stack) para emparejar y deshacer

Una lista usada como pila (append / pop) resuelve cualquier cosa con anidamiento o “lo último primero”. El ejemplo de manual: paréntesis balanceados.

def parentesis_validos(s):
    pares = {")": "(", "]": "[", "}": "{"}
    pila = []
    for c in s:
        if c in "([{":
            pila.append(c)
        elif c in pares:
            if not pila or pila.pop() != pares[c]:
                return False
    return not pila

print(parentesis_validos("({[]})"))   # True
print(parentesis_validos("([)]"))     # False

Señal para usarlo: paréntesis/etiquetas, expresiones, “deshacer”, recorridos en profundidad.

Patrón 6 — Sets para duplicados y pertenencia

Cuando solo importa “¿lo he visto?” o “¿es único?”, un set da O(1) y elimina bucles. Detectar el primer duplicado:

def primer_duplicado(numeros):
    vistos = set()
    for n in numeros:
        if n in vistos:        # O(1)
            return n
        vistos.add(n)
    return None

print(primer_duplicado([3, 1, 4, 1, 5]))   # 1

Señal para usarlo: duplicados, intersección de dos listas, comprobar pertenencia repetida.

El hilo que une todo: la complejidad

Elegir el patrón correcto es, en el fondo, elegir la estructura con el coste adecuado. Por eso en la entrevista vas a tener que decir “esto es O(n) en tiempo y O(n) en espacio”. Si ese lenguaje te suena lejano, tienes el desglose entero —con el coste de cada operación de listas, dicts y sets— en Big-O en Python para entrevistas.

Cómo practicar para que se quede

• Coge 20-30 ejercicios y, en vez de resolverlos a lo loco, clasifícalos por patrón primero. Verás que se repiten.
• Resuelve en voz alta, como en la entrevista real.
• Reescribe la solución sin mirar al día siguiente: si la entiendes, sale; si la memorizaste, no.

En resumen

No necesitas mil ejercicios: necesitas reconocer hashmap, dos punteros, sliding window, frecuencias, pila y sets, y saber por qué cada uno baja la complejidad. Con eso resuelves la mayoría de coding interviews de Python. Lleva el cheatsheet del clúster para repasar los costes el día antes.

Y si quieres llegar a la entrevista con Python realmente sólido —no solo trucos de algoritmos, sino el lenguaje a fondo con proyectos reales— ese es justo el camino del curso.