Add files via upload

Author: mrinal1704

Medium/Capital Gain.sql

@@ -0,0 +1,68 @@
+-- Question 61
+-- Table: Stocks
+
+-- +---------------+---------+
+-- | Column Name   | Type    |
+-- +---------------+---------+
+-- | stock_name    | varchar |
+-- | operation     | enum    |
+-- | operation_day | int     |
+-- | price         | int     |
+-- +---------------+---------+
+-- (stock_name, day) is the primary key for this table.
+-- The operation column is an ENUM of type ('Sell', 'Buy')
+-- Each row of this table indicates that the stock which has stock_name had an operation on the day operation_day with the price.
+-- It is guaranteed that each 'Sell' operation for a stock has a corresponding 'Buy' operation in a previous day.
+ 
+
+-- Write an SQL query to report the Capital gain/loss for each stock.
+
+-- The capital gain/loss of a stock is total gain or loss after buying and selling the stock one or many times.
+
+-- Return the result table in any order.
+
+-- The query result format is in the following example:
+
+-- Stocks table:
+-- +---------------+-----------+---------------+--------+
+-- | stock_name    | operation | operation_day | price  |
+-- +---------------+-----------+---------------+--------+
+-- | Leetcode      | Buy       | 1             | 1000   |
+-- | Corona Masks  | Buy       | 2             | 10     |
+-- | Leetcode      | Sell      | 5             | 9000   |
+-- | Handbags      | Buy       | 17            | 30000  |
+-- | Corona Masks  | Sell      | 3             | 1010   |
+-- | Corona Masks  | Buy       | 4             | 1000   |
+-- | Corona Masks  | Sell      | 5             | 500    |
+-- | Corona Masks  | Buy       | 6             | 1000   |
+-- | Handbags      | Sell      | 29            | 7000   |
+-- | Corona Masks  | Sell      | 10            | 10000  |
+-- +---------------+-----------+---------------+--------+
+
+-- Result table:
+-- +---------------+-------------------+
+-- | stock_name    | capital_gain_loss |
+-- +---------------+-------------------+
+-- | Corona Masks  | 9500              |
+-- | Leetcode      | 8000              |
+-- | Handbags      | -23000            |
+-- +---------------+-------------------+
+-- Leetcode stock was bought at day 1 for 1000$ and was sold at day 5 for 9000$. Capital gain = 9000 - 1000 = 8000$.
+-- Handbags stock was bought at day 17 for 30000$ and was sold at day 29 for 7000$. Capital loss = 7000 - 30000 = -23000$.
+-- Corona Masks stock was bought at day 1 for 10$ and was sold at day 3 for 1010$. It was bought again at day 4 for 1000$ and was sold at day 5 for 500$. At last, it was bought at day 6 for 1000$ and was sold at day 10 for 10000$. Capital gain/loss is the sum of capital gains/losses for each ('Buy' --> 'Sell') 
+-- operation = (1010 - 10) + (500 - 1000) + (10000 - 1000) = 1000 - 500 + 9000 = 9500$.
+
+-- Solution
+select stock_name, (one-two) as capital_gain_loss
+from(
+(select stock_name, sum(price) as one
+from stocks
+where operation = 'Sell'
+group by stock_name) b
+left join
+(select stock_name as name, sum(price) as two
+from stocks
+where operation = 'Buy'
+group by stock_name) c
+on b.stock_name = c.name)
+order by capital_gain_loss desc

Medium/Friend Requests 2.sql

@@ -0,0 +1,45 @@
+-- Question 60
+-- In social network like Facebook or Twitter, people send friend requests and accept others' requests as well.
+
+-- Table request_accepted
+
+-- +--------------+-------------+------------+
+-- | requester_id | accepter_id | accept_date|
+-- |--------------|-------------|------------|
+-- | 1            | 2           | 2016_06-03 |
+-- | 1            | 3           | 2016-06-08 |
+-- | 2            | 3           | 2016-06-08 |
+-- | 3            | 4           | 2016-06-09 |
+-- +--------------+-------------+------------+
+-- This table holds the data of friend acceptance, while requester_id and accepter_id both are the id of a person.
+ 
+
+-- Write a query to find the the people who has most friends and the most friends number under the following rules:
+
+-- It is guaranteed there is only 1 people having the most friends.
+-- The friend request could only been accepted once, which mean there is no multiple records with the same requester_id and accepter_id value.
+-- For the sample data above, the result is:
+
+-- Result table:
+-- +------+------+
+-- | id   | num  |
+-- |------|------|
+-- | 3    | 3    |
+-- +------+------+
+-- The person with id '3' is a friend of people '1', '2' and '4', so he has 3 friends in total, which is the most number than any others.
+
+-- Solution
+select requester_id as id, b.total as num
+from(
+select requester_id, sum(one) as total
+from((
+select requester_id, count(distinct accepter_id) as one
+from request_accepted
+group by requester_id)
+union all
+(select accepter_id, count(distinct requester_id) as two
+from request_accepted
+group by accepter_id)) a
+group by requester_id
+order by total desc) b
+limit 1

Medium/Game Play Analysis 3.sql

@@ -0,0 +1,50 @@
+-- Question 62
+-- Table: Activity
+
+-- +--------------+---------+
+-- | Column Name  | Type    |
+-- +--------------+---------+
+-- | player_id    | int     |
+-- | device_id    | int     |
+-- | event_date   | date    |
+-- | games_played | int     |
+-- +--------------+---------+
+-- (player_id, event_date) is the primary key of this table.
+-- This table shows the activity of players of some game.
+-- Each row is a record of a player who logged in and played a number of games (possibly 0) before logging out on some day using some device.
+ 
+
+-- Write an SQL query that reports for each player and date, how many games played so far by the player. That is, the total number of games played by the player until that date. Check the example for clarity.
+
+-- The query result format is in the following example:
+
+-- Activity table:
+-- +-----------+-----------+------------+--------------+
+-- | player_id | device_id | event_date | games_played |
+-- +-----------+-----------+------------+--------------+
+-- | 1         | 2         | 2016-03-01 | 5            |
+-- | 1         | 2         | 2016-05-02 | 6            |
+-- | 1         | 3         | 2017-06-25 | 1            |
+-- | 3         | 1         | 2016-03-02 | 0            |
+-- | 3         | 4         | 2018-07-03 | 5            |
+-- +-----------+-----------+------------+--------------+
+
+-- Result table:
+-- +-----------+------------+---------------------+
+-- | player_id | event_date | games_played_so_far |
+-- +-----------+------------+---------------------+
+-- | 1         | 2016-03-01 | 5                   |
+-- | 1         | 2016-05-02 | 11                  |
+-- | 1         | 2017-06-25 | 12                  |
+-- | 3         | 2016-03-02 | 0                   |
+-- | 3         | 2018-07-03 | 5                   |
+-- +-----------+------------+---------------------+
+-- For the player with id 1, 5 + 6 = 11 games played by 2016-05-02, and 5 + 6 + 1 = 12 games played by 2017-06-25.
+-- For the player with id 3, 0 + 5 = 5 games played by 2018-07-03.
+-- Note that for each player we only care about the days when the player logged in.
+
+-- Solution
+select player_id, event_date, 
+sum(games_played) over(partition by player_id order by event_date) as games_played_so_far
+from activity
+order by 1,2

Medium/Highest grade for each student.sql

@@ -0,0 +1,45 @@
+-- Question 63
+-- Table: Enrollments
+
+-- +---------------+---------+
+-- | Column Name   | Type    |
+-- +---------------+---------+
+-- | student_id    | int     |
+-- | course_id     | int     |
+-- | grade         | int     |
+-- +---------------+---------+
+-- (student_id, course_id) is the primary key of this table.
+
+-- Write a SQL query to find the highest grade with its corresponding course for each student. In case of a tie, you should find the course with the smallest course_id. The output must be sorted by increasing student_id.
+
+-- The query result format is in the following example:
+
+-- Enrollments table:
+-- +------------+-------------------+
+-- | student_id | course_id | grade |
+-- +------------+-----------+-------+
+-- | 2          | 2         | 95    |
+-- | 2          | 3         | 95    |
+-- | 1          | 1         | 90    |
+-- | 1          | 2         | 99    |
+-- | 3          | 1         | 80    |
+-- | 3          | 2         | 75    |
+-- | 3          | 3         | 82    |
+-- +------------+-----------+-------+
+
+-- Result table:
+-- +------------+-------------------+
+-- | student_id | course_id | grade |
+-- +------------+-----------+-------+
+-- | 1          | 2         | 99    |
+-- | 2          | 2         | 95    |
+-- | 3          | 3         | 82    |
+-- +------------+-----------+-------+
+
+-- Solution
+select student_id, course_id, grade
+from(
+select student_id, course_id, grade,
+rank() over(partition by student_id order by grade desc, course_id) as rk
+from enrollments) a
+where a.rk = 1

Medium/Movie Rating.sql

@@ -0,0 +1,114 @@
+-- Question 59
+-- Table: Movies
+
+-- +---------------+---------+
+-- | Column Name   | Type    |
+-- +---------------+---------+
+-- | movie_id      | int     |
+-- | title         | varchar |
+-- +---------------+---------+
+-- movie_id is the primary key for this table.
+-- title is the name of the movie.
+-- Table: Users
+
+-- +---------------+---------+
+-- | Column Name   | Type    |
+-- +---------------+---------+
+-- | user_id       | int     |
+-- | name          | varchar |
+-- +---------------+---------+
+-- user_id is the primary key for this table.
+-- Table: Movie_Rating
+
+-- +---------------+---------+
+-- | Column Name   | Type    |
+-- +---------------+---------+
+-- | movie_id      | int     |
+-- | user_id       | int     |
+-- | rating        | int     |
+-- | created_at    | date    |
+-- +---------------+---------+
+-- (movie_id, user_id) is the primary key for this table.
+-- This table contains the rating of a movie by a user in their review.
+-- created_at is the user's review date. 
+ 
+
+-- Write the following SQL query:
+
+-- Find the name of the user who has rated the greatest number of the movies.
+-- In case of a tie, return lexicographically smaller user name.
+
+-- Find the movie name with the highest average rating in February 2020.
+-- In case of a tie, return lexicographically smaller movie name.
+
+-- Query is returned in 2 rows, the query result format is in the folowing example:
+
+-- Movies table:
+-- +-------------+--------------+
+-- | movie_id    |  title       |
+-- +-------------+--------------+
+-- | 1           | Avengers     |
+-- | 2           | Frozen 2     |
+-- | 3           | Joker        |
+-- +-------------+--------------+
+
+-- Users table:
+-- +-------------+--------------+
+-- | user_id     |  name        |
+-- +-------------+--------------+
+-- | 1           | Daniel       |
+-- | 2           | Monica       |
+-- | 3           | Maria        |
+-- | 4           | James        |
+-- +-------------+--------------+
+
+-- Movie_Rating table:
+-- +-------------+--------------+--------------+-------------+
+-- | movie_id    | user_id      | rating       | created_at  |
+-- +-------------+--------------+--------------+-------------+
+-- | 1           | 1            | 3            | 2020-01-12  |
+-- | 1           | 2            | 4            | 2020-02-11  |
+-- | 1           | 3            | 2            | 2020-02-12  |
+-- | 1           | 4            | 1            | 2020-01-01  |
+-- | 2           | 1            | 5            | 2020-02-17  | 
+-- | 2           | 2            | 2            | 2020-02-01  | 
+-- | 2           | 3            | 2            | 2020-03-01  |
+-- | 3           | 1            | 3            | 2020-02-22  | 
+-- | 3           | 2            | 4            | 2020-02-25  | 
+-- +-------------+--------------+--------------+-------------+
+
+-- Result table:
+-- +--------------+
+-- | results      |
+-- +--------------+
+-- | Daniel       |
+-- | Frozen 2     |
+-- +--------------+
+
+-- Daniel and Maria have rated 3 movies ("Avengers", "Frozen 2" and "Joker") but Daniel is smaller lexicographically.
+-- Frozen 2 and Joker have a rating average of 3.5 in February but Frozen 2 is smaller lexicographically.
+
+-- Solution
+select name as results
+from(
+(select a.name
+from(
+select name, count(*),
+rank() over(order by count(*) desc) as rk
+from movie_rating m
+join users u 
+on m.user_id = u.user_id
+group by name, m.user_id
+order by rk, name) a
+limit 1)
+union
+(select title
+from(
+select title, round(avg(rating),1) as rnd
+from movie_rating m
+join movies u
+on m.movie_id = u.movie_id
+where month(created_at) = 2
+group by title
+order by rnd desc, title) b
+limit 1)) as d