Add files via upload

Author: leetlab11

00175-combine-two-tables.sql

@@ -0,0 +1,14 @@
+-- simple LEFT JOIN
+
+select p.firstName, p.lastName, a.city, a.state
+from Person p
+left join Address a
+using(personId)
+
+
+-- apple- 4
+-- bloomberg- 2
+-- amazon- 2
+-- microsoft- 2
+-- adobe- 3
+-- google- 3

00182-duplicate-emails.sql

@@ -0,0 +1,10 @@
+-- use group by for aggregate
+
+select email as Email
+from Person
+group by email
+having count(email) > 1
+
+
+-- amazon- 2
+-- uber- 2

00183-customers-who-never-order.sql

@@ -0,0 +1,12 @@
+-- pick id from Orders, and do not select those ids
+
+select name as Customers
+from Customers
+where id not in
+    (select distinct customerId
+    from Orders)
+
+-- amazon- 3
+-- apple- 7
+-- bloomberg- 5
+-- adobe- 2

00184-department-highest-salary.sql

@@ -0,0 +1,30 @@
+-- using subquery
+
+select d.name as Department, e.name as Employee, e.salary
+from Department d join Employee e
+on d.id = e.departmentId
+where (e.departmentId, e.salary) in 
+    (select departmentId, max(salary)
+    from Employee
+    group by departmentId)
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- using window function
+
+with CTE as
+(select departmentId, id, name, salary,
+    dense_rank() over(partition by departmentId order by salary desc) as rnk
+from Employee)
+
+select d.name as Department, e.name as Employee, e.salary
+from Department d join CTE e
+on d.id = e.departmentId
+where e.rnk = 1
+
+
+-- amazon- 2
+-- microsoft- 3
+-- apple- 2
+-- facebook- 2
+-- google- 2

00511-game-play-analysis-i.sql

@@ -0,0 +1,10 @@
+-- simple aggregate function
+
+select player_id, min(event_date) as first_login
+from Activity
+group by 1
+
+-- adobe- 2
+-- amazon- 4
+-- bloomberg- 4
+-- gsn games- 1

00512-game-play-analysis-ii.sql

@@ -0,0 +1,22 @@
+-- using subquery
+
+select player_id, device_id
+from Activity
+where (player_id, event_date) in
+    (select player_id, min(event_date)
+    from Activity
+    group by player_id)
+
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- using window function
+  
+with CTE as
+    (select player_id, device_id, 
+        row_number() over(partition by player_id order by event_date) as rn
+    from Activity)
+
+select player_id, device_id
+from CTE 
+where rn = 1
+
+-- gsn games- 1

00534-game-play-analysis-iii.sql

@@ -0,0 +1,8 @@
+-- running total of games played
+-- sum() over()
+
+select player_id, event_date, 
+    sum(games_played) over(partition by player_id order by event_date) as games_played_so_far
+from Activity
+
+-- gsn games

00586-customer-placing-the-largest-number-of-orders.sql

@@ -0,0 +1,14 @@
+-- the the cusotmer with maximum order count, order by, limit
+
+select customer_number
+from Orders
+group by 1
+order by count(order_number) desc
+limit 1
+
+
+-- adobe- 2
+-- google- 3
+-- apple- 2
+-- uber- 2
+-- twitter- 1

00603-consecutive-available-seats.sql

@@ -0,0 +1,31 @@
+-- lag and lead will give the rows above and below
+-- if free = 1 and either of lag_free or lead_free is 1, it means we have 2 consecutive free seats.
+-- just pick those rows
+
+with CTE as(
+    select seat_id, free, 
+        lag(free, 1) over(order by seat_id) as lag_free, 
+        lead(free, 1) over(order by seat_id) as lead_free
+    from Cinema)
+
+select seat_id 
+from CTE
+where (free = 1 and lag_free = 1) or (free = 1 and lead_free = 1)
+order by 1
+
+------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- if seat = free AND seat + 1 or seat - 1 have free = 1, then pull that seat  
+  
+select seat_id
+from Cinema
+where free = 1 and
+     (seat_id - 1 in (select seat_id
+                      from Cinema
+                      where free = 1)
+    or
+    seat_id + 1 in (select seat_id
+                      from Cinema
+                      where free = 1))
+
+
+-- amazon- 4

00607-sales-person.sql

@@ -0,0 +1,30 @@
+-- nested query
+-- select all salesPerson with company RED
+-- select all salesPerson from SalesPerson not in the above table
+
+select sp.name
+from SalesPerson sp
+where sales_id not in
+    (select o.sales_id
+    from Orders o
+    where o.com_id in
+        (select c.com_id 
+        from Company c
+        where c.name = 'RED'))
+
+------------------------------------------------------------------------------------------------------------------------------------------------
+-- JOIN Company c and Ordered o
+-- pick all sales_id with company = 'RED'
+-- pick all salesPerson from SalesPerson not in temp table above
+  
+select sp.name
+from SalesPerson sp
+where sales_id not in
+    (select o.sales_id
+    from Orders o
+    inner join Company c
+    on c.com_id = o.com_id
+    where c.name = 'RED')
+
+
+-- no companies listed

00608-tree-node.sql

@@ -0,0 +1,10 @@
+-- 3 cases- use CASE WHEN
+
+select id,
+    (case when p_id is null then 'Root' 
+    when id in (select p_id from Tree) then 'Inner'
+    else 'Leaf' end) as type
+from Tree
+
+
+-- twitter- 1

00613-shortest-distance-in-a-line.sql

@@ -0,0 +1,43 @@
+-- cross joining all the points from 2 tables, except the ones where they are same
+-- find the min of absolute distance
+
+select min(abs(a - b)) as shortest
+from
+  (select p1.x as a, p2.x as b
+  from Point p1 cross join Point p2
+  where p1.x != p2.x) temp
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- concise version of the above
+  
+select min(abs(p1.x - p2.x)) as shortest
+from Point p1 cross join Point p2
+where p1.x != p2.x
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- pull min distance with a where condition
+
+select min(p1.x - p2.x) as shortest
+from Point p1, Point p2
+where p1.x > p2.x
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- sort the table, and do lag. Now diff between current and lag- because difference between the sorted will always be lesser than difference between the larger ones
+-- pull the min distance
+  
+with CTE as 
+  (select x - lag(x) over(order by x) as distance
+  from Point)
+
+select min(distance) as shortest from CTE
+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- picking the lowest distance, 1st row will always be null hence use offset
+
+select x - lag(x) over(order by x) as shortest
+from Point
+order by 1 asc
+limit 1 offset 1
+
+
+-- no companies listed

01050-actors-and-director-who-cooperated-at-least-three-times.sql

@@ -0,0 +1,9 @@
+-- aggregate- group by 2 columns, count
+
+select actor_id, director_id
+from ActorDirector
+group by 1, 2
+having count(*) >= 3
+
+
+-- amazon- 3

01077-project-employees-iii.sql

@@ -0,0 +1,14 @@
+-- use dense_rank(), partition by project, order by years desc
+
+with CTE as
+    (select p.project_id, p.employee_id, e.experience_years, 
+        dense_rank() over(partition by p.project_id order by e.experience_years desc) as rnk
+    from Project p
+    left join Employee e
+    on p.employee_id = e.employee_id)
+
+select project_id, employee_id
+from CTE
+where rnk = 1
+
+-- facebook- 1

01112-highest-grade-for-each-student.sql

@@ -0,0 +1,24 @@
+-- use RANK() and pull results where rank = 1
+
+select student_id,  course_id, grade
+from
+    (select student_id, course_id, grade, dense_rank() over(partition by student_id order by grade desc, course_id asc) as rnk
+    from Enrollments) temp1
+where rnk = 1
+order by 1
+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- nested 
+-- first get id and highest grade, then get min course_id
+
+select student_id, min(course_id) as course_id, grade
+from Enrollments
+where (student_id, grade) in
+    (select student_id, max(grade) as grade
+    from Enrollments
+    group by student_id)
+group by student_id
+order by student_id
+
+-- amazon- 2
+-- coursera- 1

01173-immediate-food-delivery-i.sql

@@ -0,0 +1,12 @@
+-- simple condition in aggregate function- count immediate, divide by total rows in the table
+
+select round(sum(order_date = customer_pref_delivery_date) / count(*) * 100, 2) as immediate_percentage
+from Delivery
+---------------------------------------------------------------------------------------------------------------------------------------------
+-- same as above but using case
+
+select round(sum( case when order_date = customer_pref_delivery_date then 1 else 0 end) / count(*) * 100, 2) as immediate_percentage
+from Delivery
+
+
+-- doordash- 2

01212-teams-scores-in-football-tournamant.sql

@@ -0,0 +1,36 @@
+-- union all- one for host(when that team was host)- count host score, 2nd for guest(when that team was guest)- count guest score
+-- calculate sum of points
+-- group by team_id
+
+select t.team_id, t.team_name, coalesce(sum(u.points), 0) as num_points
+from Teams t
+left join
+    (select match_id, host_team as team_id, (case when host_goals > guest_goals then 3
+                when host_goals = guest_goals then 1
+                else 0 end) as points
+    from Matches
+    union all
+    select match_id, guest_team as team_id,
+                (case when host_goals < guest_goals then 3
+                when host_goals = guest_goals then 1
+                else 0 end) as points
+    from Matches) u
+on u.team_id = t.team_id
+group by team_id
+order by 3 desc, 1 asc
+
+-------------------------------------------------------------------------------------------------------------------------
+-- without using 'UNION ALL'- only used JOIN
+
+select t.team_id, t.team_name, coalesce(
+    sum(case when t.team_id = m.host_team and m.host_goals > m.guest_goals then 3
+             when t.team_id = m.guest_team and m.guest_goals > m.host_goals then 3
+             when host_goals = guest_goals then 1 end), 0) as num_points
+from Teams t
+left join Matches m
+on m.host_team = t.team_id or m.guest_team = t.team_id
+group by team_id
+order by 3 desc, 1 asc
+
+
+-- wayfair- 1

01225-report-contiguous-dates.sql

@@ -0,0 +1,42 @@
+-- cte1- unioned both tables and arranged in ascending order of dates
+-- cte2- calculated rn and rnk and diff between them
+-- final query- picked min date as start date, max date as end date, grouped by status and diff
+-- rank()- gave them ranking based on their status ascending order date
+-- row_number()- ordered by date asc
+-- diff between them will be consistent if they are contiguous, hence group by diff
+-- when the status changes, again diff between them will be contiguous hence group by status to get different records for same status
+
+with cte1 as
+    ((select fail_date as event_date, 'failed' as status
+    from Failed)
+    union all
+    (select success_date as event_date, 'succeeded' as status
+    from Succeeded)),
+    cte2 as
+    (select *,
+        row_number() over(order by event_date) as rn,
+        dense_rank() over (partition by status order by event_date) as rnk,
+        row_number() over(order by event_date) - dense_rank() over (partition by status order by event_date) as diff   
+    from cte1
+    where event_date between '2019-01-01' and '2019-12-31'
+    order by 1)
+
+select status as period_state, min(event_date) as start_date, max(event_date) as end_date
+from cte2
+group by status, diff
+order by 2
+
+-- facebook- 1
+
+------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- o/p of cte2
+  
+| event_date | status    | rn | rnk | diff |
+| ---------- | --------- | -- | --- | ---- |
+| 2019-01-01 | succeeded | 1  | 1   | 0    |
+| 2019-01-02 | succeeded | 2  | 2   | 0    |
+| 2019-01-03 | succeeded | 3  | 3   | 0    |
+| 2019-01-04 | failed    | 4  | 1   | 3    |
+| 2019-01-05 | failed    | 5  | 2   | 3    |
+| 2019-01-06 | succeeded | 6  | 4   | 2    |