├── 1683. Invalid Tweets.sql ├── 1853. Convert Date Format.sql ├── 182. Duplicate Emails.sql ├── 584. Find Customer Referee.sql ├── 596. Classes More Than 5 Students.sql ├── 1757. Recyclable and Low Fat Products.sql ├── 511. Game Play Analysis I.sql ├── 178. Rank Scores.sql ├── 620. Not Boring Movies.sql ├── 1069. Product Sales Analysis II.sql ├── 627. Swap Salary.sql ├── 1350. Students With Invalid Departments.sql ├── 183. Customers Who Never Order.sql ├── 1378. Replace Employee ID With The Unique Identifier.sql ├── 2356. Number of Unique Subjects Taught by Each Teacher.sql ├── 1068. Product Sales Analysis I.sql ├── 577. Employee Bonus.sql ├── 1729. Find Followers Count.sql ├── 175. Combine Two Tables.sql ├── 1821. Find Customers With Positive Revenue this Year.sql ├── 2339. All the Matches of the League.sql ├── 1527. Patients With a Condition.sql ├── 181. Employees Earning More Than Their Managers.sql ├── 1421. NPV Queries.sql ├── 1741. Find Total Time Spent by Each Employee.sql ├── 197. Rising Temperature.sql ├── 534. Game Play Analysis III.sql ├── 1050. Actors and Directors Who Cooperated At Least Three Times.sql ├── 1148. Article Views I.sql ├── 1308. Running Total for Different Genders.sql ├── 619. Biggest Single Number.sql ├── README.md ├── 1113. Reported Posts.sql ├── 2026. Low-Quality Problems.sql ├── 610. Triangle Judgement.sql ├── 1667. Fix Names in a Table.sql ├── 1587. Bank Account Summary II.sql ├── 1607. Sellers With No Sales.sql ├── 2377. Sort the Olympic Table.sql ├── 1075. Project Employees I.sql ├── 1988. Find Cutoff Score for Each School.sql ├── 1571. Warehouse Manager.sql ├── 1978. Employees Whose Manager Left the Company.sql ├── 1407. Top Travellers.sql ├── 1484. Group Sold Products By The Date.sql ├── 1693. Daily Leads and Partners.sql ├── 1873. Calculate Special Bonus.sql ├── 2329. Product Sales Analysis V.sql ├── 2041. Accepted Candidates From the Interviews.sql ├── 1045. Customers Who Bought All Products.sql ├── 1517. Find Users With Valid E-Mails.sql ├── 1565. Unique Orders and Customers Per Month.sql ├── 1141. User Activity for the Past 30 Days I.sql ├── 1270. All People Report to the Given Manager.sql ├── 1890. The Latest Login in 2020.sql ├── 580. Count Student Number in Departments.sql ├── 607. Sales Person.sql ├── 1241. Number of Comments per Post.sql ├── 1965. Employees With Missing Information.sql ├── 176. Second Highest Salary.sql ├── 1327. List the Products Ordered in a Period.sql ├── 1393. Capital Gain:Loss.sql ├── 2228. Users With Two Purchases Within Seven Days.sql ├── 612. Shortest Distance in a Plane.sql ├── 2230. The Users That Are Eligible for Discount.sql ├── 1459. Rectangles Area.sql ├── 1501. Countries You Can Safely Invest In.sql ├── 2372. Calculate the Influence of Each Salesperson.sql ├── 2308. Arrange Table by Gender.sql ├── 1158. Market Analysis I.sql ├── 1173. Immediate Food Delivery I.sql ├── 1939. Users That Actively Request Confirmation Messages.sql ├── 1809. Ad-Free Sessions.sql ├── 574. Winning Candidate.sql ├── 614. Second Degree Follower.sql ├── 196. Delete Duplicate Emails.sql ├── 1076. Project Employees II.sql ├── 1731. The Number of Employees Which Report to Each Employee.sql ├── 1831. Maximum Transaction Each Day.sql ├── 1211. Queries Quality and Percentage.sql ├── 1204. Last Person to Fit in the Bus.sql ├── 1251. Average Selling Price.sql ├── 1633. Percentage of Users Attended a Contest.sql ├── 1677. Product's Worth Over Invoices.sql ├── 1264. Page Recommendations.sql ├── 2205. The Number of Users That Are Eligible for Discount.sql ├── 1795. Rearrange Products Table.sql ├── 1613. Find the Missing IDs.sql ├── 2298. Tasks Count in the Weekend.sql ├── 585. Investments in 2016.sql ├── 1112. Highest Grade For Each Student.sql ├── 1294. Weather Type in Each Country.sql ├── 1777. Product's Price for Each Store.sql ├── 2199. Finding the Topic of Each Post.sql ├── 1355. Activity Participants.sql ├── 1709. Biggest Window Between Visits.sql ├── 177. Nth Highest Salary.sql ├── 569. Median Employee Salary.sql ├── 595. Big Countries.sql ├── 2314. The First Day of the Maximum Recorded Degree in Each City.sql ├── 1077. Project Employees III.sql ├── 1132. Reported Posts II.sql ├── 1285. Find the Start and End Number of Continuous Ranges.sql ├── 184. Department Highest Salary.sql ├── 2066. Account Balance.sql ├── 185. Department Top Three Salaries.sql ├── 2142. The Number of Passengers in Each Bus I.sql ├── 603. Consecutive Available Seats.sql ├── 2292. Products With Three or More Orders in Two Consecutive Years.sql ├── 2020. Number of Accounts That Did Not Stream.sql ├── 2388. Change Null Values in a Table to the Previous Value.sql ├── 1193. Monthly Transactions I.sql ├── 1321. Restaurant Growth.sql ├── 597. Friend Requests I- Overall Acceptance Rate.sql ├── 2112. The Airport With the Most Traffic.sql ├── 2324. Product Sales Analysis IV.sql ├── 618. Students Report By Geography.sql ├── 570. Managers with at Least 5 Direct Reports.sql ├── 578. Get Highest Answer Rate Question.sql ├── 1149. Article Views II.sql ├── 1783. Grand Slam Titles.sql ├── 2346. Compute the Rank as a Percentage.sql ├── 586. Customer Placing the Largest Number of Orders.sql ├── 2082. The Number of Rich Customers.sql ├── 512. Game Play Analysis II.sql ├── 626. Exchange Seats.sql ├── 1555. Bank Account Summary.sql ├── 2362. Generate the Invoice.sql ├── 1549. The Most Recent Orders for Each Product.sql ├── 1934. Confirmation Rate.sql ├── 1194. Tournament Winners.sql ├── 2238. Number of Times a Driver Was a Passenger.sql ├── 1661. Average Time of Process per Machine.sql ├── 180. Consecutive Numbers.sql ├── 1082. Sales Analysis I.sql ├── 1543. Fix Product Name Format.sql ├── 613. Shortest Distance in a Line.sql ├── 1098. Unpopular Books.sql ├── 1174. Immediate Food Delivery II.sql ├── 1440. Evaluate Boolean Expression.sql ├── 1303. Find the Team Size.sql ├── 1445. Apples & Oranges.sql ├── 1159. Market Analysis II.sql ├── 1951. All the Pairs With the Maximum Number of Common Followers.sql ├── 2010. The Number of Seniors and Juniors to Join the Company II.sql ├── 1205. Monthly Transactions II.sql ├── 1097. Game Play Analysis V.sql ├── 2175. The Change in Global Rankings.sql ├── 1495. Friendly Movies Streamed Last Month.sql ├── 1581. Customer Who Visited but Did Not Make Any Transactions.sql ├── 1843. Suspicious Bank Accounts.sql ├── 1398. Customers Who Bought Products A and B but Not C.sql ├── 1341. Movie Rating.sql ├── 2173. Longest Winning Streak.sql ├── 1841. League Statistics.sql ├── 1225. Report Contiguous Dates.sql ├── 1715. Count Apples and Oranges.sql ├── 1990. Count the Number of Experiments.sql ├── 1083. Sales Analysis II.sql ├── 602. Friend Requests II- Who Has the Most Friends.sql ├── 1867. Orders With Maximum Quantity Above Average.sql ├── 1699. Number of Calls Between Two Persons.sql ├── 2051. The Category of Each Member in the Store.sql ├── 1142. User Activity for the Past 30 Days II.sql ├── 1651. Hopper Company Queries III.sql ├── 615. Average Salary- Departments VS Company.sql ├── 1336. Number of Transactions per Visit.sql ├── 1454. Active Users.sql ├── 1212. Team Scores in Football Tournament.sql ├── 1767. Find the Subtasks That Did Not Execute.sql ├── 1126. Active Businesses.sql ├── 1747. Leetflex Banned Accounts.sql ├── 2159. Order Two Columns Independently.sql ├── 608. Tree Node.sql ├── 1107. New Users Daily Count.sql ├── 1623. All Valid Triplets That Can Represent a Country.sql ├── 1322. Ads Performance.sql ├── 1070. Product Sales Analysis III.sql ├── 2072. The Winner University.sql ├── 1364. Number of Trusted Contacts of a Customer.sql ├── 1532. The Most Recent Three Orders.sql ├── 1907. Count Salary Categories.sql ├── 1875. Group Employees of the Same Salary.sql ├── 1468. Calculate Salaries.sql ├── 1511. Customer Order Frequency.sql ├── 1635. Hopper Company Queries I.sql ├── 1384. Total Sales Amount by Year.sql ├── 1280. Students and Examinations.sql ├── 1179. Reformat Department Table.sql ├── 1369. Get the Second Most Recent Activity.sql ├── 1435. Create a Session Bar Chart.sql ├── 550. Game Play Analysis IV.sql ├── 1412. Find the Quiet Students in All Exams.sql ├── 1789. Primary Department for Each Employee.sql ├── 1645. Hopper Company Queries II.sql ├── 1972. First and Last Call On the Same Day.sql ├── 2118. Build the Equation.sql ├── 1919. Leetcodify Similar Friends.sql ├── 1892. Page Recommendations II.sql ├── 1127. User Purchase Platform.sql ├── 262. Trips and Users.sql ├── 1949. Strong Friendship.sql ├── 1917. Leetcodify Friends Recommendations.sql ├── 579. Find Cumulative Salary of an Employee.sql ├── 601. Human Traffic of Stadium.sql ├── 2004. The Number of Seniors and Juniors to Join the Company.sql ├── 1164. Product Price at a Given Date.sql ├── 1811. Find Interview Candidates.sql ├── 1596. The Most Frequently Ordered Products for Each Customer.sql ├── 2084. Drop Type 1 Orders for Customers With Type 0 Orders.sql └── 1479. Sales by Day of the Week.sql /1683. Invalid Tweets.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | tweet_id 3 | FROM tweets 4 | WHERE LENGTH(content) > 15; 5 | -------------------------------------------------------------------------------- /1853. Convert Date Format.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | date_format(day, '%W, %M %e, %Y') AS day 3 | FROM days; 4 | -------------------------------------------------------------------------------- /182. Duplicate Emails.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | email 3 | FROM person 4 | GROUP BY email 5 | HAVING COUNT(email) > 1; 6 | -------------------------------------------------------------------------------- /584. Find Customer Referee.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | name 3 | FROM customer 4 | WHERE referee_id IS NULL OR referee_id != 2; 5 | -------------------------------------------------------------------------------- /596. Classes More Than 5 Students.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | class 3 | FROM courses 4 | GROUP BY class 5 | HAVING COUNT(*) >= 5; 6 | -------------------------------------------------------------------------------- /1757. Recyclable and Low Fat Products.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | product_id 3 | FROM products 4 | WHERE low_fats = 'Y' and recyclable = 'Y'; 5 | -------------------------------------------------------------------------------- /511. Game Play Analysis I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | player_id, 3 | MIN(event_date) AS first_login 4 | FROM activity 5 | GROUP BY player_id; 6 | -------------------------------------------------------------------------------- /178. Rank Scores.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | score, 3 | DENSE_RANK() OVER(ORDER BY score DESC) AS 'rank' 4 | FROM scores 5 | ORDER BY score DESC; 6 | -------------------------------------------------------------------------------- /620. Not Boring Movies.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | * 3 | FROM cinema 4 | WHERE id % 2 != 0 AND description NOT LIKE '%boring%' 5 | ORDER BY rating DESC; 6 | -------------------------------------------------------------------------------- /1069. Product Sales Analysis II.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s.product_id, 3 | SUM(s.quantity) AS total_quantity 4 | FROM sales s 5 | GROUP BY s.product_id; 6 | -------------------------------------------------------------------------------- /627. Swap Salary.sql: -------------------------------------------------------------------------------- 1 | UPDATE salary 2 | SET sex = ( 3 | CASE 4 | WHEN sex = 'm' THEN 'f' 5 | WHEN sex = 'f' THEN 'm' 6 | END 7 | ); 8 | -------------------------------------------------------------------------------- /1350. Students With Invalid Departments.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s.id, 3 | s.name 4 | FROM students s 5 | WHERE s.department_id NOT IN (SELECT id FROM departments); 6 | -------------------------------------------------------------------------------- /183. Customers Who Never Order.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | name AS Customers 3 | FROM customers 4 | WHERE id NOT IN ( 5 | SELECT DISTINCT customerId from orders 6 | ); 7 | -------------------------------------------------------------------------------- /1378. Replace Employee ID With The Unique Identifier.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | ee.unique_id, 3 | e.name 4 | FROM employees e 5 | LEFT JOIN EmployeeUNI ee ON e.id = ee.id; 6 | -------------------------------------------------------------------------------- /2356. Number of Unique Subjects Taught by Each Teacher.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | teacher_id, 3 | COUNT(DISTINCT subject_id) AS cnt 4 | FROM teacher 5 | GROUP BY teacher_id; 6 | -------------------------------------------------------------------------------- /1068. Product Sales Analysis I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p.product_name, 3 | s.year, 4 | s.price 5 | FROM sales s 6 | LEFT JOIN product p ON s.product_id = p.product_id; 7 | -------------------------------------------------------------------------------- /577. Employee Bonus.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | e.name, 3 | b.bonus 4 | FROM employee e 5 | LEFT JOIN bonus b ON e.empId = b.empId 6 | WHERE b.bonus < 1000 OR b.bonus IS NULL; 7 | -------------------------------------------------------------------------------- /1729. Find Followers Count.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | f1.user_id, 3 | COUNT(f1.follower_id) as followers_count 4 | FROM followers f1 5 | GROUP BY f1.user_id 6 | ORDER BY f1.user_id; 7 | -------------------------------------------------------------------------------- /175. Combine Two Tables.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p.firstName, 3 | p.lastName, 4 | a.city, 5 | a.state 6 | FROM person p 7 | LEFT JOIN address a ON p.personId = a.personId; 8 | -------------------------------------------------------------------------------- /1821. Find Customers With Positive Revenue this Year.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | customer_id 3 | FROM customers 4 | WHERE year = 2021 5 | GROUP BY customer_id 6 | HAVING SUM(revenue) > 0; 7 | -------------------------------------------------------------------------------- /2339. All the Matches of the League.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | t1.team_name AS home_team, 3 | t2.team_name AS away_team 4 | FROM teams t1 5 | JOIN teams t2 ON t1.team_name <> t2.team_name; 6 | -------------------------------------------------------------------------------- /1527. Patients With a Condition.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | patient_id, 3 | patient_name, 4 | conditions 5 | FROM patients 6 | WHERE conditions LIKE "DIAB1%" OR conditions LIKE "% DIAB1%"; 7 | -------------------------------------------------------------------------------- /181. Employees Earning More Than Their Managers.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | e1.name AS Employee 3 | FROM employee e1 4 | JOIN employee e2 ON e1.managerid = e2.id 5 | WHERE e1.salary > e2.salary; 6 | -------------------------------------------------------------------------------- /1421. NPV Queries.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | q.id, 3 | q.year, 4 | IFNULL(n.npv, 0) AS npv 5 | FROM queries q 6 | LEFT JOIN npv n ON q.id = n.id AND q.year = n.year 7 | GROUP BY q.id, q.year; 8 | -------------------------------------------------------------------------------- /1741. Find Total Time Spent by Each Employee.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | event_day AS day, 3 | emp_id, 4 | SUM(out_time - in_time) AS total_time 5 | FROM employees 6 | GROUP BY event_day, emp_id; 7 | -------------------------------------------------------------------------------- /197. Rising Temperature.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | w1.id 3 | FROM weather w1 4 | JOIN weather w2 ON 5 | w1.temperature > w2.temperature AND 6 | DATEDIFF(w1.recordDate, w2.recordDate) = 1; 7 | -------------------------------------------------------------------------------- /534. Game Play Analysis III.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | player_id, 3 | event_date, 4 | SUM(games_played) OVER(PARTITION BY player_id ORDER BY event_date) AS games_played_so_far 5 | FROM activity; 6 | -------------------------------------------------------------------------------- /1050. Actors and Directors Who Cooperated At Least Three Times.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | actor_id, 3 | director_id 4 | FROM actordirector 5 | GROUP BY actor_id, director_id 6 | HAVING COUNT(*) >= 3; 7 | -------------------------------------------------------------------------------- /1148. Article Views I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | DISTINCT author_id AS id 3 | FROM views 4 | GROUP BY author_id 5 | HAVING SUM(CASE WHEN author_id = viewer_id THEN 1 ELSE 0 END) > 0 6 | ORDER BY author_id; 7 | -------------------------------------------------------------------------------- /1308. Running Total for Different Genders.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | gender, 3 | day, 4 | SUM(score_points) OVER(partition by gender order by day) as total 5 | FROM scores 6 | ORDER BY gender, day; 7 | -------------------------------------------------------------------------------- /619. Biggest Single Number.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | MAX(num) AS num 3 | FROM ( 4 | SELECT 5 | num 6 | FROM MyNumbers 7 | GROUP BY num 8 | HAVING COUNT(num) = 1 9 | ) AS cte; 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # leetcode_sql_solutions 2 | Solutions of [Leetcode SQL problems](https://leetcode.com/problemset/database/?page=1&sorting=W3sic29ydE9yZGVyIjoiQVNDRU5ESU5HIiwib3JkZXJCeSI6IkZST05URU5EX0lEIn1d) 3 | -------------------------------------------------------------------------------- /1113. Reported Posts.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | extra AS report_reason, 3 | COUNT(DISTINCT post_id) AS report_count 4 | FROM actions 5 | WHERE action = 'report' AND action_date = "2019-07-04" 6 | GROUP BY extra; 7 | -------------------------------------------------------------------------------- /2026. Low-Quality Problems.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT 3 | p.problem_id 4 | FROM problems p 5 | WHERE ((p.likes / (p.likes + p.dislikes)) * 100) < 60 6 | ORDER BY p.problem_id; 7 | -------------------------------------------------------------------------------- /610. Triangle Judgement.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | x, 3 | y, 4 | z, 5 | CASE 6 | WHEN (x + y) > z AND (y + z) > x AND (z + x) > y THEN 'Yes' ELSE 'No' 7 | END as triangle 8 | FROM triangle; 9 | -------------------------------------------------------------------------------- /1667. Fix Names in a Table.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | user_id , 3 | CONCAT( 4 | UPPER(SUBSTR(Users.name,1,1)), 5 | LOWER(SUBSTR(Users.name,2)) 6 | ) AS name 7 | FROM Users 8 | ORDER BY user_id; 9 | -------------------------------------------------------------------------------- /1587. Bank Account Summary II.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | u.name, 3 | SUM(t.amount) as balance 4 | FROM transactions t 5 | LEFT JOIN users u on t.account = u.account 6 | GROUP BY t.account 7 | HAVING SUM(t.amount) > 10000; 8 | -------------------------------------------------------------------------------- /1607. Sellers With No Sales.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s.seller_name 3 | FROM seller s 4 | WHERE s.seller_id NOT IN ( 5 | SELECT DISTINCT seller_id FROM orders WHERE YEAR(sale_date) = 2020 6 | ) 7 | ORDER BY s.seller_name; 8 | -------------------------------------------------------------------------------- /2377. Sort the Olympic Table.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | country, 3 | gold_medals, 4 | silver_medals, 5 | bronze_medals 6 | FROM olympic 7 | ORDER BY gold_medals DESC, silver_medals DESC, bronze_medals DESC, country; 8 | -------------------------------------------------------------------------------- /1075. Project Employees I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p.project_id, 3 | ROUND(AVG(e.experience_years), 2) AS average_years 4 | FROM project p 5 | LEFT JOIN employee e ON p.employee_id = e.employee_id 6 | GROUP BY p.project_id; 7 | -------------------------------------------------------------------------------- /1988. Find Cutoff Score for Each School.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s.school_id, 3 | IFNULL(MIN(e.score), -1) AS score 4 | FROM schools s 5 | LEFT JOIN exam e ON s.capacity >= e.student_count 6 | GROUP BY s.school_id, s.capacity; 7 | -------------------------------------------------------------------------------- /1571. Warehouse Manager.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | w.name AS warehouse_name, 3 | SUM(w.units * p.width * p.length * p.height) AS volume 4 | FROM warehouse w 5 | LEFT JOIN products p ON w.product_id = p.product_id 6 | GROUP BY w.name; 7 | -------------------------------------------------------------------------------- /1978. Employees Whose Manager Left the Company.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | e1.employee_id 3 | FROM employees e1 4 | WHERE e1.salary < 30000 AND 5 | e1.manager_id NOT IN (SELECT employee_id from employees) 6 | ORDER BY e1.employee_id; 7 | -------------------------------------------------------------------------------- /1407. Top Travellers.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | u.name, 3 | IFNULL(SUM(r.distance), 0) AS travelled_distance 4 | FROM users u 5 | LEFT JOIN rides r ON r.user_id = u.id 6 | GROUP BY r.user_id 7 | ORDER BY travelled_distance DESC, u.name; 8 | -------------------------------------------------------------------------------- /1484. Group Sold Products By The Date.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | sell_date, 3 | COUNT(DISTINCT product) as num_sold, 4 | GROUP_CONCAT(DISTINCT product) as products 5 | FROM activities 6 | GROUP BY sell_date 7 | ORDER BY sell_date; 8 | -------------------------------------------------------------------------------- /1693. Daily Leads and Partners.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | date_id, 3 | make_name, 4 | COUNT(DISTINCT lead_id) as unique_leads, 5 | COUNT(DISTINCT partner_id) as unique_partners 6 | FROM DailySales 7 | GROUP BY date_id, make_name; 8 | -------------------------------------------------------------------------------- /1873. Calculate Special Bonus.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | employee_id, 3 | CASE 4 | WHEN employee_id % 2 != 0 AND name NOT LIKE 'M%' THEN salary 5 | ELSE 0 6 | END AS bonus 7 | FROM employees 8 | ORDER BY employee_id; 9 | -------------------------------------------------------------------------------- /2329. Product Sales Analysis V.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s.user_id, 3 | SUM(s.quantity * p.price) AS spending 4 | FROM sales s 5 | LEFT JOIN product p ON s.product_id = p.product_id 6 | GROUP BY s.user_id 7 | ORDER BY spending DESC, s.user_id; 8 | -------------------------------------------------------------------------------- /2041. Accepted Candidates From the Interviews.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | c.candidate_id 3 | FROM candidates c 4 | LEFT JOIN rounds r ON c.interview_id = r.interview_id 5 | WHERE c.years_of_exp >= 2 6 | GROUP BY c.candidate_id 7 | HAVING SUM(r.score) > 15; 8 | -------------------------------------------------------------------------------- /1045. Customers Who Bought All Products.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | c.customer_id 3 | FROM customer c 4 | LEFT JOIN product p ON c.product_key = p.product_key 5 | GROUP BY c.customer_id 6 | HAVING COUNT(DISTINCT c.product_key) = (SELECT COUNT(*) FROM product); 7 | -------------------------------------------------------------------------------- /1517. Find Users With Valid E-Mails.sql: -------------------------------------------------------------------------------- 1 | # One of the rarest SQL problem with regular expression 2 | SELECT 3 | user_id, 4 | name, 5 | mail 6 | FROM 7 | Users 8 | WHERE 9 | mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode[.]com$'; 10 | -------------------------------------------------------------------------------- /1565. Unique Orders and Customers Per Month.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | LEFT(order_date, 7) AS month, 3 | COUNT(order_id) AS order_count, 4 | COUNT(DISTINCT customer_id) AS customer_count 5 | FROM orders 6 | WHERE invoice > 20 7 | GROUP BY LEFT(order_date, 7); 8 | -------------------------------------------------------------------------------- /1141. User Activity for the Past 30 Days I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | activity_date AS day, 3 | COUNT(DISTINCT user_id) as active_users 4 | FROM activity 5 | WHERE DATEDIFF('2019-07-27', activity_date) < 30 6 | GROUP BY activity_date 7 | HAVING COUNT(DISTINCT user_id) > 0; 8 | -------------------------------------------------------------------------------- /1270. All People Report to the Given Manager.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | e1.employee_id 3 | FROM Employees e1 4 | JOIN Employees e2 ON e1.manager_id = e2.employee_id 5 | JOIN Employees e3 ON e2.manager_id = e3.employee_id 6 | WHERE e3.manager_id = 1 AND e1.employee_id != 1; 7 | -------------------------------------------------------------------------------- /1890. The Latest Login in 2020.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | user_id, 3 | last_stamp 4 | FROM ( 5 | SELECT 6 | user_id, 7 | MAX(time_stamp) as last_stamp 8 | FROM logins 9 | WHERE YEAR(time_stamp) = 2020 10 | GROUP BY user_id 11 | ) cte; 12 | -------------------------------------------------------------------------------- /580. Count Student Number in Departments.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | d.dept_name, 3 | COUNT(DISTINCT s.student_id) as student_number 4 | FROM department d 5 | LEFT JOIN student s ON d.dept_id = s.dept_id 6 | GROUP by d.dept_name 7 | ORDER BY student_number DESC, d.dept_name; 8 | -------------------------------------------------------------------------------- /607. Sales Person.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s.name 3 | FROM salesperson s 4 | WHERE sales_id NOT IN( 5 | SELECT 6 | o.sales_id 7 | FROM orders o 8 | JOIN company c ON c.com_id = o.com_id # LEFT JOIN will also work 9 | WHERE c.name = 'RED' 10 | ); 11 | -------------------------------------------------------------------------------- /1241. Number of Comments per Post.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | s1.sub_id AS post_id, 3 | IFNULL(COUNT(DISTINCT s2.sub_id), 0) AS number_of_comments 4 | FROM submissions s1 5 | LEFT JOIN submissions s2 ON s1.sub_id = s2.parent_id 6 | WHERE s1.parent_id IS NULL 7 | GROUP BY s1.sub_id; 8 | -------------------------------------------------------------------------------- /1965. Employees With Missing Information.sql: -------------------------------------------------------------------------------- 1 | SELECT employee_id FROM employees WHERE employee_id NOT IN (SELECT employee_id FROM salaries) 2 | UNION ALL 3 | SELECT employee_id FROM salaries WHERE employee_id NOT IN (SELECT employee_id FROM employees) 4 | ORDER BY employee_id; 5 | -------------------------------------------------------------------------------- /176. Second Highest Salary.sql: -------------------------------------------------------------------------------- 1 | WITH salary_rank AS ( 2 | SELECT 3 | salary, 4 | DENSE_RANK() OVER(ORDER BY salary DESC) AS s_rank 5 | FROM employee 6 | ) 7 | SELECT 8 | MAX(salary) AS SecondHighestSalary 9 | FROM salary_rank 10 | WHERE s_rank = 2; 11 | -------------------------------------------------------------------------------- /1327. List the Products Ordered in a Period.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p.product_name, 3 | SUM(o.unit) AS unit 4 | FROM products p 5 | LEFT JOIN orders o ON o.product_id = p.product_id 6 | WHERE o.order_date BETWEEN '2020-02-01' AND '2020-02-29' 7 | GROUP BY p.product_id 8 | HAVING SUM(o.unit) >= 100; 9 | -------------------------------------------------------------------------------- /1393. Capital Gain:Loss.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | stock_name, 3 | SUM( 4 | CASE WHEN operation = 'sell' THEN price ELSE 0 END 5 | ) - 6 | SUM( 7 | CASE WHEN operation = 'buy' THEN price ELSE 0 END 8 | ) AS capital_gain_loss 9 | FROM stocks 10 | GROUP BY stock_name; 11 | -------------------------------------------------------------------------------- /2228. Users With Two Purchases Within Seven Days.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | DISTINCT p1.user_id 3 | FROM purchases p1 4 | JOIN purchases p2 ON 5 | p1.user_id = p2.user_id AND 6 | p1.purchase_id <> p2.purchase_id 7 | WHERE ABS(DATEDIFF(p1.purchase_date, p2.purchase_date)) <= 7 8 | ORDER BY p1.user_id; 9 | -------------------------------------------------------------------------------- /612. Shortest Distance in a Plane.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | ROUND( 3 | SQRT( 4 | MIN( 5 | (POW(p1.x - p2.x, 2) + POW(p1.y - p2.y, 2) 6 | ) 7 | ) 8 | ), 2) AS shortest 9 | FROM point2d p1 JOIN point2d p2 WHERE p1.x != p2.x OR p2.y != p1.y; 10 | -------------------------------------------------------------------------------- /2230. The Users That Are Eligible for Discount.sql: -------------------------------------------------------------------------------- 1 | CREATE PROCEDURE getUserIDs(startDate DATE, endDate DATE, minAmount INT) 2 | BEGIN 3 | SELECT 4 | DISTINCT user_id 5 | FROM purchases 6 | WHERE time_stamp BETWEEN startDate AND endDate AND amount >= minAmount 7 | ORDER BY user_id; 8 | END 9 | -------------------------------------------------------------------------------- /1459. Rectangles Area.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p1.id AS p1, 3 | p2.id AS p2, 4 | ( 5 | ABS(p1.x_value - p2.x_value) * ABS(p1.y_value - p2.y_value) 6 | ) AS area 7 | FROM points p1 8 | JOIN points p2 ON p1.id != p2.id 9 | HAVING area != 0 AND p1.id < p2.id 10 | ORDER BY area DESC, p1.id, p2.id; 11 | -------------------------------------------------------------------------------- /1501. Countries You Can Safely Invest In.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | c.name as country 3 | FROM person p 4 | JOIN country c ON SUBSTRING_INDEX(p.phone_number, '-', 1) = c.country_code 5 | JOIN calls cl ON p.id IN (cl.caller_id, cl.callee_id) 6 | GROUP BY c.name 7 | HAVING AVG(cl.duration) > (SELECT AVG(duration) FROM calls); 8 | -------------------------------------------------------------------------------- /2372. Calculate the Influence of Each Salesperson.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | sp.salesperson_id, 3 | sp.name, 4 | IFNULL(SUM(price), 0) as total 5 | FROM salesperson sp 6 | LEFT JOIN customer c ON sp.salesperson_id = c.salesperson_id 7 | LEFT JOIN sales s ON s.customer_id = c.customer_id 8 | GROUP BY sp.salesperson_id; 9 | -------------------------------------------------------------------------------- /2308. Arrange Table by Gender.sql: -------------------------------------------------------------------------------- 1 | WITH gender_rank AS ( 2 | SELECT 3 | user_id, 4 | gender, 5 | RANK() OVER(PARTITION BY gender ORDER BY user_id) AS g_rank 6 | FROM genders 7 | ) 8 | 9 | SELECT 10 | user_id, 11 | gender 12 | FROM gender_rank 13 | ORDER BY g_rank, gender; 14 | -------------------------------------------------------------------------------- /1158. Market Analysis I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | u.user_id AS buyer_id, 3 | u.join_date, 4 | SUM( 5 | CASE 6 | WHEN YEAR(o.order_date) = 2019 THEN 1 ELSE 0 7 | END 8 | ) AS orders_in_2019 9 | FROM users u 10 | LEFT JOIN orders o ON u.user_id = o.buyer_id 11 | GROUP BY u.user_id; 12 | -------------------------------------------------------------------------------- /1173. Immediate Food Delivery I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | ROUND(( 3 | SUM( 4 | CASE 5 | WHEN order_date = customer_pref_delivery_date THEN 1 ELSE 0 6 | END 7 | ) 8 | / 9 | (1.0 * COUNT(*))) * 100 10 | , 2) AS immediate_percentage 11 | FROM delivery; 12 | -------------------------------------------------------------------------------- /1939. Users That Actively Request Confirmation Messages.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | DISTINCT s.user_id 3 | FROM confirmations s 4 | JOIN confirmations c ON 5 | s.user_id = c.user_id AND 6 | s.time_stamp != c.time_stamp AND 7 | s.time_stamp < c.time_stamp 8 | WHERE s.time_stamp >= DATE_SUB(c.time_stamp, INTERVAL 24 HOUR); 9 | -------------------------------------------------------------------------------- /1809. Ad-Free Sessions.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | session_id 3 | FROM playback 4 | WHERE session_id NOT IN ( 5 | SELECT 6 | p.session_id 7 | FROM playback p 8 | JOIN ads a ON 9 | p.customer_id = a.customer_id AND 10 | a.timestamp >= p.start_time AND 11 | a.timestamp <= p.end_time 12 | ); 13 | -------------------------------------------------------------------------------- /574. Winning Candidate.sql: -------------------------------------------------------------------------------- 1 | WITH vote_count AS( 2 | SELECT 3 | candidateId, 4 | DENSE_RANK() OVER(ORDER BY COUNT(id) DESC) AS c_rank 5 | FROM vote 6 | GROUP BY candidateId 7 | ) 8 | SELECT 9 | c.name 10 | FROM candidate c 11 | WHERE c.id = (SELECT candidateId from vote_count WHERE c_rank = 1); 12 | -------------------------------------------------------------------------------- /614. Second Degree Follower.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | f.follower, 3 | CASE 4 | WHEN (SELECT COUNT(*) FROM follow where followee = f.follower) > 0 THEN (SELECT COUNT(*) FROM follow where followee = f.follower) ELSE 0 5 | END AS num 6 | FROM follow f 7 | GROUP BY f.follower 8 | HAVING num > 0 9 | ORDER BY f.follower; 10 | -------------------------------------------------------------------------------- /196. Delete Duplicate Emails.sql: -------------------------------------------------------------------------------- 1 | # With sub-query 2 | DELETE p1.* 3 | FROM person p1 4 | WHERE p1.id NOT IN ( 5 | SELECT * FROM 6 | (SELECT min(id) FROM person GROUP BY email) as p 7 | ) 8 | 9 | 10 | # With join 11 | DELETE p1.* 12 | FROM person p1 13 | JOIN person p2 ON p1.email = p2.email 14 | WHERE p1.id > p2.id; 15 | -------------------------------------------------------------------------------- /1076. Project Employees II.sql: -------------------------------------------------------------------------------- 1 | WITH employee_count AS ( 2 | SELECT 3 | project_id, 4 | COUNT(employee_id) AS total_employee 5 | FROM project 6 | GROUP BY project_id 7 | ) 8 | 9 | SELECT 10 | project_id 11 | FROM employee_count 12 | WHERE total_employee = (SELECT MAX(total_employee) FROM employee_count); 13 | -------------------------------------------------------------------------------- /1731. The Number of Employees Which Report to Each Employee.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | e1.employee_id, 3 | e1.name, 4 | COUNT(e2.reports_to) as reports_count, 5 | ROUND(AVG(e2.age)) AS average_age 6 | FROM employees e1 7 | JOIN employees e2 ON e1.employee_id = e2.reports_to 8 | GROUP BY employee_id, name 9 | ORDER BY employee_id; 10 | -------------------------------------------------------------------------------- /1831. Maximum Transaction Each Day.sql: -------------------------------------------------------------------------------- 1 | WITH transaction_ranker AS( 2 | SELECT 3 | transaction_id, 4 | RANK() OVER(PARTITION BY DATE(day) ORDER BY amount DESC) AS t_rank 5 | FROM transactions 6 | ) 7 | 8 | SELECT 9 | transaction_id 10 | FROM transaction_ranker 11 | WHERE t_rank = 1 12 | ORDER BY transaction_id; 13 | -------------------------------------------------------------------------------- /1211. Queries Quality and Percentage.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | query_name, 3 | ROUND( 4 | AVG(rating / position) 5 | , 2) AS quality, 6 | ROUND( 7 | ( 8 | SUM(CASE WHEN rating < 3 THEN 1 ELSE 0 END) / COUNT(*) 9 | ) * 100.00 10 | , 2) AS poor_query_percentage 11 | FROM queries 12 | GROUP BY query_name; 13 | -------------------------------------------------------------------------------- /1204. Last Person to Fit in the Bus.sql: -------------------------------------------------------------------------------- 1 | WITH weight_calculator AS ( 2 | SELECT 3 | turn, 4 | person_name, 5 | SUM(weight) OVER(ORDER BY turn) AS total_weight 6 | FROM queue 7 | ) 8 | 9 | SELECT 10 | person_name 11 | FROM weight_calculator 12 | WHERE total_weight <= 1000 13 | ORDER BY total_weight DESC 14 | LIMIT 1; 15 | -------------------------------------------------------------------------------- /1251. Average Selling Price.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p.product_id, 3 | ROUND( 4 | SUM( 5 | p.price * u.units 6 | ) / SUM(u.units) 7 | , 2) AS average_price 8 | FROM prices p 9 | LEFT JOIN unitssold u ON p.product_id = u.product_id 10 | WHERE u.purchase_date BETWEEN p.start_date AND p.end_date 11 | GROUP BY p.product_id; 12 | -------------------------------------------------------------------------------- /1633. Percentage of Users Attended a Contest.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | r.contest_id, 3 | ROUND( 4 | ( 5 | COUNT(DISTINCT r.user_id) / 6 | (SELECT COUNT(DISTINCT user_id) FROM users) 7 | ) * 100 8 | , 2) AS percentage 9 | FROM register r 10 | GROUP BY r.contest_id 11 | ORDER BY percentage DESC, r.contest_id; 12 | -------------------------------------------------------------------------------- /1677. Product's Worth Over Invoices.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | p.name, 3 | IFNULL(SUM(rest), 0) AS rest, 4 | IFNULL(SUM(paid), 0) AS paid, 5 | IFNULL(SUM(canceled), 0) AS canceled, 6 | IFNULL(SUM(refunded), 0) AS refunded 7 | FROM product p 8 | LEFT JOIN invoice i ON p.product_id = i.product_id 9 | GROUP BY p.product_id 10 | ORDER BY p.name; 11 | -------------------------------------------------------------------------------- /1264. Page Recommendations.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | DISTINCT l.page_id AS recommended_page 3 | FROM friendship f 4 | LEFT JOIN likes l ON 5 | (f.user1_id = 1 OR f.user2_id = 1) AND 6 | (f.user2_id = l.user_id OR f.user1_id = l.user_id) 7 | WHERE 8 | l.page_id NOT IN (SELECT page_id FROM likes where user_id = 1) AND 9 | l.page_id IS NOT NULL; 10 | -------------------------------------------------------------------------------- /2205. The Number of Users That Are Eligible for Discount.sql: -------------------------------------------------------------------------------- 1 | CREATE FUNCTION getUserIDs(startDate DATE, endDate DATE, minAmount INT) RETURNS INT 2 | BEGIN 3 | RETURN ( 4 | SELECT 5 | COUNT(DISTINCT user_id) AS user_cnt 6 | FROM purchases 7 | WHERE time_stamp BETWEEN startDate AND endDate AND amount >= minAmount 8 | ); 9 | END 10 | -------------------------------------------------------------------------------- /1795. Rearrange Products Table.sql: -------------------------------------------------------------------------------- 1 | SELECT product_id, 'store1' AS store, store1 AS price FROM products where store1 IS NOT NULL 2 | UNION ALL 3 | SELECT product_id, 'store2' AS store, store2 AS price FROM products where store2 IS NOT NULL 4 | UNION ALL 5 | SELECT product_id, 'store3' AS store, store3 AS price FROM products where store3 IS NOT NULL 6 | ORDER BY product_id; 7 | -------------------------------------------------------------------------------- /1613. Find the Missing IDs.sql: -------------------------------------------------------------------------------- 1 | WITH RECURSIVE nums AS ( 2 | SELECT 1 AS value 3 | UNION ALL 4 | SELECT value + 1 AS value 5 | FROM nums 6 | WHERE nums.value < (select max(customer_id) from Customers) 7 | ) 8 | 9 | SELECT 10 | value as ids 11 | FROM nums 12 | WHERE value NOT IN (SELECT DISTINCT customer_id FROM customers) 13 | ORDER BY value; 14 | -------------------------------------------------------------------------------- /2298. Tasks Count in the Weekend.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | SUM( 3 | CASE 4 | WHEN DAYNAME(submit_date) IN ("Saturday", "Sunday") THEN 1 ELSE 0 5 | END 6 | ) AS weekend_cnt, 7 | SUM( 8 | CASE 9 | WHEN DAYNAME(submit_date) NOT IN ("Saturday", "Sunday") THEN 1 ELSE 0 10 | END 11 | ) AS working_cnt 12 | FROM tasks; 13 | -------------------------------------------------------------------------------- /585. Investments in 2016.sql: -------------------------------------------------------------------------------- 1 | WITH tiv_counter AS ( 2 | SELECT 3 | *, 4 | COUNT(*) OVER(PARTITION BY tiv_2015) AS cnt_1, 5 | COUNT(*) OVER(PARTITION BY lat, lon) AS cnt_2 6 | FROM insurance 7 | ) 8 | 9 | SELECT 10 | ROUND( 11 | SUM(tiv_2016), 2 12 | ) AS tiv_2016 13 | FROM tiv_counter 14 | WHERE cnt_1 >= 2 AND cnt_2 = 1; 15 | -------------------------------------------------------------------------------- /1112. Highest Grade For Each Student.sql: -------------------------------------------------------------------------------- 1 | WITH course_grader AS( 2 | SELECT 3 | student_id, 4 | course_id, 5 | grade, 6 | RANK() OVER(partition by student_id ORDER BY grade DESC, course_id) g_rank 7 | FROM enrollments 8 | ) 9 | 10 | SELECT 11 | student_id, 12 | course_id, 13 | grade 14 | FROM course_grader 15 | WHERE g_rank = 1; 16 | -------------------------------------------------------------------------------- /1294. Weather Type in Each Country.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | c.country_name, 3 | CASE 4 | WHEN AVG(w.weather_state) >= 25 THEN 'Hot' 5 | WHEN AVG(w.weather_state) <= 15 THEN 'Cold' 6 | ELSE 'Warm' 7 | END AS weather_type 8 | FROM weather w 9 | LEFT JOIN countries c ON c.country_id = w.country_id 10 | WHERE YEAR(w.day) = 2019 AND MONTH(w.day) = 11 11 | GROUP BY w.country_id; 12 | -------------------------------------------------------------------------------- /1777. Product's Price for Each Store.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | product_id, 3 | SUM(CASE 4 | WHEN store = 'store1' THEN price ELSE NULL 5 | END) as store1, 6 | SUM(CASE 7 | WHEN store = 'store2' THEN price ELSE NULL 8 | END) AS store2, 9 | SUM(CASE 10 | WHEN store = 'store3' THEN price ELSE NULL 11 | END) AS store3 12 | FROM products 13 | GROUP BY product_id; 14 | -------------------------------------------------------------------------------- /2199. Finding the Topic of Each Post.sql: -------------------------------------------------------------------------------- 1 | WITH kw_finder AS ( 2 | SELECT 3 | post_id, 4 | topic_id 5 | FROM posts p 6 | LEFT JOIN keywords k ON 7 | CONCAT(' ', LOWER(content), ' ') LIKE CONCAT('% ', LOWER(word), ' %') 8 | ) 9 | 10 | SELECT 11 | post_id, 12 | IFNULL(GROUP_CONCAT(DISTINCT topic_id), 'Ambiguous!') AS topic 13 | FROM kw_finder 14 | GROUP BY post_id; 15 | -------------------------------------------------------------------------------- /1355. Activity Participants.sql: -------------------------------------------------------------------------------- 1 | WITH activity_ranker AS( 2 | SELECT 3 | activity, 4 | COUNT(DISTINCT id) AS total_count 5 | FROM friends 6 | GROUP BY activity 7 | ) 8 | 9 | SELECT 10 | activity 11 | FROM activity_ranker 12 | WHERE 13 | total_count != (SELECT MAX(total_count) FROM activity_ranker) AND 14 | total_count != (SELECT MIN(total_count) FROM activity_ranker); 15 | -------------------------------------------------------------------------------- /1709. Biggest Window Between Visits.sql: -------------------------------------------------------------------------------- 1 | WITH cte AS ( 2 | SELECT 3 | user_id, 4 | ABS(DATEDIFF(LEAD(visit_date, 1, '2021-01-01') 5 | OVER(PARTITION BY user_id ORDER BY visit_date), visit_date)) as date_diff 6 | FROM UserVisits 7 | ) 8 | 9 | SELECT 10 | cte.user_id, 11 | MAX(cte.date_diff) as biggest_window 12 | FROM cte 13 | GROUP BY cte.user_id 14 | ORDER BY cte.user_id; 15 | -------------------------------------------------------------------------------- /177. Nth Highest Salary.sql: -------------------------------------------------------------------------------- 1 | CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT 2 | BEGIN 3 | RETURN ( 4 | WITH SALARY_RANKER AS ( 5 | SELECT 6 | salary, 7 | DENSE_RANK() OVER (ORDER BY salary DESC) AS s_rank 8 | FROM employee 9 | ) 10 | 11 | SELECT 12 | MAX(salary) 13 | FROM SALARY_RANKER 14 | WHERE s_rank = N 15 | ); 16 | END 17 | -------------------------------------------------------------------------------- /569. Median Employee Salary.sql: -------------------------------------------------------------------------------- 1 | WITH salary_ranker AS( 2 | SELECT 3 | id, 4 | company, 5 | salary, 6 | ROW_NUMBER() OVER(PARTITION BY company ORDER BY salary) s_rank, 7 | COUNT(*) OVER(PARTITION BY company) as total 8 | FROM employee 9 | ) 10 | 11 | SELECT 12 | s.id, 13 | s.company, 14 | s.salary 15 | FROM salary_ranker s 16 | WHERE s_rank >= total/2 AND s_rank <= total/2+1; -------------------------------------------------------------------------------- /595. Big Countries.sql: -------------------------------------------------------------------------------- 1 | # Simple Solution 2 | SELECT 3 | name, 4 | population, 5 | area 6 | FROM world 7 | WHERE area >= 3000000 OR population >= 25000000; 8 | 9 | 10 | # With UNION 11 | SELECT 12 | name, 13 | population, 14 | area 15 | FROM world 16 | WHERE area >= 3000000 17 | 18 | UNION 19 | 20 | SELECT 21 | name, 22 | population, 23 | area 24 | FROM world 25 | WHERE population >= 25000000; 26 | -------------------------------------------------------------------------------- /2314. The First Day of the Maximum Recorded Degree in Each City.sql: -------------------------------------------------------------------------------- 1 | WITH max_degree AS ( 2 | SELECT 3 | city_id, 4 | MAX(degree) AS degree 5 | FROM weather 6 | GROUP BY city_id 7 | ) 8 | 9 | SELECT 10 | m.city_id, 11 | MIN(w.day) AS day, 12 | m.degree 13 | FROM max_degree m 14 | LEFT JOIN weather w ON m.city_id = w.city_id AND m.degree = w.degree 15 | GROUP BY m.city_id, m.degree 16 | ORDER BY city_id; 17 | -------------------------------------------------------------------------------- /1077. Project Employees III.sql: -------------------------------------------------------------------------------- 1 | WITH exp_ranker AS( 2 | SELECT 3 | p.project_id, 4 | p.employee_id, 5 | RANK() OVER(PARTITION BY project_id ORDER BY experience_years DESC) AS e_rank 6 | FROM project p 7 | LEFT JOIN employee e ON e.employee_id = p.employee_id 8 | ) 9 | 10 | SELECT 11 | p.project_id, 12 | p.employee_id 13 | FROM exp_ranker p 14 | WHERE p.e_rank = 1 15 | ORDER BY p.project_id, p.employee_id; 16 | -------------------------------------------------------------------------------- /1132. Reported Posts II.sql: -------------------------------------------------------------------------------- 1 | WITH posts AS ( 2 | SELECT 3 | a.action_date, 4 | COUNT(DISTINCT r.post_id) / COUNT(DISTINCT a.post_id) * 100 AS percentage 5 | FROM actions a 6 | LEFT JOIN removals r ON a.post_id = r.post_id 7 | WHERE a.extra = 'spam' 8 | GROUP BY a.action_date 9 | ) 10 | 11 | SELECT 12 | ROUND( 13 | SUM(percentage) / COUNT(action_date), 2 14 | ) AS average_daily_percent 15 | FROM posts; 16 | -------------------------------------------------------------------------------- /1285. Find the Start and End Number of Continuous Ranges.sql: -------------------------------------------------------------------------------- 1 | WITH log_ranker AS ( 2 | SELECT 3 | log_id, 4 | RANK() OVER(ORDER BY log_id) AS l_rank, 5 | ABS(log_id - RANK() OVER(ORDER BY log_id)) AS diff 6 | FROM logs 7 | ) 8 | 9 | SELECT 10 | MIN(l1.log_id) AS start_id, 11 | MAX(l2.log_id) AS end_id 12 | FROM log_ranker l1 13 | JOIN log_ranker l2 ON l1.diff = l2.diff 14 | GROUP BY l1.diff 15 | ORDER BY start_id; 16 | -------------------------------------------------------------------------------- /184. Department Highest Salary.sql: -------------------------------------------------------------------------------- 1 | WITH salary_ranker AS( 2 | SELECT 3 | name, 4 | departmentId, 5 | salary, 6 | RANK() OVER(PARTITION BY departmentId ORDER BY salary DESC) as s_rank 7 | FROM employee 8 | ) 9 | 10 | SELECT 11 | d.name AS Department, 12 | s.name AS Employee, 13 | s.salary AS Salary 14 | FROM salary_ranker s 15 | LEFT JOIN department d ON s.departmentId = d.id 16 | WHERE s.s_rank = 1; 17 | -------------------------------------------------------------------------------- /2066. Account Balance.sql: -------------------------------------------------------------------------------- 1 | WITH adjusted_transaction AS ( 2 | SELECT 3 | account_id, 4 | day, 5 | CASE 6 | WHEN type = 'Withdraw' THEN -1 * amount 7 | ELSE amount 8 | END AS amount 9 | FROM transactions 10 | ) 11 | 12 | SELECT 13 | account_id, 14 | day, 15 | SUM(amount) OVER(PARTITION BY account_id ORDER BY day) AS balance 16 | FROM adjusted_transaction 17 | ORDER BY account_id, day; 18 | -------------------------------------------------------------------------------- /185. Department Top Three Salaries.sql: -------------------------------------------------------------------------------- 1 | WITH salary_ranker AS ( 2 | SELECT 3 | e.name AS Employee, 4 | d.name AS Department, 5 | e.salary, 6 | DENSE_RANK() OVER(PARTITION BY e.departmentId ORDER BY e.salary DESC) AS s_rank 7 | FROM employee e 8 | LEFT JOIN Department d ON e.departmentId = d.id 9 | ) 10 | 11 | SELECT 12 | Department, 13 | Employee, 14 | Salary 15 | FROM salary_ranker s 16 | WHERE s.s_rank <= 3; 17 | -------------------------------------------------------------------------------- /2142. The Number of Passengers in Each Bus I.sql: -------------------------------------------------------------------------------- 1 | WITH passenger_buses AS ( 2 | SELECT 3 | p.passenger_id, 4 | MIN(b.arrival_time) AS time_to_board 5 | FROM passengers p 6 | JOIN buses b ON p.arrival_time <= b.arrival_time 7 | GROUP BY passenger_id 8 | ) 9 | 10 | SELECT 11 | bus_id, 12 | COUNT(p.time_to_board) as passengers_cnt 13 | FROM buses b 14 | LEFT JOIN passenger_buses p ON p.time_to_board = b.arrival_time 15 | GROUP BY bus_id 16 | ORDER BY bus_id; 17 | -------------------------------------------------------------------------------- /603. Consecutive Available Seats.sql: -------------------------------------------------------------------------------- 1 | # Straight forward JOIN condition 2 | SELECT 3 | DISTINCT c.seat_id 4 | FROM cinema c 5 | JOIN cinema c1 ON (c.seat_id + 1 = c1.seat_id OR c.seat_id = c1.seat_id + 1) AND c.free = 1 AND c1.free = 1 6 | ORDER BY c.seat_id; 7 | 8 | 9 | # JOIN condition with ABS 10 | SELECT 11 | DISTINCT c1.seat_id 12 | FROM cinema c1 13 | JOIN cinema c2 ON abs(c1.seat_id - c2.seat_id) = 1 AND c1.free = 1 AND c2.free = 1 14 | ORDER BY c1.seat_id; 15 | -------------------------------------------------------------------------------- /2292. Products With Three or More Orders in Two Consecutive Years.sql: -------------------------------------------------------------------------------- 1 | WITH yearly_products_cnt AS ( 2 | SELECT 3 | product_id, 4 | YEAR(purchase_date) as `year` 5 | FROM orders 6 | GROUP BY product_id, YEAR(purchase_date) 7 | HAVING COUNT(*) >= 3 8 | ) 9 | 10 | SELECT 11 | DISTINCT y1.product_id 12 | FROM yearly_products_cnt y1 13 | JOIN yearly_products_cnt y2 ON 14 | y1.product_id = y2.product_id AND 15 | y1.year + 1 = y2.year; 16 | -------------------------------------------------------------------------------- /2020. Number of Accounts That Did Not Stream.sql: -------------------------------------------------------------------------------- 1 | WITH registered_in_2021 AS ( 2 | SELECT 3 | account_id, 4 | start_date, 5 | end_date 6 | FROM subscriptions 7 | WHERE YEAR(start_date) = 2021 8 | ) 9 | 10 | SELECT 11 | COUNT(sb.account_id) AS accounts_count 12 | FROM subscriptions sb 13 | LEFT JOIN streams st ON sb.account_id = st.account_id 14 | WHERE YEAR(start_date) <= 2021 AND 15 | YEAR(end_date)>=2021 AND 16 | YEAR(stream_date) != 2021; 17 | -------------------------------------------------------------------------------- /2388. Change Null Values in a Table to the Previous Value.sql: -------------------------------------------------------------------------------- 1 | WITH row_numbering AS ( 2 | SELECT 3 | id, 4 | drink, 5 | ROW_NUMBER() OVER() AS row_num 6 | FROM CoffeeShop 7 | ) 8 | , block AS ( 9 | SELECT *, 10 | SUM( 11 | CASE WHEN drink is NULL THEN 0 ELSE 1 12 | END) OVER(ORDER BY row_num) AS block 13 | FROM row_numbering 14 | ) 15 | 16 | SELECT 17 | id, 18 | first_value(drink) OVER(PARTITION BY block) AS drink 19 | FROM block; 20 | -------------------------------------------------------------------------------- /1193. Monthly Transactions I.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | LEFT(trans_date, 7) AS month, 3 | country, 4 | COUNT(*) AS trans_count, 5 | SUM( 6 | CASE 7 | WHEN state = 'approved' THEN 1 ELSE 0 8 | END 9 | ) AS approved_count, 10 | SUM(amount) AS trans_total_amount, 11 | SUM( 12 | CASE 13 | WHEN state = 'approved' THEN amount ELSE 0 14 | END 15 | ) AS approved_total_amount 16 | FROM transactions 17 | GROUP BY LEFT(trans_date, 7), country; 18 | -------------------------------------------------------------------------------- /1321. Restaurant Growth.sql: -------------------------------------------------------------------------------- 1 | WITH daily_sum AS ( 2 | SELECT 3 | visited_on, 4 | SUM(amount) AS total_amount 5 | FROM customer 6 | GROUP BY visited_on 7 | ) 8 | SELECT 9 | d.visited_on, 10 | SUM(d1.total_amount) AS amount, 11 | ROUND(SUM(d1.total_amount) / 7.0, 2) AS average_amount 12 | FROM daily_sum d 13 | JOIN daily_sum d1 14 | WHERE DATEDIFF(d.visited_on, d1.visited_on) BETWEEN 0 AND 6 15 | GROUP BY d.visited_on 16 | HAVING COUNT(d1.visited_on) = 7 17 | ORDER BY d.visited_on; 18 | -------------------------------------------------------------------------------- /597. Friend Requests I- Overall Acceptance Rate.sql: -------------------------------------------------------------------------------- 1 | WITH distinct_accepted AS ( 2 | SELECT 3 | DISTINCT requester_id, 4 | accepter_id 5 | FROM RequestAccepted 6 | ), 7 | distinct_requests AS ( 8 | SELECT 9 | DISTINCT sender_id, 10 | send_to_id 11 | FROM FriendRequest 12 | ) 13 | SELECT 14 | IFNULL( 15 | ROUND( 16 | (SELECT COUNT(*) FROM distinct_accepted) / (SELECT COUNT(*) FROM distinct_requests) 17 | , 2) 18 | , 0.00) AS accept_rate; 19 | -------------------------------------------------------------------------------- /2112. The Airport With the Most Traffic.sql: -------------------------------------------------------------------------------- 1 | WITH flight_count AS ( 2 | SELECT departure_airport AS airport_id, flights_count FROM flights 3 | UNION ALL 4 | SELECT arrival_airport AS airport_id, flights_count FROM flights 5 | ) 6 | , total_flights AS ( 7 | SELECT 8 | airport_id, 9 | SUM(flights_count) AS total 10 | FROM flight_count 11 | GROUP BY airport_id 12 | ) 13 | 14 | SELECT 15 | airport_id 16 | FROM total_flights 17 | WHERE total = (SELECT MAX(total) FROM total_flights); 18 | -------------------------------------------------------------------------------- /2324. Product Sales Analysis IV.sql: -------------------------------------------------------------------------------- 1 | WITH product_ranker AS ( 2 | SELECT 3 | s.user_id, 4 | s.product_id, 5 | SUM(s.quantity * p.price), 6 | RANK() OVER(PARTITION BY s.user_id ORDER BY SUM(s.quantity * p.price) DESC) AS p_rank 7 | FROM sales s 8 | LEFT JOIN product p ON s.product_id = p.product_id 9 | GROUP BY s.product_id, s.user_id 10 | ) 11 | 12 | SELECT 13 | user_id, 14 | product_id 15 | FROM product_ranker 16 | WHERE p_rank = 1 17 | ORDER BY user_id, product_id; 18 | -------------------------------------------------------------------------------- /618. Students Report By Geography.sql: -------------------------------------------------------------------------------- 1 | WITH continent_ranker AS( 2 | SELECT 3 | name, 4 | continent, 5 | ROW_NUMBER() OVER(PARTITION BY continent ORDER BY name) as c_rank 6 | FROM student 7 | ) 8 | 9 | SELECT 10 | MAX(CASE WHEN continent = 'America' THEN name ELSE NULL END) as America, 11 | MAX(CASE WHEN continent = 'Asia' THEN name ELSE NULL END) as Asia, 12 | MAX(CASE WHEN continent = 'Europe' THEN name ELSE NULL END) as Europe 13 | FROM continent_ranker 14 | GROUP BY c_rank; 15 | -------------------------------------------------------------------------------- /570. Managers with at Least 5 Direct Reports.sql: -------------------------------------------------------------------------------- 1 | # Solution 1 2 | SELECT 3 | m.name 4 | FROM employee e 5 | JOIN employee m ON m.id = e.managerId 6 | GROUP by m.name 7 | HAVING count(distinct e.id) >= 5; 8 | 9 | 10 | # Solution 2 11 | WITH manager_stat AS ( 12 | SELECT 13 | managerId 14 | FROM employee 15 | GROUP BY managerId 16 | HAVING COUNT(id) >= 5 17 | ) 18 | 19 | SELECT 20 | e.name 21 | FROM manager_stat m 22 | LEFT JOIN employee e ON m.managerId = e.id 23 | WHERE e.name IS NOT null; 24 | -------------------------------------------------------------------------------- /578. Get Highest Answer Rate Question.sql: -------------------------------------------------------------------------------- 1 | WITH answer_rate_calc AS ( 2 | SELECT 3 | question_id, 4 | SUM( 5 | CASE WHEN action = 'answer' THEN 1 ELSE 0 END 6 | ) 7 | / (1.0 * 8 | SUM( 9 | CASE WHEN action = 'show' THEN 1 ELSE 0 END 10 | ) 11 | ) as ans_rate 12 | FROM SurveyLog 13 | GROUP BY question_id 14 | ) 15 | 16 | SELECT 17 | question_id AS survey_log 18 | FROM answer_rate_calc 19 | ORDER BY ans_rate DESC LIMIT 1; 20 | -------------------------------------------------------------------------------- /1149. Article Views II.sql: -------------------------------------------------------------------------------- 1 | # One query, concise 2 | SELECT 3 | DISTINCT viewer_id AS id 4 | FROM Views 5 | GROUP BY viewer_id, view_date 6 | HAVING COUNT(DISTINCT article_id) > 1 7 | ORDER BY 1; 8 | 9 | 10 | # With CTE, easier to read and understand 11 | WITH view_count AS ( 12 | SELECT 13 | viewer_id, 14 | view_date, 15 | COUNT(DISTINCT article_id) AS total_view 16 | FROM views 17 | GROUP BY viewer_id, view_date 18 | ) 19 | SELECT 20 | DISTINCT viewer_id AS id 21 | FROM view_count 22 | WHERE total_view > 1; 23 | -------------------------------------------------------------------------------- /1783. Grand Slam Titles.sql: -------------------------------------------------------------------------------- 1 | WITH champions AS ( 2 | SELECT Wimbledon AS player_id FROM Championships 3 | UNION ALL 4 | SELECT Fr_open AS player_id FROM Championships 5 | UNION ALL 6 | SELECT US_open AS player_id FROM Championships 7 | UNION ALL 8 | SELECT Au_open AS player_id FROM Championships 9 | ) 10 | 11 | SELECT 12 | c.player_id, 13 | p.player_name, 14 | COUNT(*) AS grand_slams_count 15 | FROM champions c 16 | LEFT JOIN players p ON c.player_id = p.player_id 17 | GROUP BY c.player_id, p.player_name; 18 | -------------------------------------------------------------------------------- /2346. Compute the Rank as a Percentage.sql: -------------------------------------------------------------------------------- 1 | WITH student_ranker AS( 2 | SELECT 3 | student_id, 4 | department_id, 5 | RANK() OVER(PARTITION BY department_id ORDER BY mark DESC) AS s_rank, 6 | COUNT(student_id) OVER(PARTITION BY department_id) AS total_students 7 | FROM students 8 | ) 9 | 10 | SELECT 11 | student_id, 12 | department_id, 13 | ROUND( 14 | IFNULL( 15 | (s_rank - 1) * 100 / (total_students -1) 16 | , 0) 17 | , 2) AS percentage 18 | FROM student_ranker; 19 | -------------------------------------------------------------------------------- /586. Customer Placing the Largest Number of Orders.sql: -------------------------------------------------------------------------------- 1 | # Without CTE 2 | SELECT 3 | customer_number 4 | FROM orders 5 | GROUP BY customer_number 6 | ORDER BY COUNT(order_number) DESC 7 | LIMIT 1; 8 | 9 | 10 | # With CTE 11 | WITH order_counts AS ( 12 | SELECT 13 | customer_number, 14 | COUNT(order_number) AS order_count 15 | FROM orders 16 | GROUP BY customer_number 17 | ) 18 | 19 | SELECT 20 | customer_number 21 | FROM order_counts 22 | WHERE order_count = (SELECT MAX(order_count) FROM order_counts); 23 | -------------------------------------------------------------------------------- /2082. The Number of Rich Customers.sql: -------------------------------------------------------------------------------- 1 | # Solution 1 2 | WITH rich_counter AS ( 3 | SELECT 4 | customer_id, 5 | SUM( 6 | CASE 7 | WHEN amount > 500 THEN 1 ELSE 0 8 | END 9 | ) AS total_purchase 10 | FROM store 11 | GROUP BY customer_id 12 | ) 13 | 14 | SELECT 15 | COUNT(customer_id) AS rich_count 16 | FROM rich_counter 17 | WHERE total_purchase > 0; 18 | 19 | 20 | # Solution 2 21 | SELECT 22 | COUNT(DISTINCT customer_id) AS rich_count 23 | FROM store 24 | WHERE amount > 500; 25 | -------------------------------------------------------------------------------- /512. Game Play Analysis II.sql: -------------------------------------------------------------------------------- 1 | # With sub-qeury and MIN 2 | SELECT 3 | a.player_id, 4 | a.device_id 5 | FROM activity a 6 | WHERE a.event_date = ( 7 | SELECT 8 | MIN(event_date) 9 | FROM activity 10 | WHERE player_id = a.player_id 11 | ); 12 | 13 | 14 | # With sub-query and RANK 15 | SELECT player_id, device_id FROM ( 16 | SELECT 17 | player_id, 18 | device_id, 19 | RANK() OVER (PARTITION BY player_id ORDER BY event_date) as login_rank 20 | FROM Activity 21 | ) rank_table 22 | WHERE rank_table.login_rank = 1; 23 | -------------------------------------------------------------------------------- /626. Exchange Seats.sql: -------------------------------------------------------------------------------- 1 | # Logic 1 2 | SELECT 3 | CASE 4 | WHEN id % 2 != 0 AND id != (SELECT COUNT(*) FROM seat) THEN id + 1 5 | WHEN id % 2 != 0 AND id = (SELECT COUNT(*) FROM seat) THEN id 6 | ELSE id - 1 7 | END AS id, 8 | student 9 | FROM seat 10 | ORDER BY id; 11 | 12 | 13 | # Logic 2 14 | SELECT 15 | CASE 16 | WHEN id = (SELECT COUNT(*) FROM seat) AND (SELECT COUNT(*) FROM seat) % 2 = 1 THEN id 17 | WHEN id % 2 = 0 THEN id - 1 18 | WHEN id % 2 != 0 THEN id + 1 19 | END AS id, 20 | student 21 | FROM seat 22 | ORDER BY id; 23 | -------------------------------------------------------------------------------- /1555. Bank Account Summary.sql: -------------------------------------------------------------------------------- 1 | WITH transaction_unpivot AS ( 2 | SELECT paid_by AS user_id, -1 * amount AS amount FROM transactions 3 | UNION ALL 4 | SELECT paid_to AS user_id, amount FROM transactions 5 | ) 6 | 7 | SELECT 8 | u.user_id, 9 | u.user_name, 10 | u.credit + IFNULL(SUM(tu.amount), 0) AS credit, 11 | CASE 12 | WHEN u.credit + IFNULL(SUM(tu.amount), 0) > 0 THEN 'No' 13 | ELSE 'Yes' 14 | END AS credit_limit_breached 15 | FROM users u 16 | LEFT JOIN transaction_unpivot tu ON u.user_id = tu.user_id 17 | GROUP BY u.user_id; 18 | -------------------------------------------------------------------------------- /2362. Generate the Invoice.sql: -------------------------------------------------------------------------------- 1 | WITH product_ranker AS( 2 | SELECT 3 | pc.invoice_id, 4 | SUM(pc.quantity * p.price) AS price 5 | FROM purchases pc 6 | LEFT JOIN products p ON pc.product_id = p.product_id 7 | GROUP BY pc.invoice_id 8 | ORDER BY price DESC, pc.invoice_id ASC 9 | LIMIT 1 10 | ) 11 | 12 | SELECT 13 | p.product_id, 14 | p.quantity, 15 | p.quantity * pp.price AS price 16 | FROM purchases p 17 | LEFT JOIN products pp ON p.product_id = pp.product_id 18 | RIGHT JOIN product_ranker pr ON p.invoice_id = pr.invoice_id; 19 | -------------------------------------------------------------------------------- /1549. The Most Recent Orders for Each Product.sql: -------------------------------------------------------------------------------- 1 | WITH product_ranker AS ( 2 | SELECT 3 | product_id, 4 | order_id, 5 | order_date, 6 | DENSE_RANK() OVER(PARTITION BY product_id ORDER BY order_date DESC) AS p_rank 7 | FROM orders 8 | GROUP BY product_id, order_id 9 | ) 10 | SELECT 11 | p.product_name, 12 | pr.product_id, 13 | pr.order_id, 14 | pr.order_date 15 | FROM product_ranker pr 16 | LEFT JOIN products p ON pr.product_id = p.product_id 17 | WHERE pr.p_rank = 1 18 | ORDER BY p.product_name, pr.product_id, pr.order_id; 19 | -------------------------------------------------------------------------------- /1934. Confirmation Rate.sql: -------------------------------------------------------------------------------- 1 | WITH conf_detail AS ( 2 | SELECT 3 | s.user_id, 4 | SUM( 5 | CASE WHEN c.action = 'confirmed' THEN 1 ELSE 0 END 6 | ) AS total_confirmed, 7 | COUNT(*) AS total_actions 8 | FROM signups s 9 | LEFT JOIN confirmations c ON s.user_id = c.user_id 10 | GROUP BY s.user_id 11 | ) 12 | 13 | SELECT 14 | user_id, 15 | CASE 16 | WHEN total_actions = 0 THEN 0 17 | ELSE ROUND((1.0 * total_confirmed)/(1.0 * total_actions), 2) 18 | END as confirmation_rate 19 | FROM conf_detail; 20 | -------------------------------------------------------------------------------- /1194. Tournament Winners.sql: -------------------------------------------------------------------------------- 1 | WITH cte_1 AS ( 2 | SELECT 3 | first_player as player, 4 | first_score as score 5 | FROM matches 6 | UNION ALL 7 | SELECT 8 | second_player as player, 9 | second_score as score 10 | FROM matches 11 | ), 12 | cte_2 AS ( 13 | SELECT 14 | player, 15 | SUM(score) as total_score 16 | FROM cte_1 17 | GROUP BY player 18 | ) 19 | 20 | SELECT 21 | DISTINCT p.group_id, 22 | FIRST_VALUE(cte_2.player) OVER(PARTITION BY p.group_id ORDER BY cte_2.total_score DESC) as player_id 23 | FROM cte_2 24 | LEFT JOIN players p ON p.player_id = cte_2.player; 25 | -------------------------------------------------------------------------------- /2238. Number of Times a Driver Was a Passenger.sql: -------------------------------------------------------------------------------- 1 | # With CTE for distinct driver 2 | WITH drivers AS ( 3 | SELECT 4 | DISTINCT driver_id 5 | FROM rides 6 | ) 7 | 8 | SELECT 9 | r1.driver_id, 10 | COUNT(r2.passenger_id) AS cnt 11 | FROM drivers r1 12 | LEFT JOIN rides r2 ON r1.driver_id = r2.passenger_id 13 | GROUP BY r1.driver_id; 14 | 15 | 16 | # Single query solution without CTE 17 | SELECT 18 | r1.driver_id, 19 | COUNT(DISTINCT r2.ride_id) AS cnt 20 | FROM rides r1 21 | LEFT JOIN rides r2 ON r1.driver_id = r2.passenger_id 22 | GROUP BY r1.driver_id; 23 | -------------------------------------------------------------------------------- /1661. Average Time of Process per Machine.sql: -------------------------------------------------------------------------------- 1 | WITH machine_activity AS( 2 | SELECT 3 | machine_id, 4 | SUM(CASE 5 | WHEN activity_type = 'end' THEN timestamp ELSE 0.0 6 | END) AS end_times, 7 | SUM(CASE 8 | WHEN activity_type = 'start' THEN timestamp ELSE 0.0 9 | END) AS start_times, 10 | COUNT(*) / 2 AS total_count 11 | FROM activity 12 | GROUP BY machine_id 13 | ) 14 | 15 | SELECT 16 | machine_id, 17 | ROUND((end_times - start_times) / (1.0 * total_count), 3) AS processing_time 18 | FROM machine_activity; 19 | -------------------------------------------------------------------------------- /180. Consecutive Numbers.sql: -------------------------------------------------------------------------------- 1 | # Without LEAD/LAG, two joins 2 | SELECT 3 | DISTINCT c.num AS ConsecutiveNums 4 | FROM Logs AS c 5 | JOIN Logs AS c1 ON c.num = c1.num AND c.id + 1 = c1.id 6 | JOIN Logs AS c2 ON c1.num = c2.num AND c1.id + 1 = c2.id 7 | 8 | 9 | # With LEAD/LAG, no joins 10 | WITH cons_calc AS ( 11 | SELECT 12 | id, 13 | num, 14 | LAG(num, 1) OVER() AS prev_num, 15 | LEAD(num, 1) OVER() AS next_num 16 | FROM logs 17 | ) 18 | SELECT 19 | DISTINCT c.num AS ConsecutiveNums 20 | FROM cons_calc AS c 21 | WHERE num = prev_num AND num = next_num; 22 | -------------------------------------------------------------------------------- /1082. Sales Analysis I.sql: -------------------------------------------------------------------------------- 1 | # With sub-query 2 | SELECT 3 | seller_id 4 | FROM ( 5 | SELECT 6 | seller_id, 7 | RANK() OVER(ORDER BY SUM(price) DESC) as s_rank 8 | FROM sales 9 | GROUP BY seller_id 10 | ) cte 11 | WHERE cte.s_rank = 1; 12 | 13 | 14 | # With CTE 15 | WITH seller_with_price AS ( 16 | SELECT 17 | seller_id, 18 | SUM(price) AS total_price 19 | FROM sales 20 | GROUP BY seller_id 21 | ) 22 | 23 | SELECT 24 | seller_id 25 | FROM seller_with_price 26 | WHERE total_price = ( 27 | SELECT MAX(total_price) FROM seller_with_price 28 | ); 29 | -------------------------------------------------------------------------------- /1543. Fix Product Name Format.sql: -------------------------------------------------------------------------------- 1 | # Consice, without CTE 2 | SELECT 3 | trim(lower(product_name)) product_name, 4 | DATE_FORMAT(sale_date, '%Y-%m') sale_date, 5 | COUNT(sale_id) AS total 6 | FROM sales 7 | GROUP BY 1, 2 8 | ORDER BY 1, 2; 9 | 10 | 11 | # With CTE 12 | WITH correcter AS ( 13 | SELECT 14 | trim(lower(product_name)) product_name, 15 | DATE_FORMAT(sale_date, '%Y-%m') sale_date 16 | FROM sales 17 | ) 18 | 19 | SELECT 20 | product_name, 21 | sale_date, 22 | COUNT(*) AS total 23 | FROM correcter 24 | GROUP BY product_name, sale_date 25 | ORDER BY product_name, sale_date; 26 | -------------------------------------------------------------------------------- /613. Shortest Distance in a Line.sql: -------------------------------------------------------------------------------- 1 | # Straight forward JOIN 2 | SELECT 3 | MIN(ABS(p1.x - p2.x)) AS shortest 4 | FROM point p1 JOIN point p2 ON p1.x != p2.x; 5 | 6 | 7 | # With CTE 8 | WITH distance AS ( 9 | SELECT 10 | ABS(a.x - b.x) AS distance 11 | FROM point a 12 | JOIN point b ON a.x != b.x 13 | ) 14 | 15 | SELECT 16 | MIN(distance) AS shortest 17 | FROM distance; 18 | 19 | 20 | # Same logic of second query with sub-squery 21 | SELECT 22 | MIN(diff) AS shortest 23 | FROM ( 24 | SELECT 25 | ABS(p1.x - p2.x) AS diff 26 | FROM point p1 JOIN point p2 ON p1.x != p2.x 27 | 28 | ) cte; 29 | -------------------------------------------------------------------------------- /1098. Unpopular Books.sql: -------------------------------------------------------------------------------- 1 | WITH books_with_orders AS ( 2 | SELECT 3 | b.book_id, 4 | b.name, 5 | SUM( 6 | CASE 7 | WHEN o.dispatch_date BETWEEN '2018-06-23' AND '2019-06-23' THEN o.quantity 8 | ELSE 0 9 | END 10 | ) AS total_sold 11 | FROM books b 12 | LEFT JOIN orders o ON b.book_id = o.book_id 13 | GROUP BY b.book_id 14 | ) 15 | 16 | SELECT 17 | cte.book_id, 18 | cte.name 19 | FROM books_with_orders cte 20 | LEFT JOIN books b ON b.book_id = cte.book_id 21 | WHERE ABS(DATEDIFF(b.available_from, '2019-06-23')) > 30 AND total_sold < 10; 22 | -------------------------------------------------------------------------------- /1174. Immediate Food Delivery II.sql: -------------------------------------------------------------------------------- 1 | WITH delivery_ranker AS ( 2 | SELECT 3 | customer_id, 4 | CASE 5 | WHEN order_date = customer_pref_delivery_date THEN 'immediate' 6 | ELSE 'scheduled' 7 | END as order_type, 8 | RANK() OVER(PARTITION BY customer_id ORDER BY order_date) as d_rank 9 | FROM delivery 10 | ) 11 | 12 | SELECT 13 | ROUND( 14 | SUM(CASE WHEN order_type = 'immediate' AND d_rank = 1 THEN 1 ELSE 0 END) 15 | / 16 | (1.0 * (SELECT COUNT(*) FROM delivery_ranker WHERE d_rank = 1)) * 100 17 | , 2) AS immediate_percentage 18 | FROM delivery_ranker; 19 | -------------------------------------------------------------------------------- /1440. Evaluate Boolean Expression.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | left_operand, 3 | operator, 4 | right_operand, 5 | CASE 6 | WHEN operator = '>' AND v1.value > v2.value THEN 'true' 7 | WHEN operator = '>' AND v1.value < v2.value THEN 'false' 8 | WHEN operator = '<' AND v1.value < v2.value THEN 'true' 9 | WHEN operator = '<' AND v1.value > v2.value THEN 'false' 10 | WHEN operator = '=' AND v1.value = v2.value THEN 'true' 11 | ELSE 'false' 12 | END AS value 13 | FROM expressions e 14 | LEFT JOIN variables v1 ON v1.name = e.left_operand # x 15 | LEFT JOIN variables v2 ON v2.name = e.right_operand; # y 16 | -------------------------------------------------------------------------------- /1303. Find the Team Size.sql: -------------------------------------------------------------------------------- 1 | # A very good example of how WINDOW functions can 2 | # be useful and significantly reduce code size as 3 | # well as the code complexity 4 | 5 | 6 | # With sub-query, no WINDOW function 7 | SELECT 8 | e2.employee_id, 9 | e1.team_size 10 | FROM ( 11 | SELECT 12 | team_id, 13 | COUNT(DISTINCT employee_id) AS team_size 14 | FROM employee 15 | GROUP BY team_id 16 | ) e1 17 | JOIN employee e2 ON e1.team_id = e2.team_id; 18 | 19 | 20 | # With WINDOW function, without any sub-query 21 | SELECT 22 | employee_id, 23 | COUNT(*) OVER(PARTITION BY team_id) as team_size 24 | FROM employee; 25 | -------------------------------------------------------------------------------- /1445. Apples & Oranges.sql: -------------------------------------------------------------------------------- 1 | # Solution with seperate sum and then subtract 2 | SELECT 3 | sale_date, 4 | SUM( 5 | CASE WHEN fruit = 'apples' THEN sold_num ELSE 0 END 6 | ) - 7 | SUM( 8 | CASE WHEN fruit = 'oranges' THEN sold_num ELSE 0 END 9 | ) AS diff 10 | FROM sales 11 | GROUP BY sale_date; 12 | 13 | 14 | # Same logic with single CASE and SUM 15 | SELECT 16 | sale_date, 17 | SUM( 18 | CASE 19 | WHEN fruit = 'apples' THEN sold_num 20 | WHEN fruit = 'oranges' THEN -sold_num 21 | ELSE 0 22 | END 23 | ) AS diff 24 | FROM sales 25 | GROUP BY sale_date; 26 | -------------------------------------------------------------------------------- /1159. Market Analysis II.sql: -------------------------------------------------------------------------------- 1 | WITH order_rank AS( 2 | SELECT 3 | seller_id, 4 | item_id, 5 | RANK() OVER(PARTITION BY seller_id ORDER BY order_date) as s_rank 6 | FROM orders 7 | ), 8 | fav_calculator AS( 9 | SELECT 10 | o.seller_id, 11 | i.item_brand 12 | FROM order_rank o 13 | INNER JOIN items i ON o.item_id = i.item_id 14 | WHERE o.s_rank = 2 15 | ) 16 | 17 | SELECT 18 | u.user_id AS seller_id, 19 | CASE 20 | WHEN u.favorite_brand = f.item_brand THEN 'yes' 21 | ELSE 'no' 22 | END AS 2nd_item_fav_brand 23 | FROM users u 24 | LEFT JOIN fav_calculator f ON u.user_id = f.seller_id; 25 | -------------------------------------------------------------------------------- /1951. All the Pairs With the Maximum Number of Common Followers.sql: -------------------------------------------------------------------------------- 1 | WITH common_finder AS ( 2 | SELECT 3 | f1.user_id AS user1_id, 4 | f2.user_id AS user2_id, 5 | COUNT(f1.follower_id) AS total_common 6 | FROM relations f1 7 | LEFT JOIN relations f2 ON 8 | f1.user_id <> f2.user_id AND 9 | f1.user_id < f2.user_id AND 10 | f1.follower_id = f2.follower_id 11 | GROUP BY f1.user_id, f2.user_id 12 | ) 13 | 14 | SELECT 15 | user1_id, 16 | user2_id 17 | FROM common_finder 18 | WHERE user2_id IS NOT NULL AND 19 | total_common = (SELECT MAX(total_common) FROM common_finder WHERE user2_id IS NOT NULL); 20 | -------------------------------------------------------------------------------- /2010. The Number of Seniors and Juniors to Join the Company II.sql: -------------------------------------------------------------------------------- 1 | WITH salary_ranker AS ( 2 | SELECT 3 | *, 4 | SUM(salary) OVER(PARTITION BY experience ORDER BY salary) AS budget 5 | FROM candidates 6 | ) 7 | , seniors AS( 8 | SELECT 9 | employee_id, 10 | budget 11 | FROM salary_ranker where experience="senior"and budget <= 70000 12 | ) 13 | , juniors AS( 14 | SELECT 15 | employee_id, 16 | budget 17 | FROM salary_ranker 18 | WHERE budget <= 70000 - (SELECT IFNULL(MAX(budget), 0) FROM seniors) 19 | ) 20 | 21 | SELECT employee_id FROM seniors 22 | UNION 23 | SELECT employee_id FROM juniors; 24 | -------------------------------------------------------------------------------- /1205. Monthly Transactions II.sql: -------------------------------------------------------------------------------- 1 | WITH cte AS( 2 | SELECT * FROM transactions WHERE state = 'approved' 3 | UNION ALL 4 | SELECT trans_id as id, t.country, 'backs' AS state, t.amount, c.trans_date 5 | FROM chargebacks c LEFT JOIN transactions t ON t.id = c.trans_id 6 | ) 7 | 8 | SELECT 9 | LEFT(trans_date, 7) AS month, 10 | country, 11 | SUM(state = 'approved') AS approved_count, 12 | SUM(CASE WHEN state = 'approved' THEN amount ELSE 0 END) AS approved_amount, 13 | SUM(state = 'backs') AS chargeback_count, 14 | SUM(CASE WHEN state = 'backs' THEN amount ELSE 0 END) AS chargeback_amount 15 | FROM cte 16 | GROUP BY LEFT(trans_date, 7), country; 17 | -------------------------------------------------------------------------------- /1097. Game Play Analysis V.sql: -------------------------------------------------------------------------------- 1 | WITH install_dates AS( 2 | SELECT 3 | player_id, 4 | event_date, 5 | RANK() OVER(PARTITION BY player_id ORDER BY event_date) as date_rank, 6 | LEAD(event_date) OVER(PARTITION BY player_id ORDER BY event_date) as next_date 7 | FROM activity 8 | ) 9 | 10 | SELECT 11 | event_date AS install_dt, 12 | COUNT(DISTINCT player_id) as installs, 13 | ROUND( 14 | SUM( 15 | CASE WHEN ABS(DATEDIFF(event_date, next_date)) = 1 THEN 1 ELSE 0 END 16 | ) / 17 | (1.0 * COUNT(DISTINCT player_id)) 18 | , 2) AS Day1_retention 19 | FROM install_dates 20 | WHERE date_rank = 1 21 | GROUP BY event_date; 22 | -------------------------------------------------------------------------------- /2175. The Change in Global Rankings.sql: -------------------------------------------------------------------------------- 1 | WITH global_ranks AS ( 2 | SELECT 3 | team_id, 4 | name, 5 | points, 6 | DENSE_RANK() OVER(ORDER BY points DESC, name) AS g_rank 7 | FROM teampoints 8 | ) 9 | , changed_ranks AS ( 10 | SELECT 11 | t.team_id, 12 | t.name, 13 | t.g_rank, 14 | DENSE_RANK() OVER(ORDER BY (t.points + p.points_change) DESC, t.name) AS c_rank 15 | FROM global_ranks t 16 | LEFT JOIN pointschange p ON t.team_id = p.team_id 17 | ) 18 | 19 | SELECT 20 | team_id, 21 | name, 22 | CAST(g_rank AS DECIMAL) - CAST(c_rank AS DECIMAL) AS rank_diff 23 | FROM changed_ranks 24 | ORDER BY c_rank, name; 25 | -------------------------------------------------------------------------------- /1495. Friendly Movies Streamed Last Month.sql: -------------------------------------------------------------------------------- 1 | # With GROUP BY, no distinct 2 | SELECT 3 | c.title 4 | FROM TVProgram t 5 | LEFT JOIN content c ON t.content_id = c.content_id 6 | WHERE 7 | c.Kids_content = 'Y' AND 8 | c.content_type = 'Movies' AND 9 | MONTH(t.program_date) = 6 AND YEAR(t.program_date) = 2020 10 | GROUP BY c.title 11 | ORDER BY c.title; 12 | 13 | 14 | # Without GROUP BY and distinct 15 | SELECT 16 | DISTINCT c.title 17 | FROM TVProgram t 18 | LEFT JOIN content c ON t.content_id = c.content_id 19 | WHERE 20 | c.Kids_content = 'Y' AND 21 | c.content_type = 'Movies' AND 22 | MONTH(t.program_date) = 6 AND YEAR(t.program_date) = 2020 23 | ORDER BY c.title; 24 | -------------------------------------------------------------------------------- /1581. Customer Who Visited but Did Not Make Any Transactions.sql: -------------------------------------------------------------------------------- 1 | # Concise solution with one query 2 | SELECT 3 | v.customer_id, 4 | COUNT(v.visit_id) as count_no_trans 5 | FROM visits v 6 | WHERE v.visit_id NOT IN (SELECT visit_id from transactions) 7 | GROUP BY v.customer_id; 8 | 9 | 10 | # Elaborate query with CTE, easier to understand 11 | WITH visit_wo_transaction AS ( 12 | SELECT 13 | visit_id, 14 | customer_id 15 | FROM visits 16 | WHERE visit_id NOT IN ( 17 | SELECT DISTINCT visit_id FROM transactions 18 | ) 19 | ) 20 | 21 | SELECT 22 | customer_id, 23 | COUNT(visit_id) AS count_no_trans 24 | FROM visit_wo_transaction 25 | GROUP BY customer_id; 26 | -------------------------------------------------------------------------------- /1843. Suspicious Bank Accounts.sql: -------------------------------------------------------------------------------- 1 | WITH monthly_dist AS ( 2 | SELECT 3 | account_id, 4 | transaction_id, 5 | MONTH(day) as month, 6 | SUM( 7 | CASE 8 | WHEN type = 'Creditor' THEN amount ELSE 0 9 | END 10 | ) AS total_income 11 | FROM transactions 12 | GROUP BY account_id, MONTH(day) 13 | ) 14 | 15 | SELECT 16 | DISTINCT md1.account_id 17 | FROM monthly_dist md1 18 | JOIN monthly_dist md2 ON md1.account_id = md2.account_id AND ABS(md1.month - md2.month) = 1 19 | LEFT JOIN accounts a ON md1.account_id = a.account_id 20 | WHERE md1.total_income > a.max_income AND md2.total_income > a.max_income 21 | ORDER BY md1.transaction_id; 22 | -------------------------------------------------------------------------------- /1398. Customers Who Bought Products A and B but Not C.sql: -------------------------------------------------------------------------------- 1 | WITH buying_condition AS ( 2 | SELECT 3 | customer_id, 4 | SUM( 5 | CASE WHEN product_name = 'A' THEN 1 ELSE 0 END 6 | ) AS a_sum, 7 | SUM( 8 | CASE WHEN product_name = 'B' THEN 1 ELSE 0 END 9 | ) AS b_sum, 10 | SUM( 11 | CASE WHEN product_name = 'C' THEN 1 ELSE 0 END 12 | ) AS c_sum 13 | FROM orders 14 | GROUP BY customer_id 15 | ) 16 | SELECT 17 | bc.customer_id, 18 | c.customer_name 19 | FROM buying_condition bc 20 | LEFT JOIN customers c ON bc.customer_id = c.customer_id 21 | WHERE bc.a_sum > 0 AND bc.b_sum > 0 AND bc.c_sum = 0 22 | ORDER BY bc.customer_id; 23 | -------------------------------------------------------------------------------- /1341. Movie Rating.sql: -------------------------------------------------------------------------------- 1 | WITH user_q AS ( 2 | SELECT 3 | u.name, 4 | COUNT(u.user_id) AS total_review 5 | FROM MovieRating mr 6 | LEFT JOIN users u ON u.user_id = mr.user_id 7 | GROUP BY mr.user_id 8 | ORDER BY total_review DESC, u.name 9 | LIMIT 1 10 | ), 11 | movie_q AS ( 12 | SELECT 13 | m.title, 14 | AVG(mr.rating) AS avg_rating 15 | FROM MovieRating mr 16 | LEFT JOIN movies m ON m.movie_id = mr.movie_id 17 | WHERE mr.created_at BETWEEN '2020-02-01' AND '2020-02-29' 18 | GROUP BY mr.movie_id 19 | ORDER BY avg_rating DESC, m.title 20 | LIMIT 1 21 | ) 22 | 23 | SELECT name AS results FROM user_q 24 | UNION 25 | SELECT title AS results FROM movie_q; 26 | -------------------------------------------------------------------------------- /2173. Longest Winning Streak.sql: -------------------------------------------------------------------------------- 1 | WITH win_rank AS ( 2 | SELECT 3 | player_id, 4 | result, 5 | RANK() OVER(PARTITION BY player_id ORDER BY match_day) AS RNK1, 6 | RANK() OVER(PARTITION BY player_id, result ORDER BY match_day) RNK2 7 | FROM Matches 8 | ) 9 | , win_cluster AS ( 10 | SELECT 11 | player_id, 12 | COUNT(*) AS streak 13 | FROM win_rank 14 | WHERE result = 'Win' 15 | GROUP BY player_id, ABS(RNK1 - RNK2) 16 | ) 17 | 18 | SELECT 19 | p.player_id, 20 | IFNULL( 21 | MAX(w.streak), 0 22 | ) AS longest_streak 23 | FROM (SELECT DISTINCT player_id FROM matches) p 24 | LEFT JOIN win_cluster w ON p.player_id = w.player_id 25 | GROUP BY p.player_id; 26 | -------------------------------------------------------------------------------- /1841. League Statistics.sql: -------------------------------------------------------------------------------- 1 | WITH match_pivot AS( 2 | SELECT home_team_id as team_id, home_team_goals, away_team_goals FROM matches 3 | UNION ALL 4 | SELECT away_team_id as team_id, away_team_goals, home_team_goals FROM matches 5 | ) 6 | 7 | SELECT 8 | team_name 9 | , count(*) as matches_played 10 | , sum(case when home_team_goals > away_team_goals then 3 when home_team_goals = away_team_goals then 1 else 0 end) as points 11 | , sum(home_team_goals) as goal_for 12 | , sum(away_team_goals) as goal_against 13 | , sum(home_team_goals) - sum(away_team_goals) as goal_diff 14 | FROM match_pivot m 15 | JOIN teams t ON m.team_id = t.team_id 16 | GROUP BY team_name 17 | ORDER BY points DESC, goal_diff DESC, team_name; 18 | -------------------------------------------------------------------------------- /1225. Report Contiguous Dates.sql: -------------------------------------------------------------------------------- 1 | WITH log_unpivot AS ( 2 | SELECT 3 | fail_date as p_date, 4 | 'failed' AS state, 5 | DAYOFYEAR(fail_date) - row_number() over (order by fail_date) as seq 6 | FROM failed WHERE fail_date BETWEEN '2019-01-01' AND '2019-12-31' 7 | UNION ALL 8 | SELECT 9 | success_date as p_date, 10 | 'succeeded' AS state, 11 | DAYOFYEAR(success_date) - row_number() OVER (order by success_date) AS seq 12 | FROM succeeded WHERE success_date BETWEEN '2019-01-01' AND '2019-12-31' 13 | ) 14 | 15 | SELECT 16 | state AS period_state, 17 | MIN(p_date) AS start_date, 18 | MAX(p_date) AS end_date 19 | FROM log_unpivot 20 | GROUP BY state, seq 21 | ORDER BY MIN(p_date); 22 | -------------------------------------------------------------------------------- /1715. Count Apples and Oranges.sql: -------------------------------------------------------------------------------- 1 | # Solution with CTE 2 | WITH fruits_count AS ( 3 | SELECT 4 | b.box_id, 5 | b.apple_count + IFNULL(c.apple_count, 0) AS apple_count, 6 | b.orange_count + IFNULL(c.orange_count, 0) AS orange_count 7 | FROM boxes b 8 | LEFT JOIN chests c ON b.chest_id = c.chest_id 9 | GROUP BY b.box_id 10 | ) 11 | 12 | SELECT 13 | SUM(apple_count) AS apple_count, 14 | SUM(orange_count) AS orange_count 15 | FROM fruits_count; 16 | 17 | 18 | # Concise solution without CTE 19 | SELECT 20 | SUM(b.apple_count + IFNULL(c.apple_count, 0)) AS apple_count, 21 | SUM(b.orange_count + IFNULL(c.orange_count, 0)) AS orange_count 22 | FROM boxes b 23 | LEFT JOIN chests c ON b.chest_id = c.chest_id; 24 | -------------------------------------------------------------------------------- /1990. Count the Number of Experiments.sql: -------------------------------------------------------------------------------- 1 | WITH platforms AS ( 2 | SELECT 'Android' AS platform 3 | UNION ALL 4 | SELECT 'IOS' AS platform 5 | UNION ALL 6 | SELECT 'Web' AS platform 7 | ), 8 | activities AS ( 9 | SELECT 'Reading' AS activity 10 | UNION ALL 11 | SELECT 'Sports' AS activity 12 | UNION ALL 13 | SELECT 'Programming' AS activity 14 | ) 15 | 16 | SELECT 17 | p.platform, 18 | e.activity AS experiment_name, 19 | SUM(CASE 20 | WHEN ep.experiment_name = e.activity THEN 1 ELSE 0 21 | END) AS num_experiments 22 | FROM platforms p 23 | JOIN activities e 24 | LEFT JOIN experiments ep ON 25 | p.platform = ep.platform AND 26 | e.activity = ep.experiment_name 27 | GROUP BY p.platform, e.activity; 28 | -------------------------------------------------------------------------------- /1083. Sales Analysis II.sql: -------------------------------------------------------------------------------- 1 | # With sub-query 2 | SELECT 3 | buyer_id 4 | FROM ( 5 | SELECT 6 | buyer_id, 7 | SUM(CASE 8 | WHEN p.product_name = 'S8' THEN 1 ELSE 0 9 | END) AS s8, 10 | SUM(CASE 11 | WHEN p.product_name = 'iPhone' THEN 1 ELSE 0 12 | END) AS iPhone 13 | FROM sales 14 | JOIN product p ON sales.product_id = p.product_id 15 | GROUP BY buyer_id 16 | 17 | ) cte 18 | WHERE cte.s8 > 0 and cte.iphone = 0; 19 | 20 | 21 | # Same logic with HAVING 22 | SELECT 23 | buyer_id 24 | FROM sales 25 | JOIN product p ON sales.product_id = p.product_id 26 | GROUP BY buyer_id 27 | HAVING SUM(CASE WHEN p.product_name = 's8' THEN 1 ELSE 0 END) > 0 28 | AND SUM(CASE WHEN p.product_name = 'iPhone' THEN 1 ELSE 0 END) = 0; 29 | -------------------------------------------------------------------------------- /602. Friend Requests II- Who Has the Most Friends.sql: -------------------------------------------------------------------------------- 1 | # With UNION ALL 2 | WITH id_unpivot AS( 3 | SELECT requester_id as id FROM RequestAccepted 4 | UNION ALL 5 | SELECT accepter_id as id FROM RequestAccepted 6 | ) 7 | 8 | SELECT 9 | id, 10 | COUNT(*) as num 11 | FROM id_unpivot 12 | GROUP BY id 13 | ORDER BY num DESC LIMIT 1; 14 | 15 | 16 | # With UNION ALL and sub-query 17 | WITH id_unpivot AS( 18 | SELECT requester_id as id FROM RequestAccepted 19 | UNION ALL 20 | SELECT accepter_id as id FROM RequestAccepted 21 | ), 22 | total_occ AS( 23 | SELECT 24 | id, 25 | COUNT(*) as num 26 | FROM id_unpivot 27 | GROUP BY id 28 | ) 29 | 30 | SELECT 31 | id, 32 | num 33 | FROM total_occ 34 | WHERE num = (SELECT MAX(num) FROM total_occ); 35 | -------------------------------------------------------------------------------- /1867. Orders With Maximum Quantity Above Average.sql: -------------------------------------------------------------------------------- 1 | # Standard solution with CTE and sub-query 2 | WITH order_sorter AS ( 3 | SELECT 4 | order_id, 5 | MAX(quantity) max_quantity, 6 | AVG(quantity) avg_quantity 7 | FROM OrdersDetails 8 | GROUP BY order_id 9 | ) 10 | 11 | SELECT 12 | order_id 13 | FROM order_sorter 14 | WHERE max_quantity > (SELECT MAX(avg_quantity) FROM order_sorter); 15 | 16 | 17 | # A tricky but useful solution with WINDOW function 18 | WITH order_sorter AS ( 19 | SELECT 20 | order_id, 21 | MAX(quantity) max_quantity, 22 | MAX(AVG(quantity)) OVER() avg_quantity 23 | FROM OrdersDetails 24 | GROUP BY order_id 25 | ) 26 | 27 | SELECT 28 | order_id 29 | FROM order_sorter 30 | WHERE max_quantity > avg_quantity; 31 | -------------------------------------------------------------------------------- /1699. Number of Calls Between Two Persons.sql: -------------------------------------------------------------------------------- 1 | # Solution with CASE 2 | SELECT 3 | CASE 4 | WHEN from_id > to_id THEN to_id 5 | ELSE from_id 6 | END AS person1, 7 | CASE 8 | WHEN from_id > to_id THEN from_id 9 | ELSE to_id 10 | END AS person2, 11 | COUNT(duration) AS call_count, 12 | SUM(duration) AS total_duration 13 | FROM Calls 14 | GROUP BY person1, person2; 15 | 16 | 17 | # Solution with UNIONing 18 | WITH call_pivot AS ( 19 | SELECT from_id id1, to_id id2, duration FROM calls 20 | UNION ALL 21 | SELECT to_id id1, from_id id2, duration FROM calls 22 | ) 23 | 24 | SELECT 25 | id1 as person1, 26 | id2 as person2, 27 | COUNT(*) as call_count, 28 | SUM(duration) AS total_duration 29 | FROM call_pivot 30 | WHERE id1 < id2 31 | GROUP BY id1, id2; 32 | -------------------------------------------------------------------------------- /2051. The Category of Each Member in the Store.sql: -------------------------------------------------------------------------------- 1 | WITH category_calc AS ( 2 | SELECT 3 | m.member_id, 4 | m.name, 5 | CASE 6 | WHEN COUNT(v.member_id) = 0 THEN -1 7 | ELSE ((100 * COUNT(p.visit_id)) / COUNT(v.member_id)) 8 | END AS conversion_rate 9 | FROM members m 10 | LEFT JOIN visits v ON m.member_id = v.member_id 11 | LEFT JOIN purchases p ON v.visit_id = p.visit_id 12 | GROUP BY m.member_id, m.name 13 | ) 14 | 15 | SELECT 16 | member_id, 17 | name, 18 | CASE 19 | WHEN conversion_rate >= 80 THEN 'Diamond' 20 | WHEN conversion_rate >= 50 AND conversion_rate < 80 THEN 'Gold' 21 | WHEN conversion_rate < 50 AND conversion_rate >= 0 THEN 'Silver' 22 | ELSE 'Bronze' 23 | END category 24 | FROM category_calc; 25 | -------------------------------------------------------------------------------- /1142. User Activity for the Past 30 Days II.sql: -------------------------------------------------------------------------------- 1 | # With CTE 2 | WITH total_sessions AS ( 3 | SELECT 4 | DISTINCT user_id, 5 | session_id 6 | FROM activity 7 | WHERE activity_date >= '2019-06-28' and activity_date <= '2019-07-27' 8 | ) 9 | 10 | SELECT 11 | CASE 12 | WHEN (SELECT COUNT(DISTINCT user_id) FROM total_sessions) = 0 THEN 0 13 | ELSE ROUND(COUNT(DISTINCT session_id) / (1.0 * COUNT(DISTINCT user_id)), 2) 14 | END as average_sessions_per_user 15 | FROM total_sessions; 16 | 17 | 18 | # Without CTE, small and concise 19 | SELECT 20 | IFNULL( 21 | ROUND( 22 | COUNT(DISTINCT session_id) / (1.0 * COUNT(DISTINCT user_id)) 23 | ,2) 24 | , 0.00) AS average_sessions_per_user 25 | FROM activity 26 | WHERE activity_date >= '2019-06-28' AND activity_date <= '2019-07-27'; 27 | -------------------------------------------------------------------------------- /1651. Hopper Company Queries III.sql: -------------------------------------------------------------------------------- 1 | WITH RECURSIVE months AS ( 2 | SELECT 1 AS month 3 | UNION ALL 4 | SELECT month + 1 AS month FROM months WHERE months.month < 10 5 | ), 6 | ride_calc AS ( 7 | SELECT 8 | MONTH(r.requested_at) as month, 9 | IFNULL(SUM(ar.ride_distance), 0) AS total_dist, 10 | IFNULL(SUM(ar.ride_duration), 0) AS total_dur 11 | FROM Rides r 12 | JOIN AcceptedRides ar ON r.ride_id = ar.ride_id 13 | WHERE YEAR(r.requested_at) = 2020 14 | GROUP BY MONTH(r.requested_at) 15 | ) 16 | 17 | SELECT 18 | m.month, 19 | IFNULL(ROUND(SUM(rc.total_dist) / 3, 2), 0.00) AS average_ride_distance, 20 | IFNULL(ROUND(SUM(rc.total_dur) / 3, 2), 0.00) AS average_ride_duration 21 | FROM months m 22 | LEFT OUTER JOIN ride_calc rc ON rc.month BETWEEN m.month AND m.month + 2 23 | GROUP BY m.month; 24 | -------------------------------------------------------------------------------- /615. Average Salary- Departments VS Company.sql: -------------------------------------------------------------------------------- 1 | WITH company_avg AS ( 2 | SELECT 3 | DATE_FORMAT(pay_date, '%Y-%m') AS pay_month, 4 | AVG(amount) AS c_avg 5 | FROM salary 6 | GROUP BY DATE_FORMAT(pay_date, '%Y-%m') 7 | ) 8 | , monthly_avg AS ( 9 | SELECT 10 | DATE_FORMAT(s.pay_date, '%Y-%m') AS pay_month, 11 | e.department_id, 12 | AVG(s.amount) AS m_avg 13 | FROM salary s 14 | LEFT JOIN employee e ON s.employee_id = e.employee_id 15 | GROUP BY e.department_id, DATE_FORMAT(s.pay_date, '%Y-%m') 16 | ) 17 | SELECT 18 | m.pay_month, 19 | m.department_id, 20 | CASE 21 | WHEN m_avg > c_avg THEN 'higher' 22 | WHEN m_avg < c_avg THEN 'lower' 23 | ELSE 'same' 24 | END AS comparison 25 | FROM monthly_avg m 26 | JOIN company_avg c ON m.pay_month = c.pay_month; 27 | -------------------------------------------------------------------------------- /1336. Number of Transactions per Visit.sql: -------------------------------------------------------------------------------- 1 | WITH transaction_calc AS ( 2 | SELECT 3 | v.user_id, 4 | COUNT(t.user_id) AS total 5 | FROM visits v 6 | LEFT JOIN transactions t ON v.user_id = t.user_id AND v.visit_date = t.transaction_date 7 | GROUP BY v.user_id, v.visit_date 8 | ), 9 | row_creator AS( 10 | SELECT 0 as trans_count 11 | UNION 12 | SELECT row_number() OVER() as trans_count FROM transactions 13 | ), 14 | transaction_count AS( 15 | SELECT 16 | total, 17 | COUNT(1) as total_trans 18 | FROM transaction_calc 19 | GROUP BY total 20 | ) 21 | 22 | SELECT 23 | rc.trans_count AS transactions_count, 24 | IFNULL(tc.total_trans, 0) AS visits_count 25 | FROM row_creator rc 26 | LEFT JOIN transaction_count tc ON rc.trans_count = tc.total 27 | WHERE rc.trans_count <= (SELECT MAX(total) FROM transaction_calc); 28 | -------------------------------------------------------------------------------- /1454. Active Users.sql: -------------------------------------------------------------------------------- 1 | # Solution with multi JOIN, concise but difficult to understand 2 | SELECT 3 | distinct a.id, 4 | a.name 5 | FROM Logins l1 6 | JOIN Logins l2 ON 7 | l1.id = l2.id and 8 | datediff(l2.login_date, l1.login_date) between 0 and 4 9 | JOIN Accounts a ON l1.id = a.id 10 | GROUP BY l1.id, l1.login_date 11 | HAVING COUNT(distinct l2.login_date) = 5; 12 | 13 | 14 | # Solution with CTE and single JOIN, easier to understand 15 | WITH login_ranker AS( 16 | SELECT 17 | id, 18 | login_date, 19 | DAYOFYEAR(login_date) - DENSE_RANK() OVER(PARTITION BY id ORDER BY login_date) AS seq 20 | FROM logins 21 | ORDER BY id 22 | ) 23 | 24 | SELECT 25 | DISTINCT l.id, 26 | a.name 27 | FROM login_ranker l 28 | LEFT JOIN accounts a ON l.id = a.id 29 | GROUP BY l.id, l.seq 30 | HAVING COUNT(DISTINCT l.login_date) >= 5 31 | ORDER BY id; 32 | -------------------------------------------------------------------------------- /1212. Team Scores in Football Tournament.sql: -------------------------------------------------------------------------------- 1 | WITH match_pivot AS ( 2 | SELECT 3 | match_id, 4 | host_team as team1, 5 | guest_team as team2, 6 | host_goals as team1_goals, 7 | guest_goals as team2_goals 8 | FROM matches 9 | UNION 10 | SELECT 11 | match_id, 12 | guest_team as team1, 13 | host_team as team2, 14 | guest_goals as team1_goals, 15 | host_goals as team2_goals 16 | FROM matches 17 | ) 18 | 19 | SELECT 20 | t.team_id, 21 | t.team_name, 22 | IFNULL( 23 | SUM( 24 | CASE 25 | WHEN team1_goals > team2_goals THEN 3 26 | WHEN team1_goals < team2_goals THEN 0 27 | WHEN team1_goals = team2_goals THEN 1 28 | END) 29 | , 0) AS num_points 30 | FROM teams t 31 | LEFT JOIN match_pivot mp ON t.team_id = mp.team1 32 | GROUP BY team_id 33 | ORDER BY num_points DESC, team_id; 34 | -------------------------------------------------------------------------------- /1767. Find the Subtasks That Did Not Execute.sql: -------------------------------------------------------------------------------- 1 | # Recursive query with sub-query 2 | WITH RECURSIVE cte AS ( 3 | SELECT task_id, subtasks_count FROM tasks 4 | UNION ALL 5 | SELECT task_id, subtasks_count - 1 AS subtasks_count FROM cte WHERE subtasks_count > 1 6 | ) 7 | SELECT 8 | c.task_id, 9 | c.subtasks_count AS subtask_id 10 | FROM cte c 11 | WHERE c.subtasks_count NOT IN ( 12 | SELECT subtask_id FROM executed e WHERE e.task_id = c.task_id 13 | ); 14 | 15 | 16 | # Recursive query with JOIN 17 | WITH RECURSIVE cte AS ( 18 | SELECT task_id, subtasks_count FROM tasks 19 | UNION ALL 20 | SELECT task_id, subtasks_count - 1 AS subtasks_count FROM cte WHERE subtasks_count > 1 21 | ) 22 | 23 | SELECT 24 | c.task_id, 25 | c.subtasks_count AS subtask_id 26 | FROM cte c 27 | LEFT JOIN executed e ON 28 | c.task_id = e.task_id AND 29 | c.subtasks_count = e.subtask_id 30 | WHERE e.subtask_id is NULL; 31 | -------------------------------------------------------------------------------- /1126. Active Businesses.sql: -------------------------------------------------------------------------------- 1 | # With two CTEs 2 | WITH occurences_avg AS ( 3 | SELECT 4 | DISTINCT event_type, 5 | AVG(occurences) avg_occurences 6 | FROM events 7 | GROUP BY event_type 8 | ), 9 | event_count AS( 10 | SELECT 11 | e.business_id, 12 | COUNT(*) as total 13 | FROM events e 14 | LEFT JOIN occurences_avg o ON o.event_type = e.event_type 15 | WHERE e.occurences > o.avg_occurences 16 | GROUP BY e.business_id 17 | ) 18 | 19 | SELECT business_id FROM event_count WHERE total > 1; 20 | 21 | 22 | # With one CTE 23 | WITH occurences_avg AS ( 24 | SELECT 25 | DISTINCT event_type, 26 | AVG(occurences) avg_occurences 27 | FROM events 28 | GROUP BY event_type 29 | ) 30 | 31 | SELECT 32 | e.business_id 33 | FROM events e 34 | LEFT JOIN occurences_avg o ON o.event_type = e.event_type 35 | WHERE e.occurences > o.avg_occurences 36 | GROUP BY e.business_id 37 | HAVING COUNT(*) > 1; 38 | -------------------------------------------------------------------------------- /1747. Leetflex Banned Accounts.sql: -------------------------------------------------------------------------------- 1 | # Solution with CTE 2 | WITH login_counter AS ( 3 | SELECT 4 | l1.account_id, 5 | SUM( 6 | CASE 7 | WHEN (l1.login BETWEEN l2.login AND l2.logout) OR 8 | (l1.logout BETWEEN l2.login AND l2.logout) THEN 1 9 | ELSE 0 10 | END 11 | ) AS total_sim_login 12 | FROM LogInfo l1 13 | LEFT JOIN LogInfo l2 ON 14 | l1.account_id = l2.account_id AND 15 | l1.ip_address <> l2.ip_address 16 | GROUP BY l1.account_id 17 | ) 18 | 19 | SELECT 20 | account_id 21 | FROM login_counter 22 | WHERE total_sim_login > 0; 23 | 24 | 25 | # Solution with CROSS JOIN 26 | SELECT 27 | l1.account_id 28 | FROM LogInfo l1 29 | CROSS JOIN LogInfo l2 ON 30 | l1.account_id = l2.account_id AND 31 | l1.ip_address <> l2.ip_address AND 32 | l1.login >= l2.login AND 33 | l1.login <= l2.logout 34 | GROUP BY l1.account_id; 35 | -------------------------------------------------------------------------------- /2159. Order Two Columns Independently.sql: -------------------------------------------------------------------------------- 1 | # Separate CTEs for first and second column and the JOIN 2 | WITH first_cols AS ( 3 | SELECT 4 | first_col, 5 | ROW_NUMBER() OVER(ORDER BY first_col) AS c_rank 6 | FROM data 7 | ), 8 | second_cols AS ( 9 | SELECT 10 | second_col, 11 | ROW_NUMBER() OVER(ORDER BY second_col DESC) AS c_rank 12 | FROM data 13 | ) 14 | SELECT 15 | f.first_col, 16 | s.second_col 17 | FROM first_cols f 18 | LEFT JOIN second_cols s ON f.c_rank = s.c_rank; 19 | 20 | 21 | # Single CTE for both columns and self JOIN 22 | WITH col_ranker AS ( 23 | SELECT 24 | first_col, 25 | ROW_NUMBER() OVER(ORDER BY first_col) AS f_rank, 26 | second_col, 27 | ROW_NUMBER() OVER(ORDER BY second_col DESC) AS c_rank 28 | FROM data 29 | ) 30 | 31 | SELECT 32 | c1.first_col, 33 | c2.second_col 34 | FROM col_ranker c1 35 | JOIN col_ranker c2 ON c1.f_rank = c2.c_rank 36 | ORDER BY c1.f_rank; 37 | -------------------------------------------------------------------------------- /608. Tree Node.sql: -------------------------------------------------------------------------------- 1 | # Three separate checks for Root, Inner and Leaf 2 | SELECT 3 | id, 4 | CASE 5 | WHEN p_id IS NULL THEN 'Root' 6 | WHEN id NOT IN (SELECT p_id FROM Tree WHERE p_id IS NOT NULL) THEN 'Leaf' 7 | WHEN id IN (SELECT p_id FROM Tree WHERE p_id IS NOT NULL) THEN 'Inner' 8 | END AS type 9 | FROM Tree; 10 | 11 | 12 | # Two checks for Root and Inner - Way 1 13 | SELECT 14 | t1.id, 15 | CASE 16 | WHEN t1.p_id IS NULL THEN 'Root' 17 | WHEN t1.id IN (SELECT DISTINCT p_id FROM tree) AND t1.p_id IS NOT NULL THEN 'Inner' 18 | ELSE 'Leaf' 19 | END AS type 20 | FROM tree t1 21 | ORDER BY t1.id; 22 | 23 | 24 | # Two checks for Root and Inner - Way 2 25 | SELECT 26 | t1.id, 27 | CASE 28 | WHEN t1.p_id IS NULL THEN 'Root' 29 | WHEN t1.id IN (SELECT DISTINCT p_id FROM tree WHERE p_id IS NOT NULL) THEN 'Inner' 30 | ELSE 'Leaf' 31 | END AS type 32 | FROM tree t1 33 | ORDER BY t1.id; 34 | -------------------------------------------------------------------------------- /1107. New Users Daily Count.sql: -------------------------------------------------------------------------------- 1 | # Solution with MIN 2 | WITH first_login AS ( 3 | SELECT 4 | user_id, 5 | MIN(activity_date) as login_date 6 | FROM traffic 7 | WHERE activity = 'login' 8 | GROUP BY user_id 9 | ) 10 | 11 | SELECT 12 | login_date, 13 | COUNT(user_id) AS user_count 14 | FROM first_login 15 | WHERE DATEDIFF('2019-06-30', login_date) <= 90 16 | GROUP BY login_date; 17 | 18 | 19 | # Solution with RANK or DENSE_RANK(both will work) 20 | WITH login_ranker AS ( 21 | SELECT 22 | user_id, 23 | activity, 24 | activity_date, 25 | DENSE_RANK() OVER(PARTITION BY user_id ORDER BY activity_date) AS l_rank 26 | FROM traffic 27 | WHERE activity = 'login' 28 | ) 29 | 30 | SELECT 31 | activity_date AS login_date, 32 | COUNT(DISTINCT user_id) AS user_count 33 | FROM login_ranker 34 | WHERE l_rank = 1 AND DATEDIFF('2019-06-30', activity_date) <= 90 35 | GROUP BY activity_date 36 | ORDER BY activity_date; 37 | -------------------------------------------------------------------------------- /1623. All Valid Triplets That Can Represent a Country.sql: -------------------------------------------------------------------------------- 1 | # Standard soltion 2 | SELECT 3 | a.student_name AS member_A, 4 | b.student_name AS member_B, 5 | c.student_name AS member_C 6 | FROM SchoolA a 7 | JOIN SchoolB b 8 | JOIN SchoolC c 9 | WHERE 10 | a.student_name != b.student_name AND 11 | b.student_name != c.student_name AND 12 | a.student_name != c.student_name AND 13 | a.student_id != b.student_id AND 14 | b.student_id != c.student_id AND 15 | a.student_id != c.student_id; 16 | 17 | 18 | # You can write line 22 which will also do the JOIN 19 | SELECT 20 | a.student_name AS member_A, 21 | b.student_name AS member_B, 22 | c.student_name AS member_C 23 | FROM SchoolA a, SchoolB b, SchoolC c 24 | WHERE 25 | a.student_name != b.student_name AND 26 | b.student_name != c.student_name AND 27 | a.student_name != c.student_name AND 28 | a.student_id != b.student_id AND 29 | b.student_id != c.student_id AND 30 | a.student_id != c.student_id; 31 | -------------------------------------------------------------------------------- /1322. Ads Performance.sql: -------------------------------------------------------------------------------- 1 | # With sub-query, easier to read 2 | SELECT 3 | cte.ad_id, 4 | ROUND( 5 | IFNULL( 6 | (cte.clicked / (cte.clicked + cte.viewed)) * 100 7 | , 0) 8 | , 2) AS ctr 9 | FROM ( 10 | SELECT 11 | ad_id, 12 | SUM(CASE 13 | WHEN action = 'Viewed' THEN 1 ELSE 0 14 | END) AS viewed, 15 | SUM(CASE 16 | WHEN action = 'Clicked' THEN 1 ELSE 0 17 | END) AS clicked 18 | FROM ads 19 | GROUP BY ad_id 20 | ) cte 21 | ORDER BY ctr DESC, ad_id ASC; 22 | 23 | 24 | # Without sub-query, concise 25 | SELECT 26 | ad_id, 27 | ROUND( 28 | IFNULL( 29 | SUM(CASE 30 | WHEN action = 'Clicked' THEN 1 ELSE 0 31 | END) / 32 | ( 33 | SUM(CASE WHEN action = 'Viewed' THEN 1 ELSE 0 END) + SUM(CASE WHEN action = 'Clicked' THEN 1 ELSE 0 END) 34 | ) * 100 35 | , 0) 36 | , 2) AS ctr 37 | FROM ads 38 | GROUP BY ad_id 39 | ORDER BY ctr DESC, ad_id ASC; -------------------------------------------------------------------------------- /1070. Product Sales Analysis III.sql: -------------------------------------------------------------------------------- 1 | # With sub-qeury and without DENSE_RANK 2 | SELECT 3 | product_id, 4 | year AS first_year, 5 | quantity, 6 | price 7 | FROM sales 8 | WHERE (product_id, year) IN ( 9 | SELECT product_id, MIN(year) FROM sales GROUP BY product_id 10 | ); 11 | 12 | 13 | # With sub-query and DENSE_RANK 14 | SELECT 15 | s.product_id, 16 | s.year AS first_year, 17 | s.quantity, 18 | s.price 19 | FROM ( 20 | SELECT 21 | product_id, 22 | year, 23 | quantity, 24 | price, 25 | DENSE_RANK() OVER(PARTITION BY product_id ORDER BY year) as p_rank 26 | FROM sales 27 | ) s 28 | WHERE s.p_rank = 1; 29 | 30 | 31 | # With CTE and DENSE_RANK 32 | WITH sales_rank AS ( 33 | SELECT 34 | product_id, 35 | year, 36 | quantity, 37 | price, 38 | DENSE_RANK() OVER(PARTITION BY product_id ORDER BY year) as p_rank 39 | FROM sales 40 | ) 41 | 42 | SELECT 43 | s.product_id, 44 | s.year AS first_year, 45 | s.quantity, 46 | s.price 47 | FROM sales_rank s 48 | WHERE s.p_rank = 1; 49 | -------------------------------------------------------------------------------- /2072. The Winner University.sql: -------------------------------------------------------------------------------- 1 | # Step by step solution with CTEs, easier to read and understand 2 | WITH ny_count AS ( 3 | SELECT COUNT(*) AS total FROM NewYork WHERE score >= 90 4 | ), 5 | ca_count AS ( 6 | SELECT COUNT(*) AS total FROM California WHERE score >= 90 7 | ) 8 | 9 | SELECT 10 | CASE 11 | WHEN ny.total > ca.total THEN 'New York University' 12 | WHEN ny.total < ca.total THEN 'California University' 13 | WHEN ny.total = ca.total THEN 'No Winner' 14 | END AS winner 15 | FROM ny_count ny, ca_count ca; 16 | 17 | 18 | # Concise and short solution, bit hard to read 19 | SELECT 20 | CASE 21 | WHEN (SELECT COUNT(*) FROM NewYork WHERE score >= 90) > (SELECT COUNT(*) FROM California WHERE score >= 90) THEN 'New York University' 22 | WHEN (SELECT COUNT(*) FROM NewYork WHERE score >= 90) < (SELECT COUNT(*) FROM California WHERE score >= 90) THEN 'California University' 23 | WHEN (SELECT COUNT(*) FROM NewYork WHERE score >= 90) = (SELECT COUNT(*) FROM California WHERE score >= 90) THEN 'No Winner' 24 | END AS winner; 25 | -------------------------------------------------------------------------------- /1364. Number of Trusted Contacts of a Customer.sql: -------------------------------------------------------------------------------- 1 | # Solution 1 to calculate trusted_contacts_cnt 2 | SELECT 3 | i.invoice_id, 4 | cu.customer_name, 5 | i.price, 6 | COUNT(co.contact_email) AS contacts_cnt, 7 | SUM( 8 | CASE 9 | WHEN co.contact_email IN (select distinct email from customers) THEN 1 ELSE 0 10 | END 11 | ) AS trusted_contacts_cnt 12 | FROM invoices i 13 | LEFT JOIN customers cu ON i.user_id = cu.customer_id 14 | LEFT JOIN contacts co ON i.user_id = co.user_id 15 | GROUP BY i.invoice_id 16 | ORDER BY i.invoice_id; 17 | 18 | 19 | # Solution 2 to calculate trusted_contacts_cnt 20 | SELECT 21 | i.invoice_id, 22 | cu.customer_name, 23 | i.price, 24 | COUNT(co.contact_email) AS contacts_cnt, 25 | SUM( 26 | CASE 27 | WHEN (SELECT COUNT(*) FROM customers WHERE email = co.contact_email) > 0 THEN 1 ELSE 0 28 | END 29 | ) AS trusted_contacts_cnt 30 | FROM invoices i 31 | JOIN customers cu ON i.user_id = cu.customer_id 32 | LEFT JOIN contacts co ON i.user_id = co.user_id 33 | GROUP BY i.invoice_id 34 | ORDER BY i.invoice_id; 35 | -------------------------------------------------------------------------------- /1532. The Most Recent Three Orders.sql: -------------------------------------------------------------------------------- 1 | # JOIN inside CTE 2 | WITH order_rank AS( 3 | SELECT 4 | c.name AS customer_name, 5 | o.customer_id, 6 | o.order_id, 7 | o.order_date, 8 | RANK() OVER(PARTITION BY o.customer_id ORDER BY order_date DESC) AS o_rank 9 | FROM orders o 10 | LEFT JOIN customers c ON o.customer_id = c.customer_id 11 | ) 12 | SELECT 13 | customer_name, 14 | customer_id, 15 | order_id, 16 | order_date 17 | FROM order_rank 18 | WHERE o_rank <= 3 19 | ORDER BY customer_name, customer_id, order_date DESC; 20 | 21 | 22 | # JOIN outside CTE 23 | WITH order_rank AS( 24 | SELECT 25 | o.customer_id, 26 | o.order_id, 27 | o.order_date, 28 | RANK() OVER(PARTITION BY o.customer_id ORDER BY order_date DESC) AS o_rank 29 | FROM orders o 30 | ) 31 | SELECT 32 | c.name AS customer_name, 33 | o.customer_id, 34 | o.order_id, 35 | o.order_date 36 | FROM order_rank o 37 | LEFT JOIN customers c ON o.customer_id = c.customer_id 38 | WHERE o.o_rank <= 3 39 | ORDER BY c.name, o.customer_id, o.order_date DESC; 40 | -------------------------------------------------------------------------------- /1907. Count Salary Categories.sql: -------------------------------------------------------------------------------- 1 | # Solution with CTE and UNION 2 | WITH salary_categories AS ( 3 | SELECT 4 | account_id, 5 | CASE 6 | WHEN income < 20000 THEN 'Low Salary' 7 | WHEN income >= 20000 AND income <= 50000 THEN 'Average Salary' 8 | ELSE 'High Salary' 9 | END as category 10 | FROM accounts 11 | ) 12 | , categories AS ( 13 | SELECT 'Low Salary' as category 14 | UNION 15 | SELECT 'Average Salary' as category 16 | UNION 17 | SELECT 'High Salary' as category 18 | ) 19 | 20 | SELECT 21 | c.category, 22 | IFNULL(COUNT(account_id), 0) AS accounts_count 23 | FROM categories c 24 | LEFT JOIN salary_categories sc ON c.category = sc.category 25 | GROUP BY c.category; 26 | 27 | 28 | # Solution with UNION only 29 | SELECT 'Low Salary' as category, COUNT(*) as accounts_count FROM accounts WHERE income < 20000 30 | UNION 31 | SELECT 'Average Salary' as category, COUNT(*) as accounts_count FROM accounts WHERE income >= 20000 AND income <= 50000 32 | UNION 33 | SELECT 'High Salary' as category, COUNT(*) as accounts_count FROM accounts WHERE income > 50000; 34 | -------------------------------------------------------------------------------- /1875. Group Employees of the Same Salary.sql: -------------------------------------------------------------------------------- 1 | # Solution with two CTEs and DENSE_RANK 2 | WITH salary_ranker AS( 3 | SELECT 4 | employee_id, 5 | name, 6 | salary, 7 | DENSE_RANK() OVER(PARTITION BY salary ORDER BY salary) as s_rank 8 | FROM employees 9 | ) 10 | ,salary_count AS ( 11 | SELECT 12 | employee_id, 13 | name, 14 | salary, 15 | COUNT(salary) AS occurance 16 | FROM employees 17 | GROUP BY salary 18 | ) 19 | 20 | SELECT 21 | sr.employee_id, 22 | sr.name, 23 | sr.salary, 24 | DENSE_RANK() OVER(ORDER BY sr.salary) AS team_id 25 | FROM salary_ranker sr 26 | LEFT JOIN salary_count sc ON sr.salary = sc.salary 27 | WHERE sc.occurance > 1; 28 | 29 | 30 | # Solution with one CTEs using HAVING and DENSE_RANK 31 | WITH valid_salary AS ( 32 | SELECT 33 | salary 34 | FROM employees 35 | GROUP BY salary 36 | HAVING COUNT(salary) > 1 37 | ) 38 | 39 | SELECT 40 | e.*, 41 | DENSE_RANK() OVER(ORDER BY e.salary) AS team_id 42 | FROM employees e 43 | WHERE e.salary IN (SELECT salary FROM valid_salary) 44 | ORDER BY team_id, employee_id; 45 | -------------------------------------------------------------------------------- /1468. Calculate Salaries.sql: -------------------------------------------------------------------------------- 1 | # With CTE and JOIN 2 | WITH company_category AS( 3 | SELECT 4 | company_id, 5 | CASE 6 | WHEN MAX(salary) < 1000 THEN 0 7 | WHEN MAX(salary) BETWEEN 1000 AND 10000 THEN 24 8 | ELSE 49 9 | END AS tax 10 | FROM salaries 11 | GROUP BY company_id 12 | ) 13 | 14 | SELECT 15 | s.company_id, 16 | s.employee_id, 17 | s.employee_name, 18 | ROUND( 19 | s.salary - (s.salary * (cc.tax / 100)) 20 | ) AS salary 21 | FROM salaries s 22 | LEFT JOIN company_category cc ON s.company_id = cc.company_id; 23 | 24 | 25 | # With CTE and WINDOW function 26 | WITH company_category AS( 27 | SELECT 28 | *, 29 | CASE 30 | WHEN MAX(salary) OVER(PARTITION BY company_id) < 1000 THEN 0 31 | WHEN MAX(salary) OVER(PARTITION BY company_id) BETWEEN 1000 AND 10000 THEN 24 32 | ELSE 49 33 | END AS tax 34 | FROM salaries 35 | ) 36 | SELECT 37 | s.company_id, 38 | s.employee_id, 39 | s.employee_name, 40 | ROUND( 41 | s.salary - (s.salary * (s.tax / 100)) 42 | ) AS salary 43 | FROM company_category s; 44 | -------------------------------------------------------------------------------- /1511. Customer Order Frequency.sql: -------------------------------------------------------------------------------- 1 | # Single query with HAVING 2 | SELECT 3 | c.customer_id, 4 | c.name 5 | FROM orders o 6 | LEFT JOIN customers c ON o.customer_id = c.customer_id 7 | LEFT JOIN product p ON o.product_id = p.product_id 8 | GROUP BY customer_id 9 | HAVING SUM(CASE WHEN MONTH(order_date) = 06 THEN quantity * price END) >= 100 10 | AND SUM(CASE WHEN MONTH(order_date) = 07 THEN quantity * price END) >= 100; 11 | 12 | 13 | # With CTE and without HAVING 14 | WITH spend_calc AS ( 15 | SELECT 16 | o.customer_id, 17 | SUM( 18 | CASE WHEN MONTH(order_date) = 6 THEN p.price * o.quantity ELSE 0 END 19 | ) AS june_spend, 20 | SUM( 21 | CASE WHEN MONTH(order_date) = 7 THEN p.price * o.quantity ELSE 0 END 22 | ) AS july_spend 23 | FROM orders o 24 | LEFT JOIN product p ON o.product_id = p.product_id 25 | WHERE MONTH(order_date) IN (6, 7) AND YEAR(order_date) = 2020 26 | GROUP BY o.customer_id 27 | ) 28 | 29 | SELECT 30 | s.customer_id, 31 | c.name AS name 32 | FROM spend_calc s 33 | LEFT JOIN customers c ON s.customer_id = c.customer_id 34 | WHERE s.june_spend >= 100 AND s.july_spend >= 100; 35 | -------------------------------------------------------------------------------- /1635. Hopper Company Queries I.sql: -------------------------------------------------------------------------------- 1 | WITH RECURSIVE months_unpivot AS ( 2 | SELECT 1 AS month 3 | UNION ALL 4 | SELECT month + 1 AS month FROM months_unpivot WHERE months_unpivot.month < 12 5 | ), 6 | active_drivers AS ( 7 | SELECT driver_id, 8 | CASE 9 | WHEN year(join_date) < 2020 then 1 else month(join_date) 10 | END as active_month 11 | FROM drivers 12 | WHERE year(join_date) < 2021 13 | ), 14 | total_driver AS ( 15 | SELECT 16 | m.month, 17 | COUNT(d.driver_id) AS total_drivers 18 | FROM active_drivers d 19 | LEFT JOIN months_unpivot m ON d.active_month <= m.month 20 | GROUP BY m.month 21 | ), 22 | total_acc_rides AS ( 23 | SELECT 24 | ride_id, 25 | requested_at 26 | FROM rides 27 | JOIN acceptedrides using(ride_id) 28 | HAVING year(requested_at) = 2020 29 | ) 30 | 31 | SELECT 32 | mu.month, 33 | IFNULL(td.total_drivers, 0) AS active_drivers, 34 | IFNULL(COUNT(tar.ride_id), 0) AS accepted_rides 35 | FROM months_unpivot mu 36 | LEFT JOIN total_driver td ON mu.month = td.month 37 | LEFT JOIN total_acc_rides tar ON td.month = MONTH(tar.requested_at) 38 | GROUP BY td.month 39 | ORDER BY td.month; 40 | -------------------------------------------------------------------------------- /1384. Total Sales Amount by Year.sql: -------------------------------------------------------------------------------- 1 | WITH year_unpivot AS ( 2 | SELECT 3 | product_id, 4 | '2018' as report_year, 5 | average_daily_sales * 6 | (DATEDIFF( 7 | LEAST('2018-12-31', period_end), 8 | GREATEST('2018-01-01', period_start) 9 | ) + 1) AS total_amount FROM sales 10 | WHERE YEAR(period_start) = 2018 OR YEAR(period_end) = 2018 11 | UNION ALL 12 | SELECT 13 | product_id, 14 | '2019' as report_year, 15 | average_daily_sales * 16 | (DATEDIFF( 17 | LEAST('2019-12-31', period_end), 18 | GREATEST('2019-01-01', period_start) 19 | ) + 1) AS total_amount FROM sales 20 | WHERE YEAR(period_start) <= 2019 OR YEAR(period_end) >= 2019 21 | UNION ALL 22 | SELECT 23 | product_id, 24 | '2020' as report_year, 25 | average_daily_sales * 26 | (DATEDIFF( 27 | LEAST('2020-12-31', period_end), 28 | GREATEST('2020-01-01', period_start) 29 | ) + 1) AS total_amount FROM sales 30 | WHERE YEAR(period_start) = 2020 OR YEAR(period_end) = 2020 31 | ) 32 | 33 | SELECT 34 | y.product_id, 35 | p.product_name, 36 | y.report_year, 37 | y.total_amount 38 | FROM year_unpivot y 39 | LEFT JOIN product p ON p.product_id = y.product_id 40 | WHERE y.total_amount > 0 41 | ORDER by y.product_id, y.report_year; 42 | -------------------------------------------------------------------------------- /1280. Students and Examinations.sql: -------------------------------------------------------------------------------- 1 | # Modular solution with Two CTEs 2 | WITH subject_distributor AS ( 3 | SELECT 4 | student_id, 5 | student_name, 6 | subject_name 7 | FROM students JOIN subjects 8 | ), 9 | exam_count AS( 10 | SELECT 11 | student_id, 12 | subject_name, 13 | COUNT(subject_name) AS attended_exams 14 | FROM examinations 15 | GROUP BY student_id, subject_name 16 | ) 17 | 18 | SELECT 19 | sd.student_id, 20 | sd.student_name, 21 | sd.subject_name, 22 | IFNULL(ec.attended_exams, 0) as attended_exams 23 | FROM subject_distributor sd 24 | LEFT JOIN exam_count ec ON 25 | sd.student_id = ec.student_id AND 26 | sd.subject_name = ec.subject_name 27 | GROUP BY sd.student_id, sd.subject_name 28 | ORDER BY sd.student_id, sd.subject_name; 29 | 30 | 31 | # Concise solution with two JOINs, no CTEs 32 | SELECT 33 | s.student_id, 34 | student_name , 35 | sub.subject_name , 36 | COUNT(e.student_id) AS attended_exams 37 | FROM Students s 38 | JOIN Subjects sub 39 | LEFT JOIN Examinations e ON 40 | s.student_id=e.student_id AND 41 | sub.subject_name=e.subject_name 42 | GROUP BY s.student_id,sub.subject_name 43 | ORDER BY student_id,sub.subject_name; 44 | -------------------------------------------------------------------------------- /1179. Reformat Department Table.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | id, 3 | SUM(CASE 4 | WHEN month = 'Jan' THEN revenue ELSE NULL 5 | END) Jan_Revenue, 6 | SUM(CASE 7 | WHEN month = 'Feb' THEN revenue ELSE NULL 8 | END) Feb_Revenue, 9 | SUM(CASE 10 | WHEN month = 'Mar' THEN revenue ELSE NULL 11 | END) Mar_Revenue, 12 | SUM(CASE 13 | WHEN month = 'Apr' THEN revenue ELSE NULL 14 | END) Apr_Revenue, 15 | SUM(CASE 16 | WHEN month = 'May' THEN revenue ELSE NULL 17 | END) May_Revenue, 18 | SUM(CASE 19 | WHEN month = 'Jun' THEN revenue ELSE NULL 20 | END) Jun_Revenue, 21 | SUM(CASE 22 | WHEN month = 'Jul' THEN revenue ELSE NULL 23 | END) Jul_Revenue, 24 | SUM(CASE 25 | WHEN month = 'Aug' THEN revenue ELSE NULL 26 | END) Aug_Revenue, 27 | SUM(CASE 28 | WHEN month = 'Sep' THEN revenue ELSE NULL 29 | END) Sep_Revenue, 30 | SUM(CASE 31 | WHEN month = 'Oct'THEN revenue ELSE NULL 32 | END) Oct_Revenue, 33 | SUM(CASE 34 | WHEN month = 'Nov'THEN revenue ELSE NULL 35 | END) Nov_Revenue, 36 | SUM(CASE 37 | WHEN month = 'Dec'THEN revenue ELSE NULL 38 | END) Dec_Revenue 39 | FROM department 40 | GROUP BY id; 41 | -------------------------------------------------------------------------------- /1369. Get the Second Most Recent Activity.sql: -------------------------------------------------------------------------------- 1 | # Easier to understand, with CTE 2 | WITH activity_ranker AS( 3 | SELECT 4 | username, 5 | activity, 6 | startDate, 7 | endDate, 8 | RANK() OVER(PARTITION BY username ORDER BY startDate desc) AS a_rank, 9 | COUNT(activity) over (partition by username) as a_cnt 10 | FROM UserActivity 11 | ) 12 | 13 | SELECT 14 | username, 15 | activity, 16 | startDate, 17 | endDate 18 | FROM activity_ranker 19 | WHERE a_rank = 2 OR a_cnt = 1; 20 | 21 | 22 | # A bit complex solution with two CTEs 23 | WITH activity_ranker AS( 24 | SELECT 25 | username, 26 | activity, 27 | startDate, 28 | endDate, 29 | RANK() OVER(PARTITION BY username ORDER BY startDate desc) AS a_rank 30 | FROM UserActivity 31 | ) 32 | ,users_filter AS ( 33 | SELECT username, 2 AS r_rank FROM activity_ranker WHERE a_rank = 2 34 | UNION ALL 35 | SELECT username, 1 AS r_rank FROM activity_ranker GROUP BY username HAVING MAX(a_rank) = 1 36 | ) 37 | 38 | SELECT 39 | uf.username, 40 | ar.activity, 41 | ar.startDate, 42 | ar.endDate 43 | FROM users_filter uf 44 | LEFT JOIN activity_ranker ar ON 45 | ar.username = uf.username AND 46 | ar.a_rank = uf.r_rank; 47 | -------------------------------------------------------------------------------- /1435. Create a Session Bar Chart.sql: -------------------------------------------------------------------------------- 1 | # Solution UNION, straight forward and easier to read & understand 2 | select '[0-5>' bin, count(*) total from sessions where duration/60 >=0 and duration/60<5 3 | union 4 | select '[5-10>',count(*) total from sessions where duration/60 >=5 and duration/60<10 5 | union 6 | select '[10-15>',count(*) total from sessions where duration/60 >=10 and duration/60<15 7 | union 8 | select '15 or more',count(*) total from sessions where duration/60 >=15; 9 | 10 | 11 | # Same logic with CTE and sub-query, bit complex to read & understand 12 | WITH bin_creator AS ( 13 | select '[0-5>' as bin 14 | union all 15 | select '[5-10>' as bin 16 | union all 17 | select '[10-15>' as bin 18 | union all 19 | select '15 or more' as bin 20 | ) 21 | SELECT 22 | bc.bin, 23 | COUNT(cte.session_id) AS total 24 | FROM bin_creator bc 25 | LEFT JOIN ( 26 | SELECT 27 | CASE 28 | WHEN duration / 60 >= 0 AND duration / 60 < 5 THEN "[0-5>" 29 | WHEN duration / 60 >= 5 AND duration / 60 < 10 THEN "[5-10>" 30 | WHEN duration / 60 >= 10 AND duration / 60 < 15 THEN "[10-15>" 31 | ELSE "15 or more" 32 | END AS bin, 33 | session_id 34 | FROM sessions 35 | ) AS cte ON bc.bin = cte.bin 36 | GROUP BY bc.bin; 37 | -------------------------------------------------------------------------------- /550. Game Play Analysis IV.sql: -------------------------------------------------------------------------------- 1 | # Solution 1 2 | with player_login as 3 | ( 4 | select 5 | player_id, 6 | min(event_date) as date 7 | from Activity 8 | group by 1 9 | ), 10 | main as 11 | ( 12 | select 13 | p.player_id 14 | from player_login p 15 | join activity a on 16 | p.player_id = a.player_id 17 | and date_add(p.date, interval 1 DAY) = a.event_date 18 | ) 19 | 20 | select 21 | round( 22 | (select count(*) from main) / count(distinct(player_id)), 2 23 | ) as fraction 24 | from activity; 25 | 26 | 27 | # Solution 2 28 | WITH first_login AS ( 29 | SELECT 30 | player_id, 31 | MIN(event_date) AS first_date 32 | FROM activity 33 | GROUP BY player_id 34 | ) 35 | , next_login AS ( 36 | SELECT 37 | a.player_id, 38 | MIN(a.event_date) AS next_date 39 | FROM activity a 40 | LEFT JOIN first_login f ON f.player_id = a.player_id 41 | WHERE a.event_date <> f.first_date 42 | GROUP BY player_id 43 | ) 44 | 45 | SELECT 46 | ROUND( 47 | SUM( 48 | CASE WHEN ABS(f.first_date - IFNULL(n.next_date, f.first_date)) = 1 THEN 1 ELSE 0 END 49 | ) / 50 | COUNT(f.player_id) 51 | , 2) AS fraction 52 | FROM first_login f 53 | LEFT JOIN next_login n ON f.player_id = n.player_id; 54 | -------------------------------------------------------------------------------- /1412. Find the Quiet Students in All Exams.sql: -------------------------------------------------------------------------------- 1 | # Solution with two CTEs and sub-query in WHERE clause 2 | WITH quiet_ranker AS( 3 | SELECT 4 | exam_id, 5 | student_id, 6 | RANK() OVER(PARTITION BY exam_id ORDER BY score) AS s_rank, 7 | RANK() OVER(PARTITION BY exam_id ORDER BY score DESC) AS r_rank 8 | FROM exam 9 | ) 10 | ,rank_dist AS( 11 | SELECT 12 | DISTINCT student_id 13 | FROM quiet_ranker 14 | WHERE s_rank = 1 OR r_rank = 1 15 | ) 16 | 17 | SELECT 18 | * 19 | FROM student 20 | WHERE 21 | student_id NOT IN (SELECT * FROM rank_dist) AND 22 | student_id IN (SELECT student_id FROM EXAM); 23 | 24 | 25 | # Solution with two CTEs and JOIN instead of sub-query for WHERE clause 26 | WITH quiet_ranker AS( 27 | SELECT 28 | student_id, 29 | RANK() OVER(PARTITION BY exam_id ORDER BY score) AS s_rank, 30 | RANK() OVER(PARTITION BY exam_id ORDER BY score DESC) AS r_rank 31 | FROM exam 32 | ) 33 | ,rank_dist AS( 34 | SELECT 35 | DISTINCT student_id 36 | FROM quiet_ranker 37 | WHERE s_rank = 1 OR r_rank = 1 38 | ) 39 | SELECT 40 | DISTINCT q.student_id, 41 | s.student_name 42 | FROM quiet_ranker q 43 | LEFT JOIN student s ON q.student_id = s.student_id 44 | WHERE q.student_id NOT IN (SELECT * FROM rank_dist) 45 | ORDER BY q.student_id; 46 | -------------------------------------------------------------------------------- /1789. Primary Department for Each Employee.sql: -------------------------------------------------------------------------------- 1 | # With sub-query and RANK 2 | SELECT 3 | employee_id, 4 | department_id 5 | FROM ( 6 | SELECT 7 | employee_id, 8 | department_id, 9 | RANK() OVER(PARTITION BY employee_id ORDER BY primary_flag) AS d_rank 10 | FROM employee 11 | ) cte 12 | WHERE cte.d_rank = 1; 13 | 14 | 15 | # Solution with long CASE conditions - 1 16 | WITH dept_count AS ( 17 | SELECT 18 | e.employee_id, 19 | COUNT(department_id) as dept_count 20 | FROM employee e 21 | GROUP BY e.employee_id 22 | ) 23 | 24 | SELECT 25 | d.employee_id, 26 | CASE 27 | WHEN d.dept_count > 1 THEN (SELECT department_id FROM employee e WHERE e.employee_id = d.employee_id AND e.primary_flag = 'Y') 28 | ELSE (SELECT department_id FROM employee e WHERE e.employee_id = d.employee_id) 29 | END AS department_id 30 | FROM dept_count d; 31 | 32 | 33 | # Solution with long CASE conditions - 2 34 | SELECT 35 | d.employee_id, 36 | CASE 37 | WHEN COUNT(department_id) > 1 THEN 38 | (SELECT department_id FROM employee e WHERE e.employee_id = d.employee_id AND e.primary_flag = 'Y') 39 | ELSE (SELECT department_id FROM employee e WHERE e.employee_id = d.employee_id LIMIT 1) 40 | END AS department_id 41 | FROM employee d 42 | GROUP BY d.employee_id; 43 | -------------------------------------------------------------------------------- /1645. Hopper Company Queries II.sql: -------------------------------------------------------------------------------- 1 | WITH RECURSIVE months AS ( 2 | SELECT 1 AS month 3 | UNION ALL 4 | SELECT month + 1 AS month FROM months WHERE months.month < 12 5 | ), 6 | available_drivers AS ( 7 | SELECT 8 | driver_id, 9 | CASE 10 | WHEN YEAR(join_date) < 2020 THEN 1 ELSE MONTH(join_date) 11 | END AS available_month 12 | FROM drivers 13 | WHERE YEAR(join_date) < 2021 14 | ), 15 | available_drivers_per_month AS( 16 | SELECT 17 | m.month, 18 | COUNT(DISTINCT driver_id) AS total_driver 19 | FROM months m 20 | LEFT JOIN available_drivers ad ON ad.available_month <= m.month 21 | GROUP BY m.month 22 | ), 23 | drivers_with_acc_rides_per_month AS( 24 | SELECT 25 | DISTINCT ar.driver_id, 26 | MONTH(r.requested_at) as acc_month 27 | FROM AcceptedRides ar 28 | LEFT JOIN rides r ON ar.ride_id = r.ride_id 29 | WHERE year(r.requested_at) = 2020 30 | ) 31 | 32 | SELECT 33 | ad.month, 34 | CASE 35 | WHEN ad.total_driver = 0 THEN 0.00 36 | ELSE ROUND( 37 | (COUNT(dr.driver_id) / ad.total_driver) * 100.00 38 | , 2) 39 | END AS working_percentage 40 | FROM available_drivers_per_month ad 41 | LEFT JOIN drivers_with_acc_rides_per_month dr ON ad.month = dr.acc_month 42 | GROUP BY ad.month 43 | ORDER BY ad.month; 44 | -------------------------------------------------------------------------------- /1972. First and Last Call On the Same Day.sql: -------------------------------------------------------------------------------- 1 | # Solution with two CTEs and DISTINCT 2 | WITH callers AS ( 3 | SELECT caller_id AS user1, recipient_id AS user2, call_time FROM calls 4 | UNION ALL 5 | SELECT recipient_id AS user1, caller_id AS user2, call_time FROM calls 6 | ) 7 | , find_callers AS ( 8 | SELECT 9 | user1, 10 | FIRST_VALUE(user2) OVER(PARTITION BY user1, DATE(call_time) ORDER BY call_time) AS first_caller, 11 | FIRST_VALUE(user2) OVER(PARTITION BY user1, DATE(call_time) ORDER BY call_time DESC) AS last_caller 12 | FROM callers 13 | ) 14 | 15 | SELECT 16 | DISTINCT user1 AS user_id 17 | FROM find_callers 18 | WHERE first_caller = last_caller; 19 | 20 | 21 | # Same solution without DISTINCT(final SELECT statement) 22 | WITH all_caller AS( 23 | SELECT caller_id user_id, recipient_id receiver_id, call_time FROM calls 24 | UNION 25 | SELECT recipient_id user_id, caller_id receiver_id, call_time FROM calls 26 | ), 27 | first_last_caller AS ( 28 | SELECT 29 | DISTINCT user_id, 30 | FIRST_VALUE(receiver_id) OVER(PARTITION BY user_id, DATE(call_time) ORDER BY call_time) first_recp_id, 31 | FIRST_VALUE(receiver_id) OVER(PARTITION BY user_id, DATE(call_time) ORDER BY call_time DESC) last_recp_id 32 | FROM all_caller 33 | ) 34 | 35 | SELECT 36 | user_id 37 | FROM first_last_caller 38 | WHERE first_recp_id = last_recp_id 39 | GROUP BY user_id; 40 | -------------------------------------------------------------------------------- /2118. Build the Equation.sql: -------------------------------------------------------------------------------- 1 | # Solution 1 2 | WITH term_table AS ( 3 | SELECT 4 | power, 5 | CASE 6 | WHEN factor > 0 THEN CONCAT('+', factor) 7 | ELSE factor 8 | END AS factor, 9 | ROW_NUMBER() OVER(ORDER BY power DESC) AS line 10 | FROM terms 11 | ) 12 | , line_creator AS ( 13 | SELECT 14 | line, 15 | CONCAT( 16 | LTRIM(factor), 17 | CASE 18 | WHEN power = 1 THEN 'X' 19 | WHEN power = 0 THEN '' 20 | ELSE CONCAT('X^', LTRIM(power)) 21 | END 22 | ) AS equation 23 | FROM term_table 24 | ORDER BY line 25 | ) 26 | 27 | SELECT 28 | CONCAT(GROUP_CONCAT(equation SEPARATOR ''), '=0') AS equation 29 | FROM line_creator; 30 | 31 | 32 | # Solution 2 33 | WITH term_table AS ( 34 | SELECT 35 | ROW_NUMBER() OVER(ORDER BY power DESC) AS line, 36 | CONCAT( 37 | LTRIM(CASE 38 | WHEN factor > 0 THEN CONCAT('+', factor) 39 | ELSE factor 40 | END), 41 | CASE 42 | WHEN power = 1 THEN 'X' 43 | WHEN power = 0 THEN '' 44 | ELSE CONCAT('X^', LTRIM(power)) 45 | END 46 | ) AS equation 47 | FROM terms 48 | ORDER BY line 49 | ) 50 | 51 | SELECT 52 | CONCAT(GROUP_CONCAT(equation SEPARATOR ''), '=0') AS equation 53 | FROM term_table; 54 | -------------------------------------------------------------------------------- /1919. Leetcodify Similar Friends.sql: -------------------------------------------------------------------------------- 1 | # Solution with UNION and sub-query 2 | WITH friends AS ( 3 | SELECT user1_id AS user1, user2_id AS user2 FROM friendship 4 | UNION 5 | SELECT user2_id AS user1, user1_id AS user2 FROM friendship 6 | ) 7 | ,listen_count AS( 8 | SELECT 9 | l1.user_id AS user1, 10 | l2.user_id AS user2, 11 | l1.day 12 | FROM listens l1 13 | JOIN listens l2 ON 14 | l1.user_id <> l2.user_id AND 15 | l1.song_id = l2.song_id AND 16 | l1.day = l2.day 17 | GROUP BY l1.user_id, l2.user_id, l1.day 18 | HAVING COUNT(DISTINCT l1.song_id) >= 3 19 | ) 20 | 21 | SELECT 22 | DISTINCT lc.user1 AS user1_id, 23 | lc.user2 AS user2_id 24 | FROM listen_count lc 25 | WHERE (lc.user1, lc.user2) IN ( 26 | SELECT user1_id, user2_id FROM friendship 27 | ); 28 | 29 | 30 | # Solution with JOIN and without UNION 31 | WITH listen_count AS( 32 | SELECT 33 | l1.user_id AS user1, 34 | l2.user_id AS user2, 35 | l1.day 36 | FROM listens l1 37 | JOIN listens l2 ON 38 | l1.user_id <> l2.user_id AND 39 | l1.song_id = l2.song_id AND 40 | l1.day = l2.day 41 | GROUP BY l1.user_id, l2.user_id, l1.day 42 | HAVING COUNT(DISTINCT l1.song_id) >= 3 43 | ) 44 | 45 | SELECT 46 | DISTINCT lc.user1 AS user1_id, 47 | lc.user2 AS user2_id 48 | FROM listen_count lc 49 | LEFT JOIN friendship f ON 50 | lc.user1 = f.user1_id AND 51 | lc.user2 = f.user2_id 52 | WHERE f.user1_id IS NOT NULL; 53 | -------------------------------------------------------------------------------- /1892. Page Recommendations II.sql: -------------------------------------------------------------------------------- 1 | # Solution with one CTE and sub-qeury 2 | WITH friends AS ( 3 | SELECT 4 | user1_id AS user_id, 5 | user2_id AS friend_id 6 | FROM Friendship 7 | UNION 8 | SELECT 9 | user2_id AS user_id, 10 | user1_id AS friend_id 11 | FROM Friendship 12 | ) 13 | 14 | SELECT 15 | friends.user_id, 16 | FriendsLikes.page_id, 17 | COUNT(FriendsLikes.user_id) AS friends_likes 18 | FROM friends 19 | JOIN Likes AS FriendsLikes 20 | ON friends.friend_id = FriendsLikes.user_id 21 | LEFT JOIN Likes AS MyLikes 22 | ON ( 23 | friends.user_id = MyLikes.user_id 24 | AND 25 | FriendsLikes.page_id = MyLikes.page_id 26 | ) 27 | WHERE MyLikes.user_id IS NULL 28 | GROUP BY friends.user_id, FriendsLikes.page_id; 29 | 30 | 31 | # Solution with two CTEs 32 | WITH friends AS ( 33 | SELECT 34 | user1_id AS user_id, 35 | user2_id AS friend_id 36 | FROM Friendship 37 | UNION ALL 38 | SELECT 39 | user2_id AS user_id, 40 | user1_id AS friend_id 41 | FROM Friendship 42 | ) 43 | ,friend_likes AS ( 44 | SELECT 45 | f.user_id, 46 | f.friend_id, 47 | l.page_id 48 | FROM friends f 49 | JOIN likes l ON f.friend_id = l.user_id 50 | ) 51 | 52 | SELECT 53 | fl.user_id, 54 | fl.page_id, 55 | COUNT(fl.friend_id) as friends_likes 56 | FROM friend_likes fl 57 | LEFT JOIN likes l 58 | on fl.user_id = l.user_id and fl.page_id = l.page_id 59 | where l.page_id is null 60 | group by fl.user_id, fl.page_id; 61 | -------------------------------------------------------------------------------- /1127. User Purchase Platform.sql: -------------------------------------------------------------------------------- 1 | WITH spend_by_user AS( 2 | SELECT 3 | spend_date, 4 | user_id, 5 | SUM( 6 | CASE WHEN platform = 'desktop' THEN amount ELSE 0 END 7 | ) AS desktop_spend, 8 | SUM( 9 | CASE WHEN platform = 'mobile' THEN amount ELSE 0 END 10 | ) AS mobile_spend 11 | FROM spending 12 | GROUP BY spend_date, user_id 13 | ), 14 | spend_allocation AS( 15 | SELECT 16 | spend_date, 17 | 'desktop' as platform, 18 | SUM(CASE WHEN desktop_spend > 0 AND mobile_spend = 0 THEN desktop_spend ELSE 0 END) total_amount, 19 | SUM(CASE WHEN desktop_spend > 0 AND mobile_spend = 0 THEN 1 ELSE 0 END) total_users 20 | FROM spend_by_user 21 | GROUP BY spend_date 22 | UNION ALL 23 | SELECT 24 | spend_date, 25 | 'mobile' as platform, 26 | SUM(CASE WHEN desktop_spend = 0 AND mobile_spend > 0 THEN mobile_spend ELSE 0 END) total_amount, 27 | SUM(CASE WHEN desktop_spend = 0 AND mobile_spend > 0 THEN 1 ELSE 0 END) total_users 28 | FROM spend_by_user 29 | GROUP BY spend_date 30 | UNION ALL 31 | SELECT 32 | spend_date, 33 | 'both' as platform, 34 | SUM(CASE WHEN desktop_spend > 0 AND mobile_spend > 0 THEN desktop_spend + mobile_spend ELSE 0 END) total_amount, 35 | SUM(CASE WHEN desktop_spend > 0 AND mobile_spend > 0 THEN 1 ELSE 0 END) total_users 36 | FROM spend_by_user 37 | GROUP BY spend_date 38 | ) 39 | 40 | SELECT 41 | spend_date, 42 | platform, 43 | total_amount, 44 | total_users 45 | FROM spend_allocation; 46 | -------------------------------------------------------------------------------- /262. Trips and Users.sql: -------------------------------------------------------------------------------- 1 | # Single query with JOINs 2 | SELECT 3 | request_at AS `Day`, 4 | ROUND(SUM( 5 | CASE WHEN status IN ('cancelled_by_driver', 'cancelled_by_client') THEN 1 ELSE 0 END 6 | ) / 7 | COUNT(id), 2) AS `Cancellation Rate` 8 | FROM trips 9 | JOIN users u1 ON client_id = u1.users_id AND u1.banned = 'No' 10 | JOIN users u2 ON driver_id = u2.users_id AND u2.banned = 'No' 11 | WHERE request_at BETWEEN "2013-10-01" and "2013-10-03" 12 | GROUP BY request_at; 13 | 14 | 15 | # Single query with sub-query 16 | SELECT 17 | request_at as Day, 18 | ROUND( 19 | SUM( 20 | CASE when status IN ('cancelled_by_driver', 'cancelled_by_client') THEN 1 ELSE 0 END 21 | ) / 22 | COUNT(status), 23 | 2 24 | ) AS "Cancellation Rate" 25 | FROM trips 26 | WHERE 27 | client_id NOT IN (SELECT users_id FROM users where banned='Yes') AND 28 | driver_id NOT IN (SELECT users_id FROM users where banned='Yes') AND 29 | request_at BETWEEN '2013-10-01' AND '2013-10-03' 30 | GROUP by request_at; 31 | 32 | 33 | # With CTE and JOINs 34 | WITH unbanned_users AS ( 35 | SELECT 36 | users_id 37 | FROM users 38 | WHERE banned = 'No' 39 | ) 40 | 41 | SELECT 42 | request_at AS `Day`, 43 | ROUND( 44 | SUM(CASE WHEN status in ('cancelled_by_driver', 'cancelled_by_client') THEN 1 ELSE 0 END) 45 | / 46 | COUNT(*) 47 | , 2) AS `Cancellation Rate` 48 | FROM trips t 49 | JOIN unbanned_users u ON t.driver_id = u.users_id 50 | JOIN unbanned_users u1 ON t.client_id = u1.users_id 51 | WHERE request_at BETWEEN "2013-10-01" AND "2013-10-03" 52 | GROUP BY request_at; 53 | -------------------------------------------------------------------------------- /1949. Strong Friendship.sql: -------------------------------------------------------------------------------- 1 | # Solution with CTEs and sub-query in final part 2 | WITH friends AS ( 3 | SELECT user1_id AS user1_id, user2_id AS user2_id FROM Friendship 4 | UNION ALL 5 | SELECT user2_id AS user1_id, user1_id AS user2_id FROM Friendship 6 | ) 7 | , friend_count AS ( 8 | SELECT 9 | f1.user1_id AS user1_id, 10 | f2.user1_id AS user2_id, 11 | SUM( 12 | CASE 13 | WHEN f1.user2_id = f2.user2_id THEN 1 ELSE 0 14 | END 15 | ) AS common_friend 16 | FROM friends f1 17 | JOIN friends f2 ON 18 | f1.user1_id <> f2.user1_id AND 19 | f1.user1_id < f2.user1_id 20 | GROUP BY f1.user1_id, f2.user1_id 21 | ) 22 | 23 | SELECT 24 | * 25 | FROM friend_count 26 | WHERE (user1_id, user2_id) IN 27 | (SELECT user1_id, user2_id FROM friendship ORDER BY user1_id, user2_id) AND 28 | common_friend >= 3; 29 | 30 | 31 | # Solution with CTEs and JOINs instead of sub-query 32 | WITH friends AS ( 33 | SELECT user1_id AS user1_id, user2_id AS user2_id FROM Friendship 34 | UNION ALL 35 | SELECT user2_id AS user1_id, user1_id AS user2_id FROM Friendship 36 | ) 37 | , friend_count AS ( 38 | SELECT 39 | f1.user1_id AS user1_id, 40 | f2.user1_id AS user2_id, 41 | SUM( 42 | CASE 43 | WHEN f1.user2_id = f2.user2_id THEN 1 ELSE 0 44 | END 45 | ) AS common_friend 46 | FROM friendship f 47 | LEFT JOIN friends f1 ON f.user1_id = f1.user1_id 48 | JOIN friends f2 ON 49 | f2.user1_id = f.user2_id AND 50 | f1.user1_id <> f2.user1_id AND 51 | f1.user1_id < f2.user1_id 52 | GROUP BY f1.user1_id, f2.user1_id 53 | ) 54 | 55 | SELECT 56 | * 57 | FROM friend_count 58 | WHERE common_friend >= 3; 59 | -------------------------------------------------------------------------------- /1917. Leetcodify Friends Recommendations.sql: -------------------------------------------------------------------------------- 1 | # Solution with two CTEs and NOT EXISTS 2 | WITH friends AS ( 3 | SELECT user1_id AS user1, user2_id AS user2 FROM friendship 4 | UNION 5 | SELECT user2_id AS user1, user1_id AS user2 FROM friendship 6 | ) 7 | , listen_count AS ( 8 | SELECT 9 | l1.user_id AS user1, 10 | l2.user_id AS user2, 11 | l1.day 12 | FROM listens l1 13 | JOIN listens l2 ON 14 | l1.user_id <> l2.user_id AND 15 | l1.song_id = l2.song_id AND 16 | l1.day = l2.day 17 | GROUP BY l1.user_id, l2.user_id, l1.day 18 | HAVING COUNT(DISTINCT l1.song_id) >= 3 19 | ) 20 | 21 | SELECT 22 | DISTINCT user1 as user_id, 23 | user2 as recommended_id 24 | FROM listen_count a 25 | WHERE NOT EXISTS 26 | (select 1 from friendship b where a.user1 = b.user1_id and a.user2 = b.user2_id) AND 27 | NOT EXISTS 28 | (select 1 from friendship c where a.user1 = c.user2_id and a.user2 = c.user1_id); 29 | 30 | 31 | # Solution with two CTEs and simple JOIN 32 | WITH friends AS ( 33 | SELECT user1_id AS user1, user2_id AS user2 FROM friendship 34 | UNION 35 | SELECT user2_id AS user1, user1_id AS user2 FROM friendship 36 | ) 37 | , listen_count AS ( 38 | SELECT 39 | l1.user_id AS user1, 40 | l2.user_id AS user2, 41 | l1.day 42 | FROM listens l1 43 | JOIN listens l2 ON 44 | l1.user_id <> l2.user_id AND 45 | l1.song_id = l2.song_id AND 46 | l1.day = l2.day 47 | GROUP BY l1.user_id, l2.user_id, l1.day 48 | HAVING COUNT(DISTINCT l1.song_id) >= 3 49 | ) 50 | 51 | SELECT 52 | DISTINCT a.user1 as user_id, 53 | a.user2 as recommended_id 54 | FROM listen_count a 55 | LEFT JOIN friends f ON a.user1 = f.user1 AND a.user2 = f.user2 56 | WHERE f.user1 IS NULL; 57 | -------------------------------------------------------------------------------- /579. Find Cumulative Salary of an Employee.sql: -------------------------------------------------------------------------------- 1 | # Without CTE, two JOINs 2 | SELECT 3 | e.id, 4 | e.month, 5 | e.salary + IFNULL(e1.salary, 0) + IFNULL(e2.salary , 0) AS salary 6 | FROM employee e 7 | LEFT JOIN employee e1 ON e.id = e1.id AND e.month - 1 = e1.month 8 | LEFT JOIN employee e2 ON e.id = e2.id AND e.month - 2 = e2.month 9 | WHERE e.month != (SELECT MAX(month) FROM employee WHERE id = e.id) 10 | ORDER BY e.id, e.month DESC; 11 | 12 | 13 | # With CTE and LAG 14 | WITH salary_serial AS ( 15 | SELECT 16 | id, 17 | LAG(month, 2) OVER(PARTITION BY id) AS prev2, 18 | LAG(month, 1) OVER(PARTITION BY id) AS prev1, 19 | month, 20 | IFNULL(LAG(salary, 2) OVER(PARTITION BY id ORDER BY month), 0) AS prevs2, 21 | IFNULL(LAG(salary, 1) OVER(PARTITION BY id ORDER BY month), 0) AS prevs1, 22 | salary 23 | FROM employee 24 | ) 25 | SELECT 26 | id, 27 | month, 28 | SUM( 29 | (CASE WHEN prev2 + 2 = month THEN prevs2 ELSE 0 END) 30 | + 31 | (CASE WHEN prev1 + 1 = month THEN prevs1 ELSE 0 END) 32 | + 33 | salary 34 | ) AS Salary 35 | FROM salary_serial 36 | WHERE 37 | (id, month) NOT IN (SELECT id, MAX(month) FROM employee GROUP BY id) 38 | GROUP BY id, month 39 | ORDER BY id, month desc; 40 | 41 | 42 | # With CTE and without LAG 43 | WITH cum_salary AS( 44 | SELECT 45 | e.id, 46 | e.month, 47 | e.salary, 48 | e1.salary AS salary_1, 49 | e2.salary AS salary_2 50 | FROM employee e 51 | LEFT JOIN employee e1 ON e.id = e1.id AND e.month - 1 = e1.month 52 | LEFT JOIN employee e2 ON e.id = e2.id AND e.month - 2 = e2.month 53 | WHERE e.month != (SELECT MAX(month) FROM employee WHERE id = e.id) 54 | GROUP BY e.id, e.month 55 | ) 56 | 57 | SELECT 58 | id, 59 | month, 60 | salary + IFNULL(salary_1, 0) + IFNULL(salary_2, 0) AS salary 61 | FROM cum_salary c 62 | ORDER BY id, month DESC; 63 | -------------------------------------------------------------------------------- /601. Human Traffic of Stadium.sql: -------------------------------------------------------------------------------- 1 | # Straight JOIN 2 | SELECT 3 | DISTINCT s1.id, 4 | s1.visit_date, 5 | s1.people 6 | FROM stadium s1 7 | JOIN stadium s2 8 | JOIN stadium s3 9 | WHERE s1.people >= 100 AND s2.people >= 100 AND s3.people >= 100 10 | AND ( 11 | (s1.id - s2.id = 1 AND s1.id - s3.id = 2 AND s2.id - s3.id = 1) -- t1, t2, t3 12 | OR 13 | (s2.id - s1.id = 1 AND s2.id - s3.id = 2 AND s1.id - s3.id = 1) -- t2, t1, t3 14 | OR 15 | (s3.id - s2.id = 1 AND s3.id - s1.id = 2 AND s3.id - s1.id = 2) -- t3, t2, t1 16 | ) 17 | ORDER BY s1.id; 18 | 19 | 20 | # With CTE AND LEAD/LAG by id 21 | WITH stadium_dates AS ( 22 | SELECT 23 | id, 24 | LAG(id, 2) OVER(ORDER BY visit_date) AS day_1, 25 | LAG(id, 1) OVER(ORDER BY visit_date) AS day_2, 26 | visit_date, 27 | LEAD(id, 1) OVER(ORDER BY visit_date) AS day_4, 28 | LEAD(id, 2) OVER(ORDER BY visit_date) AS day_5, 29 | people 30 | FROM stadium 31 | WHERE people >= 100 32 | ) 33 | 34 | SELECT 35 | id, 36 | visit_date, 37 | people 38 | FROM stadium_dates 39 | WHERE 40 | (day_1 + 1 = day_2 AND day_2 + 1 = id) OR 41 | (day_2 + 1 = id AND id + 1 = day_4) OR 42 | (id + 1 = day_4 AND day_4 + 1 = day_5) 43 | ORDER BY visit_date; 44 | 45 | 46 | # With CTE AND LEAD/LAG by people 47 | WITH consecutive_ids AS ( 48 | SELECT 49 | id, 50 | visit_date, 51 | LAG(people, 2) OVER(ORDER BY id) AS prev2, 52 | LAG(people, 1) OVER(ORDER BY id) AS prev1, 53 | people, 54 | LEAD(people, 1) OVER(ORDER BY id) AS next1, 55 | LEAD(people, 2) OVER(ORDER BY id) AS next2 56 | FROM stadium 57 | ) 58 | 59 | SELECT 60 | id, 61 | visit_date, 62 | people 63 | FROM consecutive_ids 64 | WHERE 65 | (prev2 >= 100 AND prev1 >= 100 AND people >= 100) OR 66 | (prev1 >= 100 AND people >= 100 AND next1 >= 100) OR 67 | (people >= 100 AND next1 >= 100 AND next2 >= 100); 68 | -------------------------------------------------------------------------------- /2004. The Number of Seniors and Juniors to Join the Company.sql: -------------------------------------------------------------------------------- 1 | # Solution 1 2 | WITH exp_rank AS( 3 | SELECT 4 | experience, 5 | salary, 6 | SUM(salary) OVER(PARTITION BY experience ORDER BY salary, employee_id) AS total_salary 7 | FROM candidates 8 | ), 9 | 10 | senior_salary AS ( 11 | SELECT 12 | experience, 13 | total_salary, 14 | COUNT(*) as accepted_candidates, 15 | CASE 16 | WHEN COUNT(*) = 0 THEN 70000 ELSE (70000 - MAX(total_salary)) END 17 | as remaining_budget 18 | FROM exp_rank 19 | WHERE experience = 'Senior' AND total_salary <= 70000 20 | ), 21 | 22 | junior_salary AS ( 23 | SELECT 24 | experience, 25 | COUNT(*) as accepted_candidates 26 | FROM exp_rank 27 | WHERE experience = 'Junior' AND total_salary <= (SELECT remaining_budget FROM senior_salary) 28 | ) 29 | 30 | SELECT 31 | 'Senior' AS experience, 32 | accepted_candidates 33 | FROM senior_salary 34 | 35 | UNION 36 | 37 | SELECT 38 | 'Junior' AS experience, 39 | accepted_candidates 40 | FROM junior_salary; 41 | 42 | 43 | # Solution 1(Different way of calculating junior salaries) 44 | WITH employee_ranker AS( 45 | SELECT 46 | employee_id, 47 | experience, 48 | SUM(salary) OVER(PARTITION BY experience ORDER BY salary) AS running_total 49 | FROM candidates 50 | ORDER BY experience, running_total 51 | ) 52 | , senior_count AS ( 53 | SELECT 54 | employee_id, 55 | running_total 56 | FROM employee_ranker 57 | WHERE running_total <= 70000 AND experience = 'Senior' 58 | ) 59 | , junior_count AS ( 60 | SELECT 61 | employee_id 62 | FROM employee_ranker 63 | WHERE running_total <= (70000 - IFNULL((SELECT MAX(running_total) FROM senior_count), 0)) 64 | AND experience = 'Junior' 65 | ) 66 | 67 | SELECT 'Senior' as experience, COUNT(*) AS accepted_candidates FROM senior_count 68 | UNION ALL 69 | SELECT 'Junior' as experience, COUNT(*) AS accepted_candidates FROM junior_count; 70 | -------------------------------------------------------------------------------- /1164. Product Price at a Given Date.sql: -------------------------------------------------------------------------------- 1 | # With sub-query JOIN 2 | SELECT 3 | distinct a.product_id, 4 | ifnull(temp.new_price,10) as price 5 | FROM products as a 6 | LEFT JOIN 7 | ( 8 | SELECT 9 | * 10 | FROM products 11 | WHERE (product_id, change_date) in ( 12 | select 13 | product_id, 14 | max(change_date) 15 | from products 16 | where change_date<="2019-08-16" 17 | group by product_id 18 | ) 19 | ) as temp on a.product_id = temp.product_id; 20 | 21 | 22 | # Modular with two CTEs, easy to understand 23 | WITH ids_with_no_change AS( 24 | SELECT 25 | product_id 26 | FROM products 27 | GROUP BY product_id 28 | HAVING MIN(change_date) > '2019-08-16' 29 | 30 | ) 31 | , ids_with_change AS ( 32 | SELECT 33 | product_id, 34 | change_date, 35 | new_price AS price 36 | FROM products 37 | WHERE (product_id, change_date) IN ( 38 | SELECT 39 | product_id, 40 | MAX(change_date) 41 | FROM products 42 | WHERE change_date <= '2019-08-16' 43 | GROUP BY product_id 44 | ) 45 | ) 46 | 47 | SELECT product_id, 10 AS price FROM ids_with_no_change 48 | UNION 49 | SELECT product_id, price FROM ids_with_change; 50 | 51 | 52 | # More modular with three CTEs, easier to understand 53 | WITH id_with_no_change AS( 54 | SELECT 55 | product_id 56 | FROM products 57 | GROUP BY product_id 58 | HAVING MIN(change_date) > '2019-08-16' 59 | ) 60 | , max_change_date AS ( 61 | SELECT 62 | product_id, 63 | MAX(change_date) AS change_date 64 | FROM products 65 | WHERE change_date <= '2019-08-16' 66 | GROUP BY product_id 67 | ) 68 | , id_with_change AS ( 69 | SELECT 70 | product_id, 71 | change_date, 72 | new_price 73 | FROM products 74 | WHERE (product_id, change_date) IN ( 75 | SELECT product_id, change_date FROM max_change_date 76 | ) 77 | ) 78 | 79 | SELECT product_id, 10 AS price FROM id_with_no_change 80 | UNION 81 | SELECT product_id, new_price AS price FROM id_with_change; 82 | -------------------------------------------------------------------------------- /1811. Find Interview Candidates.sql: -------------------------------------------------------------------------------- 1 | # Solution with multiple CTEs, easier to understand 2 | WITH contest_pivot AS ( 3 | SELECT gold_medal AS user_id, contest_id, 'gold' AS medal FROM contests 4 | UNION 5 | SELECT silver_medal AS user_id, contest_id, 'silver' AS medal FROM contests 6 | UNION 7 | SELECT bronze_medal AS user_id, contest_id, 'bronze' AS medal FROM contests 8 | ) 9 | , three_cons_wins AS ( 10 | SELECT 11 | c.user_id 12 | FROM contest_pivot c 13 | LEFT JOIN contest_pivot c1 ON c.user_id = c1.user_id 14 | LEFT JOIN contest_pivot c2 ON c.user_id = c2.user_id 15 | WHERE c.contest_id + 1 = c1.contest_id AND c.contest_id + 2 = c2.contest_id 16 | ) 17 | , three_gold_medals AS ( 18 | SELECT 19 | user_id 20 | FROM contest_pivot 21 | WHERE medal = 'gold' 22 | GROUP BY user_id 23 | HAVING COUNT(*) >= 3 24 | ) 25 | , final_result AS ( 26 | SELECT user_id FROM three_cons_wins 27 | UNION 28 | SELECT user_id FROM three_gold_medals 29 | ) 30 | SELECT 31 | u.name, 32 | u.mail 33 | FROM final_result f 34 | LEFT JOIN users u ON f.user_id = u.user_id; 35 | 36 | 37 | # Solution with LEAD and LAG 38 | WITH pivot_contest AS ( 39 | SELECT contest_id, gold_medal AS 'winner' FROM contests 40 | UNION ALL 41 | SELECT contest_id, silver_medal AS 'winner' FROM contests 42 | UNION ALL 43 | SELECT contest_id, bronze_medal AS 'winner' FROM contests 44 | ) 45 | 46 | , consecutive_wins AS( 47 | SELECT 48 | winner, 49 | Users.name, 50 | Users.mail, 51 | contest_id, 52 | LAG(contest_id) OVER(PARTITION BY winner ORDER BY contest_id) AS prev_contest, 53 | LEAD(contest_id) OVER(PARTITION BY winner ORDER BY contest_id) AS next_contest 54 | FROM pivot_contest 55 | LEFT JOIN Users ON winner = Users.user_id 56 | ) 57 | , gold_medalists AS ( 58 | SELECT 59 | gold_medal as winner, 60 | Users.name, 61 | Users.mail 62 | FROM contests 63 | LEFT JOIN Users ON gold_medal = Users.user_id 64 | GROUP BY gold_medal 65 | HAVING COUNT(contest_id) >= 3 66 | ) 67 | SELECT DISTINCT name, mail FROM consecutive_wins WHERE prev_contest + 1 = contest_id AND contest_id + 1 = next_contest 68 | UNION 69 | SELECT DISTINCT name, mail FROM gold_medalists; 70 | -------------------------------------------------------------------------------- /1596. The Most Frequently Ordered Products for Each Customer.sql: -------------------------------------------------------------------------------- 1 | # CTE with RANK, JOIN in final query 2 | WITH order_ranker AS ( 3 | SELECT 4 | customer_id, 5 | product_id, 6 | # COUNT(product_id), #OVER(PARTITION BY customer_id, product_id) 7 | RANK() OVER(PARTITION BY customer_id ORDER BY COUNT(product_id) DESC) AS c_rank 8 | FROM orders 9 | GROUP BY customer_id, product_id 10 | ) 11 | 12 | SELECT 13 | rr.customer_id, 14 | rr.product_id, 15 | p.product_name 16 | FROM order_ranker rr 17 | LEFT JOIN products p ON rr.product_id = p.product_id 18 | WHERE rr.c_rank = 1; 19 | 20 | 21 | # CTE with RANK and JOIN 22 | WITH order_ranker AS ( 23 | SELECT 24 | o.customer_id, 25 | o.product_id, 26 | p.product_name, 27 | RANK() OVER(PARTITION BY o.customer_id ORDER BY COUNT(o.product_id) DESC) AS c_rank 28 | FROM orders o 29 | LEFT JOIN products p ON o.product_id = p.product_id 30 | GROUP BY o.customer_id, o.product_id 31 | ) 32 | 33 | SELECT 34 | rr.customer_id, 35 | rr.product_id, 36 | rr.product_name 37 | FROM order_ranker rr 38 | WHERE rr.c_rank = 1; 39 | 40 | 41 | # A different way of solving with COUNT instead on RANK 42 | WITH freq_count AS ( 43 | SELECT 44 | customer_id, 45 | product_id, 46 | COUNT(product_id) AS total_order 47 | FROM orders 48 | GROUP BY customer_id, product_id 49 | ) 50 | , max_order AS ( 51 | SELECT 52 | customer_id, 53 | product_id 54 | FROM freq_count f 55 | WHERE total_order = (SELECT MAX(total_order) FROM freq_count WHERE customer_id = f.customer_id) 56 | ) 57 | SELECT 58 | customer_id, 59 | product_id, 60 | product_name 61 | FROM max_order 62 | LEFT JOIN products using(product_id); 63 | 64 | 65 | # Another solution with COUNT 66 | WITH prod_count AS ( 67 | SELECT 68 | customer_id, 69 | product_id, 70 | COUNT(*) AS total_buy 71 | FROM orders 72 | GROUP BY customer_id, product_id 73 | ) 74 | 75 | SELECT 76 | p.customer_id, 77 | p.product_id, 78 | pr.product_name 79 | FROM prod_count p 80 | LEFT JOIN products pr ON p.product_id = pr.product_id 81 | WHERE total_buy = ( 82 | SELECT MAX(total_buy) FROM prod_count WHERE customer_id = p.customer_id 83 | ); 84 | -------------------------------------------------------------------------------- /2084. Drop Type 1 Orders for Customers With Type 0 Orders.sql: -------------------------------------------------------------------------------- 1 | # With CTEs and sub-query 2 | WITH customers_with_zero_type AS ( 3 | SELECT 4 | DISTINCT customer_id 5 | FROM orders 6 | WHERE order_type = 0 7 | ) 8 | , zero_orders_customers AS ( 9 | SELECT 10 | o.order_id, 11 | o.customer_id, 12 | o.order_type 13 | FROM orders o 14 | WHERE customer_id IN 15 | (SELECT customer_id FROM customers_with_zero_type) AND 16 | o.order_type = 0 17 | ) 18 | , nonzero_orders_customers AS ( 19 | SELECT 20 | o.order_id, 21 | o.customer_id, 22 | o.order_type 23 | FROM orders o 24 | WHERE o.customer_id NOT IN 25 | (SELECT customer_id FROM customers_with_zero_type) 26 | ) 27 | 28 | SELECT * FROM zero_orders_customers 29 | UNION 30 | SELECT * FROM nonzero_orders_customers; 31 | 32 | 33 | # Zero order calculation with LEFT JOIN 34 | WITH customers_with_zero_type AS ( 35 | SELECT 36 | DISTINCT customer_id 37 | FROM orders 38 | WHERE order_type = 0 39 | ) 40 | , zero_orders_customers AS ( 41 | SELECT 42 | o.order_id, 43 | o.customer_id, 44 | o.order_type 45 | FROM customers_with_zero_type c 46 | LEFT JOIN orders o ON 47 | o.customer_id = c.customer_id AND 48 | o.order_type = 0 49 | ) 50 | , nonzero_orders_customers AS ( 51 | SELECT 52 | o.order_id, 53 | o.customer_id, 54 | o.order_type 55 | FROM orders o 56 | WHERE o.customer_id NOT IN 57 | (SELECT customer_id FROM customers_with_zero_type) 58 | ) 59 | 60 | SELECT * FROM zero_orders_customers 61 | UNION 62 | SELECT * FROM nonzero_orders_customers; 63 | 64 | 65 | # Zero order calculation with RIGHT JOIN 66 | WITH customers_with_zero_type AS ( 67 | SELECT 68 | DISTINCT customer_id 69 | FROM orders 70 | WHERE order_type = 0 71 | ) 72 | , zero_orders_customers AS ( 73 | SELECT 74 | o.order_id, 75 | o.customer_id, 76 | o.order_type 77 | FROM orders o 78 | RIGHT JOIN customers_with_zero_type c ON 79 | o.customer_id = c.customer_id AND 80 | o.order_type = 0 81 | ) 82 | , nonzero_orders_customers AS ( 83 | SELECT 84 | o.order_id, 85 | o.customer_id, 86 | o.order_type 87 | FROM orders o 88 | WHERE o.customer_id NOT IN (SELECT customer_id FROM customers_with_zero_type) 89 | ) 90 | 91 | SELECT * FROM zero_orders_customers 92 | UNION 93 | SELECT * FROM nonzero_orders_customers; 94 | -------------------------------------------------------------------------------- /1479. Sales by Day of the Week.sql: -------------------------------------------------------------------------------- 1 | # CTE with WEEKDAY and JOIN at the end 2 | WITH weekday_distributor AS( 3 | SELECT 4 | orders.*, 5 | CASE 6 | WHEN WEEKDAY(order_date) = 0 THEN 'Monday' 7 | WHEN WEEKDAY(order_date) = 1 THEN 'Tuesday' 8 | WHEN WEEKDAY(order_date) = 2 THEN 'Wednesday' 9 | WHEN WEEKDAY(order_date) = 3 THEN 'Thursday' 10 | WHEN WEEKDAY(order_date) = 4 THEN 'Friday' 11 | WHEN WEEKDAY(order_date) = 5 THEN 'Saturday' 12 | WHEN WEEKDAY(order_date) = 6 THEN 'Sunday' 13 | END AS week_day 14 | FROM orders 15 | ) 16 | 17 | SELECT 18 | items.item_category AS Category, 19 | SUM( 20 | CASE 21 | WHEN week_day = 'Monday' THEN quantity ELSE 0 22 | END 23 | ) AS 'Monday', 24 | SUM( 25 | CASE 26 | WHEN week_day = 'Tuesday' THEN quantity ELSE 0 27 | END 28 | ) AS 'Tuesday', 29 | SUM( 30 | CASE 31 | WHEN week_day = 'Wednesday' THEN quantity ELSE 0 32 | END 33 | ) AS 'Wednesday', 34 | SUM( 35 | CASE 36 | WHEN week_day = 'Thursday' THEN quantity ELSE 0 37 | END 38 | ) AS 'Thursday', 39 | SUM( 40 | CASE 41 | WHEN week_day = 'Friday' THEN quantity ELSE 0 42 | END 43 | ) AS 'Friday', 44 | SUM( 45 | CASE 46 | WHEN week_day = 'Saturday' THEN quantity ELSE 0 47 | END 48 | ) AS 'Saturday', 49 | SUM( 50 | CASE 51 | WHEN week_day = 'Sunday' THEN quantity ELSE 0 52 | END 53 | ) AS 'Sunday' 54 | FROM items 55 | LEFT JOIN weekday_distributor ON Items.item_id = weekday_distributor.item_id 56 | GROUP BY items.item_category 57 | ORDER BY items.item_category; 58 | 59 | 60 | # CTE with WEEKDAY and JOIN 61 | WITH weekday_distributor AS( 62 | SELECT 63 | items.item_category, 64 | orders.item_id, 65 | orders.quantity, 66 | CASE 67 | WHEN WEEKDAY(order_date) = 0 THEN 'Monday' 68 | WHEN WEEKDAY(order_date) = 1 THEN 'Tuesday' 69 | WHEN WEEKDAY(order_date) = 2 THEN 'Wednesday' 70 | WHEN WEEKDAY(order_date) = 3 THEN 'Thursday' 71 | WHEN WEEKDAY(order_date) = 4 THEN 'Friday' 72 | WHEN WEEKDAY(order_date) = 5 THEN 'Saturday' 73 | WHEN WEEKDAY(order_date) = 6 THEN 'Sunday' 74 | END AS week_day 75 | FROM orders 76 | RIGHT JOIN Items ON Items.item_id = orders.item_id 77 | ) 78 | SELECT 79 | item_category AS Category, 80 | SUM( 81 | CASE 82 | WHEN week_day = 'Monday' THEN quantity ELSE 0 83 | END 84 | ) AS 'Monday', 85 | SUM( 86 | CASE 87 | WHEN week_day = 'Tuesday' THEN quantity ELSE 0 88 | END 89 | ) AS 'Tuesday', 90 | SUM( 91 | CASE 92 | WHEN week_day = 'Wednesday' THEN quantity ELSE 0 93 | END 94 | ) AS 'Wednesday', 95 | SUM( 96 | CASE 97 | WHEN week_day = 'Thursday' THEN quantity ELSE 0 98 | END 99 | ) AS 'Thursday', 100 | SUM( 101 | CASE 102 | WHEN week_day = 'Friday' THEN quantity ELSE 0 103 | END 104 | ) AS 'Friday', 105 | SUM( 106 | CASE 107 | WHEN week_day = 'Saturday' THEN quantity ELSE 0 108 | END 109 | ) AS 'Saturday', 110 | SUM( 111 | CASE 112 | WHEN week_day = 'Sunday' THEN quantity ELSE 0 113 | END 114 | ) AS 'Sunday' 115 | FROM weekday_distributor 116 | GROUP BY item_category 117 | ORDER BY item_category; 118 | 119 | 120 | # Another way of doing the same query with DAYNAME 121 | WITH category_finder AS ( 122 | SELECT 123 | i.item_category, 124 | o.quantity, 125 | DAYNAME(order_date) AS week_day 126 | FROM items i 127 | LEFT JOIN orders o ON i.item_id = o.item_id 128 | ) 129 | 130 | SELECT 131 | item_category AS Category, 132 | SUM(CASE WHEN week_day = 'Monday' THEN quantity ELSE 0 END) AS Monday, 133 | SUM(CASE WHEN week_day = 'Tuesday' THEN quantity ELSE 0 END) AS Tuesday, 134 | SUM(CASE WHEN week_day = 'Wednesday' THEN quantity ELSE 0 END) AS Wednesday, 135 | SUM(CASE WHEN week_day = 'Thursday' THEN quantity ELSE 0 END) AS Thursday, 136 | SUM(CASE WHEN week_day = 'Friday' THEN quantity ELSE 0 END) AS Friday, 137 | SUM(CASE WHEN week_day = 'Saturday' THEN quantity ELSE 0 END) AS Saturday, 138 | SUM(CASE WHEN week_day = 'Sunday' THEN quantity ELSE 0 END) AS Sunday 139 | FROM category_finder 140 | GROUP BY item_category 141 | ORDER BY item_category; 142 | --------------------------------------------------------------------------------