question_slug
stringlengths 3
77
| title
stringlengths 1
183
| slug
stringlengths 12
45
| summary
stringlengths 1
160
⌀ | author
stringlengths 2
30
| certification
stringclasses 2
values | created_at
stringdate 2013-10-25 17:32:12
2025-04-12 09:38:24
| updated_at
stringdate 2013-10-25 17:32:12
2025-04-12 09:38:24
| hit_count
int64 0
10.6M
| has_video
bool 2
classes | content
stringlengths 4
576k
| upvotes
int64 0
11.5k
| downvotes
int64 0
358
| tags
stringlengths 2
193
| comments
int64 0
2.56k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
product-sales-analysis-iii | MySQL Solution | mysql-solution-by-small_friend-85k8 | SELECT product_id, year AS first_year, quantity, price\nFROM Sales\nWHERE (product_id, year) IN (\nSELECT product_id, MIN(year) as year\nFROM Sales\nGROUP BY pr | Small_friend | NORMAL | 2019-06-06T02:13:56.572755+00:00 | 2019-06-06T02:13:56.572805+00:00 | 19,812 | false | SELECT product_id, year AS first_year, quantity, price\nFROM Sales\nWHERE (product_id, year) IN (\nSELECT product_id, MIN(year) as year\nFROM Sales\nGROUP BY product_id) ; | 65 | 1 | [] | 19 |
product-sales-analysis-iii | MySQL solution MIN(year) group by product_id | mysql-solution-minyear-group-by-product_-jngq | Intuition\n Describe your first thoughts on how to solve this problem. \nselect year of first sold of each prodcut in Sales table\nuse then to filter Sales tabl | andy3278 | NORMAL | 2023-08-16T03:02:53.021460+00:00 | 2023-08-16T03:02:53.021481+00:00 | 20,668 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nselect year of first sold of each prodcut in Sales table\nuse then to filter Sales table\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n# Write your MySQL query statement below\n\n# product id, year, quantity, and price \n# first year of every product sold\n\n\nSELECT product_id, year AS first_year, quantity, price\nFROM Sales\nWHERE (product_id, year) in (\n SELECT product_id, MIN(year) \n FROM Sales\n GROUP BY product_id\n)\n``` | 58 | 0 | ['MySQL'] | 12 |
product-sales-analysis-iii | Clearing aggregation concept (sol. using subquery) | clearing-aggregation-concept-sol-using-s-0dil | Clearing conceptsYou might be thinking just partition/group by product_id and find the min() out of it.So, accordingly below code should work right?But surprisi | aadarshkumar131 | NORMAL | 2025-01-12T12:58:25.684455+00:00 | 2025-01-14T09:40:57.920401+00:00 | 6,494 | false | ## Clearing concepts
You might be thinking just partition/group by `product_id` and find the `min()` out of it.
So, accordingly below code should work right?
```sql
select product_id, min(year) as first_year, quantity, price
from sales
group by product_id
```
**But surprisingly its wrong.**
##### Reason-
> SQL rules state that any column not in the `GROUP BY` clause and not aggregated (like `quantity` and `price`) will return **indeterminate results** from one of the rows in the group.
Just for an example, output **could** be this table (which is not the desired output)
| sale_id | product_id | year | quantity | price |
|---|---|---|---|---|
| 1 | 100 | 2008 | 12 | 5000 |
| 7 | 200 | 2011 | 15 | 9000 |
(notice, how `quantity` of `product_id` 100 is 12 instead of 10, this value 12 has come from its group's neigbour, i.e from the row with `sale_id`= 2)
So now we know this behavior depends on the database implementation.
## Solution-
1. Group by `product_id`, but extract only the `(product_id, min(year))` (to avoid arbitrary values problem as we discussed above)
2. and then filter out table's row based on those extracted `(product_id, min(year))` values
## Correct Code
```mysql []
select product_id, year as first_year, quantity, price
from sales where (product_id, year) in (
select product_id, min(year)
from sales
group by product_id
)
```
NOTE: in the inner query-`product_id`, `min(year)` are part of the `group by` and `aggregation function` respectively, so no arbitrary value can be assigned to them, hence our code is correct
| 31 | 0 | ['MySQL'] | 6 |
product-sales-analysis-iii | Super Each Approach | super-each-approach-by-lovepreet12a-rgi5 | Intuition\n\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Tim | Lovepreet12a | NORMAL | 2023-08-25T19:03:31.401056+00:00 | 2023-08-25T19:03:31.401082+00:00 | 4,306 | false | # Intuition\n\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/* Write your T-SQL query statement below */\n\nSELECT S.product_id, S.year as first_year, S.quantity, S.price\nFROM Sales S\nWHERE S.year IN (SELECT MIN(year) FROM Sales S1 WHERE S.product_id = S1.product_id)\n``` | 23 | 0 | ['MS SQL Server'] | 6 |
product-sales-analysis-iii | Help! Why is my solution wrong? Did I misunderstand the problem? | help-why-is-my-solution-wrong-did-i-misu-1wct | From my understanding, this question is the same as this game analysis 1\nso I wrote similar code as below\n\n# select product_id, min(year), quantity, price f | swallow_liu | NORMAL | 2019-08-30T23:46:05.705590+00:00 | 2019-08-30T23:46:05.705624+00:00 | 4,062 | false | From my understanding, this question is the same as this [game analysis 1](https://leetcode.com/problems/game-play-analysis-i/)\nso I wrote similar code as below\n```\n# select product_id, min(year), quantity, price from Sales \n# group by product_id\n```\n\nwhich does not pass, I saw people wrote below that passed \n\n```\nSELECT product_id, year as first_year, quantity, price\nfrom Sales \nWHERE (product_id, year) IN (SELECT product_id, min(year) as year\nFROM Sales \ngroup by product_id)\n\n```\n\nAm I misunderstanding the problem?\n | 19 | 0 | [] | 6 |
product-sales-analysis-iii | ✅EASY AND SIMPLE SOLUTION✅ | easy-and-simple-solution-by-deleted_user-t7fi | \n# Code\n\n# Write your MySQL query statement below\nselect \n product_id, \n year as first_year, \n quantity, \n price\nfrom \n Sales\nwhere\n | deleted_user | NORMAL | 2024-05-26T15:32:23.449278+00:00 | 2024-05-26T15:32:23.449297+00:00 | 9,112 | false | \n# Code\n```\n# Write your MySQL query statement below\nselect \n product_id, \n year as first_year, \n quantity, \n price\nfrom \n Sales\nwhere\n (product_id, year) in (\n select \n product_id, \n min(year) \n from \n Sales\n group by \n product_id\n )\n``` | 18 | 0 | ['MySQL'] | 6 |
product-sales-analysis-iii | Window function solution | window-function-solution-by-connieee-abwk | \nselect product_id, year as first_year, quantity, price\nfrom(\nselect *,\nrank() over(partition by product_id order by year) as year_rnk\nfrom sales) as tbl\n | connieee | NORMAL | 2019-08-09T19:05:23.253750+00:00 | 2019-08-09T19:05:23.253791+00:00 | 4,444 | false | ```\nselect product_id, year as first_year, quantity, price\nfrom(\nselect *,\nrank() over(partition by product_id order by year) as year_rnk\nfrom sales) as tbl\nwhere year_rnk = 1\n\n``` | 18 | 1 | [] | 6 |
product-sales-analysis-iii | MySQL solution for beginners ✅✅ with explanation for why min(year) alone doesn't work | mysql-solution-for-beginners-with-explan-6iaz | \n\n# Approach\nSELECT product_id, MIN(year) as first_year, quantity, price FROM Sales GROUP BY product_id) \nThis will not work as when you ask for the MIN yea | Samar3007 | NORMAL | 2023-08-22T16:56:38.541355+00:00 | 2023-08-22T16:56:38.541380+00:00 | 2,631 | false | \n\n# Approach\nSELECT product_id, MIN(year) as first_year, quantity, price FROM Sales GROUP BY product_id) \nThis will not work as when you ask for the MIN year it will inspect each year from the pool and return it, but it will not select the entire row after returning the year.\n\nLet\'s say we have this input:\n\n| sale_id | product_id | year | quantity | price |\n| 1 | 400 | 2008 | 10 | 5000 |\n| 2 | 400 | 2009 | 12 | 5000 |\n| 3 | 400 | 2012 | 14 | 5500 |\n| 7 | 600 | 2012 | 15 | 9000 |\n\nIf we don\'t use the product_id, we end up with this result:\n\n| product_id | first_year | quantity | price |\n| 400 | 2008 | 10 | 5000 |\n| 400 | 2012 | 14 | 5500 |\n| 600 | 2012 | 15 | 9000 |\n\nFor more info refer this http://bernardoamc.github.io/sql/2015/05/04/group-by-non-aggregate-columns/ \n\n# Code\n```\n# Write your MySQL query statement below\nSELECT product_id, year as first_year, quantity, price \nfrom Sales \nwhere (product_id, year) in (\n SELECT product_id, min(year) as year \n from Sales \n group by product_id \n )\n``` | 16 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | MySQL simple solution, beats 90%, w/o window functions | mysql-simple-solution-beats-90-wo-window-vi7p | \nselect\n product_id,\n year as first_year,\n quantity,\n price\nfrom Sales\nwhere (product_id, year) in (select product_id, min(year) from Sales g | zhihui329 | NORMAL | 2020-12-24T08:16:25.239498+00:00 | 2020-12-24T08:16:25.239537+00:00 | 4,119 | false | ```\nselect\n product_id,\n year as first_year,\n quantity,\n price\nfrom Sales\nwhere (product_id, year) in (select product_id, min(year) from Sales group by 1)\n``` | 16 | 0 | ['MySQL'] | 3 |
product-sales-analysis-iii | pandas || 2 lines, rank, merge || T/S: 92% / 99% | pandas-2-lines-rank-merge-ts-92-99-by-sp-f28l | \nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n\n sales[\'rnk\'] = sales.groupby([\'product_id\']) | Spaulding_ | NORMAL | 2024-05-15T21:01:30.358458+00:00 | 2024-05-31T22:33:29.097319+00:00 | 3,137 | false | ```\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n\n sales[\'rnk\'] = sales.groupby([\'product_id\'])[\'year\'\n ].rank(method=\'dense\')\n \n return sales.loc[sales.rnk == 1\n ].merge(product).iloc[:,[1,2,3,4]\n ].rename(columns = {\'year\': \'first_year\'})\n```\n[https://leetcode.com/problems/product-sales-analysis-iii/submissions/1088479316/](https://leetcode.com/problems/product-sales-analysis-iii/submissions/1088479316/)\n\n\n\nI could be wrong, but I think that time complexity is *O*(*N* log *N*) and space complexity is *O*(*N*), in which *N* ~ `len(sales)`. | 14 | 0 | ['Pandas'] | 1 |
product-sales-analysis-iii | MySQL Solution for Product Sales Analysis III Problem | mysql-solution-for-product-sales-analysi-gmdg | Intuition\n Describe your first thoughts on how to solve this problem. \nThe intuition behind the given solution is to retrieve the first year of sale for each | Aman_Raj_Sinha | NORMAL | 2023-05-18T03:36:14.667165+00:00 | 2023-05-18T03:36:14.667214+00:00 | 8,248 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe intuition behind the given solution is to retrieve the first year of sale for each product along with the corresponding quantity and price information from the Sales table. The approach involves using a subquery to identify the minimum year for each product and then filtering the Sales table based on the product_id and year values.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. In the subquery, select the product_id and the minimum year for each product by grouping the Sales table by product_id and using the aggregate function min(year). Alias this column as "year".\n1. In the main query, select the product_id, year (aliased as "first_year"), quantity, and price columns from the Sales table.\n1. Add a filter condition to the main query to include only the rows where the product_id and year values match the results from the subquery.\n1. Return the resulting rows.\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity of this solution depends on the size of the Sales table and the efficiency of the grouping and filtering operations. If the Sales table is properly indexed on the product_id and year columns, the subquery and filtering can be performed efficiently. The time complexity of the subquery and filtering can be estimated as O(n * log n), where n is the number of rows in the Sales table.\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity of this solution depends on the size of the resulting dataset, which includes the selected columns from the Sales table.\n\n# Code\n```\n# Write your MySQL query statement below\nselect product_id, year as first_year, quantity, price from Sales \nwhere (product_id, year) in (select product_id, min(year) as year from Sales group by product_id)\n``` | 14 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | 2 PostgreSQL solutions | 2-postgresql-solutions-by-alexlinus-7ea2 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Code\n\npostgresql []\nSELECT \n Sales.product_id as product_id,\n Sales.year | alexlinus | NORMAL | 2024-11-02T02:01:48.187760+00:00 | 2024-11-02T02:01:48.187780+00:00 | 1,111 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Code\n\n```postgresql []\nSELECT \n Sales.product_id as product_id,\n Sales.year as first_year,\n Sales.quantity as quantity,\n Sales.price as price\nFROM Sales\nJOIN (\n SELECT product_id, MIN(year) AS first_year\n FROM Sales\n GROUP BY product_id\n) as Selftable ON Sales.product_id = Selftable.product_id AND Sales.year = Selftable.first_year; \n```\n\n```\nSELECT \n product_id,\n year AS first_year,\n quantity,\n price\nFROM Sales\nWHERE (product_id, year) IN (\n SELECT product_id, MIN(year)\n FROM Sales\n GROUP BY product_id\n);\n```\n\n\n | 12 | 0 | ['PostgreSQL'] | 0 |
product-sales-analysis-iii | Is the expected solution correct? | is-the-expected-solution-correct-by-hsta-1rzr | Shortened the second test case for displayability. Below is the table screenshot. \nExpected output of OJ is actually the minimum year of a product_id, with qua | hstangnatsh | NORMAL | 2019-06-02T14:03:07.312930+00:00 | 2019-06-02T14:09:21.273717+00:00 | 3,212 | false | Shortened the second test case for displayability. Below is the table screenshot. \nExpected output of OJ is actually the **minimum** year of a product_id, with quantity and price of the **first** row. That\'s obviously an outcome from query similar with \n```\nselect product_id, min(year), quantity, price \nfrom Sales \ngroup by product_id \n``` \nin which those ungrouped fields with mutiple values only shows the first row.\nIt hardly has anything to do with the discreption "product id, year, quantity, and price **for the first year** of every product sold."\n\n\nMy failed code was:\n```\nselect Sales.product_id as product_id, Sales.year as first_year, quantity, price\nfrom Sales, (select product_id as id, min(year) as my\nfrom Sales\ngroup by product_id) t\nwhere Sales.product_id=t.id and Sales.year=t.my\norder by product_id\n``` | 10 | 0 | [] | 10 |
product-sales-analysis-iii | Easy and Simple Solution | Beginner-friendly🚀 | easy-and-simple-solution-beginner-friend-igrf | CodeIf you found this solution helpful, please give it an upvote! 🌟✨ It really motivates me to share more solutions like this. 😊👍
Happy coding! 💻🐱🏍
IntuitionWe | Yadav_Akash_ | NORMAL | 2025-02-09T13:00:01.835537+00:00 | 2025-02-09T13:00:01.835537+00:00 | 2,522 | false | # Code
```mysql []
# Write your MySQL query statement below
select product_id,year as first_year, quantity, price
from Sales
where (product_id,year) in (select product_id, min(year) from Sales group by product_id)
```
**If you found this solution helpful, please give it an upvote! 🌟✨ It really motivates me to share more solutions like this. 😊👍
Happy coding! 💻🐱🏍**
<img src="https://assets.leetcode.com/users/images/6e8c623a-1111-4d21-9a5b-54e00e7feabb_1738093236.165277.jpeg" width=250px>
# Intuition
We need to find the **first year** each product appeared in the `Sales` table along with its `quantity` and `price` for that year. The `Sales` table contains multiple records for different `product_id`s over different `year`s, so we must identify the earliest year for each product.
# Approach
1. **Find the earliest year each product was sold**
- Use `MIN(year)` to get the first occurrence of each `product_id`.
- Group by `product_id` to ensure we retrieve only the first year.
2. **Filter only records corresponding to the first year**
- Use a `WHERE (product_id, year) IN (...)` condition to match rows where `year` is the **earliest year** for that `product_id`.
3. **Select the required columns**
- Return `product_id`, rename `year` as `first_year`, and include `quantity` and `price`.
# Complexity Analysis
- **Finding the first year (`MIN(year) GROUP BY product_id`)**
- This requires scanning and grouping by `product_id`, leading to **O(N log P)** complexity, where `P` is the number of unique products.
- **Filtering with `IN` clause**
- The `(product_id, year) IN (...)` condition involves checking each record against the first-year subquery, leading to approximately **O(N log P)** complexity.
- **Final selection of columns (`SELECT product_id, year, quantity, price`)**
- Runs in **O(N)**.
### **Overall Complexity:**
- The dominant steps are **grouping and filtering**, leading to an approximate **O(N log P) ≈ O(N log N)** complexity in the worst case. | 9 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Only JOIN and WITH (Common Table Expressions) | only-join-and-with-common-table-expressi-mxyw | \n\nWITH min_year_table AS (\nSELECT product_id, min(year) min_year\nFROM sales\nGROUP BY product_id)\n\nSELECT s.product_id, s.year first_year, quantity, price | SergeyZhirkov | NORMAL | 2023-08-20T22:16:46.775462+00:00 | 2024-09-22T18:59:52.259361+00:00 | 806 | false | \n```\nWITH min_year_table AS (\nSELECT product_id, min(year) min_year\nFROM sales\nGROUP BY product_id)\n\nSELECT s.product_id, s.year first_year, quantity, price\nFROM sales s\nJOIN min_year_table m ON s.product_id = m.product_id and s.year = m.min_year\n```\n\n\n | 9 | 0 | ['MySQL'] | 5 |
product-sales-analysis-iii | Without using any fancy Keyword || Simple JOINs used ✅✅ | without-using-any-fancy-keyword-simple-j-2zdu | Code\n\nselect s.product_id, s.year as first_year, s.quantity, s.price\nfrom Sales s\njoin (select product_id, min(year) as year from sales group by product_id) | Lil_ToeTurtle | NORMAL | 2023-06-14T07:53:57.432026+00:00 | 2023-06-14T07:53:57.432045+00:00 | 3,727 | false | # Code\n```\nselect s.product_id, s.year as first_year, s.quantity, s.price\nfrom Sales s\njoin (select product_id, min(year) as year from sales group by product_id) ss\non s.product_id = ss.product_id and s.year = ss.year\n``` | 9 | 0 | ['Oracle'] | 1 |
product-sales-analysis-iii | Easy way using IN operator | MySQL | easy-way-using-in-operator-mysql-by-lutf-94di | Intuition\n Describe your first thoughts on how to solve this problem. \nOur task is to find the product_id, year, quantity, and price for the first year of eve | lutfiddindev | NORMAL | 2023-11-06T06:55:41.544016+00:00 | 2023-11-06T06:55:41.544063+00:00 | 2,801 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nOur task is to find the `product_id`, `year`, `quantity`, and `price` for the first year of every product sold.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n> `IN` \u2192 This operator allows to specify multiple values\n> `MIN()` \u2192 This function returns the smallest value of the selected column\n> `GROUP BY` \u2192 This command groups rows that have the same values into summary rows, typically to perform aggregate functions on them\n\n# Code\n```\n# Write your MySQL query statement below\nSELECT product_id, year AS first_year, quantity, price \nFROM sales\nWHERE (product_id, year) IN (\n SELECT product_id, MIN(year) \n FROM sales \n GROUP BY product_id\n);\n``` | 8 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | ✅ Simple solution using only CTE ✅ | simple-solution-using-only-cte-by-daniel-crn5 | \n\n# Approach\n Describe your approach to solving the problem. \nFirst prepared the temp table that has the MIN year for the particular product_id (GROUP BY).\ | Daniel_Charles_J | NORMAL | 2024-09-24T06:01:34.658265+00:00 | 2024-09-24T06:01:34.658294+00:00 | 1,487 | false | \n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nFirst prepared the temp table that has the MIN year for the particular product_id (GROUP BY).\n\nThen by using this record, fetched the desired rows from Sales table.\n\nNOTE : No need for JOIN here, because we don\'t need to show the product_name from the Product table, If required in future we can join both table with product_id.\n\n# Code\n```postgresql []\n-- Write your PostgreSQL query statement below\nWITH temp as (SELECT product_id, MIN(year) as first_year FROM Sales GROUP BY product_id)\n\nSELECT s.product_id,s.year as first_year, s.quantity,s.price \nFROM Sales s \nWHERE (s.product_id,s.year) IN (SELECT product_id,first_year FROM temp)\n``` | 7 | 0 | ['PostgreSQL'] | 0 |
product-sales-analysis-iii | ✅Easiest Basic Sql Solution |4 Approaches| Beginner Level to Advance🏆 | easiest-basic-sql-solution-4-approaches-u5a2f | null | dev_yash_ | NORMAL | 2024-03-15T13:25:50.533124+00:00 | 2025-04-06T06:28:20.217477+00:00 | 4,367 | false | ```sql
#Approach 1 :Subquery and Join
SELECT
Sales.product_id,
SubSales.first_year,
Sales.quantity,
Sales.price
FROM
Sales
JOIN
(
SELECT
product_id,
MIN(year) AS first_year
FROM
Sales
GROUP BY
product_id
) AS SubSales #subtable 1
ON Sales.product_id = SubSales.product_id AND Sales.year = SubSales.first_year;
```
```sql
#Approach 2; Using IN
SELECT product_id, year AS first_year, quantity, price
FROM Sales
WHERE (product_id, year) in (
SELECT product_id, MIN(year)
FROM Sales
GROUP BY product_id
)
```
```sql
#Approach 3: Cross Join
SELECT s.product_id, sub.min_year AS first_year, s.quantity, s.price
FROM Sales s
CROSS JOIN (
SELECT product_id, MIN(year) AS min_year
FROM Sales
GROUP BY product_id
) AS sub
WHERE s.product_id = sub.product_id AND s.year = sub.min_year;
```
```sql
#Approach 4 : Using Except
SELECT product_id, year AS first_year, quantity, price
FROM Sales
EXCEPT
SELECT s1.product_id, s1.year, s1.quantity, s1.price
FROM Sales s1
JOIN Sales s2 ON s1.product_id = s2.product_id AND s1.year > s2.year; | 7 | 0 | ['MySQL', 'MS SQL Server'] | 2 |
product-sales-analysis-iii | ✔✔✔simple solution with simple explanation - PANDAS | simple-solution-with-simple-explanation-5q51d | Code\n\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n # Merge sales and product tables\n merged | anish_sule | NORMAL | 2024-02-02T09:52:31.967200+00:00 | 2024-02-02T09:52:31.967230+00:00 | 559 | false | # Code\n```\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n # Merge sales and product tables\n merged_df = sales.merge(product, how=\'left\', on=\'product_id\')\n \n # Find the first year of sale for each product\n first_year_df = merged_df.groupby(\'product_id\')[\'year\'].min().reset_index()\n \n # Merge the first year information back to the merged dataframe to get the corresponding quantity and price\n result_df = first_year_df.merge(merged_df, how=\'inner\', on=[\'product_id\', \'year\']).rename(columns = {\'year\' : \'first_year\'})\n \n return result_df[[\'product_id\', \'first_year\', \'quantity\', \'price\']]\n``` | 7 | 0 | ['Database', 'Pandas'] | 1 |
product-sales-analysis-iii | Medium🔥 | Easy Approach 2023🤝|| Explained 📝|| SQL50/25✅ | medium-easy-approach-2023-explained-sql5-i0u5 | Hello LeetCode fans,\nBelow I presented a solution to the problem (1070. Product Sales Analysis III).\nIf you found it useful or informative,\nClick the "UPVOTE | komronabdulloev | NORMAL | 2023-10-26T21:34:03.480814+00:00 | 2023-10-26T21:34:03.480875+00:00 | 1,467 | false | # Hello LeetCode fans,\nBelow I presented a solution to the problem (1070. Product Sales Analysis III).\nIf you found it `useful` or `informative`,\nClick the "`UPVOTE`" button below and it means I was able to `help someone.`\nYour UPVOTES encourage me and others who are `working hard` to improve their problem solving skills.\n# Code\n```\nSELECT PRODUCT_ID, YEAR \nAS FIRST_YEAR, QUANTITY, PRICE\n FROM (SELECT PRODUCT_ID,\n YEAR, QUANTITY,PRICE, rank() OVER(\n PARTITION BY PRODUCT_ID ORDER BY YEAR) RN\n FROM SALES ) _rank WHERE _rank.RN=1 ORDER BY PRODUCT_ID\n``` | 7 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | Easy Soution with Step by Step Explanation | easy-soution-with-step-by-step-explanati-rqly | Intuition\nImagine you have a list of all the sales made by a store, and each sale has information about the product sold, the date of the sale, how many of the | deepankyadav | NORMAL | 2023-07-28T07:11:43.586342+00:00 | 2023-07-28T07:11:43.586371+00:00 | 3,065 | false | # Intuition\nImagine you have a list of all the sales made by a store, and each sale has information about the product sold, the date of the sale, how many of the product were sold, and the price of each unit. Now, we want to figure out which products were sold more than once on the same day and how much money was made from those products.\n\n# Approach\nHere\'s how we can approach the problem using SQL (a language for working with databases):\n\n1. First, we need to look at the sales data and identify products that were sold in their first year. We do this by finding the minimum year for each product.\n\n1. Once we know which products were sold in their first year, we can use that information to calculate the total sales amount for each of these products on each day they were sold.\n\n1. Finally, we\'ll add up the total sales amounts for all the products that were sold more than once on the same day.\n\n# **SQL Query Steps:**\nHere\'s the SQL query that accomplishes the above steps:\n\n**Subquery (finding first year sales):**\n\n1. We create a small "temporary" table by using a subquery. This table will contain the product_id and the minimum year of sale for each product. This subquery groups the sales data by product_id and finds the minimum year for each product using the MIN() function.\n1. So, in this temporary table, we have one row for each product, showing which year it was first sold.\n\n**Main Query (calculating total sales amount):**\n\n1. We use the main query to retrieve the product_id, year, quantity sold, and price for all sales data.\n1. We then filter the results to only include rows where the product was sold in its first year. We do this by matching the product_id and year with the product_id and minimum year from the temporary table we created in the subquery.\n\n**Summing up the total sales amount:**\n\n1. With the filtered results, we now have the sales data for products that were sold in their first year. We calculate the total sales amount for each product on each day they were sold. This is done by multiplying the quantity sold with the price per unit for each sale.\n1. Finally, we add up the total sales amounts for all the products that were sold more than once on the same day.\n\n# Complexity\n- Time complexity:\nThe time complexity is $$O(NlogN)$$, where N is the number of rows in the "Sales" table. The main contributor to this time complexity is the subquery, which involves grouping and finding the minimum year for each product_id, and this operation takes $$O(NlogN)$$ time.\n\n\n- Space complexity:\nThe space complexity is $$O(N)$$, where N is the number of unique products in the "Sales" table. The subquery creates a temporary table with one row for each unique product_id, leading to O(N) space usage.\n\n\n# Code\n```\n# Write your MySQL query statement below\n\nselect\n product_id,\n year as first_year,\n quantity,\n price\nfrom Sales\nwhere (product_id, year) in (select product_id, min(year) from Sales group by 1)\n\n``` | 7 | 0 | ['Database', 'MySQL'] | 4 |
product-sales-analysis-iii | 🔥🔥🔥 3 solutions in MySQL | Beats 66.61%🔥🔥🔥 | 3-solutions-in-mysql-beats-6661-by-prito-t09p | 1. GROUP BY & Sub-query with 1080ms Runtime (Beats 66.61%)\n- Time complexity: O(n log n) + O(NM) (with indexing optimizations)\n- Space complexity: O(m)\n\n# C | pritom5928 | NORMAL | 2024-11-06T05:00:11.106047+00:00 | 2024-11-06T05:00:11.106071+00:00 | 1,798 | false | # 1. GROUP BY & Sub-query with 1080ms Runtime (Beats 66.61%)\n- **Time complexity:** O(n log n) + O(N*M) (with indexing optimizations)\n- **Space complexity:** O(m)\n\n# Code\n```mysql []\nSELECT \n product_id,\n year AS first_year,\n quantity ,\n price\nFROM sales \nWHERE (product_id, year) IN (\n SELECT \n product_id,\n MIN(year) AS first_year\n FROM sales\n GROUP BY product_id\n);\n```\n\n# 2. Window function with 1094ms Runtime (Beats 63.36%)\n- **Time complexity:** O(n log n)\n- **Space complexity:** O(n)\n\n# Code\n```mysql []\nSELECT \n res.product_id,\n res.min_year AS first_year,\n res.quantity,\n res.price\nFROM (\n SELECT \n a.*,\n MIN(year) OVER (PARTITION BY product_id) AS min_year\n FROM sales a\n) res\nWHERE res.year = res.min_year;\n```\n\n# 3. CTE & JOIN with 1091ms Runtime (Beats 64.01%)\n- **Time complexity:** O(n)\n- **Space complexity:** O(n)\n\n# Code\n```mysql []\nWITH min_year_cte AS (\n SELECT \n product_id,\n MIN(year) AS min_year\n FROM sales\n GROUP BY product_id\n)\nSELECT \n s.product_id,\n my.min_year AS first_year,\n s.quantity,\n s.price\nFROM sales s\nJOIN min_year_cte my ON s.product_id = my.product_id AND s.year = my.min_year;\n``` | 5 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | easiest solution in MySql | easiest-solution-in-mysql-by-mantosh_kum-sruj | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | mantosh_kumar04 | NORMAL | 2024-08-25T09:03:26.710575+00:00 | 2024-08-25T09:03:26.710603+00:00 | 3,064 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```mysql []\n# Write your MySQL query statement below\nselect product_id , year as first_year, quantity, price\nfrom Sales \nwhere (product_id, year) in (select product_id, min(year)as year from Sales \ngroup by product_id);\n``` | 5 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Simple MySQL solution | simple-mysql-solution-by-_preeti-a9aq | \n# Code\n\nselect distinct product_id, year as first_year, quantity, price \nfrom Sales \nwhere ((product_id, year) in (select product_id, min(year) from sales | _preeti | NORMAL | 2024-03-10T13:38:05.912562+00:00 | 2024-03-10T13:38:05.912595+00:00 | 1,384 | false | \n# Code\n```\nselect distinct product_id, year as first_year, quantity, price \nfrom Sales \nwhere ((product_id, year) in (select product_id, min(year) from sales group by product_id))\n``` | 5 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Step by step solution development | Easy to understand | step-by-step-solution-development-easy-t-vv85 | Steps: \n1. Find the First Year of Sale for Each Product\n2. Product Details for the First Year of Every Product Sold\n3. Summary\n\n# Code\n\nSELECT product_id | Pacman45 | NORMAL | 2023-12-28T15:36:43.573073+00:00 | 2023-12-28T15:36:43.573099+00:00 | 1,500 | false | # Steps: \n1. Find the First Year of Sale for Each Product\n2. Product Details for the First Year of Every Product Sold\n3. Summary\n\n# Code\n```\nSELECT product_id, year AS first_year, quantity, price\nFROM sales\nWHERE (product_id, year) IN (\n SELECT product_id, MIN(year)\n FROM sales\n GROUP BY product_id\n)\n```\n```\nSales table:\n+---------+------------+------+----------+-------+\n| sale_id | product_id | year | quantity | price |\n+---------+------------+------+----------+-------+ \n| 1 | 100 | 2008 | 10 | 5000 |\n| 2 | 100 | 2009 | 12 | 5000 |\n| 7 | 200 | 2011 | 15 | 9000 |\n+---------+------------+------+----------+-------+\nProduct table:\n+------------+--------------+\n| product_id | product_name |\n+------------+--------------+\n| 100 | Nokia |\n| 200 | Apple |\n| 300 | Samsung |\n+------------+--------------+\n```\n\n## Step 1: Find the First Year of Sale for Each Product\n```\nSELECT \n product_id,\n MIN(year) AS first_year\nFROM \n Sales\nGROUP BY \n product_id;\n```\n\n## Result:\n\n```\n+------------+------------+\n| product_id | first_year |\n+------------+------------+\n| 100 | 2008 |\n| 200 | 2011 |\n+------------+------------+\n```\n\n## Step 2: Select the Product Details for the First Year of Every Product Sold\n```\nSELECT \n product_id,\n year AS first_year,\n quantity,\n price\nFROM \n Sales\nWHERE \n (product_id, year) IN \n (\n -- Subquery: First year of sale for each product\n SELECT \n product_id,\n MIN(year) AS first_year\n FROM \n Sales\n GROUP BY \n product_id\n );\n```\n\n## Result:\n\n```\n+------------+------------+----------+-------+\n| product_id | first_year | quantity | price |\n+------------+------------+----------+-------+\n| 100 | 2008 | 10 | 5000 |\n| 200 | 2011 | 15 | 9000 |\n+------------+------------+----------+-------+\n```\n\n## Summary: \nThus final query selects the `product id, year, quantity, and price` for the `first year of every product sold`, based on the results obtained from the subquery. \n\nIn above example, it shows the details for the first year of sale for products with ids 100 and 200. | 5 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | Pandas oneliner, groupby with transform, no merge needed | pandas-oneliner-groupby-with-transform-n-zved | Intuition\nWe simply have to find minimum year for each product, which you could do with transform - it is equivallent of window functions in SQL or pyspark.\n\ | piocarz | NORMAL | 2023-08-19T06:26:10.623177+00:00 | 2023-08-19T07:39:28.062306+00:00 | 650 | false | # Intuition\nWe simply have to find minimum year for each product, which you could do with transform - it is equivallent of window functions in SQL or pyspark.\n\n# Approach\n1. Create new column with minium year for each product:\n`sales.assign(first_year = sales.groupby(\'product_id\').year.transform(min))`\n2. Select only rows, where created first_year == year:\n`.query("first_year == year")`\n3. And finally select only relevant columns:\n`.iloc[:,[1,5,3,4]]`\n\n- Notice, that we dont have to use second dataframe at all, since all required columns are from `sales`\n\n**CAUTION**: however `.iloc[]` passes all testcases, it is always best practice to select by actual column names, becouse in case of merging empty dataframes, order of columns may change.\n`[[\'product_id\',\'first_year\',\'quantity\',\'product_name\']]`\n\n# Code\n```\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n return sales.assign(first_year = sales.groupby(\'product_id\').year.transform(min)).query("first_year == year").iloc[:,[1,5,3,4]]\n``` | 5 | 0 | ['Pandas'] | 2 |
product-sales-analysis-iii | MYSQL : Two Solution - Window Function/ Subquery. Good Luck 👍✨ | mysql-two-solution-window-function-subqu-43oi | \n# Write your MySQL query statement below\n/**\nTwo Tables: Sales/Product\n\n(sale_id, year) is the primary key of Sales table.\nproduct_id is a foreign key to | ashlyjoseph | NORMAL | 2022-08-29T16:31:26.936459+00:00 | 2022-08-29T16:31:26.936489+00:00 | 3,448 | false | ```\n# Write your MySQL query statement below\n/**\nTwo Tables: Sales/Product\n\n(sale_id, year) is the primary key of Sales table.\nproduct_id is a foreign key to Product table.\nSales table shows a sale on the product product_id in a certain year.\nNote that the price is per unit.\n\nproduct_id is the primary key of Product table.\nProduct table indicates the product name of each product.\n\nPROBLEM: selects the product id, year, quantity, and price for the first year of every product sold\n*/\n#First Solution\n\nWITH CTE AS\n(\n SELECT \n product_id,\n MIN(year) AS first_year\n FROM Sales\n GROUP BY 1\n)\nSELECT \n product_id,\n year AS first_year,\n quantity,\n price\nFROM Sales \nWHERE (product_id, year) in (select * from CTE)\n\n#Second Solution\n\nWITH CTE AS\n(\nSELECT\n product_id,\n year,\n quantity,\n price,\n dense_rank() over(partition by product_id order by year asc) as rnk\nFROM Sales\n)\n\nSELECT\n product_id,\n year AS first_year,\n quantity,\n price\nFROM CTE where rnk = 1\n``` | 5 | 0 | ['MySQL'] | 3 |
product-sales-analysis-iii | mysql intuitive and easy solution | mysql-intuitive-and-easy-solution-by-jad-zxtt | \nselect product_id, year as first_year, quantity, price from sales\nwhere (product_id, year) in\n\n(\nselect product_id, min(year) from sales\ngroup by product | jadecheng258 | NORMAL | 2019-11-27T20:25:24.567493+00:00 | 2019-11-27T20:25:24.567527+00:00 | 907 | false | ```\nselect product_id, year as first_year, quantity, price from sales\nwhere (product_id, year) in\n\n(\nselect product_id, min(year) from sales\ngroup by product_id\n )\n``` | 5 | 0 | [] | 0 |
product-sales-analysis-iii | simple solution, not using join | simple-solution-not-using-join-by-phong-i2sur | Code | phong-sudo252 | NORMAL | 2025-01-07T13:37:49.801167+00:00 | 2025-01-07T13:37:49.801167+00:00 | 1,107 | false |
# Code
```mysql []
select product_id, year as first_year, quantity, price
from Sales
where (product_id, year) in (
select product_id, min(year)
from Sales
group by product_id
)
``` | 4 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | MySQL | GROUP BY | mysql-group-by-by-sudhikshaghanathe-uk4v | \n\n# Code\nmysql []\n# Write your MySQL query statement below\nSELECT PRODUCT_ID, YEAR AS FIRST_YEAR, QUANTITY, PRICE FROM SALES\nWHERE (PRODUCT_ID, YEAR) IN \ | SudhikshaGhanathe | NORMAL | 2024-09-21T10:50:41.745270+00:00 | 2024-09-21T10:50:41.745304+00:00 | 2,991 | false | \n\n# Code\n```mysql []\n# Write your MySQL query statement below\nSELECT PRODUCT_ID, YEAR AS FIRST_YEAR, QUANTITY, PRICE FROM SALES\nWHERE (PRODUCT_ID, YEAR) IN \n(SELECT PRODUCT_ID, MIN(YEAR) AS YEAR FROM SALES \nGROUP BY PRODUCT_ID); \n``` | 4 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | MS SQL Solution, Beats 93.15% | ms-sql-solution-beats-9315-by-kristina_m-2kzx | Code\n\n/* Write your T-SQL query statement below */\nselect s1.product_id, s2.first_year, quantity, price \nfrom Sales s1 join (\n select product_id, min(ye | Kristina_m | NORMAL | 2024-07-24T11:31:17.400908+00:00 | 2024-07-24T11:31:17.400928+00:00 | 1,320 | false | # Code\n```\n/* Write your T-SQL query statement below */\nselect s1.product_id, s2.first_year, quantity, price \nfrom Sales s1 join (\n select product_id, min(year) as first_year from Sales \n group by product_id\n ) s2\non s1.product_id = s2.product_id and s1.year = s2.first_year \n\n```\n\n\n | 4 | 0 | ['MS SQL Server'] | 2 |
product-sales-analysis-iii | MySql | mysql-by-shyambabujayswal-q26c | \nSELECT\n product_id, \n year first_year,\n quantity,\n price\nFROM\n Sales\nWHERE\n (product_id, year) \n IN\n (\n SELECT\n | ShyamBabuJayswal | NORMAL | 2024-03-04T03:09:07.942792+00:00 | 2024-03-04T03:09:07.942835+00:00 | 1,507 | false | \nSELECT\n product_id, \n year first_year,\n quantity,\n price\nFROM\n Sales\nWHERE\n (product_id, year) \n IN\n (\n SELECT\n product_id,\n MIN(year) first_year\n FROM\n Sales\n GROUP BY\n product_id\n )\n | 4 | 0 | ['MySQL'] | 4 |
product-sales-analysis-iii | ✅ Oracle. MySQL Solution with CTE - Common Table Expression Approach | oracle-mysql-solution-with-cte-common-ta-z23j | Intuition\n Describe your first thoughts on how to solve this problem. \nIn this query, a common table expression (CTE) first_year_sales is used to find the fir | nkorgik | NORMAL | 2023-06-08T02:55:12.256690+00:00 | 2023-06-08T02:55:12.256740+00:00 | 2,842 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nIn this query, a common table expression (CTE) first_year_sales is used to find the first year of sales for each product. Then we join this CTE with the Sales table to get the corresponding quantity and price information for the first year of each product.\n\n\n# Code\n```\n# Write your MySQL query statement below\n\nWITH first_year_sales AS (\n SELECT \n s.product_id,\n MIN(s.year) AS first_year\n FROM \n Sales s\n INNER JOIN \n Product p ON p.product_id = s.product_id\n GROUP BY \n s.product_id\n)\n\nSELECT \n f.product_id,\n f.first_year,\n s.quantity,\n s.price\nFROM \n first_year_sales f\nJOIN \n Sales s ON f.product_id = s.product_id AND f.first_year = s.year\n\n``` | 4 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | Easy Solution | easy-solution-by-ayu_0308958-f5jn | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | Ayu_0308958 | NORMAL | 2023-06-02T12:21:42.434841+00:00 | 2023-06-02T12:21:42.434888+00:00 | 3,771 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n\nSelect product_id,(year) as first_year,quantity,price from Sales where (product_id,year) in (select product_id,min(year) from sales group by product_id);\n\n``` | 4 | 0 | ['MySQL', 'Ruby', 'Oracle', 'MS SQL Server'] | 5 |
product-sales-analysis-iii | MySQL Solution | mysql-solution-by-thehawk-0j0j | Apparently, the store can have different prices and quantities for the same product in a given year. \nThe problem does not explicitly mention this.\n\nWITH cte | thehawk | NORMAL | 2021-09-12T01:43:41.219560+00:00 | 2021-09-12T01:43:41.219592+00:00 | 370 | false | Apparently, the store can have different prices and quantities for the same product in a given year. \nThe problem does not explicitly mention this.\n```\nWITH cte AS (\n\nSELECT\n product_id,\n MIN(year) as first_year\nFROM\n sales\nGROUP BY\n product_id\nORDER BY\n product_id\n)\n\nSELECT\n t1.product_id,\n t1.year as "first_year",\n t1.quantity,\n t1.price\nFROM\n sales t1\nINNER JOIN\n cte t2\nON\n t1.product_id = t2.product_id\nAND\n t1.year = t2.first_year;\n \n``` | 4 | 0 | [] | 0 |
product-sales-analysis-iii | NO JOINS -> filter with DENSE_RANK() | no-joins-filter-with-dense_rank-by-artam-mt7l | Intuitionthe clue was "for the first year of every product sold."Approachrank them by YEAR (ORDER BY year) and split them on product_id (PARTITION BY product_id | artameviaaa | NORMAL | 2025-03-01T04:27:45.979132+00:00 | 2025-03-01T04:27:45.979132+00:00 | 597 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
the clue was ***"for the first year of every product sold."***
# Approach
<!-- Describe your approach to solving the problem. -->
rank them by YEAR (ORDER BY year) and split them on product_id (PARTITION BY product_id)
# Code
```mysql []
SELECT product_id, year AS first_year, quantity, price
FROM (
SELECT product_id, year, quantity, price,
DENSE_RANK() OVER (PARTITION BY product_id ORDER BY year) AS rn
FROM Sales
) AS s
WHERE rn = 1;
``` | 3 | 0 | ['Database', 'MySQL'] | 1 |
product-sales-analysis-iii | 1070. Solution of Product Sales Analysis III | 1070-solution-of-product-sales-analysis-1vx7k | \n\n# Approach\nDivide given problem into sub problems in first step have to print \n\' product id, year, quantity, and price for the first year\' so writed in | tanish2610 | NORMAL | 2024-10-04T04:24:22.610718+00:00 | 2024-10-04T04:24:22.610760+00:00 | 956 | false | \n\n# Approach\nDivide given problem into sub problems in *first step* have to print \n\' product id, year, quantity, and price for the first year\' so writed in select block then *STEP 2* user only want to get data from first year (min year) so write query for first year. then remember we have to filter data group wise for each product id so write like wise\n\n\n\n# Code\n```mysql []\n# Write your MySQL query statement below\nSELECT product_id,year AS first_year,quantity,price\nFROM Sales\nWHERE (product_id, year) IN\n (SELECT product_id,MIN(year)\nFROM Sales\n GROUP BY product_id);\n``` | 3 | 0 | ['Database', 'MySQL'] | 0 |
product-sales-analysis-iii | MySQL | Easy solution | mysql-easy-solution-by-siyadhri-0prk | \n\n# Code\nmysql []\n# Write your MySQL query statement below\nselect product_id,year as first_year, quantity, price\nfrom Sales\nwhere(product_id, year) in (s | siyadhri | NORMAL | 2024-08-20T05:03:50.881551+00:00 | 2024-08-20T05:03:50.881582+00:00 | 1,066 | false | \n\n# Code\n```mysql []\n# Write your MySQL query statement below\nselect product_id,year as first_year, quantity, price\nfrom Sales\nwhere(product_id, year) in (select product_id, min(year) from Sales group by product_id)\n``` | 3 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | cte sql | cte-sql-by-rishurajj-wsaw | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \nthink of cte and then t | rishurajj | NORMAL | 2024-07-11T04:51:50.305298+00:00 | 2024-07-11T04:51:50.305321+00:00 | 827 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nthink of cte and then try to get the link between main table through join\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\no(n)\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n0(n)\n# Code\n```\n# Write your MySQL query statement below\nselect product_id , year as first_year,quantity, price from sales where (product_id,year )in\n(\nselect product_id,min(year) as year from sales group by product_id\n)\n\n\n``` | 3 | 0 | ['Database', 'C++', 'MySQL', 'Pandas'] | 1 |
product-sales-analysis-iii | 🌟 explained PostgreSQL solution 🚀 Beats 85% and use only one INNER JOIN and one DISTINCT | explained-postgresql-solution-beats-85-a-vn6x | Explaination\n\n- Common Table Expression (CTE) - product_id_with_first_year:\n SELECT DISTINCT ON(product_id) product_id, year FROM Sales ORDER BY produ | mathieusoysal | NORMAL | 2024-04-17T07:46:30.528358+00:00 | 2024-04-17T07:48:21.029876+00:00 | 441 | false | # Explaination\n\n- **Common Table Expression (CTE) - product_id_with_first_year**:\n `SELECT DISTINCT ON(product_id) product_id, year FROM Sales ORDER BY product_id, year ASC`: This CTE is used to select the earliest sales record for each product_id based on the year. The DISTINCT ON clause ensures that for each product_id, only the first entry (the earliest year) is selected.\n\n- **Main Query**:\n - The main query then joins the CTE with the original Sales table to get the detailed sales records for the first year of sales for each product.\n - `INNER JOIN Sales USING (product_id, year)`: This join is made on both product_id and year to ensure that the sales data corresponds to the first year of sales for each product as identified in the CTE.\n\n\n# Code\n```\nWITH product_id_with_first_year AS (\n SELECT DISTINCT ON(product_id)\n product_id, year\n FROM Sales\n ORDER BY product_id, year ASC\n)\n\nSELECT product_id,\n year AS first_year,\n quantity,\n price \nFROM product_id_with_first_year\nINNER JOIN Sales\nUSING (product_id, year);\n```\n____\n\nIf it was useful don\'t hesitate to upvote \uD83C\uDF20 Or keep it in your favorite \uD83C\uDF1F\n\n | 3 | 0 | ['PostgreSQL'] | 1 |
product-sales-analysis-iii | ✔✔✔easy solution - SUBQUERY, WHERE, MIN⚡⚡⚡MySQL | MS SQL Server | PostgreSQL | easy-solution-subquery-where-minmysql-ms-qnng | Code\n\nSELECT s.product_id, s.year AS first_year, s.quantity, s.price\nFROM Sales AS s\nWHERE s.year IN (\n SELECT MIN(year)\n FROM Sales AS s1\n WHER | anish_sule | NORMAL | 2024-01-25T06:36:07.234759+00:00 | 2024-05-02T08:08:38.892735+00:00 | 421 | false | # Code\n```\nSELECT s.product_id, s.year AS first_year, s.quantity, s.price\nFROM Sales AS s\nWHERE s.year IN (\n SELECT MIN(year)\n FROM Sales AS s1\n WHERE s.product_id = s1.product_id\n)\n``` | 3 | 0 | ['Database', 'MySQL', 'MS SQL Server', 'PostgreSQL'] | 2 |
product-sales-analysis-iii | Simple Solution Using Rank Function | simple-solution-using-rank-function-by-v-ljdf | Intuition\n Describe your first thoughts on how to solve this problem. \nThe problem looks a bit on the moderate side if we do not use the rank function but as | 20250316.vinitsingh27 | NORMAL | 2023-12-30T06:55:16.748622+00:00 | 2023-12-30T06:55:16.748642+00:00 | 407 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem looks a bit on the moderate side if we do not use the rank function but as soon as we rank the product id according to the year it will be easy to solve .\n\n---\n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nFirst thing to look is that we dont need the product table as we can see from the output example . \nsecond thing is that we have to modify the sales table on the basis of the rank pf the products on the basis of the product id \n```\nRANK() over (partition by product_id order by year) as rnk\nfrom sales\n```\nName this table as a seperate table to be used for the future use .\n```\nwith vi as \n(select * ,\nRANK() over (partition by product_id order by year) as rnk\nfrom sales)\n```\n\n---\n\n# Code\n```\n# Write your MySQL query statement below\n#30-12-2023\nwith vi as \n(select * ,\nRANK() over (partition by product_id order by year) as rnk\nfrom sales)\nselect product_id , year as first_year , quantity , price \nfrom vi where rnk = 1\n``` | 3 | 0 | ['Database', 'MySQL'] | 2 |
product-sales-analysis-iii | SQL: Identifying Initial Sales Data for Products | sql-identifying-initial-sales-data-for-p-268t | Code\n\nSELECT product_id, year AS first_year, quantity, price\nFROM sales\nWHERE (product_id, year) IN \n (SELECT product_id, MIN(year) FROM sales GROUP | aleos-dev | NORMAL | 2023-12-17T13:16:47.904856+00:00 | 2023-12-18T16:14:02.821557+00:00 | 1,414 | false | # Code\n```\nSELECT product_id, year AS first_year, quantity, price\nFROM sales\nWHERE (product_id, year) IN \n (SELECT product_id, MIN(year) FROM sales GROUP BY product_id)\n```\n# Complexity\n- Time complexity: $$O(n * logn)$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity is influenced by the size of the sales table. The GROUP BY operation in the subquery and the IN clause in the main query both contribute to the overall complexity. Assuming efficient indexing, the complexity would likely be O(n log n), where n is the number of rows in the sales table.\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(m)$$ -->\nThe space complexity is mainly determined by the size of the data returned by the subquery. It should be relatively low, as the subquery only returns a list of product_id and their corresponding minimum year. Thus, it can be considered O(m), where m is the number of distinct products.\n\n\n\n | 3 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | 💻Think like SQL Engine🔥Mastering MS SQL (SubQuery✅) | think-like-sql-enginemastering-ms-sql-su-lhw6 | Intuition\nThis SQL query is selecting the product ID, first year, quantity, and price for all products in the Sales table. It is doing this by joining the Sale | k_a_m_o_l | NORMAL | 2023-11-22T09:28:41.780390+00:00 | 2023-11-22T09:28:41.780412+00:00 | 1,766 | false | # Intuition\nThis SQL query is selecting the product ID, first year, quantity, and price for all products in the Sales table. It is doing this by joining the Sales table with itself, using the min(year) subquery to identify the first year for each product ID. The inner join clause ensures that only records that match between the two tables are included in the result set.\n\n# Approach\n1. The select clause specifies the columns that you want to select from the table. In this case, you are selecting the product_id, year, quantity, and price.\n\n2. The from clause specifies the table that you want to select from. In this case, you are selecting from the Sales table, aliased as s1.\n\n3. The inner join clause joins the Sales table with itself, aliased as s2. The join condition is that the product_id in s1 must match the product_id in s2, and the year in s1 must match the min_year in s2.\n\n4. The min(year) subquery is used to identify the first year for each product ID. This subquery selects the product_id and the min(year) from the Sales table, and then groups the results by product_id.\n\n5. The and operator is used to combine the two join conditions. This ensures that only records that match both conditions are included in the result set.\n\n# Code\n```\n# Write your MySQL query statement below\nselect \n s1.product_id, \n year as first_year, \n quantity, \n price \nfrom \n Sales s1 \n inner join (\n select \n product_id, \n min(year) min_year \n from \n Sales \n group by \n product_id\n ) s2 on s1.product_id = s2.product_id \n and s2.min_year = s1.year\n``` | 3 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | Identifying Earliest Product Sales | MySQL Solution | identifying-earliest-product-sales-mysql-26ht | Intuition\n Describe your first thoughts on how to solve this problem. \nWe need to find the product id, year, quantity, and price for the first year of every p | samabdullaev | NORMAL | 2023-10-21T23:37:19.831865+00:00 | 2023-10-21T23:37:19.831884+00:00 | 700 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nWe need to find the product id, year, quantity, and price for the first year of every product sold.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. Find the earliest year each product was sold by grouping sales data.\n\n > `MIN()` \u2192 This function returns the smallest value of the selected column\n\n > `GROUP BY` \u2192 This command groups rows that have the same values into summary rows, typically to perform aggregate functions on them\n\n2. Select and display product details for those earliest years.\n\n > `SELECT` \u2192 This command retrieves data from a database\n\n > `AS` \u2192 This command renames a column with an alias (temporary name). In most database languages, we can skip the `AS` keyword and get the same result\n\n > `IN` \u2192 This operator allows to specify multiple values\n\n# Complexity\n- Time complexity: $O(n)$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n`n` is the number of rows in the table. This is because the query processes each row in the table once to find the first year of every product sold.\n\n# Code\n```\nSELECT product_id, year AS first_year, quantity, price \nFROM Sales\nWHERE (product_id, year) IN (\n SELECT product_id, MIN(year) \n FROM Sales \n GROUP BY product_id\n);\n``` | 3 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | Using Window Function: Why row_number() doesn't work | using-window-function-why-row_number-doe-sc5n | Intuition\nFrom the problem description, since we need the first of each product, it shoud be easy to solve using the window functions. Hence, we need to rank t | aishwaryatw | NORMAL | 2023-08-22T05:41:17.072909+00:00 | 2023-08-22T05:41:17.072926+00:00 | 105 | false | # Intuition\nFrom the problem description, since we need the first of each product, it shoud be easy to solve using the window functions. Hence, we need to rank the years for each product, and then select the row with lowest value in year.\n\n# Approach\nI started by using the row_number() function to rank years for each product. However, only one test case passed with this approach.\n\nWhy?\n\nBecause row_number() always give a unique value to each row, even duplicates. In case of duplicates, it randomly assigns one year as higher rank and the other lower.\n\nSo now we could use either rank() or dense_rank().\n\nI preferred using dense_rank() since the rank numbers are continuous in this case.\n\n# Code\n```\nselect product_id, year as first_year, quantity, price from\n(select product_id, year, dense_rank() over (partition by product_id order by year) as firsty, quantity, price\nfrom Sales) as d\nwhere d.firsty= 1\n``` | 3 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | Easy MySQL solution with explanation(Best for beginners) | easy-mysql-solution-with-explanationbest-ogtl | Intuition\n Describe your first thoughts on how to solve this problem. \n- The question asks to retrieve the required columns for the first year of sale only.\n | prathams29 | NORMAL | 2023-06-06T12:16:51.347750+00:00 | 2023-06-06T12:16:51.347781+00:00 | 969 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n- The question asks to retrieve the required columns for the first year of sale only.\n- For that, we write a sub-query which selects product_id and the first year of the product sale.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. In the SELECT statement, we retrieve the product_id, first_year, quantity and price.\n2. In the FROM statement, we write the table name Sales from which we retrieve the columns.\n3. The WHERE clause retrieves the product_id and MIN(year) as first_year and then uses GROUP BY clause to group the query by product_id.\n\n# Code\n```\n# Write your MySQL query statement below\nSELECT product_id, year as first_year, quantity, price \nFROM Sales \nWHERE (product_id, year) IN \n(\n SELECT product_id, MIN(year) as year FROM Sales GROUP BY product_id\n)\n```\n# Note\nPlease upvote if you find my solution helpful. If you have any doubts, suggestion or want to discuss any solution, comment it. If you wish to discuss other related topics, feel free to message me on LinkedIn, https://leetcode.com/prathams29/ | 3 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | SQL ✅ || WHERE || Subquery || MIN || Easy Solution | sql-where-subquery-min-easy-solution-by-9kh4a | \n\n\n# Code\n\n# Write your MySQL query statement below\nselect \nproduct_id, year as first_year, quantity, price\nfrom Sales\nwhere(product_id, year) in (sele | jasurbekaktamov081 | NORMAL | 2023-05-24T16:39:37.193601+00:00 | 2023-05-24T16:39:37.193638+00:00 | 246 | false | \n\n\n# Code\n```\n# Write your MySQL query statement below\nselect \nproduct_id, year as first_year, quantity, price\nfrom Sales\nwhere(product_id, year) in (select product_id, min(year) from Sales group by product_id)\n\n``` | 3 | 1 | ['Database', 'MySQL'] | 1 |
product-sales-analysis-iii | why run the code "accepted",but the answer is wrong? | why-run-the-code-acceptedbut-the-answer-6r8k1 | select distinct product_id, min(year)as first_year, quantity, price\nfrom Sales\ngroup by product_id;\n\nplease help! | YYYJH | NORMAL | 2022-08-18T18:10:25.689900+00:00 | 2022-08-18T18:10:25.689951+00:00 | 1,543 | false | select distinct product_id, min(year)as first_year, quantity, price\nfrom Sales\ngroup by product_id;\n\nplease help! | 3 | 0 | [] | 3 |
product-sales-analysis-iii | Simple solution using window function and rank | simple-solution-using-window-function-an-oh7a | \nselect product_id,year as first_year,quantity,price\nfrom (\nselect product_id, year, quantity, price, rank() over (partition by product_id order by year asc) | findritesh | NORMAL | 2022-01-29T17:19:56.633198+00:00 | 2022-01-29T17:19:56.633245+00:00 | 527 | false | ```\nselect product_id,year as first_year,quantity,price\nfrom (\nselect product_id, year, quantity, price, rank() over (partition by product_id order by year asc) as rnk\nfrom Sales)a\nwhere a.rnk=1\n``` | 3 | 0 | [] | 1 |
product-sales-analysis-iii | MySQL beat 99.58% | mysql-beat-9958-by-liangpaloma-42dt | select product_id, year as first_year, quantity, price\nfrom sales \nwhere (product_id, year) in (select product_id, min(year) from sales group by product_id) | liangpaloma | NORMAL | 2020-02-14T22:09:13.800829+00:00 | 2020-02-14T22:09:13.800866+00:00 | 716 | false | select product_id, year as first_year, quantity, price\nfrom sales \nwhere (product_id, year) in (select product_id, min(year) from sales group by product_id) | 3 | 0 | [] | 0 |
product-sales-analysis-iii | Why Row_number failed? | why-row_number-failed-by-yz541-q1j2 | Using rank over works, can anyone help me understand why switching to row_number failed for this problem?? From my understanding there should not be any differ | yz541 | NORMAL | 2020-01-09T14:52:44.165435+00:00 | 2020-01-09T14:52:44.165464+00:00 | 345 | false | Using rank over works, can anyone help me understand why switching to row_number failed for this problem?? From my understanding there should not be any difference using the two in this case. \n\n```\nselect product_id, year as first_year, quantity, price from\n(select product_id, year, quantity, price, rank()over(partition by product_id order by year asc) as year_rank from Sales)tmp\nwhere year_rank = 1\n``` | 3 | 0 | [] | 2 |
product-sales-analysis-iii | Easy MySQL solution | easy-mysql-solution-by-chaudharysrikant-prjb | IntuitionTo solve this problem, we need to find the first year each product was sold and retrieve the corresponding sales data (quantity and price). The key ide | chaudharysrikant | NORMAL | 2025-02-11T18:58:06.957040+00:00 | 2025-02-11T18:58:06.957040+00:00 | 540 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
To solve this problem, we need to find the first year each product was sold and retrieve the corresponding sales data (quantity and price). The key idea is to:
1. Identify the earliest year (MIN(year)) for each product.
2. Use this information to filter the rows in the Sales table that match the first year of sales for each product.
# Approach
<!-- Describe your approach to solving the problem. -->
**1. Subquery to Find First Year:**
- Use a subquery to group the Sales table by product_id and calculate the minimum year (i.e., the first year) for each product.
- This subquery returns a list of (product_id, first_year) pairs.
**2. Filter Rows Using Subquery:**
- In the main query, use the WHERE (product_id, year) IN (...) clause to filter the rows in the Sales table.
- This ensures that only the rows where the year matches the first year of sales for each product are selected.
**3. Select Required Columns:**
- Select the product_id, year (aliased as first_year), quantity, and price from the filtered rows.
# *# Do upvote if you like the solution*
# Code
```mysql []
# Write your MySQL query statement below
SELECT product_id, year AS first_year, quantity, price
FROM Sales
WHERE (product_id, year) IN
(SELECT product_id, MIN(year) FROM Sales GROUP BY product_id);
``` | 2 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Easy and Simple Solution | easy-and-simple-solution-by-mayankluthya-9gwg | Please Like ❤️IntuitionWe need to find the first year in which each product was sold along with its quantity and price.Approach
Find the earliest year for each | mayankluthyagi | NORMAL | 2025-02-10T15:11:03.528598+00:00 | 2025-02-10T15:11:03.528598+00:00 | 261 | false | ```mysql
# Write your MySQL query statement below
SELECT product_id, year AS first_year, quantity, price
FROM Sales
WHERE (product_id, year) IN (
SELECT product_id, MIN(year) AS year
FROM Sales
GROUP BY product_id
);
```
# Please Like ❤️
# Intuition
We need to find the first year in which each product was sold along with its quantity and price.
# Approach
1. **Find the earliest year** for each `product_id` using `MIN(year)` and `GROUP BY product_id`.
2. **Retrieve relevant records** using `WHERE (product_id, year) IN (...)`, ensuring we get quantity and price for that year.
# Complexity
- **Time Complexity:** $$O(n)$$ – The subquery computes `MIN(year)` in $$O(n)$$, and filtering runs in $$O(n)$$.
- **Space Complexity:** $$O(1)$$ – The query only stores results temporarily. | 2 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | easy and crispy | easy-and-crispy-by-sanil_kumar_barik-v165 | IntuitionApproachComplexity
Time complexity:
Space complexity:
Code | sanil_kumar_barik | NORMAL | 2025-01-04T07:21:59.934301+00:00 | 2025-01-04T07:21:59.934301+00:00 | 833 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
# Approach
<!-- Describe your approach to solving the problem. -->
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
# Code
```mssql []
with cte as(select s.product_id, year, quantity, price,
rank() over(partition by s.product_id order by year asc) as rnk
from sales s join product p
on s.product_id = p.product_id)
select product_id, year as first_year, quantity, price
from cte
where rnk = 1;
``` | 2 | 0 | ['MS SQL Server'] | 1 |
product-sales-analysis-iii | EASIEST SOLUTION WITH 1046ms RUNTIME and BEATS 74.61% | easiest-solution-with-1046ms-runtime-and-3994 | Intuition\n Describe your first thoughts on how to solve this problem. \nTo find the first year each product was sold and retreive the quantity and price for th | saikrish230503 | NORMAL | 2024-11-11T15:28:26.476210+00:00 | 2024-11-11T15:28:26.476247+00:00 | 123 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nTo find the first year each product was sold and retreive the quantity and price for the year \n# Approach\n<!-- Describe your approach to solving the problem. -->\nIdentify the first year each product was sold and then retrieve them using join\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(N)\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nO(P) p-number of unique products\n# Code\n```mysql []\nSELECT s.product_id, s.year AS first_year, s.quantity, s.price\nFROM Sales s\nJOIN (\n SELECT product_id, MIN(year) AS first_year\n FROM Sales\n GROUP BY product_id\n) AS first_sales\nON s.product_id = first_sales.product_id AND s.year = first_sales.first_year;\n\n``` | 2 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Easy to understand Pandas solution | easy-to-understand-pandas-solution-by-sh-2ihs | Approach\nWe first get all first years of each product, using groupby and transform.\nThen we get a subset of all sales data where products were sold in their f | shaikasaad | NORMAL | 2024-10-30T15:26:11.146832+00:00 | 2024-10-30T15:26:11.146871+00:00 | 119 | false | # Approach\nWe first get all first years of each product, using groupby and transform.\nThen we get a subset of all sales data where products were sold in their first year\nLastly, we return the required columns\n# Code\n```pythondata []\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n sales[\'first_year\'] = sales.groupby(\'product_id\')[[\'year\']].transform(\'min\')\n\n sales = sales[sales.first_year == sales.year]\n\n return sales[[\'product_id\', \'first_year\', \'quantity\', \'price\']]\n``` | 2 | 0 | ['Database', 'Python3', 'Pandas'] | 0 |
product-sales-analysis-iii | 1070. Product Sales Analysis III # best solution # beats 99.83% | 1070-product-sales-analysis-iii-best-sol-jfqo | Intuition\nWe can either solve using a min(year) or using windows function Rank\n\n# Approach\nHere I have assigned the rank to each record based on the year of | Vivek_Rahul_ch | NORMAL | 2024-10-13T13:23:25.844437+00:00 | 2024-10-13T13:23:25.844458+00:00 | 1,296 | false | # Intuition\nWe can either solve using a min(year) or using windows function Rank\n\n# Approach\nHere I have assigned the rank to each record based on the year of the sales\n\n# Complexity\n- Time complexity:\n813ms\n\n- Space complexity:\n0B\n\n# Code\n```mysql []\n# Write your MySQL query statement below\nwith sale as \n(select *,rank() over (partition by product_id order by year) as rw\nfrom sales)\n\nselect product_id,year as first_year,quantity, price from sale\nwhere rw=1;\n\n\n``` | 2 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | Solution to the CORRECT version of this question | solution-to-the-correct-version-of-this-7r8bu | Intuition\nThe present version of the question, as well as it\'s test cases are incorrect. The product table is correctly present, but test cases do not seem to | mrkorolev | NORMAL | 2024-06-17T22:24:07.221365+00:00 | 2024-06-17T22:24:07.221391+00:00 | 455 | false | # Intuition\nThe present version of the question, as well as it\'s test cases are incorrect. The product table is correctly present, but test cases do not seem to be using it properly.\n\n# Approach\nMy first solution went through all possible tests:\n```\nSELECT product_id, year AS first_year, quantity, price\nFROM sales\nWHERE (product_id, year) IN (\n SELECT product_id, MIN(year)\n FROM sales\n GROUP BY 1\n);\n```\nThis solution should not have been correct. For the reason of existence of the product table, there could be a product that would not be sold (consider me nerdy, idc.). For that reason, the previous solution should not reveal all products the company had in their posession. \nTherefore, it makes sense to first left join the products table with sales, and then join it with the (product_id, year) table. Yes, 2 joins, but logically valid now - conciousness happy now:)\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n-- Write your PostgreSQL query statement below\nSELECT \n p.product_id, \n COALESCE(year, 0) AS first_year, \n COALESCE(quantity, 0) AS quantity, \n COALESCE(price, 0) AS price\nFROM product p\nLEFT JOIN sales s\n ON p.product_id = s.product_id\nWHERE (s.product_id, s.year) IN (\n SELECT product_id, MIN(year)\n FROM sales\n GROUP BY 1\n);\n\n``` | 2 | 0 | ['PostgreSQL'] | 1 |
product-sales-analysis-iii | Solution using Sub-query and Window function | solution-using-sub-query-and-window-func-fwxz | Intuition\n Describe your first thoughts on how to solve this problem. \nTo group the result set and identify the first record by year.\n# Approach\n Describe y | 6edQektZ0C | NORMAL | 2024-06-05T01:38:57.529712+00:00 | 2024-06-05T01:53:53.955705+00:00 | 358 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nTo group the result set and identify the first record by year.\n# Approach\n<!-- Describe your approach to solving the problem. -->\nTo group the data, window function is used, the first_value window function identifies the first_year partitioned by product_id, the outer query matches the year entry with the first_year to give the result.\n# Complexity\n- Time complexity: $$O(nlogn)$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(n)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n-- Write your PostgreSQL query statement below\nselect product_id, first_year, quantity, price \nfrom\n(select product_id, year, quantity, price, \nfirst_value(year) over (partition by product_id order by product_id, year) as first_year\nfrom Sales) as subquery\nwhere year = first_year;\n``` | 2 | 0 | ['PostgreSQL'] | 0 |
product-sales-analysis-iii | ORACLE | EASY SOLUTUION | USING WITH() | RANK() | oracle-easy-solutuion-using-with-rank-by-ebj2 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | shivangisharma94 | NORMAL | 2024-06-01T09:31:08.826052+00:00 | 2024-06-01T09:31:08.826072+00:00 | 1,583 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/* Write your PL/SQL query statement below */\nwith abc as \n(\n SELECT product_id, year, quantity, price, \n RANK() OVER (PARTITION BY product_id ORDER BY year) AS rank\n FROM sales\n )\nselect a.product_id , a.year as first_year , a.quantity , a.price \nfrom abc a\nwhere a.rank = 1;\n\n\n``` | 2 | 0 | ['Oracle'] | 1 |
product-sales-analysis-iii | WINDOW-Solution | window-solution-by-your8god-byeb | Intuition\nWe can use window-function to get the first year. This part we just put to CTE.\nAfter that we can find answers comparing current year and the first | your8god | NORMAL | 2024-05-13T09:59:48.624196+00:00 | 2024-05-16T07:35:59.430215+00:00 | 1,071 | false | # Intuition\nWe can use window-function to get the first year. This part we just put to CTE.\nAfter that we can find answers comparing current year and the first year\n\n# Code\n```\nWITH helper AS \n(\n SELECT Sales.* ,\n FIRST_VALUE(year) OVER (PARTITION BY product_id ORDER BY product_id, year) first_year\n FROM Sales \n)\nSELECT \n product_id,\n first_year,\n quantity,\n price\nFROM helper\nWHERE year = first_year;\n``` | 2 | 0 | ['Sliding Window', 'PostgreSQL'] | 2 |
product-sales-analysis-iii | SQL SERVER | sql-server-by-lshigami-jsxu | \n# Code\n\nWITH cte AS (\n SELECT product_id, MIN(year) AS minyear \n FROM sales \n GROUP BY product_id \n)\nSELECT s.product_id, s.year AS first_year | lshigami | NORMAL | 2024-04-04T00:51:02.578511+00:00 | 2024-04-04T00:51:02.578539+00:00 | 782 | false | \n# Code\n```\nWITH cte AS (\n SELECT product_id, MIN(year) AS minyear \n FROM sales \n GROUP BY product_id \n)\nSELECT s.product_id, s.year AS first_year, s.quantity, s.price \nFROM sales s\nINNER JOIN cte ON cte.product_id = s.product_id \n AND s.year = cte.minyear;\n\n``` | 2 | 0 | ['MS SQL Server'] | 2 |
product-sales-analysis-iii | Beats 95.24% | Easy solution Using Subquery and min() function | beats-9524-easy-solution-using-subquery-o98u0 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | vp13112000 | NORMAL | 2024-02-16T20:28:47.427224+00:00 | 2024-02-16T20:28:47.427255+00:00 | 1,279 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n# Write your MySQL query statement below\nselect \n product_id,\n year as first_year,\n quantity,\n price\nfrom Sales\nwhere (product_id, year) in (select product_id, min(year) from Sales group by product_id);\n``` | 2 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | Efficient Query | efficient-query-by-krishnak7-6x88 | Code\n\nselect product_id , year as first_year , quantity , price from sales \nwhere (product_id , year) in (select product_id , min(year) as year \n | KrishnaK7 | NORMAL | 2023-11-21T17:45:28.708418+00:00 | 2023-11-21T17:45:28.708447+00:00 | 1,403 | false | # Code\n```\nselect product_id , year as first_year , quantity , price from sales \nwhere (product_id , year) in (select product_id , min(year) as year \n from sales group by product_id)\n\n\n``` | 2 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Oracle PLSQL solution using rank | oracle-plsql-solution-using-rank-by-diby-2mka | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | DibyaJyoti_Sarmah | NORMAL | 2023-06-06T09:41:25.823009+00:00 | 2023-06-06T09:41:25.823067+00:00 | 1,591 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/* Write your PL/SQL query statement below */\n\nSelect Q.product_id , Q.first_year , Q.quantity , Q.price from (\n\nSelect product_id , year first_year ,quantity ,price , rank() over(partition by product_id order by year ) rn \nfrom Sales\n\n) Q\n\nwhere Q.rn = 1 \n\n``` | 2 | 0 | ['Oracle'] | 1 |
product-sales-analysis-iii | easy oracle solution | easy-oracle-solution-by-sirojiddin12-w8h1 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | Sirojiddin12 | NORMAL | 2023-04-30T00:06:47.199478+00:00 | 2023-04-30T00:06:47.199523+00:00 | 272 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/* Write your PL/SQL query statement below */\nselect s.product_id, s.year first_year, s.quantity, s.price\nfrom sales s\nwhere s.year = (select min(year) from sales where product_id=s.product_id);\n``` | 2 | 0 | ['Oracle'] | 0 |
product-sales-analysis-iii | Using Subquery and self join | using-subquery-and-self-join-by-rjvshrm-0g9w | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | rjvshrm | NORMAL | 2023-04-23T18:06:35.892001+00:00 | 2023-04-23T18:06:35.892076+00:00 | 1,067 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/* Write your T-SQL query statement below */\nselect a.product_id, a.first_year, s.quantity, s.price\nfrom (\nselect product_id, min(year) as first_year\nfrom Sales \ngroup by product_id\n) a\njoin Sales s\non a.product_id= s.product_id\nand a.first_year= s.year\n``` | 2 | 0 | ['MS SQL Server'] | 1 |
product-sales-analysis-iii | SOLUTION: WINDOW FUNCTION RANK() OVER() => FOR BIG DATA ( MySQL + SQL Server) 🔥🔥🔥🔥 | solution-window-function-rank-over-for-b-myxz | Intuition\r\n Describe your first thoughts on how to solve this problem. \r\n\r\n# Approach\r\n Describe your approach to solving the problem. \r\n\r\n# Complex | cooking_Guy_9ice | NORMAL | 2023-04-18T09:42:12.812096+00:00 | 2023-07-21T07:27:54.964887+00:00 | 3,179 | false | # Intuition\r\n<!-- Describe your first thoughts on how to solve this problem. -->\r\n\r\n# Approach\r\n<!-- Describe your approach to solving the problem. -->\r\n\r\n# Complexity\r\n- Time complexity:\r\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\r\n\r\n- Space complexity:\r\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\r\n\r\n# Code\r\n```\r\n/* Write your T-SQL query statement below */\r\n\r\nWITH RESULT AS (\r\n\r\n SELECT\r\n s.product_id,\r\n year,\r\n quantity,\r\n price,\r\n RANK() OVER(PARTITION BY s.product_id ORDER BY s.product_id,year) AS Rank\r\n FROM\r\n Sales s\r\n)\r\nSELECT\r\n product_id,\r\n year first_year,\r\n quantity,\r\n price\r\nFROM\r\n RESULT\r\nWHERE\r\n Rank = 1\r\n\r\n``` | 2 | 0 | ['MS SQL Server'] | 3 |
product-sales-analysis-iii | concat | concat-by-paonevergivup-6moc | select product_id, year as first_year, quantity, price\nfrom Sales\nwhere concat(product_id, year) in (select concat(product_id, min(year)) from Sales group by | paonevergivup | NORMAL | 2022-06-28T19:32:08.134140+00:00 | 2022-06-28T19:32:08.134182+00:00 | 37 | false | select product_id, year as first_year, quantity, price\nfrom Sales\nwhere concat(product_id, year) in (select concat(product_id, min(year)) from Sales group by product_id | 2 | 0 | [] | 0 |
product-sales-analysis-iii | 🚀 Simplest Solution Using Rank 👍✨ | simplest-solution-using-rank-by-vadlamud-xvm6 | \n# Code author Naveen Kumar Vadlamudi \n# Simplest Solution Using Rank..\n# Upvote if it helps \uD83D\uDC4D\n\nSELECT \nA.PRODUCT_ID,\nA.YEAR AS FIRST_YEAR,\nA | vadlamudinaveen999 | NORMAL | 2022-06-28T01:59:32.571899+00:00 | 2022-06-28T02:00:18.600579+00:00 | 273 | false | ```\n# Code author Naveen Kumar Vadlamudi \n# Simplest Solution Using Rank..\n# Upvote if it helps \uD83D\uDC4D\n\nSELECT \nA.PRODUCT_ID,\nA.YEAR AS FIRST_YEAR,\nA.QUANTITY,\nA.PRICE\nFROM\n(\n SELECT *,\n DENSE_RANK() OVER(PARTITION BY PRODUCT_ID ORDER BY YEAR) AS CRANK\n FROM SALES\n) A\nWHERE A.CRANK = 1 \n\n``` | 2 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | my SQL inner join solution - works | my-sql-inner-join-solution-works-by-boke-z76c | select s.product_id, first_year, quantity, price \nfrom sales s \ninner join(\nselect product_id, min(year) as first_year \nfrom sales \ngroup by product_id \n | bokelai1989 | NORMAL | 2020-08-25T14:42:37.936535+00:00 | 2020-08-25T14:42:37.936587+00:00 | 145 | false | select s.product_id, first_year, quantity, price \nfrom sales s \ninner join(\nselect product_id, min(year) as first_year \nfrom sales \ngroup by product_id \n) as a \non s.product_id = a.product_id and s.year = a.first_year | 2 | 1 | [] | 0 |
product-sales-analysis-iii | why this is not working in mysql | why-this-is-not-working-in-mysql-by-qtmd-ccqs | select product_id, min(year) as first_year, quantity, price from Sales group by product_id;\n\n\n\nthanks for reply.\n\n\n | qtmdsxydz | NORMAL | 2020-02-26T15:15:53.058435+00:00 | 2020-02-26T15:15:53.058480+00:00 | 309 | false | select product_id, min(year) as first_year, quantity, price from Sales group by product_id;\n\n\n\nthanks for reply.\n\n\n | 2 | 0 | [] | 1 |
product-sales-analysis-iii | MSSQLSERVER 97% faster and easier to understand | mssqlserver-97-faster-and-easier-to-unde-61fc | select\nproduct_id,year as first_year,quantity,price\nfrom\n(select\nproduct_id,year,quantity,price,\nrank() over (partition by product_id order by year) as yea | karthik3010 | NORMAL | 2019-11-11T08:57:15.524165+00:00 | 2019-11-11T08:57:15.524234+00:00 | 324 | false | select\nproduct_id,year as first_year,quantity,price\nfrom\n(select\nproduct_id,year,quantity,price,\nrank() over (partition by product_id order by year) as year_row\nfrom\nsales)a where a.year_row = 1 | 2 | 1 | [] | 1 |
product-sales-analysis-iii | Mysql solution faster than 100% so far | mysql-solution-faster-than-100-so-far-by-gi4v | \nselect s.product_id, s.year as first_year, s.quantity, s.price\nfrom Sales s\njoin (\nselect product_id, min(year) as y1\nfrom Sales\ngroup by product_id) t\n | omglalaalahaha | NORMAL | 2019-06-06T17:00:44.887748+00:00 | 2019-06-06T17:00:44.887800+00:00 | 751 | false | ```\nselect s.product_id, s.year as first_year, s.quantity, s.price\nfrom Sales s\njoin (\nselect product_id, min(year) as y1\nfrom Sales\ngroup by product_id) t\non (s.product_id=t.product_id and s.year=t.y1)\n``` | 2 | 0 | [] | 2 |
product-sales-analysis-iii | Easy Solution || MYSQL🤓🚀 | easy-solution-mysql-by-uwwcpcfmx5-6sdi | CodeFeel Free To Ask Your Queries | UWWcPcfMx5 | NORMAL | 2025-03-30T09:29:18.829277+00:00 | 2025-03-30T09:29:18.829277+00:00 | 346 | false |
# Code
```mysql []
# Write your MySQL query statement below
select product_id,year as first_year, quantity, price
from Sales
where(product_id, year) in (select product_id, min(year) from Sales group by product_id)
```
# Feel Free To Ask Your Queries | 1 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | ✅"Easy-way to solve this mysql problem"|99.50% beats|💯🎯😊 | easy-way-to-solve-this-mysql-problem9950-r53a | Approachwe want to the task is to select the product,year,quantity,price for the first year of sales for every product.Code | kabirydv | NORMAL | 2025-03-28T13:43:52.063728+00:00 | 2025-03-28T13:43:52.063728+00:00 | 271 | false |
# Approach
<!-- Describe your approach to solving the problem. -->
**we want to the task is to select the product,year,quantity,price for the first year of sales for every product.**
# Code
```mysql []
# Write your MySQL query statement below
WITH FirstYearSales AS (SELECT product_id,MIN(year) AS first_year
FROM Sales GROUP BY product_id)SELECT s.product_id,f.first_year,s.quantity,s.price
FROM FirstYearSales f JOIN Sales s ON f.product_id = s.product_id AND f.first_year = s.year;
``` | 1 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Easy Solution I guess 🔥 | easy-solution-i-guess-by-amoghamayya-cyty | IntuitionApproachComplexity
Time complexity:
Space complexity:
Code | AmoghaMayya | NORMAL | 2025-03-23T15:10:08.464838+00:00 | 2025-03-23T15:10:08.464838+00:00 | 320 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
# Approach
<!-- Describe your approach to solving the problem. -->
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
# Code
```postgresql []
select product_id , year as first_year , quantity , price from (
select * ,
rank() over (partition by product_id order by year) as rank
from sales
) as x where x.rank = 1;
``` | 1 | 0 | ['PostgreSQL'] | 0 |
product-sales-analysis-iii | More efficient alternative to using IN Subqueries 🚀 | more-efficient-alternative-to-using-in-s-5vwm | Did you find this helpful? If so, Please let me a 👍IntuitionTo solve this problem, we need to find, for each product, the first year it was sold and return its | giandev10 | NORMAL | 2025-03-22T01:13:02.416576+00:00 | 2025-03-22T01:13:02.416576+00:00 | 242 | false | **Did you find this helpful?** If so, Please let me a 👍
---
# Intuition
To solve this problem, we need to find, for each product, the first year it was sold and return its corresponding sale details — specifically, the quantity and price. Our goal is to match each product with its earliest year of sale and retrieve the relevant data for that specific record.
# Approach
We first use a subquery to calculate the minimum year of sale `(MIN(year))` for each `product_id` using `GROUP BY`. This gives us the first year of sale for every product.
Then, we `JOIN` this result with the original `Sales` table on both `product_id` and `year` to retrieve the full sale record (including `quantity` and `price`) that occurred in that earliest year.
# Code
```mssql []
/* Write your T-SQL query statement below */
SELECT
s.product_id,
s.year AS first_year,
s.quantity,
s.price
FROM Sales s
JOIN (
SELECT product_id, MIN(year) AS first_year
FROM Sales
GROUP BY product_id
) first_sale
ON s.product_id = first_sale.product_id AND s.year = first_sale.first_year;
``` | 1 | 0 | ['MS SQL Server'] | 1 |
product-sales-analysis-iii | product sales analysis III | product-sales-analysis-iii-by-avinash516-v42h | IntuitionApproachComplexity
Time complexity:
Space complexity:
Code | avinash516 | NORMAL | 2025-03-14T11:09:22.239308+00:00 | 2025-03-14T11:09:22.239308+00:00 | 52 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
# Approach
<!-- Describe your approach to solving the problem. -->
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
# Code
```mysql []
# Write your MySQL query statement below
SELECT s.product_id, s.year AS first_year, s.quantity, s.price
FROM Sales s
JOIN (SELECT product_id, MIN(year) AS first_year FROM Sales GROUP BY product_id) first_Sales
ON s.product_id = first_sales.product_id AND s.year = first_sales.first_year;
``` | 1 | 1 | ['MySQL'] | 0 |
product-sales-analysis-iii | Easy Simple Solution in MYSQL | easy-simple-solution-in-mysql-by-musafir-47we | \Code | musafircodes | NORMAL | 2025-03-13T15:23:35.992513+00:00 | 2025-03-13T15:23:35.992513+00:00 | 300 | false | \
# Code
```mysql []
select
product_id,
year as first_year,
quantity,
price
from Sales
where (product_id,year) in (
select product_id,MIN(year) as mf_year
from Sales
group by product_id
)
``` | 1 | 0 | ['Database', 'MySQL'] | 0 |
product-sales-analysis-iii | SQL Server | sql-server-by-adchoudhary-j79c | Code | adchoudhary | NORMAL | 2025-03-12T02:07:56.964578+00:00 | 2025-03-12T02:07:56.964578+00:00 | 303 | false | # Code
```mssql []
WITH CTE AS (
SELECT product_id, MIN(year) AS minyear FROM Sales
GROUP BY product_id
)
SELECT s.product_id, s.year AS first_year, s.quantity, s.price
FROM Sales s
INNER JOIN CTE ON cte.product_id = s.product_id AND s.year = cte.minyear;
``` | 1 | 0 | ['MS SQL Server'] | 0 |
product-sales-analysis-iii | Easy Explanation | easy-explanation-by-pratyushpanda91-z5b8 | Explanation:Recursive Flattening:The helper function flatten takes the current depth and the array as arguments.
If the currentDepth reaches 0, it stops flatten | pratyushpanda91 | NORMAL | 2025-01-25T16:34:59.585355+00:00 | 2025-01-25T16:34:59.585355+00:00 | 141 | false | # Explanation:
### Recursive Flattening:
The helper function flatten takes the current depth and the array as arguments.
If the currentDepth reaches 0, it stops flattening and returns the array as is.
### Handling Arrays and Non-Arrays:
If an element is an array, it is recursively flattened with the depth reduced by 1.
Otherwise, the element is directly added to the result.
### Concatenation:
The concat method is used to merge the results of recursive flattening into a single array.
# Code
```mysql []
# Write your MySQL query statement below
WITH FirstYearSales AS (
SELECT
product_id,
MIN(year) AS first_year
FROM
Sales
GROUP BY
product_id
)
SELECT
s.product_id,
f.first_year,
s.quantity,
s.price
FROM
Sales s
JOIN
FirstYearSales f
ON
s.product_id = f.product_id AND s.year = f.first_year;
``` | 1 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Easy Solution using RANK 🔥 | easy-solution-using-rank-by-amoghamayya-pl3o | ApproachThe first step is to join the sales and product tables based on the product_id. This ensures we retrieve the required columns: product_id, year, quantit | AmoghaMayya | NORMAL | 2025-01-25T06:05:35.226240+00:00 | 2025-01-25T06:05:35.226240+00:00 | 460 | false |
# Approach
<!-- Describe your approach to solving the problem. -->
The first step is to join the sales and product tables based on the product_id. This ensures we retrieve the required columns: product_id, year, quantity, and price.
**Ranking with Window Function:**
Use the RANK() function with a PARTITION BY product_id and ORDER BY year ASC to rank rows for each product. This helps in identifying the first year for each product.
**Filter the First Year:**
In the final step, filter only the rows where the rank is 1, as these correspond to the earliest year for each product.
# Code
```postgresql []
-- Write your PostgreSQL query statement below
with cte as (
select s.product_id as product_id , year , quantity , price
from sales s join
product p on s.product_id = p.product_id
)
select product_id , year as first_year , quantity , price from (
select *,
rank() over (partition by product_id order by year)
from cte
) as x where x.rank = 1;
``` | 1 | 0 | ['PostgreSQL'] | 0 |
product-sales-analysis-iii | 👉🏻FAST AND EASY TO UNDERSTAND SOLUTION || MySQL | fast-and-easy-to-understand-solution-mys-y0rt | IntuitionApproachComplexity
Time complexity:
Space complexity:
Code | djain7700 | NORMAL | 2025-01-08T18:04:40.720939+00:00 | 2025-01-08T18:04:40.720939+00:00 | 113 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
# Approach
<!-- Describe your approach to solving the problem. -->
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
# Code
```mysql []
# Write your MySQL query statement below
WITH cte AS(SELECT *, MIN(year) OVER(PARTITION BY product_id) as min_year
FROM Sales)
SELECT product_id, min_year as first_year, quantity, price
FROM cte
WHERE min_year = year
``` | 1 | 0 | ['Database', 'MySQL'] | 0 |
product-sales-analysis-iii | ✅✅Beats 99%🔥MySQL🔥|| 🚀🚀Super Simple and Efficient Solution🚀🚀||🔥🔥MySQL✅✅ | beats-99mysql-super-simple-and-efficient-ktax | Code | shobhit_yadav | NORMAL | 2024-12-27T09:39:01.354342+00:00 | 2024-12-27T09:40:05.111324+00:00 | 476 | false | # Code
```mysql []
# Write your MySQL query statement below
WITH
ProductToYear AS (
SELECT product_id, MIN(year) AS year
FROM Sales
GROUP BY 1
)
SELECT
Sales.product_id,
ProductToYear.year AS first_year,
Sales.quantity,
Sales.price
FROM Sales
INNER JOIN ProductToYear
USING (product_id, year);
``` | 1 | 0 | ['Database', 'MySQL'] | 0 |
product-sales-analysis-iii | 👉🏻EASY TO UNDERSTAND SOLUTION || MySQL | easy-to-understand-solution-mysql-by-sid-fsx5 | IntuitionApproachComplexity
Time complexity:
Space complexity:
Code | Siddarth9911 | NORMAL | 2024-12-22T16:55:46.986668+00:00 | 2024-12-22T16:55:46.986668+00:00 | 420 | false | # Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
# Approach
<!-- Describe your approach to solving the problem. -->
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
# Code
```mysql []
SELECT product_id , year as first_year, quantity, price
FROM Sales
WHERE (product_id, year) IN (SELECT product_id, min(year) AS year FROM Sales
GROUP BY product_id)
``` | 1 | 0 | ['MySQL'] | 0 |
product-sales-analysis-iii | Pandas, Polars, PostgreSQL | pandas-polars-postgresql-by-speedyy-n9dk | Its better to solve Game Play Analysis IV first (Solution, 2nd Logic used here)\n- No need INNER JOIN between these 2 tables because product_id in sales table i | speedyy | NORMAL | 2024-11-04T17:05:36.985988+00:00 | 2024-11-04T19:44:34.174552+00:00 | 24 | false | - Its better to solve [Game Play Analysis IV](https://leetcode.com/problems/game-play-analysis-iv/description/) first ([Solution](https://leetcode.com/problems/game-play-analysis-iv/solutions/5996925/pandas-polars-postgresql), `2nd Logic` used here)\n- No need `INNER JOIN between these 2 tables` because `product_id` in `sales` table is `a foreign key` which means every `product_id in \'sales\' table` `100% exists in \'product\' table`. We just have to take care the `sales` table now.\n# Pandas\n```py []\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n return ( sales.assign(first_year = sales.groupby(by=\'product_id\') [\'year\'].transform(\'min\'))\n .query("year == first_year")\n .loc[:, [\'product_id\', \'first_year\', \'quantity\', \'price\']]\n )\n```\n```py []\nimport pandas as pd\n\ndef sales_analysis(sales: pd.DataFrame, product: pd.DataFrame) -> pd.DataFrame:\n return ( sales.assign(first_year = sales.groupby(by=\'product_id\') [\'year\'].transform(\'min\'))\n .query("year == first_year")\n .filter(items=[\'product_id\', \'first_year\', \'quantity\', \'price\'], axis=1)\n ) # filter(..) here selects the columns.\n```\n\n# Polars\n```py\nimport polars as pl\nfrom polars import col\n\ndef sales_analysis(sales: pl.LazyFrame, product: pl.LazyFrame) -> pl.LazyFrame:\n return ( sales.with_columns( first_year = col(\'year\').min() .over(partition_by=\'product_id\') )\n .filter(col(\'year\') == col(\'first_year\'))\n .select(col(\'product_id\', \'first_year\', \'quantity\', \'price\'))\n )\n\nsales_analysis(pl.LazyFrame(sales), pl.LazyFrame(product)) .collect()\n```\n\n# PostgreSQL (Execution Order : WITH -> FROM -> WHERE -> SELECT)\n```postgresql\n-- Write your PostgreSQL query statement below\nWITH sales1 AS (\n\t\tSELECT *, MIN(sales.year) OVER (PARTITION BY product_id) AS "first_year"\n\t FROM sales\n) -- It\'s a DERIVED TABLE not subquery.\n\nSELECT product_id, first_year, quantity, price\nFROM sales1\nWHERE "year" = first_year;\n``` | 1 | 0 | ['PostgreSQL', 'Pandas'] | 0 |
product-sales-analysis-iii | Subqueries are powerful Specially beats Self JOIN | subqueries-are-powerful-specially-beats-xd5ro | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | alif126426 | NORMAL | 2024-10-27T16:21:51.305844+00:00 | 2024-10-27T16:21:51.305877+00:00 | 508 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```mysql []\n# Write your MySQL query statement below\nSELECT product_id, year as first_year, quantity,price\nFROM Sales\nWHERE (product_id,year) in (\nSELECT product_id,MIN(year)\nFROM Sales\nGROUP BY product_id\n)\n\n\n\n``` | 1 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | Easy Solution || SQL || For Beginner's Only | easy-solution-sql-for-beginners-only-by-ilike | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | GhatakCoder | NORMAL | 2024-10-11T20:49:28.571988+00:00 | 2024-10-11T20:49:28.572027+00:00 | 214 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```mysql []\n \n select product_id,year as first_year,quantity,price from\n (select sale_id,product_id,year,quantity,price,RANK() over(PARTITION by product_id order by year asc)as rno\n from Sales) a where a.rno=1\n\n``` | 1 | 0 | ['MySQL'] | 1 |
product-sales-analysis-iii | Beats 97.63% | 2 Ways| CTE | Dense_Rank | beats-9763-2-ways-cte-dense_rank-by-bloo-yas2 | \n\n# Code\n## First Way\n\n/* Write your T-SQL query statement below */\nWith cte as(\n select product_id, min(year) as first_year\n from Sales\n group by prod | Bloom0010 | NORMAL | 2024-08-03T14:42:08.063717+00:00 | 2024-08-03T14:42:08.063743+00:00 | 191 | false | \n\n# Code\n## First Way\n```\n/* Write your T-SQL query statement below */\nWith cte as(\n select product_id, min(year) as first_year\n from Sales\n group by product_id\n )\nselect cte.product_id, cte.first_year, quantity,price\nfrom cte join Sales on cte.product_id = Sales.product_id and cte.first_year=Sales.year\n\n```\n## Second Way\n```\n/* Write your T-SQL query statement below */\n\nwith cte as (\n select product_id,\n year AS first_year,\n quantity,\n price,\n dense_rank() over(partition by product_id order by year asc) as rk\nfrom sales\n)\nselect product_id,first_year, quantity, price\nfrom cte\nwhere rk = 1\n``` | 1 | 0 | ['MS SQL Server'] | 1 |
product-sales-analysis-iii | 🐘PostgreSQL ❗ Beats 91.48% ❗ Simple solution with FIRST_VALUE window function | postgresql-beats-9148-simple-solution-wi-wgyg | Approach\nThis SQL query you have written aims to extract the first year, quantity, and price for each product in the sales table. The subquery assigns the firs | IliaAvdeev | NORMAL | 2024-05-27T11:26:23.098954+00:00 | 2024-05-27T11:26:23.098986+00:00 | 114 | false | # Approach\nThis SQL query you have written aims to extract the first year, quantity, and price for each product in the sales table. The subquery assigns the first year of sales for each product using the `FIRST_VALUE` window function, and the outer query filters the results to include only the records where the year matches this first year.\n\n1. **Subquery (`stb`)**:\n - `FIRST_VALUE(year) OVER (PARTITION BY product_id ORDER BY year) AS first_year`: This part assigns the first year of sales for each product.\n - `PARTITION BY product_id`: This ensures the window function resets for each `product_id`.\n - `ORDER BY year`: This orders the rows within each partition by the `year`.\n\n2. **Outer Query**:\n - Filters the results where `year` is equal to `first_year`, effectively selecting only the rows where the year is the first year of sales for each product.\n\nThis query ensures you get the `product_id`, the first year it was sold (`first_year`), and the corresponding `quantity` and `price` for that first year.\n\n# Code\n```\nSELECT product_id, first_year, quantity, price\nFROM (\n SELECT *,\n FIRST_VALUE(year) OVER (PARTITION BY product_id \n ORDER BY year) first_year\n FROM sales\n) stb\nWHERE year = first_year;\n\n``` | 1 | 0 | ['PostgreSQL'] | 0 |
product-sales-analysis-iii | Beats 76% | Simple CTE| | beats-76-simple-cte-by-nithin415-3ynx | Intuition\nFirst we need to find first year per product_id then fetch the results.\n\n# Approach\nFor selecting first year we are using cte which is "with" to f | Nithin415 | NORMAL | 2024-04-20T05:02:05.759847+00:00 | 2024-04-20T05:02:05.759875+00:00 | 197 | false | # Intuition\nFirst we need to find first year per product_id then fetch the results.\n\n# Approach\nFor selecting first year we are using cte which is "with" to find first year and grouping it with product_id.\nusing it i main query and join conditions where both product and year are matching will give us desired results.\n\n# Complexity\n- Time complexity:\neasy to write and fast\n\n- Space complexity:\nNo ambigious or complex syntaxes, simple exectuion of logic\n\n# Code\n```\n/* Write your PL/SQL query statement below */\nwith Start_year as (\n SELECT product_id,MIN(year) as f_year\n FROM SALES \n GROUP BY product_id\n)\n SElECT s.product_id,sy.f_year as first_year,s.quantity,s.price\n from sales s\n join start_year sy\n on s.year = sy.f_year and s.product_id = sy.product_id\n``` | 1 | 0 | ['Oracle'] | 1 |
product-sales-analysis-iii | RANK() function MYSQL | rank-function-mysql-by-mengchen_ye-pc4f | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | Mengchen_Ye | NORMAL | 2024-03-16T01:33:22.415907+00:00 | 2024-03-16T01:33:22.415931+00:00 | 353 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n# Write your MySQL query statement below\nSELECT product_id, year as first_year, quantity, price\nFROM (\n SELECT product_id, year, quantity, price,\n RANK() OVER (PARTITION BY product_id ORDER BY year) AS r\n FROM Sales\n)t\nWHERE r = 1;\n``` | 1 | 0 | ['MySQL'] | 2 |
product-sales-analysis-iii | 💣 using FIRST_VALUE function in Oracle | using-first_value-function-in-oracle-by-pznhi | \n# 1\uFE0F\u20E3. FIRST_VALUE Code\nsql\n/* Write your PL/SQL query statement below */\nWITH sale_id_first AS (\n SELECT \n product_id,\n year | ayon_ssp | NORMAL | 2024-02-09T14:52:43.858007+00:00 | 2024-02-09T14:52:43.858036+00:00 | 1,743 | false | \n# 1\uFE0F\u20E3. FIRST_VALUE Code\n```sql\n/* Write your PL/SQL query statement below */\nWITH sale_id_first AS (\n SELECT \n product_id,\n year,\n FIRST_VALUE(year) OVER (PARTITION BY product_id ORDER BY year) AS first_year,\n quantity,\n price \n FROM sales\n)\nSELECT \n product_id,\n FIRST_VALUE(year) OVER (PARTITION BY product_id ORDER BY year) AS first_year,\n quantity,\n price \nFROM sale_id_first\nWHERE first_year = year;\n```\n# 2\uFE0F\u20E3. using Subqueries\n```sql\nSELECT product_id, year AS first_year, quantity, price\nFROM sales s\nWHERE year = (\n SELECT MIN(YEAR)\n FROM sales\n WHERE s.product_id = product_id\n GROUP BY product_id;\n);\n```\n\nYou Can also Look At My SDE Prep Repo [\uD83E\uDDE2 GitHub](https://github.com/Ayon-SSP/The-SDE-Prep) | 1 | 0 | ['Oracle'] | 1 |
product-sales-analysis-iii | 100 % || EASY & INTUITIVE || SQL QUERY || ( Well - Defined ) || Using Sub - Query || Beats 96.92 %.. | 100-easy-intuitive-sql-query-well-define-a3r9 | Intuition\n Describe your first thoughts on how to solve this problem. \nSELECT product_id, --> show the product_id from Sales table...\nyear AS first_year, --> | ganpatinath07 | NORMAL | 2024-02-07T16:06:46.057231+00:00 | 2024-02-07T16:06:46.057250+00:00 | 1,452 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nSELECT product_id, --> show the product_id from Sales table...\nyear AS first_year, --> also show year alias as first_year...\nquantity, price --> also show quantity & price from Sales table...\nFROM Sales --> Association from Sales table...\nWHERE (product_id, year) IN --> Using sub - query for desire o/p...\n(SELECT product_id, --> as a sub - query show product_id...\nMIN(year) AS f_year --> Using Aggregation function MIN to find first year alias as f_year...\nFROM Sales --> Association...\nGROUP BY product_id); --> Grouping w.r.t. product_id (Aggregation)...\n# Approach\n<!-- Describe your approach to solving the problem. -->\nUsing Fundamentals of SQL...\n# Complexity\n- Time complexity: O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nSELECT product_id, \nyear AS first_year, \nquantity, \nprice \nFROM Sales \n# ----SUB - QUERY----\nWHERE (product_id, year) IN \n(SELECT product_id, \nMIN(year) AS f_year \nFROM Sales \nGROUP BY product_id);\n``` | 1 | 0 | ['Database', 'MySQL'] | 4 |
employees-with-missing-information | Implementing FULL JOIN in MySQL | implementing-full-join-in-mysql-by-speed-6hkk | There is no natively implemented Outer Join in MySQL.\n But we can implement OUTER JOIN in MySQL by taking a LEFT JOIN and RIGHT JOIN union.\n If column names o | speedychital | NORMAL | 2022-04-14T09:56:08.409093+00:00 | 2022-11-20T04:16:21.649015+00:00 | 40,641 | false | * There is no natively implemented Outer Join in MySQL.\n* But we can implement **OUTER JOIN** in MySQL by taking a LEFT JOIN and RIGHT JOIN union.\n* If column names of two tables are identical, we can use the USING clause instead of the ON clause.\n```\nSELECT T.employee_id\nFROM \n (SELECT * FROM Employees LEFT JOIN Salaries USING(employee_id)\n UNION \n SELECT * FROM Employees RIGHT JOIN Salaries USING(employee_id))\nAS T\nWHERE T.salary IS NULL OR T.name IS NULL\nORDER BY employee_id; | 272 | 0 | ['Union Find', 'MySQL'] | 21 |
employees-with-missing-information | UNION + WHERE NOT IN () | union-where-not-in-by-mirandanathan-p3v6 | \nSELECT employee_id FROM Employees WHERE employee_id NOT IN (SELECT employee_id FROM Salaries)\nUNION \nSELECT employee_id FROM Salaries WHERE employee_id NOT | mirandanathan | NORMAL | 2021-08-08T16:11:40.241107+00:00 | 2021-08-08T16:11:40.241148+00:00 | 22,357 | false | ```\nSELECT employee_id FROM Employees WHERE employee_id NOT IN (SELECT employee_id FROM Salaries)\nUNION \nSELECT employee_id FROM Salaries WHERE employee_id NOT IN (SELECT employee_id FROM Employees)\n\nORDER BY 1 ASC\n``` | 196 | 1 | [] | 14 |
employees-with-missing-information | ⭐TWO METHODS BY Using JOINS and UNION (Full outer join) || mySQL⭐ | two-methods-by-using-joins-and-union-ful-6hwv | \uD83D\uDE0APLEASE UPVOTE IF YOU FIND USEFUL \uD83D\uDE0A\nFull outer join is not supported in mySQL , instead we use UNION\nMethod1\n\nSELECT employee_id from | 123_tripathi | NORMAL | 2022-08-28T16:05:32.145133+00:00 | 2022-08-28T16:05:58.750713+00:00 | 13,770 | false | **\uD83D\uDE0APLEASE UPVOTE IF YOU FIND USEFUL \uD83D\uDE0A**\n*Full outer join is not supported in mySQL , instead we use UNION*\n**Method1**\n```\nSELECT employee_id from Employees e WHERE employee_id not in (Select employee_id from Salaries)\nUNION \nSELECT employee_id from Salaries s WHERE employee_id not in (Select employee_id from Employees)\nORDER BY employee_id;\n```\n**Method2**\n```\nSelect e.employee_id from Employees e \nLEFT JOIN Salaries s \nON e.employee_id = s.employee_id\nWHERE s.salary is NULL\n\nUNION\n\nSelect s.employee_id from Salaries s\nLEFT JOIN Employees e \nON e.employee_id = s.employee_id\nWHERE e.name is NULL\n\nORDER BY employee_id;\n``` | 91 | 0 | ['Union Find', 'MySQL'] | 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.