Questions d'entretien Meta

Sur quoi portent les entretiens chez Meta

Questions d'entretien courantes chez Meta

• Étant donné un tableau d'intervalles, fusionnez les intervalles qui se chevauchent.
  Ce qu'une bonne réponse couvre

  • Tri des intervalles par début
  • Parcours linéaire avec fusion si chevauchement
  • Complexité O(n log n) due au tri
  • Cas particuliers : intervalles non triés, vidés

  Voir un exemple de réponse

  Pour fusionner des intervalles qui se chevauchent, on commence par trier la liste par début d'intervalle. Ensuite, on parcourt les intervalles triés et on fusionne si l'intervalle courant chevauche le dernier intervalle fusionné (c'est-à-dire si le début de l'intervalle courant est inférieur ou égal à la fin du dernier fusionné). On met à jour la fin du dernier intervalle fusionné avec le maximum des deux fins. Sinon, on ajoute l'intervalle courant à la liste résultat. La complexité temporelle est O(n log n) due au tri, et spatiale O(n) pour stocker le résultat. Un piège courant est d'oublier de trier, ce qui donne un résultat incorrect. En entretien, on peut aussi discuter d'une complexité O(n) si les données sont déjà triées.

  def merge_intervals(intervals):
      if not intervals:
          return []
      # Trier par début d'intervalle
      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:  # chevauchement
              merged[-1] = (last_start, max(last_end, end))
          else:
              merged.append((start, end))
      return merged
  
  # Exemple d'utilisation
  intervals = [(1,3),(2,6),(8,10),(15,18)]
  print(merge_intervals(intervals))  # [(1,6),(8,10),(15,18)]

• Concevez un système de chat distribué comme WhatsApp.
  Ce qu'une bonne réponse couvre

  • Architecture client-serveur avec WebSockets
  • Stockage distribué (Cassandra) pour messages
  • Sharding par ID de conversation
  • Gestion de la cohérence éventuelle et du cache

  Voir un exemple de réponse

  Un système de chat distribué comme WhatsApp doit gérer des millions d'utilisateurs et des messages en temps réel. L'architecture s'appuie sur des serveurs de chat avec WebSockets pour maintenir des connexions persistantes. Les messages sont envoyés à un service de distribution qui les achemine vers le destinataire via son serveur de chat. Pour la persistance, on utilise une base NoSQL comme Cassandra, partitionnée par conversation (sharding par conversation_id) pour une écriture rapide. La cohérence éventuelle suffit car les messages doivent être livrés rapidement, même si l'ordre exact peut être géré par des horodatages côté client. On utilise un cache Redis pour les sessions utilisateur et les conversations récentes. Pour la fiabilité, on implémente des files d'attente (Kafka) pour les messages non livrés. Un défi est la synchronisation des messages entre appareils : on stocke l'état de lecture et on utilise des notifications push (FCM/APNs). La scalabilité horizontale est assurée en ajoutant des serveurs de chat et en répartissant les connexions via un load balancer.

• Parlez-moi d'une fois où vous avez eu un désaccord avec un collègue. Comment l'avez-vous résolu ?
  Ce qu'une bonne réponse couvre

  • Contexte et désaccord technique
  • Écoute active et compréhension des points de vue
  • Recherche de compromis basé sur des données
  • Résolution collaborative et suivi

  Voir un exemple de réponse

  J'ai eu un désaccord avec un collègue sur le choix d'une base de données pour un nouveau service. Il préférait MongoDB pour sa flexibilité, tandis que je proposais PostgreSQL pour la cohérence transactionnelle et les jointures. Nous avons pris le temps d'écouter nos arguments respectifs, puis nous avons défini les critères de décision : besoin de transactions ACID, volume de données modéré, et équipe familière avec SQL. Nous avons fait un benchmark rapide sur un prototype : PostgreSQL répondait à tous nos cas d'usage avec de meilleures performances pour les requêtes complexes. J'ai proposé d'utiliser PostgreSQL avec des JSONB pour la flexibilité, ce qui a satisfait les deux parties. Nous avons documenté notre décision et partagé avec l'équipe. Cette expérience m'a appris l'importance de baser les décisions sur des faits et de chercher des solutions hybrides.

• Étant donné une liste de mots, retournez le groupe d'anagrammes.
  Ce qu'une bonne réponse couvre

  • Utilisation d'un dictionnaire avec clé triée
  • Complexité O(n * k log k) où k est la longueur moyenne des mots
  • Alternative : compter les lettres (tableau de 26) pour clé
  • Gestion des mots vides et casse

  Voir un exemple de réponse

  Pour regrouper des anagrammes, on peut utiliser un dictionnaire dont la clé est une version canonique de chaque mot, par exemple les lettres triées par ordre alphabétique. On parcourt chaque mot, on le trie, et on ajoute le mot original à la liste correspondant à cette clé. La complexité temporelle est O(n * k log k) où n est le nombre de mots et k la longueur moyenne, car le tri domine. On peut optimiser en utilisant un compteur de lettres (tableau de 26) comme clé dans un dictionnaire, réduisant à O(n * k) mais avec une complexité spatiale légèrement plus élevée. Il faut gérer la casse en normalisant (minuscules) et ignorer les espaces. Un piège est d'utiliser un hash mutable (list) comme clé ; on utilise un tuple. En entretien, on commencera par le tri, puis on pourra discuter de l'optimisation du compteur de fréquences.

  def group_anagrams(words):
      from collections import defaultdict
      anagram_map = defaultdict(list)
      for word in words:
          # Norme : en minuscules, sans espaces
          cleaned = ''.join(word.lower().split())
          key = ''.join(sorted(cleaned))
          anagram_map[key].append(word)
      return list(anagram_map.values())
  
  # Exemple
  words = ["listen", "silent", "enlist", "hello", "olleh"]
  print(group_anagrams(words))
  # [['listen', 'silent', 'enlist'], ['hello', 'olleh']]

• Comment reconcevriez-vous la fonctionnalité de partage de photos de Facebook pour augmenter l'engagement ?
  Ce qu'une bonne réponse couvre

  • Objectif : augmenter l'engagement (partages, commentaires)
  • Simplifier le processus de partage (moins de clics)
  • Personnalisation : suggérer des destinataires et groupes
  • Ajouter des fonctionnalités sociales : histoires, réactions
  • Intégration avec d'autres plateformes

  Voir un exemple de réponse

  Pour reconcevoir le partage de photos sur Facebook et augmenter l'engagement, il faut réduire les frictions et rendre le partage plus social. Actuellement, partager une photo nécessite plusieurs clics. Je proposerais un bouton de partage en un clic qui ouvre une interface légère avec des suggestions de destinataires basées sur les interactions récentes (amis, groupes, pages). On pourrait aussi permettre de créer des « collections » temporaires (histoires) ou permanentes (albums) directement depuis l'interface de partage. Pour encourager les partages, on ajouterait des incitations visuelles comme des réactions animées et des options de tag automatique via reconnaissance faciale. L'intégration avec des applis externes (Instagram, Messenger) permettrait un partage croisé fluide. Enfin, on pourrait introduire un système de « cadeaux » ou de « rappels » pour partager des photos d'événements passés, augmentant la rétention. Il faut cependant veiller à ne pas surcharger l'interface et respecter la vie privée. Un suivi des métriques de partage permettrait d'itérer rapidement.

• Trouvez la plus longue sous-séquence croissante dans un tableau.
  Ce qu'une bonne réponse couvre

  • Programmation dynamique O(n^2) ou O(n log n)
  • Solution O(n log n) avec tableau de séquences minimales
  • Parcours avec recherche binaire (bisect)
  • Cas dégénéré : tableau vide

  Voir un exemple de réponse

  La plus longue sous-séquence croissante (LIS) peut être trouvée en O(n^2) avec DP classique, mais on peut atteindre O(n log n) en utilisant un tableau `tails` qui stocke la plus petite valeur possible pour une longueur de sous-séquence donnée. On parcourt les éléments et on utilise la recherche binaire pour trouver la position dans `tails` où l'élément courant peut remplacer ou étendre la séquence. La longueur finale de `tails` est la taille de la LIS. La complexité spatiale est O(n). Un piège courant est de confondre la sous-séquence (non nécessairement contiguë) avec une sous-chaîne. En entretien, on présentera d'abord la solution DP simple, puis on optimisera. Il faut gérer les doublons en utilisant `bisect_left` pour les séquences strictement croissantes.

  import bisect
  
  def longueur_LIS(nums):
      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)
  
  # Exemple
  print(longueur_LIS([10, 9, 2, 5, 3, 7, 101, 18]))  # 4 (2,3,7,101)
  
  # Pour retourner la sous-séquence elle-même (plus complexe)
  def LIS(nums):
      if not nums:
          return []
      dp = [1] * len(nums)
      prev = [-1] * len(nums)
      max_len = 0
      max_idx = 0
      for i in range(len(nums)):
          for j in range(i):
              if nums[j] < nums[i] and dp[j] + 1 > dp[i]:
                  dp[i] = dp[j] + 1
                  prev[i] = j
          if dp[i] > max_len:
              max_len = dp[i]
              max_idx = i
      # Reconstruction
      seq = []
      while max_idx != -1:
          seq.append(nums[max_idx])
          max_idx = prev[max_idx]
      return seq[::-1]
  
  print(LIS([10, 9, 2, 5, 3, 7, 101, 18]))  # [2, 5, 7, 101] ou [2,3,7,101]

• Décrivez une fois où vous avez commis une erreur et comment vous l'avez gérée.
  Ce qu'une bonne réponse couvre

  • Situation contextuelle et erreur spécifique
  • Responsabilité prise rapidement
  • Communication proactive aux parties prenantes
  • Mise en place de mesures correctives
  • Apprentissage et prévention future

  Voir un exemple de réponse

  Lors d'un déploiement, j'ai accidentellement cassé la base de production en exécutant un script de migration sans vérifier les index. L'application est devenue extrêmement lente. Immédiatement, j'ai notifié mon responsable et l'équipe ops, puis j'ai reverti la migration en utilisant un backup. J'ai ensuite analysé la cause : le script ajoutait une colonne non indexée sur une table avec des millions de lignes, ralentissant les requêtes. J'ai corrigé le script en ajoutant un index, et j'ai testé sur un environnement de staging. J'ai aussi mis en place une revue automatique des migrations avec un outil (Flyway) et ajouté des tests de performance. J'ai documenté l'incident et partagé les leçons apprises. Depuis, nous avons un processus de déploiement plus rigoureux avec des vérifications automatiques. Cette erreur m'a appris l'importance de toujours tester les migrations sur une copie de la production et de ne jamais déployer le vendredi soir.

• Concevez un algorithme de classement du fil d'actualité.
  Ce qu'une bonne réponse couvre

  • Score dynamique basé sur la récence, l'affinité, la popularité
  • Utilisation de Machine Learning pour personnaliser
  • Infrastructure temps réel avec stream processing
  • Équilibre entre pertinence et diversité

  Voir un exemple de réponse

  Un algorithme de classement du fil d'actualité doit équilibrer plusieurs signaux : récence du post, affinité utilisateur-auteur (interactions passées), type de média (photo, vidéo, lien), et popularité globale (likes, commentaires, partages). On peut attribuer un score initial basé sur un modèle linéaire (poids appris) ou un modèle non linéaire comme un arbre de décision ou un réseau de neurones (comme Meta utilise). Le système doit traiter des milliers de posts candidats par utilisateur. On peut utiliser un pipeline de scoring avec une couche de filtrage initial (par récence et affinité), puis un calcul de score plus précis sur un sous-ensemble. Pour l'infrastructure, on peut utiliser un traitement par lot (Spark) pour les scores précalculés et un flux temps réel (Kafka Streams) pour les mises à jour. On doit aussi éviter les bulles de filtre en injectant de la diversité (posts de nouveaux amis, sujets variés). Un défi est la personnalisation à grande échelle ; on utilise des embeddings utilisateur et post calculés hors ligne. En entretien, on discutera des compromis entre fraîcheur et pertinence, et de la nécessité d'A/B testing.

Conseils pour se préparer

• Maîtrisez la recherche en profondeur et en largeur, car les problèmes d'arbres/graphes sont très courants.
• Entraînez-vous à la conception de systèmes en 45 minutes, en vous concentrant sur les compromis et la mise à l'échelle.
• Préparez trois à cinq histoires STAR qui mettent en valeur le leadership, l'impact et la résolution de conflits.
• Comprenez parfaitement les principes de leadership de Meta et alignez vos expériences sur eux.
• Entraînez-vous à coder sur un tableau blanc ou un éditeur de texte simple pour simuler l'environnement d'entretien sans coloration syntaxique.

Questions fréquentes