0Pricing
SQL Interview Prep · Lección

Reconocer un problema de huecos y segmentos

Identifique el patrón en un problema planteado y la idea central de agrupación

Reconocer un problema de huecos y segmentos es una lección gratuita de SQL Interview Prep en CoddyKit. Esta es la lección 1 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 SQL Interview Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de SQL Interview Prep incluye 4 lecciones en total.

El patrón que evalúan los entrevistadores

Cuando un entrevistador sénior le pide encontrar secuencias consecutivas de algo, se encuentra ante un problema de huecos e islas. El nombre procede de una imagen mental: las filas que pertenecen juntas forman una isla y las interrupciones entre ellas son huecos.

  • Una isla es una secuencia máxima de filas adyacentes según alguna regla (enteros consecutivos, fechas consecutivas o el mismo estado repetido).
  • Un hueco es el espacio que falta entre dos islas.

Reconocer esta clase de problemas al instante es en sí una señal de experiencia sénior. Muchos candidatos recurren a una maraña de self-joins; la respuesta elegante casi siempre son las funciones de ventana.

Enunciados que esconden una isla

El reto es que los entrevistadores rara vez dicen «huecos e islas». Lo disfrazan. Acostúmbrese a expresiones como:

  • «Encuentre cada periodo en el que un usuario estuvo suscrito de forma continua».
  • «¿Durante cuántos días consecutivos permaneció activo el servidor?»
  • «¿Qué rangos de IDs faltan en esta tabla?»
  • «Agrupe las filas adyacentes con el mismo estado en una sola fila».

Todas tienen la misma estructura: agrupar las filas que están juntas y después informar del inicio, el final o la ausencia de esos grupos. Cuando relaciona las palabras con las islas, la consulta SQL sale casi sola.

La idea central: crear una clave de grupo

Aquí está todo el truco en una frase: si puede asignar a cada fila de la misma isla una clave de grupo idéntica, un simple GROUP BY reduce cada isla a una fila de resumen.

Por tanto, el trabajo real en cualquier problema de huecos e islas consiste en calcular esa clave de grupo. Las distintas variantes la calculan de manera diferente, pero todas persiguen el mismo objetivo. Una vez que tiene la clave, el último paso es trivial:

SELECT
  grp,
  MIN(value) AS island_start,
  MAX(value) AS island_end,
  COUNT(*)   AS island_length
FROM rows_with_group_key
GROUP BY grp
ORDER BY island_start;

Un conjunto de datos concreto

Fijemos la idea con datos. Imagine una tabla logins que registra los números de día en los que un usuario inició sesión:

  • Días presentes: 1, 2, 3, 7, 8, 10

A simple vista, las islas son {1,2,3}, {7,8} y {10}. Los huecos son los días 4-6 y el día 9. Su tarea en una entrevista es conseguir que la base de datos vea estas tres islas sin señalárselas manualmente. Tenga presente este pequeño conjunto de datos mientras exploramos cada técnica.

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

Por qué fallan los enfoques ingenuos

Un primer impulso habitual es comparar cada fila con la siguiente mediante un self-join y marcar las interrupciones. Esto sirve para encontrar un único hueco, pero enseguida se vuelve difícil de manejar:

  • Debe detectar tanto el inicio como el final de cada isla, lo que implica dos pasadas o dos joins.
  • Las filas de los extremos (la primera y la última) requieren un tratamiento especial.
  • No se generaliza para responder «indíqueme la longitud de cada secuencia» sin añadir más complejidad.

Los entrevistadores observan si se embarca en una guerra de self-joins o si reconoce que una sola pasada con una función de ventana es más clara.

El modelo mental para detectar huecos

Una forma sólida de plantearlo es la siguiente: una nueva isla comienza cuando la fila actual no es adyacente a la fila anterior. Utilice LAG para retroceder una fila y comparar.

Si day_no - LAG(day_no) es mayor que 1 (o NULL para la primera fila), esta fila inicia una nueva isla. Lo indicamos con un valor de 1; en caso contrario, usamos 0. Observe cómo quedan esos indicadores para nuestros datos.

SELECT
  day_no,
  CASE
    WHEN day_no - LAG(day_no) OVER (ORDER BY day_no) = 1 THEN 0
    ELSE 1
  END AS is_new_island
FROM logins
ORDER BY day_no;

Convertir indicadores en una clave de grupo

Los indicadores del paso anterior son 1, 0, 0, 1, 0, 1 para los días 1,2,3,7,8,10. Observe que una suma acumulada de esos indicadores produce un número que permanece constante dentro de una isla y aumenta en cada nueva isla: 1,1,1,2,2,3.

Esa suma acumulada es nuestra clave de grupo creada artificialmente. Envolvemos la consulta de los indicadores en un CTE y la sumamos con otra función de ventana:

WITH flagged AS (
  SELECT
    day_no,
    CASE WHEN day_no - LAG(day_no) OVER (ORDER BY day_no) = 1
         THEN 0 ELSE 1 END AS is_new_island
  FROM logins
)
SELECT
  day_no,
  SUM(is_new_island) OVER (ORDER BY day_no) AS grp
FROM flagged;

Completar el ejemplo práctico

Ahora coloque el GROUP BY final sobre la clave de grupo. Cada valor distinto de grp representa una isla, y se informan sus límites y su tamaño:

El resultado coincide exactamente con las tres islas que identificamos a simple vista: 1-3 (longitud 3), 7-8 (longitud 2) y 10-10 (longitud 1). Esta receta de tres capas (indicador, suma acumulada y agrupación) es la base de casi todas las respuestas sobre huecos e islas que escribirá.

WITH flagged AS (
  SELECT day_no,
    CASE WHEN day_no - LAG(day_no) OVER (ORDER BY day_no) = 1
         THEN 0 ELSE 1 END AS is_new
  FROM logins
),
keyed AS (
  SELECT day_no,
    SUM(is_new) OVER (ORDER BY day_no) AS grp
  FROM flagged
)
SELECT grp, MIN(day_no) AS start_day,
       MAX(day_no) AS end_day, COUNT(*) AS len
FROM keyed GROUP BY grp ORDER BY start_day;

La adyacencia depende del dominio

La única parte que cambia entre los problemas es la definición de adyacencia. Reconocer la regla de adyacencia adecuada es la mitad de reconocer el problema:

  • Enteros: son adyacentes cuando la diferencia es exactamente 1.
  • Días del calendario: son adyacentes cuando una fecha es el día siguiente (date = prev + INTERVAL '1 day').
  • Periodos de estado: son adyacentes cuando el valor del estado no cambia respecto a la fila anterior.

La estructura es la misma, pero cambia la comparación dentro del CASE. Identificar qué regla de adyacencia corresponde es la pregunta de aclaración que debe plantear en voz alta durante la entrevista.

Preguntas de aclaración que conviene hacer

Antes de escribir una sola línea de SQL, gane puntos aclarando el alcance. Algunas buenas preguntas para problemas de huecos e islas son:

  • «¿Debo tratar los datos por usuario o de forma global?» (Esto determina si añade PARTITION BY user_id.)
  • «¿Puede haber valores duplicados el mismo día y, en ese caso, interrumpen o amplían una secuencia?»
  • «¿Quiere que obtenga las islas, los huecos o ambas cosas?»
  • «¿La secuencia está garantizada como ordenada o debo ordenarla yo?»

Plantear estas preguntas demuestra que ya ha resuelto esta clase de problemas y comprende sus casos límite.

Islas por grupo con PARTITION BY

Los datos reales de una entrevista casi siempre están agrupados, por ejemplo, los inicios de sesión por usuario. La solución es mecánica: añada PARTITION BY user_id a cada función de ventana para que las islas nunca se extiendan de un usuario a otro.

La estructura es idéntica; solo debe particionar. Por eso dominar primero el caso de una sola secuencia resulta útil: adaptarlo a cada grupo requiere cambiar una sola cláusula.

SELECT
  user_id, day_no,
  CASE WHEN day_no - LAG(day_no)
         OVER (PARTITION BY user_id ORDER BY day_no) = 1
       THEN 0 ELSE 1 END AS is_new
FROM logins;

Comprobación rápida

Ponga a prueba su capacidad para reconocer patrones.

Resumen: reconocer el patrón

Ahora puede identificar un problema de huecos e islas aunque esté disfrazado y nombrar la estrategia:

  • Palabras clave: consecutivo, continuo, sin interrupciones, racha, rangos faltantes, agrupar filas adyacentes.
  • Idea central: asigne a cada fila de la misma secuencia una clave de grupo idéntica y después use GROUP BY con ella.
  • Receta: marque las nuevas islas con LAG, convierta los indicadores en una clave mediante una suma acumulada y agregue.
  • La adyacencia depende del dominio (enteros, fechas o un estado sin cambios).
  • Añada PARTITION BY para analizar cada grupo y aclare el alcance antes de programar.

A continuación, perfeccionaremos el método más elegante para crear la clave: la técnica de la diferencia de números de fila.

Preguntas frecuentes

¿La lección «Reconocer un problema de huecos y segmentos» es gratis?

Sí — el texto completo de «Reconocer un problema de huecos y segmentos» 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 SQL Interview Prep, actualiza a CoddyKit PRO. El curso de SQL Interview Prep incluye 4 lecciones en total.

¿Qué aprenderé en «Reconocer un problema de huecos y segmentos»?

Identifique el patrón en un problema planteado y la idea central de agrupación Practicas SQL 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 SQL Interview Prep?

No se requiere experiencia previa. SQL 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 1 de 4.

¿Cuánto tiempo toma la lección «Reconocer un problema de huecos y segmentos»?

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

Sí. Cada lección de SQL 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 SQL Interview Prep