0Pricing
SQL Interview Prep · Leçon

Trouver les lacunes d’une séquence

Détecter les valeurs manquantes ainsi que le début et la fin de chaque lacune

Trouver les lacunes d’une séquence est une leçon SQL Interview Prep gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage SQL Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Interview Prep comprend 4 leçons au total.

À la recherche des lacunes

Jusqu'à présent, nous avons regroupé les lignes en îlots. La question d'entretien qui lui fait pendant est la suivante : quelles valeurs sont manquantes ? Elle peut être formulée ainsi : « trouvez les lacunes dans cette séquence d'ID », « quels numéros de facture ont été oubliés » ou « quels jours n'ont connu aucune activité ».

Les lacunes sont les espaces vides entre les îlots. L'idée essentielle est que vous n'avez généralement pas besoin d'énumérer chaque valeur manquante ; vous devez signaler le début et la fin de chaque plage de valeurs manquantes, ce qui est beaucoup plus compact et correspond à ce que les personnes qui vous interrogent attendent.

Le jeu de données exemple des lacunes

Réutilisons les valeurs présentes 1, 2, 3, 7, 8, 10 dans une table seq(n). Les lacunes à signaler sont les suivantes :

  • De 4 à 6 (après le premier îlot, avant 7)
  • De 9 à 9 (entre 8 et 10)

Remarquez que nous décrivons une lacune comme une plage : début de la lacune = dernière valeur présente + 1, fin de la lacune = prochaine valeur présente - 1. Cette forme compacte est l'objectif de la technique fondamentale présentée ci-dessous.

CREATE TABLE seq (n INT);
INSERT INTO seq VALUES (1),(2),(3),(7),(8),(10);

L'approche LEAD pour trouver les lacunes

Le détecteur de lacunes le plus simple compare chaque ligne à la ligne suivante à l'aide de LEAD. Si la valeur suivante est supérieure de plus de 1 à la valeur courante, une lacune se trouve entre les deux.

Pour chacune de ces lignes, la lacune commence à n + 1 et se termine à next_n - 1. Observez d'abord la sortie brute de LEAD :

SELECT
  n,
  LEAD(n) OVER (ORDER BY n) AS next_n
FROM seq
ORDER BY n;

Signaler les plages de lacunes

Placez le résultat de LEAD dans un CTE et ne conservez que les lignes pour lesquelles le saut vers la valeur suivante dépasse 1. Ces lignes indiquent les lacunes :

Le résultat renvoie exactement la lacune 4-6 et la lacune 9-9. L'expression next_n - n - 1 donne également le nombre de valeurs manquantes dans chaque lacune, une question complémentaire fréquente.

WITH stepped AS (
  SELECT n, LEAD(n) OVER (ORDER BY n) AS next_n
  FROM seq
)
SELECT
  n + 1            AS gap_start,
  next_n - 1       AS gap_end,
  next_n - n - 1   AS missing_count
FROM stepped
WHERE next_n - n > 1
ORDER BY gap_start;

La variante symétrique avec LAG

Vous pouvez détecter les mêmes lacunes en regardant vers l'arrière avec LAG. Une lacune existe avant la ligne courante lorsque la valeur précédente lui est inférieure de plus de 1.

Les deux méthodes sont parfaitement équivalentes ; choisissez celle qui se lit le plus naturellement pour la question posée. Certaines personnes qui vous interrogent préfèrent LEAD, car la lacune est décrite par rapport à la ligne qui la précède, ce qui correspond davantage à la façon dont on s'exprime.

WITH stepped AS (
  SELECT n, LAG(n) OVER (ORDER BY n) AS prev_n
  FROM seq
)
SELECT prev_n + 1 AS gap_start,
       n - 1       AS gap_end
FROM stepped
WHERE n - prev_n > 1
ORDER BY gap_start;

Énumérer toutes les valeurs manquantes

Parfois, la personne qui vous interroge souhaite réellement obtenir la liste complète des nombres manquants, et pas seulement les plages. L'approche robuste consiste à générer la séquence complète attendue, puis à effectuer une jointure anti- avec les valeurs existantes. Dans Postgres, generate_series construit la plage complète :

Chaque entier de l'intervalle attendu qui n'est pas présent dans seq est une valeur manquante. Cette méthode gère également les lacunes situées aux deux extrémités si vous connaissez le minimum et le maximum prévus.

SELECT g.n AS missing_value
FROM generate_series(
       (SELECT MIN(n) FROM seq),
       (SELECT MAX(n) FROM seq)
     ) AS g(n)
LEFT JOIN seq s ON s.n = g.n
WHERE s.n IS NULL
ORDER BY g.n;

Générer des séries selon le dialecte

Tous les moteurs ne disposent pas de generate_series. Vous devez connaître les solutions de remplacement :

  • Postgres : generate_series(1, 100).
  • SQL Server : un CTE récursif ou une table de nombres/de comptage.
  • MySQL 8 : un CTE récursif qui compte jusqu'au maximum.

Un CTE récursif constitue la solution de repli portable. Il produit la même séquence attendue, avec laquelle effectuer une jointure anti-.

WITH RECURSIVE nums AS (
  SELECT (SELECT MIN(n) FROM seq) AS n
  UNION ALL
  SELECT n + 1 FROM nums
  WHERE n + 1 <= (SELECT MAX(n) FROM seq)
)
SELECT nums.n AS missing_value
FROM nums
LEFT JOIN seq s ON s.n = nums.n
WHERE s.n IS NULL;

Lacunes dans les dates calendaires

Pour les dates manquantes, générez un calendrier complet avec un pas quotidien, puis effectuez une jointure anti-. C'est la requête standard pour répondre à la question « quels jours n'ont enregistré aucune commande ? » :

Combinez cette méthode avec la technique des plages en appliquant LEAD aux dates réelles afin de signaler des plages de dates manquantes plutôt que des jours individuels, en utilisant + INTERVAL '1 day' pour les limites.

SELECT d::date AS missing_day
FROM generate_series(
       DATE '2026-01-01', DATE '2026-01-31',
       INTERVAL '1 day') AS d
LEFT JOIN daily_logins l ON l.login_date = d::date
WHERE l.login_date IS NULL
ORDER BY missing_day;

Lacunes aux extrémités au-delà des données

Voici un piège subtil : LEAD/LAG ne trouvent que les lacunes entre les valeurs présentes. Si un nombre manque avant le minimum ou après le maximum des valeurs présentes, l'approche par fonctions de fenêtrage ne peut pas le détecter, car aucune ligne voisine n'existe.

Si la personne qui vous interroge définit une plage complète attendue (par exemple les identifiants de 1 à 100) et que vos données commencent à 5, vous devez utiliser une jointure anti- sur une série générée, limitée par la plage déclarée, et non par le minimum et le maximum propres aux données. Demandez toujours si les limites attendues sont fixes.

SELECT g.n AS missing_value
FROM generate_series(1, 100) AS g(n)
LEFT JOIN seq s ON s.n = g.n
WHERE s.n IS NULL;

Détecter les lacunes par groupe

Pour rechercher les lacunes par utilisateur, partitionnez LEAD/LAG selon la colonne de groupe afin qu'une lacune ne soit jamais signalée entre les séquences de deux utilisateurs différents :

Les plages manquantes de chaque utilisateur sont calculées indépendamment. Comme pour les îlots, oublier le partitionnement fusionne silencieusement les utilisateurs et produit des lacunes fantômes couvrant des lignes sans lien.

WITH stepped AS (
  SELECT user_id, n,
    LEAD(n) OVER (PARTITION BY user_id ORDER BY n) AS next_n
  FROM seq_per_user
)
SELECT user_id, n + 1 AS gap_start, next_n - 1 AS gap_end
FROM stepped
WHERE next_n - n > 1
ORDER BY user_id, gap_start;

Choisir la bonne méthode pour les lacunes

Guide de décision pour l'entretien :

  • Vous voulez des plages compactes et uniquement les lacunes internes ? Utilisez LEAD/LAG et filtrez lorsque le pas dépasse 1.
  • Vous voulez chaque valeur manquante ou les lacunes au-delà des extrémités des données ? Utilisez une jointure anti-série avec generate_series sur la plage complète déclarée.

Mentionner les deux possibilités et préciser dans quel cas chacune s'applique témoigne d'une compréhension approfondie. La méthode LEAD est moins coûteuse ; la méthode par série est plus complète.

Vérification rapide

Cernez bien le piège lié aux cas limites.

Récapitulatif : trouver les lacunes

La détection des lacunes est désormais maîtrisée :

  • Signalez les lacunes sous forme de plages : début de la lacune = valeur + 1, fin de la lacune = valeur suivante - 1.
  • LEAD (ou LAG de manière symétrique), filtré lorsque le pas dépasse 1, trouve efficacement les lacunes internes.
  • La jointure anti-série avec generate_series énumère chaque valeur manquante et détecte les lacunes aux extrémités par rapport à une plage déclarée.
  • Les CTE récursifs génèrent la série lorsque generate_series n'est pas disponible.
  • Partitionnez selon la colonne de groupe pour rechercher les lacunes par utilisateur.
  • Clarifiez toujours les limites attendues.

Nous abordons enfin la variante la plus riche : les îlots définis par la date et les changements d'état.

Questions Fréquemment Posées

La leçon « Trouver les lacunes d’une séquence » est-elle gratuite ?

Oui — le texte complet de « Trouver les lacunes d’une séquence » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours SQL Interview Prep, passe à CoddyKit PRO. Le cours SQL Interview Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Trouver les lacunes d’une séquence » ?

Détecter les valeurs manquantes ainsi que le début et la fin de chaque lacune Tu pratiques SQL Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer SQL Interview Prep ?

Aucune expérience préalable n'est requise. SQL Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Trouver les lacunes d’une séquence » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon SQL Interview Prep ?

Oui. Chaque leçon SQL Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Reconnaître un problème de lacunes et d’îlots
  2. Astuce de la différence entre numéros de ligne
  3. Trouver les lacunes d’une séquence
  4. Îlots avec changements de date et de statut
← Retour à SQL Interview Prep