Preguntas de entrevista en Apple

En qué se centran las entrevistas de Apple

Preguntas comunes en entrevistas de Apple

• Cuéntame sobre una vez que tuviste que influir en alguien sin autoridad directa.
  Lo que cubre una buena respuesta

  • Influencia sin autoridad: construir relaciones
  • Entender intereses del otro
  • Presentar datos y beneficios mutuos
  • Negociar y encontrar soluciones win-win

  Ver respuesta de ejemplo

  En mi rol anterior como ingeniero de software, necesitaba que el equipo de QA priorizara la automatización de pruebas para un feature crítico, pero no tenía autoridad directa sobre ellos. Primero, investigué sus cargas de trabajo actuales y encontré que tenían cuellos de botella en pruebas manuales. Luego, organicé una reunión para presentar datos concretos: mostrar cómo la automatización reduciría su tiempo de prueba en un 30% y liberaría recursos para otras tareas. También ofrecí colaborar en la implementación de las pruebas. Finalmente, acordamos un plan de implementación gradual que beneficiaba a ambos equipos. La clave fue entender sus necesidades y ofrecer valor tangible en lugar de imponer.

• Explica el problema técnico más desafiante que hayas resuelto y cómo lo abordaste.
  Lo que cubre una buena respuesta

  • Problema: carrera crítica en sistema distribuido
  • Abordaje: análisis de logs y reproducción
  • Solución: bloqueo distribuido con Redis
  • Resultado: eliminación de fallos intermitentes

  Ver respuesta de ejemplo

  El problema técnico más desafiante fue una carrera crítica en un sistema de procesamiento de eventos. Los eventos se duplicaban aleatoriamente porque dos servicios podían procesar el mismo evento simultáneamente. Primero, reproduje el problema en un entorno de pruebas con carga controlada. Analicé los logs y encontré que ambos servicios obtenían el mismo evento de Kafka con el mismo offset. Implementé un bloqueo distribuido usando Redis con expiración automática para garantizar que solo un servicio procesara cada evento. También añadí idempotencia en el consumidor. La solución eliminó las duplicaciones y mejoró la confiabilidad del sistema. Aprendí la importancia de la idempotencia y las pruebas de carga en sistemas concurrentes.

• Diseña un sistema como iMessage: ¿cómo asegurarías una entrega confiable y baja latencia?
  Lo que cubre una buena respuesta

  • Arquitectura cliente-servidor con push
  • Almacenamiento y reenvío (store-and-forward)
  • Balanceo de carga y particionamiento
  • Uso de WebSockets y notificaciones push

  Ver respuesta de ejemplo

  Para diseñar un sistema como iMessage con entrega confiable y baja latencia, primero definiría requisitos: mensajes entregados una sola vez, ordenados y con baja latencia (<1s). Los componentes principales serían: cliente (app), servidor de mensajes, base de datos de mensajes, servicio de notificaciones push y un sistema de colas. El flujo: el cliente envía un mensaje al servidor a través de una conexión WebSocket persistente. El servidor almacena el mensaje en una base de datos (Cassandra para escrituras rápidas) y lo encola para entrega. Si el destinatario está conectado, se envía directamente por WebSocket; si no, se envía una notificación push (APNs/FCM). Para escalar, usaría balanceo de carga con sticky sessions, particionamiento de usuarios por shard en la base de datos, y caché de mensajes recientes en Redis. Los cuellos de botella son la latencia de push y la consistencia de mensajes. Para garantizar entrega, implementaría confirmaciones de recepción (ACKs) y reintentos con backoff exponencial.

• Implementa una función para aplanar un arreglo anidado en JavaScript.
  Lo que cubre una buena respuesta

  • Recursión o iteración
  • Uso de Array.isArray
  • Manejo de profundidad variable
  • Complejidades O(n) tiempo y O(d) espacio

  Ver respuesta de ejemplo

  La función anterior aplane un arreglo anidado usando recursión. Recorre cada elemento; si es un arreglo, se llama a sí misma y concatena el resultado; si no, lo agrega al resultado. La complejidad temporal es O(n) donde n es el número total de elementos. La complejidad espacial es O(d) por la pila de recursión, siendo d la profundidad máxima del anidamiento. Una alternativa iterativa con pila explícita podría reducir el espacio en casos de anidamiento profundo, pero la versión recursiva es más clara. Un error común es olvidar manejar arreglos vacíos o no usar la comprobación correcta de array.

  // Función para aplanar un arreglo anidado recursivamente
  function flattenArray(arr) {
    let result = [];
    for (let i = 0; i < arr.length; i++) {
      if (Array.isArray(arr[i])) {
        // Si es un arreglo, concatenamos recursivamente
        result = result.concat(flattenArray(arr[i]));
      } else {
        // Si es un elemento, lo agregamos
        result.push(arr[i]);
      }
    }
    return result;
  }
  
  // Ejemplo de uso:
  const nested = [1, [2, [3, 4], 5], 6];
  console.log(flattenArray(nested)); // [1, 2, 3, 4, 5, 6]
  // Complejidad de tiempo: O(n) donde n es el número total de elementos
  // Complejidad de espacio: O(d) por la pila de recursión, d es la profundidad máxima del anidamiento

• ¿Cómo mejorarías la duración de la batería de una aplicación de iPhone? Explica tu proceso de depuración.
  Lo que cubre una buena respuesta

  • Perfilamiento con Instruments de Xcode
  • Identificar culpables: ubicación, red, CPU
  • Reducir wakeups y optimizar polling
  • Uso de URLSession con configuración adecuada

  Ver respuesta de ejemplo

  Para mejorar la duración de la batería de una app de iPhone, primero perfilaría con Instruments (Energy Log) para identificar componentes de alto consumo. Las causas comunes son: ubicación (GPS continuo en lugar de regiones), actualizaciones en segundo plano frecuentes, y solicitudes de red excesivas. Mi proceso de depuración incluye: 1) Habilitar el Energy Diagnostics en Xcode, 2) Ejecutar la app y usar Energy Log para ver apps con alto impacto, 3) Identificar picos de CPU y wakeups. Luego, optimizaría: para ubicación, usar el menor nivel de precisión necesario y regiones en lugar de actualizaciones continuas. Para red, agrupar solicitudes y usar caché. Para trabajo en segundo plano, usar Background Tasks con prioridad y procesamiento por lotes. También revisaría el uso de temporizadores y animaciones. Finalmente, probar con iOS Energy Saver y Device Logs para validar mejoras.

• Describe una situación en la que no estuviste de acuerdo con tu gerente. ¿Cómo lo manejaste?
  Lo que cubre una buena respuesta

  • Situación: desacuerdo sobre enfoque técnico
  • Acción: presentar datos y alternativas
  • Compromiso: implementar prueba de concepto
  • Resultado: aprendizaje mutuo y mejor solución

  Ver respuesta de ejemplo

  En una ocasión, mi gerente quería migrar una base de datos relacional a NoSQL para mejorar la escalabilidad. Yo no estaba de acuerdo porque las consultas complejas y las transacciones eran críticas para el negocio. Primero, preparé un análisis comparativo de ambos enfoques: mostré que NoSQL aumentaría la complejidad del código y los costos de mantenimiento. Luego, propuse una solución híbrida: mantener la base relacional para datos transaccionales y usar una cache NoSQL para lecturas de alto volumen. Mi gerente aceptó hacer una prueba de concepto. Los resultados mostraron que la solución híbrida cumplía con los requisitos de escalabilidad sin sacrificar la consistencia. Aprendí la importancia de llegar con datos concretos en lugar de opiniones, y de estar abierto a compromisos.

• Diseña un acortador de URLs (como TinyURL) con alto rendimiento y bajo costo de almacenamiento.
  Lo que cubre una buena respuesta

  • Sistema: hash y base de datos
  • Alto rendimiento: caché y redirección rápida
  • Bajo costo: almacenamiento de metadatos mínimo
  • Escalabilidad: sharding y consistencia hashing

  Ver respuesta de ejemplo

  Para diseñar un acortador de URLs como TinyURL con alto rendimiento y bajo costo de almacenamiento, los componentes principales son: un servicio web para crear y redirigir URLs, una base de datos (como Cassandra o DynamoDB) para almacenar el mapeo hash->URL, y una caché de alta velocidad (Redis) para los hashes más populares. El flujo: al crear un acortador, el servidor genera un hash único (base62, por ejemplo) y guarda la URL original en la base de datos; para la redirección, el servidor busca el hash primero en caché, si no está, en base de datos, y redirige con 301. Para bajo costo de almacenamiento, el hash puede ser de 6-7 caracteres, y la URL original no se guarda por mucho tiempo (expiración). Para alto rendimiento, usar caché con TTL y balanceo de carga con sticky sessions. La escalabilidad se logra con sharding de la base de datos por rango de hash y consistencia hashing para distribuir la carga. Los cuellos de botella son la latencia de base de datos y la contención de escritura; se mitigan con caché y escrituras asíncronas.

• Dado un árbol binario, encuentra el ancestro común más bajo de dos nodos.
  Lo que cubre una buena respuesta

  • Recorrido postorden recursivo
  • Caso base: raíz es nulo o es uno de los nodos
  • Combinar resultados de subárboles
  • Complejidades O(n) tiempo, O(h) espacio

  Ver respuesta de ejemplo

  La función anterior encuentra el ancestro común más bajo (LCA) de dos nodos en un árbol binario usando recursión con un recorrido postorden. La idea es: si el nodo actual es nulo o es igual a p o q, lo devolvemos. Luego, buscamos en los subárboles izquierdo y derecho. Si ambos subárboles devuelven un nodo no nulo, significa que p y q están en subárboles diferentes, por lo que el nodo actual es el LCA. Si solo un subárbol devuelve un nodo, ese es el LCA. La complejidad de tiempo es O(n) porque visitamos cada nodo una vez. La complejidad de espacio es O(h) por la pila de recursión, donde h es la altura del árbol (en el peor caso, árbol inclinado, O(n)). Este enfoque asume que p y q existen en el árbol; si no, devolvería el nodo encontrado de manera incorrecta. Una variante con punteros a padres podría ser más eficiente en árboles con acceso a padres.

  class TreeNode:
      def __init__(self, val=0, left=None, right=None):
          self.val = val
          self.left = left
          self.right = right
  
  def lowestCommonAncestor(root, p, q):
      """
      Encuentra el ancestro común más bajo de dos nodos en un árbol binario.
      Complejidad: O(n) tiempo, O(h) espacio (h = altura del árbol).
      """
      # Caso base: si el nodo actual es None o es uno de los nodos buscados
      if root is None or root == p or root == q:
          return root
  
      # Buscar en subárbol izquierdo y derecho
      left = lowestCommonAncestor(root.left, p, q)
      right = lowestCommonAncestor(root.right, p, q)
  
      # Si ambos lados devuelven no-None, entonces este nodo es el LCA
      if left and right:
          return root
  
      # Si solo uno de los lados tiene resultado, ese es el LCA
      return left if left else right
  
  # Ejemplo de uso:
  # Construir árbol: root = TreeNode(3)
  # root.left = TreeNode(5)
  # root.right = TreeNode(1)
  # ... y luego llamar lowestCommonAncestor(root, p, q)

Consejos para prepararse

• Estudia los principios de diseño y la filosofía de producto de Apple. Menciona cómo tu trabajo se alinea con la simplicidad y la experiencia del usuario.
• Practica la narración conductual: usa el método STAR (Situación, Tarea, Acción, Resultado) para estructurar tus respuestas.
• Concéntrate en código limpio y legible durante las entrevistas de codificación. Apple valora soluciones elegantes, no solo correctas.
• Prepárate para discutir compensaciones en el diseño de sistemas. Los ingenieros de Apple aprecian el razonamiento profundo sobre escalabilidad, latencia y confiabilidad.
• Investiga a tus entrevistadores y el equipo al que te postulas. Adapta tus ejemplos a sus productos específicos (por ejemplo, iOS, Mac, Servicios).

Preguntas frecuentes