0Pricing
Coding Interview Prep · Lección

Encontrar huecos en una secuencia

Detecte valores ausentes y el inicio y final de cada hueco

Encontrar huecos en una secuencia es una lección gratuita de Coding Interview Prep en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Coding Interview Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Coding Interview Prep incluye 4 lecciones en total.

Ahora busquemos los huecos

Hasta ahora hemos agrupado las filas en islas. La pregunta de entrevista opuesta es: ¿qué valores faltan? Los entrevistadores pueden plantearla como «encuentre los huecos en esta secuencia de ID», «¿qué números de factura se omitieron?» o «¿en qué días no hubo actividad?».

Los huecos son los espacios vacíos entre islas. La idea clave es que normalmente no necesita enumerar cada valor ausente; debe informar del inicio y el final de cada intervalo de hueco, que es mucho más compacto y es lo que esperan los entrevistadores.

El conjunto de datos de ejemplo con huecos

Vuelva a utilizar los valores presentes 1, 2, 3, 7, 8, 10 de una tabla seq(n). Los huecos que debe informar son:

  • Del 4 al 6 (después de la primera isla y antes del 7)
  • Del 9 al 9 (entre el 8 y el 10)

Observe que describimos un hueco como un intervalo: gap_start = último valor presente + 1, gap_end = siguiente valor presente - 1. Ese formato compacto es el objetivo de la técnica principal que se muestra a continuación.

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

El enfoque LEAD para encontrar huecos

El detector de huecos más claro compara cada fila con la siguiente mediante LEAD. Si el siguiente valor es más de 1 mayor que el valor actual, hay un hueco entre ambos.

Para cada fila de ese tipo, el hueco comienza en n + 1 y termina en next_n - 1. Observe primero el resultado sin procesar de LEAD:

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

Informar de intervalos de huecos

Incluya el resultado de LEAD en una CTE y conserve solo las filas en las que el salto al siguiente valor sea superior a 1. Esas filas señalan los huecos:

Esto devuelve exactamente el hueco 4-6 y el hueco 9-9. La expresión next_n - n - 1 también proporciona la cantidad de valores ausentes en cada hueco, una pregunta de seguimiento frecuente.

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 simétrica con LAG

También puede detectar los mismos huecos mirando hacia atrás con LAG. Existe un hueco antes de la fila actual cuando el valor anterior es más de 1 menor que el actual.

Es completamente equivalente; elija la opción que se lea de forma más natural para la pregunta. Algunos entrevistadores prefieren LEAD porque el hueco se describe en relación con la fila que lo precede, que coincide con la forma habitual de expresarlo.

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;

Enumerar todos los valores ausentes

A veces el entrevistador realmente necesita la lista completa de números ausentes, no solo los intervalos. El enfoque más sólido consiste en generar la secuencia completa esperada y hacer un anti-join con los valores existentes. En Postgres, generate_series construye el intervalo completo:

Cada entero del intervalo esperado que no esté presente en seq es un valor ausente. Esto también permite detectar huecos en los extremos si conoce el mínimo y el máximo previstos.

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;

Generación de series entre dialectos

No todos los motores tienen generate_series. Conozca las alternativas:

  • Postgres: generate_series(1, 100).
  • SQL Server: una CTE recursiva o una tabla de números/tally.
  • MySQL 8: una CTE recursiva que cuente hasta el máximo.

Una CTE recursiva es la alternativa portátil. Produce la misma secuencia esperada para hacer el 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;

Huecos en fechas del calendario

Para encontrar fechas ausentes, genere un calendario completo con un paso diario y haga un anti-join. Esta es la consulta estándar para saber «qué días no hubo pedidos»:

Combine este enfoque con la técnica de intervalos aplicando LEAD sobre las fechas reales para informar de intervalos de fechas ausentes en lugar de días individuales, usando + INTERVAL '1 day' para los límites.

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;

Huecos en los extremos fuera de los datos

Una trampa sutil: LEAD/LAG solo encuentra huecos entre valores presentes. Si falta un número antes del mínimo o después del máximo de los valores presentes, el enfoque de funciones de ventana no puede detectarlo porque no existe una fila vecina.

Si el entrevistador define un intervalo completo esperado (por ejemplo, los ID del 1 al 100) y sus datos comienzan en 5, debe usar el anti-join con generate-series limitado por el intervalo declarado, no por el mínimo y el máximo de los propios datos. Aclare siempre si los límites esperados son fijos.

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;

Detección de huecos por grupo

Para encontrar huecos por usuario, particione LEAD/LAG por la columna del grupo, de modo que nunca se informe de un hueco entre las secuencias de dos usuarios distintos:

Los intervalos ausentes de cada usuario se calculan de forma independiente. Al igual que con las islas, olvidar la partición combina usuarios silenciosamente y produce huecos ficticios que abarcan filas sin relación.

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;

Elegir el método adecuado para los huecos

Guía para decidir en la entrevista:

  • Si quiere intervalos compactos y solo huecos internos, use LEAD/LAG y filtre cuando el paso sea superior a 1.
  • Si quiere cada valor ausente o huecos más allá de los extremos de los datos, use el anti-join con generate-series contra el intervalo completo declarado.

Mencionar ambas opciones y cuándo se aplica cada una demuestra profundidad. El método con LEAD es más económico; el método con series es más completo.

Comprobación rápida

Identifique con precisión la trampa de los casos límite.

Repaso: encontrar huecos

Detección de huecos, dominada:

  • Informe de los huecos como intervalos: gap_start = valor + 1, gap_end = siguiente_valor - 1.
  • LEAD (o su versión simétrica LAG), filtrado cuando el paso sea superior a 1, encuentra de forma económica los huecos internos.
  • El anti-join con generate-series enumera cada valor ausente y detecta los huecos en los extremos respecto a un intervalo declarado.
  • Las CTE recursivas generan la serie cuando no está disponible generate_series.
  • Particione por la columna del grupo para encontrar huecos por usuario.
  • Aclare siempre los límites esperados.

Por último, abordaremos la variante más completa: islas definidas por cambios de fecha y estado.

Preguntas frecuentes

¿La lección «Encontrar huecos en una secuencia» es gratis?

Sí — el texto completo de «Encontrar huecos en una secuencia» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Coding Interview Prep, actualiza a CoddyKit PRO. El curso de Coding Interview Prep incluye 4 lecciones en total.

¿Qué aprenderé en «Encontrar huecos en una secuencia»?

Detecte valores ausentes y el inicio y final de cada hueco Practicas Coding Interview Prep con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Coding Interview Prep?

No se requiere experiencia previa. Coding Interview Prep en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Encontrar huecos en una secuencia»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Coding Interview Prep?

Sí. Cada lección de Coding Interview Prep incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Reconocer un problema de huecos y segmentos
  2. El truco de la diferencia de números de fila
  3. Encontrar huecos en una secuencia
  4. Segmentos con cambios de fecha y estado
← Volver a Coding Interview Prep