No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Práctico de SQL

Curso Práctico de SQL

Israel Vázquez Morales

Israel Vázquez Morales

Selectores de rango

16/29
Recursos

Aportes 79

Preguntas 10

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Los tipos de rango que vienen en PostgreSQL son:

  • int4range: Que trae un rango de enteros.

  • int8range: Es un rango de enteros grandes.

  • numrange: Es un rango numérico.

  • tsrange: Es un rango del tipo timestamp pero sin la zona horaria.

  • tstzrange: Es un rango del tipo timestamp con la zona horaria

  • daterange: Es un rango del tipo fecha.

    Esos son los que podemos usar como selectores de rango dentro de PostgreSQL si les interesa conocer más Acá

Solucion del reto

SELECT INT4RANGE(MIN(tutor_id), MAX(tutor_id)) * INT4RANGE(MIN(carrera_id), MAX(carrera_id))
    FROM platzi.alumnos;

Como cuando crees que dominas Postgres y aparece esto. 😮

En SQL Server

-- CREAR UN RANGO DE VALORES [9; 11]
SELECT TOP 11
	9 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
FROM syscolumns A, syscolumns B


-- UNION DE 2 RANGOS
(
	SELECT TOP 9 -- [11; 19]
		10 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
	FROM syscolumns A, syscolumns B
)
UNION
(
	SELECT TOP 11 -- [15; 25]
	14 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
    FROM syscolumns A, syscolumns B
)

-- INTERSECCION DE 2 RANGOS
(
	SELECT TOP 9 -- [11; 19]
		10 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
	FROM syscolumns A, syscolumns B
)
INTERSECT
(
	SELECT TOP 11 -- [15; 25]
	14 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
    FROM syscolumns A, syscolumns B
)


-- METODO 3
-- RANGO CON UNA SUBCONSULTA
USE [platzi]
SELECT *
FROM platzi.alumnos
WHERE tutor_id IN
(
	SELECT TOP 11
	9 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
	FROM syscolumns A, syscolumns B
)
GO 


/*
INTERSECCION ENTRE CARRERA_ID Y TUTOR_ID
*/

SELECT carrera_id AS interseccion
FROM 
(
	(
		SELECT DISTINCT carrera_id
		FROM platzi.alumnos
	)
	INTERSECT
	(
		SELECT DISTINCT tutor_id
		FROM platzi.alumnos
	)
) AS interseccion_ids


Mi respuesta :

‘=>’ Significa ‘devuelve’ en este apunte

‘&&’ si se solapan estos dos rangos

(11.1,22.2) && (20.0,30.0) => TRUE
(11.1,19.9) && (20.0,30.0) => FALSE

* Para seleccionar los elementos de la interseccion entre los dos rangos. SI no hay, marca error

SELECT int4ramge(10,20) * int4range(15,25) =>[15,20)

@> si el rango se encuentra en el grupo

SELECT *
FROM platzi.alumnos
WHERE int4range(10,20) @> tutor_id

Mi solución

SELECT 
	numrange(min_carrera, max_carrera) * numrange(min_tutor, max_tutor)
FROM (
	SELECT 
		MIN(carrera_id) as min_carrera,
		MAX(carrera_id) as max_carrera,
		MIN(tutor_id) as min_tutor,
		MAX(tutor_id) as max_tutor
	FROM alumnos
) AS rangos

SACAR EL RANGO QUE HAY ENTRE TUTOR_ID Y CARRERA_ID

SELECT int4range(min(tutor_id), max(tutor_id)) * int4range(min(carrera_id), max(carrera_id))
FROM platzi.alumnos;

SACAR LOS DATOS QUE PERTENECEN AL RANGO ENTRE TUTOR_ID Y CARRERA_ID

SELECT *
FROM platzi.alumnos
WHERE(
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id),MAX(carrera_id))
FROM platzi.alumnos
) @> tutor_id
AND
(
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id),MAX(carrera_id))
FROM platzi.alumnos
) @> carrera_id;

Selectores de rango
Son especialmente útiles para utilizar en el WHERE statement.

SELECT int4range(1,20) @> 3;

Esta consulta trae un entero pequeño y pregunta si el rango contiene al numero 3

SELECT numrange(11,20) && numrange(20.0, 30.0);

Esta consulta trae un resultado booleano, ya que los && consultan entre los dos rangos de números de alta precisión si existen valores solapados entre ambos

SELECT LOWER int8range(15,25);

Simplemente trae el menor número del rango. Funciona igual con UPPER

SELECT int4range(10,20) * int4range(15,25);

Esta consulta trae el rango numérico que comparten ambos rangos

SELECT ISEMPTY(numrange(1,5));

Booleano que detecta si el rango esta vacío

SELECT *
FROM platzi.alumnos
WHERE int4range(10,20) @> tutor_id 
	AND int4range(10,20) @> carrera_id```

Reto:

<code> 
SELECT *
FROM platzi.alumnos
WHERE tutor_id = carrera_id;

RESPUESTA DEL RETO en MySQL

SELECT a.tutor_id,b.carrera_id
FROM alumnos as a
inner JOIN alumnos as b
ON a.tutor_id = b.carrera_id
group by a.tutor_id
order by a.tutor_id

Use este query y se me borro toda la base de datos, como hago para restaurarla al punto anterior al query.


DELETE FROM platzi.alumnos 
WHERE id IN 
	(SELECT id FROM(
		SELECT id FROM (
			SELECT ROW_NUMBER() OVER( PARTITION BY
				nombre, apellido,
				email, colegiatura,
				fecha_incorporacion, carrera_id,
				tutor_id ORDER BY id ASC) AS row
		FROM platzi.alumnos) AS duplicados 
		WHERE duplicados.row >1) AS duplicados_id);```
SELECT int4range((SELECT min(carrera_id) FROM platzi.alumnos),
				 (SELECT max(carrera_id) FROM platzi.alumnos)) *
	int4range((SELECT min(tutor_id) FROM platzi.alumnos),
			  (SELECT max(tutor_id) FROM platzi.alumnos));
--Modo 1:
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id), MAX(carrera_id)) AS interseccion
FROM platzi.alumnos;

--Modo 2:
SELECT 
	numrange(min_carrera, max_carrera) * numrange(min_tutor, max_tutor) AS interseccion
FROM (
	SELECT 
		MIN(carrera_id) as min_carrera,
		MAX(carrera_id) as max_carrera,
		MIN(tutor_id) as min_tutor,
		MAX(tutor_id) as max_tutor
	FROM platzi.alumnos
) AS rangos;

Posible Respuesta:

SELECT  int4range( (SELECT MIN(carrera_id) FROM platzi.alumnos), 
(SELECT MAX(carrera_id) FROM platzi.alumnos)) * int4range(
				(SELECT MIN(tutor_id) FROM platzi.alumnos), 
(SELECT MAX(tutor_id) FROM platzi.alumnos));

Listo!

SELECT 

int4range(
(SELECT MIN (Carrera_id)), (SELECT MAX (Carrera_id))) 
* 
int4range(
(SELECT MIN (tutor_id)), (SELECT MAX (tutor_id)))

FROM platzi.alumnos;

Primero busque los MAX y MIN de los campos carrera_id y tutor_id con

SELECT MAX/MIN ()
FROM platzi.alumnos

Luego con el comando de calculo de intersección saco el conjunto en comun entre ambos reemplazando la querys donde van el max y min de tutor_id y carrera_id

SELECT int4range(,) * int4range(,);

Finalmente con esto armado, filtro por el conjunto obtenido
reemplazando en valor la query anterior que ya me va a arrojar un conjunto

SELECT *
FROM platzi.alumnos
WHERE int4range(,) @> tutor_id;

Resultado final:

SELECT *
FROM platzi.alumnos
WHERE int4range((SELECT int4range(
					(SELECT MIN (carrera_id)
					FROM platzi.alumnos), (
					SELECT MAX (carrera_id)
					FROM platzi.alumnos)) 
				* int4range(
					(SELECT MIN (tutor_id)
					FROM platzi.alumnos),
					(SELECT MAX (tutor_id)
					FROM platzi.alumnos)))
) @> tutor_id;

Hola, esta fue mi solucion parcial al reto:

SELECT *
FROM platzi.alumnos
WHERE alumnos.tutor_id<@(
	SELECT (int4range(MIN(tutor_id),MAX(tutor_id)) * int4range(MIN(carrera_id),MAX(carrera_id))) AS valores_comunes
	FROM platzi.alumnos
SELECT int4range(MIN(carrera_id),MAX(carrera_id), '[]') * int4range(MIN(tutor_id),MAX(tutor_id), '[]') AS intersección_ids
FROM platzi.alumnos;
--Aporte desde MySQL
SELECT a.tutor_id,b.carrera_id
FROM alumnos as a
inner JOIN alumnos as b
ON a.tutor_id = b.carrera_id
group by a.tutor_id
order by a.tutor_id;

Mi Reto:

select * 
from platzi.alumnos
where tutor_id = carrera_id;

Mi solución al reto. No creo que sea muy práctico pero jala.

SELECT *
FROM platzi.alumnos
WHERE (
	SELECT UPPER(int8range(0, tutor_id))
) = carrera_id;
SELECT 
	numrange(min_c, max_c) * numrange(min_t, max_t)
FROM (
	SELECT 
		MIN(carrera_id) as min_c,
		MAX(carrera_id) as max_c,
		MIN(tutor_id) as min_t,
		MAX(tutor_id) as max_t
	FROM alumnos
) AS rangos

Bueno así deje el query de eliminación

WITH duplicados AS (
	SELECT
		id,
		ROW_NUMBER() OVER(
			PARTITION BY
				nombre,
				apellido,
				email,
				colegiatura,
				fecha_incorporacion,
				carrera_id,
				tutor_id
			ORDER BY id ASC
		) AS row
	FROM platzi.alumnos
), duplicados_a_borrar AS (
	SELECT
		id
	FROM duplicados
	WHERE duplicados.row > 1
)

DELETE FROM platzi.alumnos
WHERE id IN ( SELECT * FROM duplicados_a_borrar	)

Aquí está mi respuesta;
En la primera consulta veo si hay intersecciones y en la segunda veo cuales son:

select int4range(min(tutor_id),max(tutor_id)) && int4range(min(carrera_id),max(carrera_id))
from platzi.alumnos

select int4range(min(tutor_id),max(tutor_id))*int4range(min(carrera_id),max(carrera_id))
from platzi.alumnos

El reto:

SELECT int4range(MIN(carrera_id),MAX(carrera_id)) * int4range(MIN(tutor_id),MAX(tutor_id))
FROM platzi.alumnos;

Desafío:

-- Reto: Interseccion o valores en comun entre dos rangos: los id de tutores y los id de carreras

-- Comparten numeros ambos rangos? 

SELECT numrange(MIN(platzi.alumnos.carrera_id), MAX(platzi.alumnos.carrera_id)) 
&& numrange(MIN(platzi.alumnos.tutor_id), MAX(platzi.alumnos.tutor_id)) AS comparten_rango
from platzi.alumnos;

-- ¿Que numeros comparten?

SELECT numrange(MIN(platzi.alumnos.carrera_id), MAX(platzi.alumnos.carrera_id)) 
* numrange(MIN(platzi.alumnos.tutor_id), MAX(platzi.alumnos.tutor_id)) AS numeros_compartidos
from platzi.alumnos;

WITH STUDENT_DATA AS
(SELECT id
FROM (
SELECT id, ROW_NUMBER() OVER(PARTITION BY nombre,
apellido,
email,
colegiatura,
fecha_incorporacion,
carrera_id,
tutor_id
ORDER BY id ASC
)AS rep_data_student
FROM platzi.alumnos
)AS dups
WHERE dups.rep_data_student > 1
)
DELETE
FROM platzi.alumnos
WHERE id IN (SELECT id
FROM STUDENT_DATA);

solución al reto del video anterior

delete from platzi.alumnos
where id in (
	select row_num
	from (
		select id, row_number() over(
			partition by nombre, apellido, email, colegiatura, carrera_id, tutor_id
			order by id asc
		) as row_num
		from platzi.alumnos
		order by id desc
	) as alumnos_with_row_num
	where row_num > 1
)

SELECT int4range(min(carrera_id),max(carrera_id)) * int4range(min(tutor_id),max(tutor_id))
FROM platzi.alumnos;

Tarea

Uso de rangos para filtrado de datos de una tabla

Evaluación de rangos vacios ISEMPTY(rango)

Interseccion de rangos [rango * rango]

UPPER y LOWER, seleccion de valores maximos y minimos dentro de un rango.

Creacion de un rango y evaluación de solapamiento (rango && rango)

Creacion de un rango con int4range y consulta de un valor dentro de ese rango

Selección de un conjunto de datos empleando IN, condicion booleana y BETWEEN

Solución de tarea leccion 15 Eliminar Duplicados

/*EJERCICIO VIDEO SELECTORES DE RANGO*/
select int4range(min(carrera_id),max(carrera_id)) * 
	   int4range(min(tutor_id),max(tutor_id))
from platzi.alumnos;

Mi aporte, no es mucho pero es trabajo honesto :

SELECT *
FROM platzi.alumnos 
WHERE (
	SELECT * 
	FROM (
		SELECT INT4RANGE((SELECT MIN(tutor_id) 
		FROM platzi.alumnos), (SELECT MAX(tutor_id) 
		FROM platzi.alumnos)) * INT4RANGE((SELECT MIN(carrera_id) 
		FROM platzi.alumnos), (SELECT MAX(carrera_id) 
		FROM platzi.alumnos)) AS RANGO
		) AS INTERSIONES  
) @> tutor_id AND (
	SELECT * 
	FROM (
		SELECT INT4RANGE((SELECT MIN(tutor_id) 
		FROM platzi.alumnos), (SELECT MAX(tutor_id) 
		FROM platzi.alumnos)) * INT4RANGE((SELECT MIN(carrera_id) 
		FROM platzi.alumnos), (SELECT MAX(carrera_id) 
		FROM platzi.alumnos)) AS RANGO
		) AS INTERSIONES  
) @> carrera_id
ORDER BY carrera_id;
	

)

RETO
¡Listo!

-- Conocer las tuplas que se encuentran --
-- en la intersección de los rangos --
-- de tutor_id y carrera_id --
SELECT *
FROM platzi.alumnos
WHERE (
	SELECT
	int4range(MIN(tutor_id), MAX(tutor_id)) * 
	int4range(MIN(carrera_id), MAX(carrera_id)) AS tcrange
	FROM platzi.alumnos
) @> tutor_id

AND (
	SELECT
	int4range(MIN(tutor_id), MAX(tutor_id)) * 
	int4range(MIN(carrera_id), MAX(carrera_id)) AS tcrange
	FROM platzi.alumnos
) @> carrera_id;

-- Saber la intersección de los rangos --
-- de tutor_id y carrera_id --
SELECT
int4range(MIN(tutor_id), MAX(tutor_id)) * 
int4range(MIN(carrera_id), MAX(carrera_id)) AS tcrange
FROM platzi.alumnos;
select tutor_id  from platzi.alumnos as datos1

where tutor_id in (select tutor_id  from platzi.alumnos as datos2
			where int4range(1,(select count(tutor_id):: int  from platzi.alumnos)) @>datos2.carrera_id)
group  by  1

order by 1 

compañeros , si quieren para descansar la vista del fondo blanco en la opcion de file - preferences - miscellaneous - themes , ustedes pueden seleccionar la opcion mas adecuada

en mi caso use el tema dark ya que con el se pueden ver los parentesis mejor

Seleccionar la intersección entre los valores de la columna carrera y la columna tutor.
Así lo entendí yo

SELECT * FROM platzi.alumnos
WHERE carrera_id IN (
	carrera_id * tutor_id) or tutor_id IN (
	carrera_id * tutor_id
)

Mi solución:

SELECT int4range(MIN(carrera_id), MAX(carrera_id))
 * int4range(MIN(tutor_id), MAX(tutor_id))
FROM platzi.alumnos;

El reto lo resolví así. Creo que puede servir si se quiere una consulta con unos rangos definidos, Pero no estoy muy seguro, si alguien me puede explicar qué sentido tendría, por favor.

SELECT *
FROM platzi.alumnos
WHERE int4range(0, 20) @> carrera_id AND int4range(10, 30)@> tutor_id
;
SELECT int4range (MIN (tutor_id), max (tutor_id))*int4range(MIN(carrera_id),max(carrera_id))
FROM platzi.alumnos

SELECT 
	numrange(min_carrera, max_carrera) * numrange(min_tutor, max_tutor)
FROM (
	SELECT 
		MIN(carrera_id) as min_carrera,
		MAX(carrera_id) as max_carrera,
		MIN(tutor_id) as min_tutor,
		MAX(tutor_id) as max_tutor
	FROM platzi.alumnos
) AS carrera_tutor

Mi aporte a la última tarea:

SELECT *
FROM platzi.alumnos
WHERE id IN(
 SELECT id
 from platzi.alumnos
  WHERE tutor_id <>30);
 
SELECT
*
from 
(select ROW_NUMBER() over() AS row_id, * 
from platzi.alumnos)
as alumnos_with_row_num
where row_id  not in (1,5,10,12,15,20);

Aquí mi solución 😃

Usé el rango para filtrar la tabla

/* RETO */

/* CONFIRMANDO INTERSECCIÓN */
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) && int4range(MIN(carrera_id), MAX(carrera_id))		 
FROM platzi.alumnos;

/* EXTRAYENDO RANGO DE INTERESECCIÓN */
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id), MAX(carrera_id))		 
FROM platzi.alumnos;

/* FILTRANDO CON EL RANGO DE INTERSECCIÓN */
SELECT *		 
FROM platzi.alumnos
WHERE (
	SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id), MAX(carrera_id))
	FROM platzi.alumnos) @> carrera_id
AND (
	SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id), MAX(carrera_id))
	FROM platzi.alumnos) @> tutor_id
ORDER BY carrera_id,tutor_id ASC;

SELECT int4range(MIN (carrera_id), MAX (carrera_id))
* int4range(MIN (tutor_id), MAX (tutor_id))
FROM platzi.alumnos

RETO
Tengo una respuesta corta con algo que aún no vimos en clase:

SELECT
numrange(MIN(tutor_id),MAX(tutor_id)) *
numrange(MIN(carrera_id),MAX(carrera_id))
FROM platzi.alumnos;

Y otra muuuuy larga con herramientas ya vistas xD

SELECT 

numrange( primer_tutor.tutor_id, ultimo_tutor.tutor_id ) * 
numrange( primera_carrera.carrera_id, ultima_carrera.carrera_id)

FROM 

( SELECT tutor_id
FROM platzi.alumnos
ORDER BY tutor_id ASC
FETCH FIRST 1 ROW ONLY ) AS primer_tutor
,
( SELECT tutor_id
FROM platzi.alumnos
ORDER BY tutor_id DESC
FETCH FIRST 1 ROW ONLY ) AS ultimo_tutor
,
( SELECT carrera_id
FROM platzi.alumnos
ORDER BY carrera_id ASC
FETCH FIRST 1 ROW ONLY ) AS primera_carrera
,
( SELECT carrera_id
FROM platzi.alumnos
ORDER BY carrera_id DESC
FETCH FIRST 1 ROW ONLY ) AS ultima_carrera

mi aporte

DELETE FROM alumnos WHERE id in (SELECT id FROM `alumnos` GROUP by email HAVING COUNT(email) >1);

Mi solución al reto

SELECT int4range(MIN(tutor_id), MAX(tutor_id)) 
* int4range(MIN(carrera_id), MAX(carrera_id))
FROM platzi.alumnos;

Por lo general creo que antes de ejecutar la sentencia DELETE, nos aseguramos visualizando los datos que deseamos eliminar con un SELECT.
*Adicional: Ejecutar una sentencia también lo podemos realizar con F5

Mi solución.

SELECT int4range(min_carrera,max_carrera) * int4range(min_tutor,max_tutor)
FROM (
	SELECT MAX(carrera_id) AS max_carrera,
		MIN(carrera_id) AS min_carrera,
		MAX(tutor_id) AS max_tutor,
		MIN(tutor_id) AS min_tutor
	FROM platzi.alumnos
) AS maximos_minimos;
SELECT INT4RANGE(MIN(tutor_id), MAX(tutor_id)) * INT4RANGE(MIN(carrera_id), MAX(carrera_id))
    FROM platzi.alumnos;

Para el reto hice:

SELECT numrange(
	(SELECT MIN(tutor_id) FROM platzi.alumnos),
	(SELECT MAX(tutor_id) FROM platzi.alumnos)
) * numrange(
	(SELECT MIN(carrera_id) FROM platzi.alumnos),
	(SELECT MAX(carrera_id) FROM platzi.alumnos)
);

aca esta mi respuesta al problema:
–TAREA
select int4range(min(tutor_id),max(tutor_id)) * int4range(min(carrera_id),max(carrera_id))
from platzi.alumnos;
–select distinct tutor_id from platzi.alumnos order by tutor_id
–select distinct carrera_id from platzi.alumnos order by carrera_id
las últimas dos consultas comentadas es para saber los diferentes valores que hay en tutor_id y carrera_id

El código del profesor bien aplicado… me pareció bueno:

DELETE FROM PLATZI.ALUMNOS
WHERE ID IN (
select id from (
	select id,
	row_number() over(
		partition by nombre,
		apellido,email,colegiatura,fecha_incorporacion,carrera_id,tutor_id
		order by id ASC
	) as row
	   from platzi.alumnos
) as duplicados
where row>1)```

Mi respuesta

SELECT *
FROM platzi.alumnos
WHERE int4range (10,20) @> tutor_id and int4range (20,30) @> carrera_id;

Así quedó mi solución

SELECT int4range(
	int4range((SELECT MIN(tutor_id) FROM platzi.alumnos),(SELECT MAX(tutor_id) FROM platzi.alumnos)) 
  * int4range((SELECT MIN(carrera_id) FROM platzi.alumnos),(SELECT MAX(carrera_id) FROM platzi.alumnos))
	)

Sol:

SELECT * FROM platzi.alumnos
WHERE(
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id),MAX(carrera_id))
FROM platzi.alumnos
) @> tutor_id
AND 
(
SELECT int4range(MIN(tutor_id), MAX(tutor_id)) * int4range(MIN(carrera_id),MAX(carrera_id))
FROM platzi.alumnos
) @> carrera_id;```
SELECT int4range(MIN(carrera_id),MAX(carrera_id)) * int4range(MIN(tutor_id),MAX(tutor_id))
FROM platzi.alumnos
WHERE carrera_id=tutor_id;```

Hola

Estoy haciendo el curso pero lo llevo con MYSQL.
Para este reto hice la siguiente query.

¿Alguien podría ayudarme y ver que sea correcta?

Gracias.


Query:

SELECT DISTINCT t.tutor_id, c.carrera_id
FROM alumnos AS t
	JOIN alumnos AS c
	ON t.tutor_id = c.carrera_id;

Resultado:

+----------+------------+
| tutor_id | carrera_id |
+----------+------------+
|       23 |         23 |
|       14 |         14 |
|       28 |         28 |
|       17 |         17 |
|       24 |         24 |
|        7 |          7 |
|       15 |         15 |
|        2 |          2 |
|        4 |          4 |
|        3 |          3 |
|       18 |         18 |
|        9 |          9 |
|       25 |         25 |
|        1 |          1 |
|       26 |         26 |
|       12 |         12 |
|       16 |         16 |
|       29 |         29 |
|       10 |         10 |
|        8 |          8 |
|       13 |         13 |
|       27 |         27 |
|        5 |          5 |
|       20 |         20 |
|       19 |         19 |
|       22 |         22 |
|        6 |          6 |
|       11 |         11 |
|       21 |         21 |
|       30 |         30 |
+----------+------------+
30 rows in set (0.00 sec)


Les comparto mi solución

SELECT *
FROM platzi.alumnos
WHERE 
(
 SELECT int4range(min(tutor_id),max(tutor_id)) *      int4range(min(carrera_id),max(carrera_id))
FROM platzi.alumnos
) @> tutor_id
AND   
(
	SELECT int4range(min(tutor_id),max(tutor_id)) * int4range(min(carrera_id),max(carrera_id))
FROM platzi.alumnos) @>carrera_id ;
// seleccionan los rangos en los cuales coincide el tutor y la carrera, asi entendi el ejercicio
SELECT INT4RANGE(MIN(carrera_id) ,MAX(carrera_id)) AS carrera_range, INT4RANGE(MIN(tutor_id),MAX(tutor_id)) AS tutor_range
FROM platzi.alumnos
WHERE carrera_id = tutor_id;

SELECT INT4RANGE(MIN(carrera_id) ,MAX(carrera_id)) AS rango_iguales
FROM platzi.alumnos
WHERE carrera_id = tutor_id;

SELECT carrera_id , tutor_id
FROM platzi.alumnos
WHERE carrera_id = tutor_id;


// seleccionan el rango en común entre los maximos y minimos (vi que se entendió asi)
SELECT numrange(min_carrera, max_carrera) * numrange(min_tutor, max_tutor)
FROM (
	SELECT MIN(carrera_id) AS min_carrera,
			MAX(carrera_id) AS max_carrera,
			MIN(tutor_id) AS min_tutor,
			MAX(tutor_id) AS max_tutor
	FROM platzi.alumnos		
) AS rango;

SELECT INT4RANGE(MIN(carrera_id),MAX(carrera_id)) * INT4RANGE(MIN(tutor_id),MAX(tutor_id))
FROM platzi.alumnos;


SELECT carrera_range * tutor_range
FROM(
	SELECT INT4RANGE(MIN(carrera_id) ,MAX(carrera_id)) AS carrera_range, INT4RANGE(MIN(tutor_id),MAX(tutor_id)) AS tutor_range
	FROM platzi.alumnos
) AS rangos

Mi solución al reto (postgreSQL);

SELECT numrange(MIN(a1.tutor_id),MAX(a1.tutor_id))
		* numrange(MIN(a1.carrera_id),MAX(a1.carrera_id))
FROM platzi.alumnos as a1

Este es mi reto!

SELECT numrange(
			(SELECT MIN(tutor_id) FROM platzi.alumnos),
			(SELECT MAX(tutor_id) FROM platzi.alumnos))
			*
		numrange(
			(SELECT MIN(id) FROM platzi.alumnos),
			(SELECT MAX(id) FROM platzi.alumnos));

SELECT *
FROM platzi.alumnos
WHERE int4range (1,100) @>tutor_id 
	AND int4range (1,100) @>carrera_id;

Esta es mi solución:

SELECT CONCAT('[', (SELECT MIN(carrera_id) FROM platzi.alumnos), ',',
			  (SELECT MAX(carrera_id) FROM platzi.alumnos), ']')::int8range
			  *
		CONCAT('[', (SELECT MIN(tutor_id) FROM platzi.alumnos), ',',
			   (SELECT MAX(tutor_id) FROM platzi.alumnos), ']')::int8range
SELECT int4range(
	(SELECT MIN(tutor_id) FROM platzi.alumnos), 
	(SELECT MAX(tutor_id) FROM platzi.alumnos)
) * int4range(
	(SELECT MIN(carrera_id) FROM platzi.alumnos), 
	(SELECT MAX(carrera_id) FROM platzi.alumnos)
);
SELECT int8range(1,COUNT(DISTINCT(carrera_id))+1) *
int8range(1,COUNT(DISTINCT(tutor_id))+1)
FROM platzi.alumnos
;
SELECT * 
FROM platzi.alumnos
WHERE (int4range(10,20) @> tutor_id) AND (int4range(10,20) @> carrera_id ) ; 

Mi respuesta, lo que entendi es que hay que mostrar en rango de interseccion entre carrera_id con tutori_id
el rango de carrera_id va de 1,50
el rango de tutor_id va de 1,30
por lo tanto la interseccion entre estos dos el rango es 1,30

--interseccion entre dos rangos, entre carrera_id y tutor_id
SELECT int4range((SELECT min(carrera_id) FROM platzi.alumnos),(SELECT max(carrera_id) FROM platzi.alumnos)) *
int4range((SELECT min(tutor_id) FROM platzi.alumnos),(SELECT max(tutor_id) FROM platzi.alumnos))
delete  
FROM [HAHM].[dbo].[platzialumnos] 

where id = (


Select id from (


SELECT 
[id]
,[nombre]
,[apellido]
,[email]
,[colegiatura]
,[fecha_incorporacion]
,[carrera_id]
,[tutor_id]
,ROW_NUMBER () over(order by id desc ) Row
FROM [HAHM].[dbo].[platzialumnos] A

where CONCAT(
[nombre]
,[apellido]
,[email]
,[colegiatura]
,[fecha_incorporacion]
,[carrera_id]
,[tutor_id]) in (Select Llave from (
						SELECT
						CONCAT(
						[nombre]
						,[apellido]
						,[email]
						,[colegiatura]
						,[fecha_incorporacion]
						,[carrera_id]
						,[tutor_id]) Llave

						,COUNT(
						CONCAT(
						[nombre]
						,[apellido]
						,[email]
						,[colegiatura]
						,[fecha_incorporacion]
						,[carrera_id]
						,[tutor_id])) Cuenta
						FROM [HAHM].[dbo].[platzialumnos]

						Group by 
						CONCAT(
						[nombre]
						,[apellido]
						,[email]
						,[colegiatura]
						,[fecha_incorporacion]
						,[carrera_id]
						,[tutor_id])
						) a 

						where a.Cuenta <> 1)

) aa 

where row = 1) ```

Mi solucion a la interseccion de ids

SELECT int4range(
(SELECT MIN(id) FROM carreras),(SELECT MAX(id) FROM carreras) + 1) * 
int4range((SELECT MIN(tutor_id) FROM alumnos),(SELECT MAX(tutor_id ) FROM alumnos a3 ) + 1)