Forberedelse til SQL-intervju · leksjon

Finne hull i en sekvens

Finn manglende verdier og starten og slutten på hvert hull.

Leksjon 3 av 413 trinn

Finne hull i en sekvens er en gratis leksjon i Forberedelse til SQL-intervju på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Forberedelse til SQL-intervju, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Forberedelse til SQL-intervju inneholder totalt 4 leksjoner.

Finn hullene nå

Så langt har vi gruppert rader i sammenhengende sekvenser. Det motsatte intervjuspørsmålet er: Hvilke verdier mangler? Intervjuere formulerer det gjerne som «finn hullene i denne ID-sekvensen», «hvilke fakturanumre ble hoppet over?» eller «hvilke dager var det ingen aktivitet?»

Hull er de tomme mellomrommene mellom sammenhengende sekvenser. Den viktige innsikten er at du vanligvis ikke trenger å liste opp hver eneste manglende verdi; du skal rapportere starten og slutten på hvert hullintervall, noe som er langt mer kompakt og det intervjuere forventer.

Eksempeldatasettet for hull

Bruk de eksisterende verdiene 1, 2, 3, 7, 8, 10 på nytt fra en tabell seq(n). Hullene som skal rapporteres, er:

Fra 4 til 6 (etter den første sammenhengende sekvensen og før 7)
Fra 9 til 9 (mellom 8 og 10)

Legg merke til at vi beskriver et hull som et intervall: gap_start = sist eksisterende verdi + 1, gap_end = neste eksisterende verdi - 1. Dette kompakte formatet er målet for kjerneteknikken nedenfor.

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

LEAD-metoden for å finne hull

Den ryddigste måten å finne hull på er å sammenligne hver rad med den neste raden ved hjelp av LEAD. Hvis den neste verdien er mer enn 1 større enn den gjeldende verdien, finnes det et hull mellom dem.

For hver slik rad begynner hullet på n + 1 og slutter på next_n - 1. Se først på resultatet fra den rå LEAD-beregningen:

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

Rapportere hullintervaller

Legg LEAD-resultatet i en CTE, og behold bare rader der hoppet til neste verdi er større enn 1. Disse radene markerer hull:

Dette gir nøyaktig hullene 4–6 og 9–9. Uttrykket next_n - n - 1 gir også antallet manglende verdier i hvert hull, noe som ofte kommer som et oppfølgingsspørsmål.

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;

Den symmetriske LAG-varianten

Du kan finne de samme hullene ved å se bakover med LAG i stedet. Det finnes et hull før den gjeldende raden når den forrige verdien er mer enn 1 mindre enn den.

Dette er helt tilsvarende. Velg den varianten som leses mest naturlig i oppgaven. Noen intervjuere foretrekker LEAD fordi hullet beskrives i forhold til raden som kommer før det, slik man vanligvis uttrykker seg.

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;

Liste opp hver manglende verdi

Noen ganger vil intervjueren faktisk ha en fullstendig liste over manglende tall, ikke bare intervaller. Den robuste løsningen er å generere den fullstendige forventede sekvensen og bruke en anti-join mot det som finnes. I Postgres bygger generate_series hele intervallet:

Hvert heltall i det forventede intervallet som ikke finnes i seq, er en manglende verdi. Dette håndterer også hull helt i ytterkantene hvis du kjenner ønsket minimums- og maksimumsverdi.

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;

Generere sekvenser på tvers av SQL-dialekter

Ikke alle motorer har generate_series. Kjenn alternativene:

Postgres: generate_series(1, 100).
SQL Server: en rekursiv CTE eller en talltabell.
MySQL 8: en rekursiv CTE som teller opp til maksimumsverdien.

En rekursiv CTE er det portable alternativet. Den produserer den samme forventede sekvensen som du kan bruke i en anti-join.

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;

Hull i kalenderdatoer

For manglende datoer genererer du en fullstendig kalender med ett døgns trinn og bruker en anti-join. Dette er standardspørringen for «hvilke dager hadde ingen bestillinger?»:

Kombiner dette med intervallteknikken ved å bruke LEAD på de faktiske datoene for å rapportere manglende datoperioder i stedet for enkeltdager. Bruk + INTERVAL '1 day' for grensene.

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;

Hull utenfor datagrensene

En subtil fallgruve er at LEAD/LAG bare finner hull mellom eksisterende verdier. Hvis et tall mangler før den minste eller etter den største eksisterende verdien, kan vindusmetoden ikke se det fordi det ikke finnes noen naborad.

Hvis intervjueren definerer et forventet fullstendig intervall (for eksempel ID-ene 1 til 100) og dataene dine begynner på 5, må du bruke en generate-series-anti-join avgrenset av det deklarerte intervallet, ikke dataenes eget minimum og maksimum. Avklar alltid om de forventede grensene er faste.

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;

Finne hull per gruppe

For hull per bruker partisjonerer du LEAD/LAG etter gruppek kolonnen, slik at et hull aldri rapporteres på tvers av to forskjellige brukeres datastrømmer:

De manglende intervallene for hver bruker beregnes uavhengig av hverandre. Som med sammenhengende sekvenser vil det å glemme partisjoneringen stille slå sammen brukere og skape kunstige hull mellom uvedkommende rader.

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;

Velge riktig metode for hull

Beslutningsguide for intervjuet:

Vil du ha kompakte intervaller og bare interne hull? Bruk LEAD/LAG, og filtrer der trinnet er større enn 1.
Vil du ha hver enkelt manglende verdi eller hull utenfor dataenes ytterkanter? Bruk en generate-series-anti-join mot det deklarerte fullstendige intervallet.

Hvis du nevner begge alternativene og når de passer, viser du dybdeforståelse. LEAD-metoden er billigere, mens sekvensmetoden er mer komplett.

Kort kontroll

Avklar fallgruven ved ytterkantene.

Besvar den i den interaktive leksjonen

Oppsummering: Finne hull

Du har nå kontroll på å finne hull:

Rapporter hull som intervaller: gap_start = value + 1, gap_end = next_value - 1.
LEAD (eller den symmetriske LAG) filtrert på trinn større enn 1 finner interne hull på en effektiv måte.
En generate-series-anti-join lister opp alle manglende verdier og finner hull ved ytterkantene opp mot et deklarert intervall.
Rekursive CTE-er genererer sekvensen der generate_series ikke finnes.
Partisjoner etter gruppek kolonnen for hull per bruker.
Avklar alltid de forventede grensene.

Til slutt tar vi for oss den mest innholdsrike varianten: sammenhengende sekvenser definert av dato- og statusendringer.

Gratis å komme i gang

Lær deg SQL med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Finne hull i en sekvens» gratis?

Ja – hele teksten i «Finne hull i en sekvens» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Forberedelse til SQL-intervju-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Forberedelse til SQL-intervju inneholder totalt 4 leksjoner.

Hva lærer jeg i «Finne hull i en sekvens»?

Finn manglende verdier og starten og slutten på hvert hull. Du øver på Forberedelse til SQL-intervju med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Forberedelse til SQL-intervju?

Ingen tidligere erfaring er nødvendig. Forberedelse til SQL-intervju på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Finne hull i en sekvens»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Forberedelse til SQL-intervju-leksjonen?

Ja. Alle Forberedelse til SQL-intervju-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Forberedelse til SQL-intervju