OpenCodex Blog

Publicación

- 8 min read

Cómo Resolver Tu Primer Problema en LeetCode: Guía para Principiantes

programming leetcode competitive-programming algorithms data-structures interview-preparation coding-interview beginners tutorial problem-solving
img of Cómo Resolver Tu Primer Problema en LeetCode: Guía para Principiantes

Cómo Resolver Tu Primer Problema en LeetCode: Guía para Principiantes

LeetCode se ha convertido en el terreno de juego predilecto de los desarrolladores que se preparan para entrevistas técnicas. Con más de 3,500 problemas que van desde “fácil” hasta “difícil”, es fácil sentirse abrumado antes de escribir tu primera línea de código.

Si alguna vez abriste LeetCode, miraste un problema por 30 minutos y cerraste la pestaña con frustración, no estás solo. Cada desarrollador que ahora aprueba su entrevista técnica estuvo una vez exactamente donde tú estás ahora.

Resolveremos un problema real de LeetCode juntos, paso a paso. Al final, tendrás un sistema repetible para abordar cualquier problema nuevo.

Índice

Por Qué LeetCode Es Importante

LeetCode no se trata solo de resolver puzzles. Se trata de desarrollar pensamiento algorítmico, la habilidad de descomponer problemas complejos en piezas manejables.

Lo Que LeetCode Realmente Evalúa

  • Descomposición de problemas: ¿Puedes entender qué está preguntando el problema?
  • Reconocimiento de patrones: ¿Has visto problemas similares antes?
  • Implementación de código: ¿Puedes traducir tu idea en código funcional?
  • Optimización: ¿Puedes mejorar tu solución inicial?

Beneficios en el Mundo Real

Más allá de las entrevistas, LeetCode te ayuda a:

  1. Pensar como programador: Aprendes a abordar problemas sistemáticamente
  2. Entender estructuras de datos profundamente: La implementación enseña más que solo leer
  3. Construir confianza: Resolver problemas difíciles se siente gratificante
  4. Unirte a una comunidad: Millones de desarrolladores comparten soluciones y discuten enfoques

Antes de Empezar: La Mentalidad Correcta

Antes de sumergirte en problemas, establece expectativas realistas:

La Regla de los 30 Minutos

Nunca mires un problema por más de 30 minutos sin ayuda. Si estás atascado:

  1. Vuelve a leer la descripción del problema
  2. Intenta resolver manualmente con ejemplos
  3. Revisa las pistas (LeetCode las proporciona)
  4. Busca problemas similares etiquetados con los mismos conceptos

Fácil No Significa Fácil

Los problemas “Fácil” de LeetCode se llaman Fácil porque su solución es corta, no porque sean triviales. Muchos problemas Fácil todavía requieren perspicacia que viene con la práctica.

Fracasarás

Cada experto ha resuelto cientos de problemas incorrectamente antes de encontrar el enfoque correcto. El fracaso es parte del proceso, no una señal de que no perteneces.

Entendiendo el Problema: Two Sum

Resolveremos LeetCode #1: Two Sum, el problema introductorio clásico que todo desarrollador encuentra.

El Problema

Dado un array de enteros nums y un entero target, devuelve los índices de los dos números tales que sumen target.

Puedes asumir que cada entrada tendría exactamente una solución, y no puedes usar el mismo elemento dos veces.

Puedes devolver la respuesta en cualquier orden.

Ejemplo:

   Input: nums = [2, 7, 11, 15], target = 9
Output: [0, 1]
Explicación: nums[0] + nums[1] = 2 + 7 = 9

Este problema ha sido resuelto por más de 1 millón de usuarios en LeetCode. Resolvámoslo juntos.

Paso 1: Lee y Descompón el Problema

Antes de escribir cualquier código, responde estas preguntas:

Preguntas que Deberías hacerte

  1. ¿Cuáles son las entradas? → Un array de enteros, un entero objetivo
  2. ¿Cuáles son las salidas? → Índices de dos números (el orden del array no importa)
  3. ¿Cuáles son las restricciones? → Necesitamos encontrar exactamente una solución, no podemos reutilizar el mismo elemento
  4. ¿Qué debo devolver si no existe solución? → El problema garantiza que existe exactamente una solución

Escribe Lo Que Entiendes

   Input:  nums = [2, 7, 11, 15], target = 9
Output: [0, 1]

Necesitamos: nums[i] + nums[j] = target, donde i ≠ j

Paso 2: Piensa con Ejemplos

Resuelve manualmente algunos ejemplos para construir intuición.

Ejemplo 1

   nums = [2, 7, 11, 15], target = 9
2 + 7 = 9 ✓ → índices [0, 1]

Ejemplo 2

   nums = [3, 2, 4], target = 6
3 + 2 = 5 ✗
3 + 4 = 7 ✗
2 + 4 = 6 ✓ → índices [1, 2]

Ejemplo 3

   nums = [3, 3], target = 6
3 + 3 = 6 ✓ → índices [0, 1]

Paso 3: Identifica la Estructura de Datos

Aquí es donde entra el reconocimiento de patrones.

El Enfoque Ingenuo (O(n²))

La solución de fuerza bruta verifica cada par:

   def two_sum(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

Complejidad Temporal: O(n²) - verificamos cada par Complejidad Espacial: O(1) - sin espacio extra necesario

Esto funciona, pero LeetCode probablemente mostrará timeout en entradas grandes. Podemos hacerlo mejor.

El Enfoque Óptimo (O(n))

Idea Clave: Para cada número x, necesitamos encontrar target - x.

En lugar de buscar hacia atrás (verificando todos los números anteriores), podemos buscar hacia adelante usando un Hash Map:

   def two_sum(nums, target):
    hashmap = {}  # valor -> índice

    for i, num in enumerate(nums):
        complement = target - num
        if complement in hashmap:
            return [hashmap[complement], i]
        hashmap[num] = i

    return []

Cómo funciona:

  1. Para cada número, calcula qué necesitamos para alcanzar el objetivo
  2. Si ese complemento ya existe en nuestro mapa, encontramos nuestro par
  3. De lo contrario, almacena este número y su índice para búsquedas futuras

Complejidad Temporal: O(n) - una sola pasada Complejidad Espacial: O(n) - almacenando números en el mapa

Paso 4: Escribe la Solución

Aquí está la solución completa en Python:

   class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashmap = {}  # Mapea número -> índice

        for i, num in enumerate(nums):
            complement = target - num

            if complement in hashmap:
                return [hashmap[complement], i]

            hashmap[num] = i

        return []  # No se encontró solución (no debería pasar según las restricciones)

Soluciones Alternativas

JavaScript:

   var twoSum = function (nums, target) {
	const map = new Map()

	for (let i = 0; i < nums.length; i++) {
		const complement = target - nums[i]

		if (map.has(complement)) {
			return [map.get(complement), i]
		}

		map.set(nums[i], i)
	}

	return []
}

C++:

   class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashmap;

        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];

            if (hashmap.count(complement)) {
                return {hashmap[complement], i};
            }

            hashmap[nums[i]] = i;
        }

        return {};
    }
};

Paso 5: Prueba Tu Solución

LeetCode proporciona casos de prueba automáticamente, pero deberías verificar tu solución manualmente.

Casos de Prueba para Probar

   # Prueba 1: Caso básico
print(two_sum([2, 7, 11, 15], 9))  # Esperado: [0, 1]

# Prueba 2: Solución en medio del array
print(two_sum([3, 2, 4], 6))  # Esperado: [1, 2]

# Prueba 3: Valores duplicados
print(two_sum([3, 3], 6))  # Esperado: [0, 1]

# Prueba 4: Números negativos
print(two_sum([-1, -2, -3, -4, -5], -8))  # Esperado: [2, 4]

Errores Comunes que Evitar

  1. Olvidar verificar el complemento antes de agregar - Siempre verifica, luego agrega
  2. Usar el mismo índice dos veces - Nuestro enfoque naturalmente evita esto
  3. No manejar casos extremos - Números negativos, ceros, arrays grandes

Patrones Comunes que Deberías Memorizar

Los problemas de LeetCode frecuentemente reutilizan estos patrones fundamentales:

1. Dos Punteros

   # Úsalo cuando: Necesitas encontrar pares en un array ordenado
def two_pointer_example(arr, target):
    left, right = 0, len(arr) - 1
    while left < right:
        current = arr[left] + arr[right]
        if current == target:
            return [left, right]
        elif current < target:
            left += 1
        else:
            right -= 1

2. Ventana Deslizante (Sliding Window)

   # Úsalo cuando: Encontrar subarrays/subcadenas con propiedades específicas
def sliding_window_example(arr, k):
    window_sum = sum(arr[:k])
    max_sum = window_sum

    for i in range(k, len(arr)):
        window_sum += arr[i] - arr[i - k]
        max_sum = max(max_sum, window_sum)

    return max_sum

3. Hash Map para Búsquedas

   # Úsalo cuando: Necesitas búsquedas O(1) para elementos anteriores
def hashmap_example(nums, target):
    hashmap = {}
    for i, num in enumerate(nums):
        if target - num in hashmap:
            return [hashmap[target - num], i]
        hashmap[num] = i
    return []

Recursos para Seguir Aprendiendo

Plataformas de Práctica

PlataformaMejor ParaRango de Dificultad
LeetCodePreparación para entrevistas, problemas seleccionadosFácil → Difícil
NeetCodeAprendizaje estructurado, video solucionesFácil → Medio
CodeforcesProgramación competitiva, velocidadMedio → Difícil
HackerRankFundamentos, certificadosFácil → Medio

Planes de Estudio

  1. NeetCode 150: Lista curada de 150 problemas esenciales
  2. LeetCode Top 100 Liked: Problemas que la comunidad ama
  3. Grind 75: 75 problemas optimizados para preparación de entrevistas

Canales de YouTube

  • NeetCode: Explicaciones en video de alta calidad
  • Take U Forward: Enfoque sistemático a problemas
  • BackToBack SWE: Explicaciones visuales detalladas

Conclusión

Resolver tu primer problema de LeetCode es un hito. Lo que parecía imposible se vuelve manejable una vez que tienes un enfoque sistemático.

Lo Que Aprendimos

  1. Entiende el problema antes de escribir código
  2. Trabaja con ejemplos manualmente primero
  3. Identifica patrones que has visto antes
  4. Comienza simple (fuerza bruta), luego optimiza
  5. Usa la estructura de datos correcta para búsquedas rápidas

Tus Próximos Pasos

  • Practica: Resuelve 1-2 problemas Fácil diariamente durante la primera semana
  • Revisa: Después de resolver, lee otras soluciones para aprender alternativas
  • Mide tu tiempo: Eventualmente apunta a 15-20 minutos por problema Fácil
  • Construye hábitos: La consistencia importa más que la intensidad

La Verdad Sobre LeetCode

No necesitas resolver 1,000 problemas para aprobar tu entrevista. La mayoría de los ingenieros que pasan entrevistas han resuelto 100-300 problemas con comprensión genuina, no memorización.

La diferencia entre quienes tienen éxito y quienes se rinden no es la inteligencia, es la persistencia y la práctica metódica.

Si encontraste esta guía útil, compártela con otros desarrolladores que inician su viaje en LeetCode. ¡Hasta el próximo post!

¿Listo para más? Consulta nuestra guía sobre Estructuras de Datos que Todo Desarrollador Debe Conocer para construir la base para abordar problemas más difíciles.