Preguntas de entrevista en Meta

En qué se centran las entrevistas de Meta

Preguntas comunes en entrevistas de Meta

• Dado un arreglo de intervalos, fusiona los intervalos superpuestos.
  Lo que cubre una buena respuesta

  • Ordenar por inicio
  • Comparar fin actual con inicio siguiente
  • Fusionar si hay superposición
  • Complejidad O(n log n)
  • Espacio O(n)

  Ver respuesta de ejemplo

  Para fusionar intervalos superpuestos, primero ordenamos los intervalos por su tiempo de inicio. Luego iteramos, manteniendo un intervalo actual. Si el inicio del siguiente intervalo es menor o igual al fin del actual, hay superposición y fusionamos (actualizamos el fin como el máximo de ambos). Si no, añadimos el actual a la respuesta y pasamos al siguiente. La complejidad temporal es O(n log n) por el ordenamiento, y espacial O(n) para la salida. Un error común es no ordenar o manejar correctamente los casos donde un intervalo contiene completamente a otro. Un seguimiento típico es cuando los intervalos son muy grandes y se necesita procesamiento en streaming.

  def merge_intervals(intervals):
      if not intervals:
          return []
      # Ordenar por inicio
      intervals.sort(key=lambda x: x[0])
      merged = [intervals[0]]
      for start, end in intervals[1:]:
          last_start, last_end = merged[-1]
          if start <= last_end:  # Hay superposición
              merged[-1][1] = max(last_end, end)
          else:
              merged.append([start, end])
      return merged

• Diseña un sistema de chat distribuido como WhatsApp.
  Lo que cubre una buena respuesta

  • Servicios de mensajería y almacenamiento
  • WebSockets para conexión persistente
  • Base de datos distribuida (Cassandra)
  • Particionamiento por ID de usuario
  • Almacenamiento de mensajes en caché

  Ver respuesta de ejemplo

  Diseñar un sistema de chat distribuido como WhatsApp requiere alta disponibilidad, baja latencia y consistencia eventual. Se compone de un servicio de conexión (WebSockets) que mantiene conexiones persistentes con los usuarios, un servicio de enrutamiento de mensajes que los reenvía al destinatario, y un almacenamiento persistente para mensajes (Cassandra o DynamoDB para escrituras pesadas). Los mensajes se envían a través de un message broker (Kafka) para garantizar durabilidad. Para escalar, se particionan los datos por ID de usuario (o par de usuarios para chats grupales) y se usan réplicas para tolerancia a fallos. La latencia se reduce con caché de sesiones (Redis) y colas de mensajes. Un cuello de botella común es la sincronización de estado en múltiples dispositivos; se resuelve con un registro de eventos. Para cumplir con requisitos de privacidad, se implementa cifrado de extremo a extremo.

• Cuéntame sobre una vez que tuviste un desacuerdo con un colega. ¿Cómo lo resolviste?
  Lo que cubre una buena respuesta

  • Situación específica
  • Enfoque basado en datos
  • Comunicación respetuosa
  • Compromiso negociado
  • Resultado positivo

  Ver respuesta de ejemplo

  En un proyecto anterior, tuve un desacuerdo con un colega sobre si debíamos migrar a un microservicio o refactorizar el monolito. Él quería la migración completa, pero yo argumentaba que era riesgoso para el plazo ajustado. Propuse una reunión para revisar datos: analizamos el impacto en el tiempo de desarrollo, la deuda técnica y los beneficios a largo plazo. Acordamos hacer un refactor gradual del módulo más crítico y posponer la migración completa. Al final, el refactor mejoró el rendimiento sin retrasar el lanzamiento. La clave fue escuchar, basarnos en hechos y buscar una solución intermedia que satisficiera ambos objetivos.

• Dada una lista de palabras, devuelve el grupo de anagramas.
  Lo que cubre una buena respuesta

  • Diccionario para agrupar
  • Firma ordenada o por frecuencia
  • Complejidad O(n * k log k)
  • Uso de tuplas como claves
  • Manejo de mayúsculas

  Ver respuesta de ejemplo

  Para agrupar anagramas, podemos usar un diccionario donde la clave sea la representación ordenada de cada palabra (o una tupla de frecuencia de caracteres). Recorremos la lista, ordenamos los caracteres de cada palabra y la agregamos al grupo correspondiente. La complejidad temporal es O(n * k log k) donde k es la longitud máxima de palabra, y espacial O(n * k). Una optimización es usar un contador de 26 letras como clave (tupla) para evitar ordenamiento, reduciendo a O(n * k). Un error común es no considerar que las palabras pueden tener diferente longitud, pero al ordenar se compara correctamente. Un seguimiento típico es si se permite mezclar mayúsculas, en cuyo caso normalizamos a minúsculas.

  def group_anagrams(strs):
      from collections import defaultdict
      groups = defaultdict(list)
      for s in strs:
          key = tuple(sorted(s))  # o usar contador de frecuencias
          groups[key].append(s)
      return list(groups.values())

• ¿Cómo rediseñarías la función de compartir fotos de Facebook para aumentar la participación?
  Lo que cubre una buena respuesta

  • Flujo actual de compartir fotos
  • Problemas: bajos clics, poca personalización
  • Propuesta: integración con historias
  • Uso de IA para sugerir contactos
  • Métrica: tasa de compartición

  Ver respuesta de ejemplo

  Rediseñaría la función de compartir fotos para aumentar la participación analizando primero por qué los usuarios no comparten. Problemas comunes: demasiados pasos, falta de contexto, privacidad confusa. Mi propuesta: integrar el botón de compartir directamente en el visor de fotos (sin abrir menú), y al presionarlo, mostrar una lista inteligente de contactos y grupos sugeridos por IA basada en interacciones previas (amigos frecuentes, etiquetados). Además, permitir agregar un mensaje corto o sticker. Para privacidad, ofrecer opciones rápidas: solo amigos, amigos cercanos o personalizado. Mediríamos éxito por la tasa de compartición por foto vista. También incluiría la opción de compartir en Historias con un clic, ya que las Historias tienen mayor engagement. Un posible riesgo es saturar a los contactos; por eso limitar sugerencias y permitir silenciar.

• Encuentra la subsecuencia creciente más larga en un arreglo.
  Lo que cubre una buena respuesta

  • Programación dinámica
  • Ecuación: dp[i] = max(dp[j]+1)
  • Optimización con binary search (Patience sorting)
  • Complejidad O(n^2) y O(n log n)
  • Almacenamiento de subsecuencia

  Ver respuesta de ejemplo

  Para la subsecuencia creciente más larga (LIS), podemos usar programación dinámica con O(n^2): dp[i] es la longitud de LIS terminando en i, calculamos tomando el máximo de dp[j]+1 para j < i con nums[j] < nums[i]. También existe una solución O(n log n) llamada 'patience sorting' donde mantenimos una lista 'tails' que guarda el menor valor posible para cada longitud de subsecuencia, y para cada número hacemos binary search para encontrar dónde colocarlo. Para reconstruir la subsecuencia, se necesita rastrear predecesores. La complejidad espacial es O(n). Un error común es confundir con subarreglo contiguo. Un seguimiento típico es el caso de subsecuencia no decreciente (cambiar < por <=).

  def length_of_lis(nums):
      import bisect
      tails = []
      for x in nums:
          i = bisect.bisect_left(tails, x)
          if i == len(tails):
              tails.append(x)
          else:
              tails[i] = x
      return len(tails)

• Describe una vez que cometiste un error y cómo lo manejaste.
  Lo que cubre una buena respuesta

  • Error específico con impacto
  • Responsabilidad asumida
  • Plan de mitigación inmediata
  • Lecciones aprendidas
  • Prevención futura

  Ver respuesta de ejemplo

  En un lanzamiento de producto, desplegué código a producción sin pruebas de integración adecuadas, lo que causó una caída parcial del servicio por 20 minutos. Inmediatamente revertí el cambio, notifiqué al equipo y redacté un post-mortem. Acepté mi error públicamente y propuse agregar pruebas automatizadas en el pipeline de CI/CD, así como un proceso de revisión por pares obligatorio para deploys. Implementé un mecanismo de feature flags para despliegues graduales. Desde entonces, no hemos tenido incidentes similares. El error me enseñó la importancia de la validación en etapas y la comunicación temprana.

• Diseña un algoritmo de ranking de feed de noticias.
  Lo que cubre una buena respuesta

  • Recolección de señales
  • Modelo de ranking: relevancia, recencia, engagement
  • Features: interacciones pasadas, tiempo de publicación
  • Balance entre personalización y diversidad
  • Evaluación con métricas A/B

  Ver respuesta de ejemplo

  Un algoritmo de ranking de feed de noticias debe combinar relevancia y recencia. Primero, extraemos señales de cada publicación: autor, tipo de contenido, interacciones (likes, shares, comentarios) de amigos del usuario, y tiempo de publicación. Luego, un modelo de aprendizaje automático asigna un score a cada publicación potencial. Puede ser un modelo basado en regresión logística o un modelo más avanzado como GBDT. Factores importantes: afinidad con el autor (frecuencia de interacción), peso del tipo de contenido (video > texto), y penalización por contenido promocionado. Para evitar burbujas, se añade diversidad: no mostrar demasiadas publicaciones del mismo autor o mismo tema. Se entrena con datos de clics y tiempo de visualización. Se despliega con pruebas A/B para evaluar métricas como retención y tiempo en sesión. Un cuello de botella es la latencia: se requiere precomputar scores para usuarios activos y usar caché. La actualización en tiempo real de señales (likes) puede hacerse con streams (Kafka).

Consejos para prepararse

• Domina la búsqueda en profundidad y en amplitud, ya que los problemas de árboles/grafos son muy comunes.
• Practica diseño de sistemas en 45 minutos, enfocándote en compensaciones y escalado.
• Prepara de tres a cinco historias STAR que destaquen liderazgo, impacto y resolución de conflictos.
• Comprende a fondo los principios de liderazgo de Meta y alinea tus experiencias con ellos.
• Practica codificación en una pizarra o editor de texto sin formato para simular el entorno de entrevista sin resaltado de sintaxis.

Preguntas frecuentes