0Pricing
Coding Interview Prep · Leçon

N lignes consécutives remplissant une condition

Le classique motif de fenêtre « trois jours consécutifs avec des ventes supérieures à X »

N lignes consécutives remplissant une condition est une leçon Coding 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 Coding Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Coding Interview Prep comprend 4 leçons au total.

Un classique de LeetCode

C'est l'un des problèmes SQL les plus fréquemment posés en entretien : « Trouvez toutes les dates comprenant au moins trois jours consécutifs où les ventes dépassent un seuil », ou le classique de LeetCode : « signalez le stade comprenant au moins 3 lignes consécutives dont la fréquentation dépasse 100 ».

La structure est toujours la même : une ligne n'est admissible que si elle se trouve dans une série de N lignes consécutives qui satisfont à la condition. Cette leçon présente deux solutions claires et le piège dans lequel tombent la plupart des candidats.

Les données d'exemple

Nous utilisons une table quotidienne sales. La condition est amount > 100. Nous devons renvoyer chaque jour qui appartient à une série d'au moins 3 jours calendaires consécutifs satisfaisant tous à la condition.

  • sale_date — une ligne par jour
  • amount — le total des ventes de ce jour

Subtilité essentielle : les lignes doivent être consécutives dans la séquence et, dans les versions fondées sur des dates, également dans le calendrier.

SELECT * FROM sales ORDER BY sale_date;
-- sale_date  | amount
-- 2024-03-01 |  120
-- 2024-03-02 |  150
-- 2024-03-03 |  130
-- 2024-03-04 |   90
-- 2024-03-05 |  200

Approche 1 : filtrer puis former les îlots

L'approche robuste consiste d'abord à ne conserver que les lignes qui satisfont à la condition, puis à regrouper les lignes restantes en îlots consécutifs, et enfin à conserver les îlots dont la longueur est au moins égale à N.

La première étape est le filtrage WHERE. La deuxième réutilise l'ancre des écarts et des îlots. Comme nous avons filtré en premier, un îlot signifie ici « une série de jours consécutifs satisfaisant à la condition ».

WITH qualifying AS (
  SELECT sale_date
  FROM sales
  WHERE amount > 100
)
SELECT * FROM qualifying ORDER BY sale_date;

Ancrer les séries admissibles

Numérotez les lignes admissibles par date et effectuez une soustraction pour obtenir l'ancre de l'îlot. Les lignes qui sont consécutives dans le calendrier AND qui satisfont toutes à la condition partagent une même ancre ; tout jour qui ne satisfait pas à la condition a été supprimé, ce qui interrompt la série exactement au bon endroit.

WITH qualifying AS (
  SELECT sale_date
  FROM sales
  WHERE amount > 100
),
numbered AS (
  SELECT sale_date,
    ROW_NUMBER() OVER (ORDER BY sale_date) AS rn
  FROM qualifying
)
SELECT sale_date, sale_date - rn AS grp
FROM numbered;

Conserver les îlots assez longs

Regroupez par ancre, comptez les lignes et ne conservez que les groupes vérifiant COUNT(*) >= 3. Si le recruteur souhaite récupérer les dates admissibles individuelles, joignez les ancres conservées aux lignes numérotées.

WITH qualifying AS (
  SELECT sale_date FROM sales WHERE amount > 100
),
numbered AS (
  SELECT sale_date,
    ROW_NUMBER() OVER (ORDER BY sale_date) AS rn
  FROM qualifying
),
islands AS (
  SELECT sale_date - rn AS grp, COUNT(*) AS len
  FROM numbered
  GROUP BY sale_date - rn
  HAVING COUNT(*) >= 3
)
SELECT n.sale_date
FROM numbered n
JOIN islands i ON n.sale_date - n.rn = i.grp
ORDER BY n.sale_date;

Approche 2 : fenêtre COUNT glissante

Une approche plus élégante lorsque N est petit et fixe consiste à utiliser un cadre de fenêtre pour compter combien de lignes voisines satisfont également à la condition. Si une fenêtre de N lignes consécutives contenant cette ligne est entièrement admissible, la ligne appartient au résultat.

Ajoutez d'abord un indicateur booléen, puis additionnez cet indicateur sur des cadres glissants.

SELECT sale_date, amount,
  CASE WHEN amount > 100 THEN 1 ELSE 0 END AS ok
FROM sales;

Additionner sur trois cadres

Pour une série de 3, une ligne admissible appartient au résultat si la fenêtre de 3 lignes qui se termine ici, est centrée ici ou commence ici totalise 3. Calculez les trois sommes glissantes et vérifiez si l'une d'elles vaut 3.

C'est la technique utilisée dans la solution de LeetCode 601 (Trafic humain du stade).

WITH flagged AS (
  SELECT sale_date, amount,
    CASE WHEN amount > 100 THEN 1 ELSE 0 END AS ok
  FROM sales
),
w AS (
  SELECT *,
    SUM(ok) OVER (ORDER BY sale_date
      ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS s_end,
    SUM(ok) OVER (ORDER BY sale_date
      ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS s_mid,
    SUM(ok) OVER (ORDER BY sale_date
      ROWS BETWEEN CURRENT ROW AND 2 FOLLOWING) AS s_start
  FROM flagged
)
SELECT sale_date, amount
FROM w
WHERE ok = 1 AND (s_end = 3 OR s_mid = 3 OR s_start = 3);

Le piège des écarts du calendrier

L'approche par somme de fenêtre utilise ROWS, qui compte les lignes de résultat adjacentes et non les jours adjacents du calendrier. Si un jour ne satisfaisant pas à la condition a déjà été filtré, deux lignes peuvent être adjacentes dans le résultat sans être consécutives dans le calendrier.

À retenir : appliquez la fenêtre glissante à la série quotidienne complète (ne filtrez pas au préalable), ou utilisez la méthode de l'ancre de date, qui respecte intrinsèquement les écarts du calendrier. Mentionnez ce compromis pendant l'entretien.

Généraliser à N quelconque

L'approche 1 (filtrer puis former les îlots) se généralise immédiatement : il suffit de modifier HAVING COUNT(*) >= N. C'est son principal avantage par rapport à la somme de fenêtres multiples, qui nécessite davantage de cadres à mesure que N augmente.

Pour un N paramétré ou élevé, préférez la méthode des îlots — il suffit de modifier un seuil plutôt que d'écrire manuellement N−1 fenêtres.

-- only the threshold changes for N = 5
HAVING COUNT(*) >= 5

Choisir une approche

Voici un guide de décision rapide à énoncer à voix haute :

  • Filtrer puis former les îlots : respecte les écarts du calendrier, se généralise à tout N et renvoie les séries complètes — c'est le choix sûr par défaut.
  • Somme sur fenêtre glissante : élégante pour un N petit et fixe sur une série quotidienne dense, mais surveillez le piège entre ROWS et le calendrier.

Nommer les deux approches, puis justifier votre choix, est exactement ce que les recruteurs de niveau intermédiaire à confirmé apprécient.

Solution complète

La solution portable, valable pour tout N, qui respecte le caractère consécutif des dates et renvoie les dates admissibles :

WITH qualifying AS (
  SELECT sale_date FROM sales WHERE amount > 100
),
numbered AS (
  SELECT sale_date,
    ROW_NUMBER() OVER (ORDER BY sale_date) AS rn
  FROM qualifying
),
islands AS (
  SELECT sale_date - rn AS grp, COUNT(*) AS len
  FROM numbered
  GROUP BY sale_date - rn
  HAVING COUNT(*) >= 3
)
SELECT n.sale_date
FROM numbered n
JOIN islands i ON n.sale_date - n.rn = i.grp
ORDER BY n.sale_date;

Vérification rapide

Repérez le bug subtil.

Récapitulatif

Pour N lignes consécutives satisfaisant à une condition :

  • Filtrer puis former les îlots : conservez les lignes admissibles, ancrez-les avec date - ROW_NUMBER(), regroupez-les et utilisez HAVING COUNT(*) >= N. Cette méthode se généralise et respecte les écarts du calendrier.
  • Somme sur fenêtre glissante : marquez les lignes et additionnez-les sur des cadres fixes de N lignes ; cette méthode est élégante, mais méfiez-vous du piège entre ROWS et le calendrier avec des données préfiltrées.

Ensuite : calculer la série active actuelle d'un utilisateur à la date d'aujourd'hui.

Questions Fréquemment Posées

La leçon « N lignes consécutives remplissant une condition » est-elle gratuite ?

Oui — le texte complet de « N lignes consécutives remplissant une condition » 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 Coding Interview Prep, passe à CoddyKit PRO. Le cours Coding Interview Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « N lignes consécutives remplissant une condition » ?

Le classique motif de fenêtre « trois jours consécutifs avec des ventes supérieures à X » Tu pratiques Coding 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 Coding Interview Prep ?

Aucune expérience préalable n'est requise. Coding 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 « N lignes consécutives remplissant une condition » ?

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 Coding Interview Prep ?

Oui. Chaque leçon Coding 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. Détecter les jours consécutifs du calendrier
  2. Plus longue série par utilisateur
  3. N lignes consécutives remplissant une condition
  4. Série active en cours aujourd’hui
← Retour à Coding Interview Prep