Preguntas de entrevista en JD.com

En qué se centran las entrevistas de JD.com

Preguntas comunes en entrevistas de JD.com

• Implementa una función para serializar y deserializar un árbol binario (LeetCode 297).
  Lo que cubre una buena respuesta

  • Utilizar recorrido preorden para preservar la estructura del árbol.
  • Manejar nodos nulos con un marcador especial (por ejemplo, 'null').
  • La serialización produce una cadena separada por comas.
  • La deserialización usa un índice global o un iterador para reconstruir el árbol.

  Ver respuesta de ejemplo

  Para serializar y deserializar un árbol binario, podemos usar un recorrido preorden. La serialización convierte el árbol en una cadena con valores separados por comas, representando nodos nulos con un marcador como 'null'. La deserialización reconstruye el árbol usando un índice que avanza por la cadena. Esta solución es simple y funciona para cualquier árbol binario. La complejidad temporal es O(n), ya que visitamos cada nodo una vez. La complejidad espacial también es O(n) por la cadena y la pila de recursión. Una alternativa es usar recorrido por niveles, pero el preorden es más directo para este problema.

  class Codec:
  
      def serialize(self, root):
          """Serializa un árbol binario a una cadena."""
          def dfs(node):
              if not node:
                  vals.append('null')
                  return
              vals.append(str(node.val))
              dfs(node.left)
              dfs(node.right)
          vals = []
          dfs(root)
          return ','.join(vals)
  
      def deserialize(self, data):
          """Deserializa una cadena a un árbol binario."""
          def dfs():
              val = next(vals)
              if val == 'null':
                  return None
              node = TreeNode(int(val))
              node.left = dfs()
              node.right = dfs()
              return node
          vals = iter(data.split(','))
          return dfs()
  # Complejidad temporal: O(n) para ambos métodos.
  # Complejidad espacial: O(n) para la cadena y la recursión.

• Diseña un sistema distribuido de procesamiento de pedidos que maneje millones de transacciones por día.
  Lo que cubre una buena respuesta

  • Alta disponibilidad y tolerancia a fallos son críticas.
  • Desacoplar componentes usando colas de mensajes (Kafka).
  • Microservicios para cada etapa del pedido: validación, pago, inventario, envío.
  • Escalabilidad horizontal mediante sharding de la base de datos.

  Ver respuesta de ejemplo

  Para un sistema distribuido de procesamiento de pedidos que maneje millones de transacciones diarias, propondría una arquitectura basada en microservicios y colas de mensajes. Los pedidos entrantes pasan por un balanceador de carga hasta un servicio de API que publica eventos en Kafka. Los consumidores procesan validación, pago, inventario y envío de forma asíncrona. Las bases de datos se particionan por identificador de usuario para evitar cuellos de botella. Se implementa idempotencia para manejar reintentos y evitar duplicados. Para la consistencia eventual, se usa un patrón saga con compensaciones. El monitoreo y alertas son esenciales para detectar fallos rápidamente.

• Describe una ocasión en la que tuviste que hacer una compensación entre velocidad y calidad en un proyecto. ¿Cómo decidiste?
  Lo que cubre una buena respuesta

  • Usar el método STAR (Situación, Tarea, Acción, Resultado).
  • Citar un proyecto real con detalles específicos.
  • Mostrar análisis de riesgos y criterios de decisión.
  • Incluir el resultado y las lecciones aprendidas.

  Ver respuesta de ejemplo

  En un proyecto de migración de un sistema legacy, teníamos que decidir entre una migración por fases (más lenta pero segura) o una migración completa (rápida pero con alto riesgo de errores). Evaluamos el impacto en el negocio: la migración completa podría causar tiempo de inactividad significativo. Decidimos por la migración por fases, comenzando por el módulo de menor riesgo. Esto permitió detectar problemas temprano y ajustar. El proyecto se completó a tiempo con cero incidentes mayores. Aunque fue más lento, la calidad y la confianza del equipo fueron superiores. Aprendí que en sistemas críticos, la velocidad no debe comprometer la estabilidad.

• Dada una lista de intervalos, fusiona todos los intervalos superpuestos (LeetCode 56).
  Lo que cubre una buena respuesta

  • Ordenar los intervalos por su inicio.
  • Iterar y fusionar cuando el inicio actual es <= fin anterior.
  • Actualizar el fin fusionado con el máximo de ambos fines.
  • Complejidad O(n log n) por el ordenamiento.

  Ver respuesta de ejemplo

  Para fusionar intervalos superpuestos, primero ordenamos la lista por el valor de inicio. Luego iteramos, manteniendo un intervalo actual. Si el inicio del siguiente intervalo es menor o igual al fin del actual, los fusionamos actualizando el fin con el máximo. Si no, añadimos el actual a la respuesta y empezamos uno nuevo. Este algoritmo es eficiente: O(n log n) por el ordenamiento y O(n) para el recorrido. El espacio extra es O(n) para la salida.

  def merge(self, intervals):
      if not intervals:
          return []
      intervals.sort(key=lambda x: x[0])
      merged = []
      current = intervals[0]
      for start, end in intervals[1:]:
          if start <= current[1]:  # hay superposición
              current[1] = max(current[1], end)
          else:
              merged.append(current)
              current = [start, end]
      merged.append(current)
      return merged
  # Complejidad temporal: O(n log n)
  # Complejidad espacial: O(n) para la salida

• Diseña un sistema de seguimiento logístico en tiempo real para la red de entrega de JD.
  Lo que cubre una buena respuesta

  • Captura de datos en tiempo real mediante GPS y dispositivos IoT.
  • Procesamiento de flujo con Apache Kafka y Flink para actualizaciones de ubicación.
  • Almacenamiento en base de datos de series temporales (InfluxDB) para consultas históricas.
  • Servicio de geocercas para alertas y estimaciones de llegada.

  Ver respuesta de ejemplo

  Para un sistema de seguimiento logístico en tiempo real, los vehículos y paquetes envían datos GPS a través de dispositivos IoT. Estos datos se ingieren en Apache Kafka para garantizar alta disponibilidad y tolerancia a fallos. Spark Streaming o Flink procesan las actualizaciones de ubicación, calculan ETA y generan alertas si se desvían de la ruta. Las posiciones se almacenan en una base de datos de series temporales como InfluxDB para consultas históricas. Un servicio de geocercas monitorea áreas predefinidas. Las APIs REST exponen los datos en tiempo real a los usuarios. Para escalar, se particionan los streams por identificador de envío y se usa caché para datos recientes. La latencia total desde la captura hasta la visualización se mantiene por debajo de los 10 segundos.

• ¿Cómo optimizarías una consulta de base de datos que es lenta debido a joins en tablas grandes?
  Lo que cubre una buena respuesta

  • Analizar el plan de ejecución con EXPLAIN.
  • Asegurar índices apropiados en las columnas de join y filtros.
  • Considerar la desnormalización para reducir joins complejos.
  • Evaluar el uso de vistas materializadas o resúmenes periódicos.

  Ver respuesta de ejemplo

  Para optimizar una consulta lenta con joins en tablas grandes, primero se debe analizar el plan de ejecución usando EXPLAIN para identificar cuellos de botella. Luego, asegurarse de que las columnas de join y filtros tengan índices adecuados. Si los índices ya existen, considerar cambiar el tipo de join (por ejemplo, usar HASH JOIN vs NESTED LOOPS ajustando parámetros). En algunos casos, la desnormalización puede reducir la necesidad de joins, aunque incrementa la redundancia. Otra opción es usar vistas materializadas que precalculen los resultados o particionar las tablas por fecha para limitar el escaneo. También se puede reescribir la consulta para que sea más eficiente, por ejemplo, filtrando antes del join. Si el problema persiste, escalar horizontalmente la base de datos mediante réplicas de lectura o sharding.

• Cuéntame sobre un proyecto en el que tuviste que colaborar entre equipos. ¿Cuál fue el resultado?
  Lo que cubre una buena respuesta

  • Describir la situación y el objetivo del proyecto.
  • Mencionar los equipos involucrados y sus responsabilidades.
  • Explicar cómo se gestionó la comunicación y las dependencias.
  • Destacar el resultado positivo y las habilidades colaborativas.

  Ver respuesta de ejemplo

  En mi trabajo anterior, lideré un proyecto para integrar el sistema de pedidos con el nuevo sistema de inventario de almacenes. Mi equipo (backend) y el equipo de almacén tenían APIs diferentes y lógicas de negocio conflictivas. Organizamos reuniones semanales y creamos un documento compartido de requisitos. Decidimos usar un contrato de API común y un adaptador para traducir mensajes. Durante la integración, surgieron problemas de rendimiento que resolvimos mediante pruebas de carga conjuntas. El resultado fue una integración exitosa que redujo el tiempo de procesamiento de pedidos en un 30%. Aprendí la importancia de la alineación temprana y la comunicación constante entre equipos.

• Implementa un caché con política de desalojo LRU (LeetCode 146).
  Lo que cubre una buena respuesta

  • Usar una estructura combinada: lista doblemente enlazada + diccionario hash.
  • El diccionario mapea clave al nodo correspondiente.
  • Obtener y poner deben mantener el orden de uso reciente.
  • Operaciones con complejidad O(1) en promedio.

  Ver respuesta de ejemplo

  Para implementar un caché LRU, combinamos un diccionario hash con una lista doblemente enlazada. La lista mantiene el orden de uso: los nodos más recientes están al inicio y los menos al final. En una operación get, si la clave existe, movemos el nodo al inicio y devolvemos su valor. En put, si la clave existe, actualizamos el valor y lo movemos al inicio; si es nueva, creamos un nodo al inicio y, si superamos la capacidad, eliminamos el nodo del final (y su entrada en el hash). Esto garantiza acceso O(1) promedio. La implementación usa nodos con punteros prev y next, y un diccionario que asigna clave al nodo.

  class Node:
      def __init__(self, key, val):
          self.key = key
          self.val = val
          self.prev = None
          self.next = None
  
  class LRUCache:
      def __init__(self, capacity):
          self.cap = capacity
          self.cache = {}  # mapea clave a nodo
          self.head = Node(0, 0)  # dummy head
          self.tail = Node(0, 0)  # dummy tail
          self.head.next = self.tail
          self.tail.prev = self.head
  
      def _remove(self, node):
          node.prev.next = node.next
          node.next.prev = node.prev
  
      def _add_to_front(self, node):
          node.next = self.head.next
          node.prev = self.head
          self.head.next.prev = node
          self.head.next = node
  
      def get(self, key):
          if key in self.cache:
              node = self.cache[key]
              self._remove(node)
              self._add_to_front(node)
              return node.val
          return -1
  
      def put(self, key, value):
          if key in self.cache:
              node = self.cache[key]
              node.val = value
              self._remove(node)
              self._add_to_front(node)
          else:
              if len(self.cache) >= self.cap:
                  # eliminar el nodo menos reciente (tail.prev)
                  lru = self.tail.prev
                  self._remove(lru)
                  del self.cache[lru.key]
              nuevo = Node(key, value)
              self.cache[key] = nuevo
              self._add_to_front(nuevo)
  # Complejidad temporal: O(1) para get y put
  # Complejidad espacial: O(capacidad)

Consejos para prepararse

• Practica la codificación en un pizarrón o editor de texto plano: JD.com a menudo usa sesiones de codificación en persona sin autocompletado.
• Revisa el negocio y las últimas noticias tecnológicas de JD.com, especialmente sobre automatización logística, nube (JD Cloud) y tecnología minorista.
• Prepárate para explicar tu proceso de pensamiento tanto en chino como en inglés, ya que las entrevistas pueden alternar entre idiomas.
• Enfócate en escalabilidad y tolerancia a fallos al diseñar sistemas: JD.com maneja cargas pico como el Día del Soltero.
• Ten ejemplos concretos listos para preguntas conductuales que destaquen iniciativa, resolución de problemas y alineación con los valores de JD.

Preguntas frecuentes