Soluciones a las preguntas de la entrevista SQL en los principales fabricantes de LeetCode (1)

Hola a todos, soy Ning Yi.

Recientemente, los temas de SQL se actualizarán todos los días en el grupo.

También me instó indirectamente a trabajar más duro——

Tema uno:

182. Encuentra direcciones de correo electrónico duplicadas (fácil)

Escriba una consulta SQL para encontrar todas las direcciones de correo electrónico duplicadas en la tabla Persona.

Ejemplo:

+----+---------+
| Id | Emai    |
+----+---------+
|1 |  [email protected] |
| 2 | [email protected]  |
|3 | [email protected]  |
+----+---------+

Según la entrada anterior, su consulta debería devolver los siguientes resultados:

+---------+
| Email   |
+---------+
| [email protected] |
+---------+

Ideas para resolver problemas:

Primero puede usar una subconsulta y usar la función de recuento agregado combinada con agrupar por para consultar el número de cada buzón. Luego use la consulta principal para determinar los registros con un número de buzón mayor que 1, que es el resultado final que queremos obtener.

Paso 1:
utilice una subconsulta para averiguar el número de cada buzón.

SELECT Email FROM(
  SELECT Email, COUNT(Email) AS num
  FROM Person
  GROUP BY Email

Paso 2:
Con base en los resultados obtenidos en el primer paso, determinamos los registros cuyo número de buzón num es mayor que 1.

SELECT Email FROM(
  SELECT Email, COUNT(Email) AS num
  FROM Person
  GROUP BY Email
) AS a
WHERE num > 1;

Si desea realizar pruebas localmente en su propia computadora, puede usar esto para crear rápidamente una declaración de base de datos:

-- 创建数据库
CREATE database SQLCode;
-- 选择数据库
USE SQLCode;


-- 创建科目表Person 
CREATE TABLE Person(
Id INT,
Email VARCHAR(10));
-- 插入语句
INSERT INTO Person VALUES
(1,'[email protected]'),
(2,'[email protected]'),
(3,'[email protected]');

Tema 2:

176. Segundo salario más alto (fácil)

Escriba una consulta SQL para obtener y devolver el segundo salario más alto en la tabla Empleado. Si el segundo salario más alto no existe, la consulta debería devolver nulo.

Ejemplo 1:

Entrada: tabla de empleados

+----+--------+
| id | salary |
+----+--------+
|  1 | 100    |
|  2 | 200    |
|  3 | 300    |
+----+--------+

Producción:

+---------------------+
| SecondHighestSalary |
+---------------------+
| 200                 |
+---------------------+

Ejemplo 2:

Entrada: Tabla de empleados:

+----+--------+
| id | salary |
+----+--------+
| 1  | 100    |
+----+--------+

Producción:

+---------------------+
| SecondHighestSalary |
+---------------------+
| null                |
+---------------------+

Ideas para resolver problemas:

Ordene los diferentes salarios en orden descendente y luego use LIMIT OFFSET para obtener el segundo salario más alto.

Sin embargo, si hay menos de 2 datos salariales diferentes en la tabla, estará vacía, así que agregue un IFNULL para juzgar.

Puntos de conocimiento:

(1) Uso básico de la cláusula LIMIT:

Se utiliza para limitar el número de registros devueltos.

Puede usar LIMIT m,n para omitir los primeros m registros en el conjunto de resultados y tomar n registros. Esta frase es un poco confusa, pongamos un ejemplo.

Tome los registros del 7.º al 9.º, es decir, omita los primeros 6 registros, comience desde el 7.º registro y tome los 3 registros 7, 8 y 9. Eso debería lograrse usando LIMIT 6,3.

(2) Sintaxis básica de la declaración IFNULL:

IFNULL(valor1,valor2)

Si el valor 1 es NULL, devuelve el valor 2; si el valor 1 no es NULL, devuelve el valor 1.

primer paso:

Ordene los salarios en orden inverso, use DISTINCT para eliminar duplicados y use LIMIT 1,1 para obtener el segundo salario más alto.

SELECT DISTINCT Salary
FROM Employee
ORDER by Salary DESC
LIMIT 1,1 # 获取第二高的salary

Segundo paso:

Si no hay un segundo salario más alto, devuelve nulo y usa IFNULL para lograrlo.

SELECT IFNULL(
    (
        SELECT DISTINCT Salary
        FROM Employee
        ORDER by Salary DESC
        LIMIT 1,1 # 获取第二高的salary
    ),
    NULL # 如果没有，则为 NULL
)

Si desea realizar pruebas localmente en su propia computadora, puede usar esto para crear rápidamente una declaración de tabla de datos:

-- 创建员工表Employee 
CREATE TABLE Employee(
Id INT,
salary INT);
-- 插入语句
INSERT INTO Employee VALUES
(1,100),
(2,200),
(3,300);

Tema tres:

180. Números consecutivos (medio)

Tabla: Registros

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
|  id         | int     |
| num         | varchar |
+-------------+---------+

id es la clave principal de esta tabla.

Escriba una consulta SQL para encontrar todos los números que aparecen al menos tres veces seguidas.

Los datos de la tabla de resultados devueltos se pueden organizar en cualquier orden.

Ejemplo 1:

Entrada: tabla de registros

+----+-----+
| Id | Num |
+----+-----+
| 1  | 1   |
| 2  | 1   |
| 3  | 1   |
| 4  | 3   |
| 5  | 2   |
| 6  | 2   |
| 7  | 2   |
+----+-----+

Producción:

+-----------------+
| ConsecutiveNums |
+-----------------+
| 1               |
| 2               |
+-----------------+

Ideas para resolver problemas:

Encuentre el número que aparecerá la próxima vez usando id + 1, y encuentre el número que aparecerá la próxima vez usando id + 2. Principalmente, el número que aparece la próxima vez y la próxima vez es el mismo que el número actual, lo que significa que aparece al menos 3 veces condiciones de.

Punto de conocimiento: ÚNETE a la conexión

La consulta conjunta de múltiples tablas de datos requiere el uso de conexiones JOIN. Hay varios tipos de conexiones JOIN. En esta pregunta, utilizamos combinaciones internas.

UNIÓN INTERNA: Conexión interna, también puedes simplemente escribir UNIRSE. Solo los datos que coincidan con los criterios de conexión se conservarán en las dos tablas que se unen, lo que equivale a la intersección de las dos tablas. Si se une a la misma tabla antes y después, también se denomina autounión.

primer paso:

Coloque el número que aparece la próxima vez y el número que aparece la próxima vez en la misma tabla para facilitar la comparación en el segundo paso.

SELECT *
FROM Logs t1
JOIN Logs t2
ON t1.id+1=t2.id
JOIN Logs t3
ON t1.id+2=t3.id

Segundo paso:

Con las condiciones de filtro agregadas, los números de la tabla t1 son iguales a los números de la tabla t2 y a los números de la tabla t3.

SELECT *
FROM Logs t1
JOIN Logs t2
ON t1.id+1=t2.id
JOIN Logs t3
ON t1.id+2=t3.id
WHERE t1.Num=t2. Num
    AND t1.Num=t3.Num;

tercer paso:

Modifique los campos después de SELECT y solo genere NUM.

SELECT DISTINCT t1.Num
FROM Logs t1
JOIN Logs t2
ON t1.id+1=t2.id
JOIN Logs t3
ON t1.id+2=t3.id
WHERE t1.Num=t2. Num
    AND t1.Num=t3.Num;

Si desea realizar pruebas localmente en su propia computadora, puede usar esto para crear rápidamente una declaración de tabla de datos:

-- 创建表
CREATE TABLE Logs(
Id INT,
Num INT);
-- 插入语句
INSERT INTO Logs VALUES
(1,1),
(2,1),
(3,1),
(4,3),
(5,2),
(6,2),
(7,2);

Tema cuatro:

1454. Usuarios activos (medio)

Ahora tenemos la tabla Cuentas: esta tabla contiene la identificación de la cuenta y el nombre de usuario de la cuenta.

Tabla de inicios de sesión: contiene la identificación de la cuenta y la fecha de inicio de sesión del usuario que inició sesión, login_date. (Los usuarios pueden iniciar sesión varias veces al día)

Escriba una consulta SQL para encontrar la identificación y el nombre de los usuarios activos. Los usuarios activos son aquellos que han iniciado sesión en su cuenta durante al menos 3 días consecutivos. La tabla de resultados devuelta está ordenada por identificación.

El formato de la tabla de resultados es como se muestra en el siguiente ejemplo:

Tabla de cuentas:

+----+----------+
| id | name     |
+----+----------+
| 1  | '小王'    |
| 7  | ‘小李'    |
+----+----------+

Tabla de inicios de sesión:

+----+------------+
| id | login_date |
+----+------------+
| 7  | 2020-05-30 |
| 1  | 2020-05-30 |
| 7  | 2020-05-31 |
| 7  | 2020-06-01 |
| 7  | 2020-06-03 |
| 1  | 2020-06-07 |
+----+------------+

El usuario Xiao Wang con id = 1 solo ha iniciado sesión dos veces, por lo que Xiao Wang no es un usuario activo.

El usuario con id = 7, Xiao Li, inició sesión durante 3 días consecutivos, por lo que Xiao Li es un usuario activo.

Ideas para resolver problemas:

Este también es un problema continuo. Es lo mismo que la idea anterior de encontrar números continuos. Utilice una autounión para conectar primero la tabla Cuentas y la tabla Inicios de sesión.

Vuelva a conectar la tabla de inicios de sesión, asigne un nombre al alias L2 y conecte solo las fechas de la tabla L1 que tengan el mismo ID y estén separadas por 2 días. De esta forma se mostrarán todas las fechas que difieran en dos días de la tabla L1.

Por ejemplo: en la tabla L1 es 30 de mayo, la tabla L2 encontrará las fechas de 30 de mayo, 31 de mayo y 1 de junio como máximo. Si corresponde a 3 fechas, significa que el usuario ha iniciado sesión durante 3 días consecutivos. Si hay dos fechas que se corresponden entre sí, significa que el usuario solo inició sesión dos días dentro de tres días.

Puntos de conocimiento:

DATEDIFF calcula el número de días entre dos fechas:

SELECT
  DATEDIFF('2022-04-11','2021-04-11') AS "间隔天数",
  DATEDIFF('2022-04-11 01:00','2022-04-10 23:00') AS "间隔天数"

primer paso:

Primero conecte las tablas y busque las fechas en las tablas L1 y L2 que tengan el mismo ID y estén con 2 días de diferencia.

SELECT A.*,L1.login_date,L2.login_date
FROM Accounts A
JOIN logins L1 ON A.id = L1.id
JOIN Logins L2 ON L1.id=L2.id
    AND DATEDIFF(L2.login_date,L1.login_date) BETWEEN 0 AND 2

Segundo paso:

Agrupe los resultados encontrados arriba y vea cómo las mismas fechas en la tabla L1 corresponden al número de fechas en la tabla L2.

SELECT A.*,L1.login_date
FROM Accounts A
JOIN logins L1 ON A.id = L1.id
JOIN Logins L2 ON L1.id=L2.id
    AND DATEDIFF(L2.login_date,L1.login_date) BETWEEN 0 AND 2
GROUP BY A.id,A.name,L1.login_date

tercer paso:

El número de registros en la tabla anterior es 3 y el nombre de la cuenta correspondiente es lo que estamos buscando. Luego elimine los campos después de SELECCIONAR, dejando solo el campo Cuenta.

SELECT A.*
FROM Accounts A
JOIN logins L1 ON A.id = L1.id
JOIN Logins L2 ON L1.id=L2.id
    AND DATEDIFF(L2.login_date,L1.login_date) BETWEEN 0 AND 2
GROUP BY A.id,A.name,L1.login_date
HAVING COUNT(DISTINCT L2.login_date)=3

Si desea realizar pruebas localmente en su propia computadora, puede usar esto para crear rápidamente una declaración de tabla de datos:

-- 创建表
CREATE TABLE Accounts(
Id INT,
name VARCHAR(10));
-- 插入语句
INSERT INTO Accounts VALUES
(1,'小王' ),
(7, '小李');
-- 创建表
CREATE TABLE Logins(
Id INT,
login_date DATETIME);
-- 插入语句
INSERT INTO Logins VALUES
(7,'2020-05-30' ),
(1,'2020-05-30' ),
(7,'2020-05-31' ),
(7,'2020-06-01' ),
(7,'2020-06-03' ),
(1,'2020-06-07' );

Haz clic para seguir y comenzar a programar sin perderte ~