update

leetcode/originData/[no content]highest-salaries-difference.json

@@ -0,0 +1,63 @@
+{
+    "data": {
+        "question": {
+            "questionId": "3155",
+            "questionFrontendId": "2853",
+            "boundTopicId": null,
+            "title": "Highest Salaries Difference",
+            "titleSlug": "highest-salaries-difference",
+            "content": null,
+            "translatedTitle": null,
+            "translatedContent": null,
+            "isPaidOnly": true,
+            "difficulty": "Easy",
+            "likes": 2,
+            "dislikes": 1,
+            "isLiked": null,
+            "similarQuestions": "[]",
+            "exampleTestcases": "{\"headers\": {\"Salaries\": [\"emp_name\", \"department\", \"salary\"]},\"rows\":  {\"Salaries\": [[\"Kathy\",\"Engineering\",50000],[\"Roy\",\"Marketing\",30000],[\"Charles\",\"Engineering\",45000],[\"Jack\",\"Engineering\",85000],[\"Benjamin\",\"Marketing\",34000],[\"Anthony\",\"Marketing\",42000],[\"Edward\",\"Engineering\",102000],[\"Terry\",\"Engineering\",44000],[\"Evelyn\",\"Marketing\",53000],[\"Arthur\",\"Engineering\",32000]]}}",
+            "categoryTitle": "Database",
+            "contributors": [],
+            "topicTags": [
+                {
+                    "name": "Database",
+                    "slug": "database",
+                    "translatedName": null,
+                    "__typename": "TopicTagNode"
+                }
+            ],
+            "companyTagStats": null,
+            "codeSnippets": null,
+            "stats": "{\"totalAccepted\": \"176\", \"totalSubmission\": \"208\", \"totalAcceptedRaw\": 176, \"totalSubmissionRaw\": 208, \"acRate\": \"84.6%\"}",
+            "hints": [],
+            "solution": null,
+            "status": null,
+            "sampleTestCase": "{\"headers\": {\"Salaries\": [\"emp_name\", \"department\", \"salary\"]},\"rows\":  {\"Salaries\": [[\"Kathy\",\"Engineering\",50000],[\"Roy\",\"Marketing\",30000],[\"Charles\",\"Engineering\",45000],[\"Jack\",\"Engineering\",85000],[\"Benjamin\",\"Marketing\",34000],[\"Anthony\",\"Marketing\",42000],[\"Edward\",\"Engineering\",102000],[\"Terry\",\"Engineering\",44000],[\"Evelyn\",\"Marketing\",53000],[\"Arthur\",\"Engineering\",32000]]}}",
+            "metaData": "{\"mysql\": [\"Create table if not exists Salaries(emp_name varchar(30), department varchar(30),salary int)\"], \"mssql\": [\"Create table Salaries(emp_name varchar(30), department varchar(30),salary int)\"], \"oraclesql\": [\"Create table Salaries(emp_name varchar(30), department varchar(30),salary int)\"], \"database\": true, \"languages\": [\"mysql\", \"mssql\", \"oraclesql\"], \"database_schema\": {\"Salaries\": {\"emp_name\": \"VARCHAR(30)\", \"department\": \"VARCHAR(30)\", \"salary\": \"INT\"}}}",
+            "judgerAvailable": true,
+            "judgeType": "large",
+            "mysqlSchemas": [
+                "Create table if not exists Salaries(emp_name varchar(30), department varchar(30),salary int)",
+                "Truncate table Salaries",
+                "insert into Salaries (emp_name, department, salary) values ('Kathy', 'Engineering', '50000')",
+                "insert into Salaries (emp_name, department, salary) values ('Roy', 'Marketing', '30000')",
+                "insert into Salaries (emp_name, department, salary) values ('Charles', 'Engineering', '45000')",
+                "insert into Salaries (emp_name, department, salary) values ('Jack', 'Engineering', '85000')",
+                "insert into Salaries (emp_name, department, salary) values ('Benjamin', 'Marketing', '34000')",
+                "insert into Salaries (emp_name, department, salary) values ('Anthony', 'Marketing', '42000')",
+                "insert into Salaries (emp_name, department, salary) values ('Edward', 'Engineering', '102000')",
+                "insert into Salaries (emp_name, department, salary) values ('Terry', 'Engineering', '44000')",
+                "insert into Salaries (emp_name, department, salary) values ('Evelyn', 'Marketing', '53000')",
+                "insert into Salaries (emp_name, department, salary) values ('Arthur', 'Engineering', '32000')"
+            ],
+            "enableRunCode": true,
+            "enableTestMode": false,
+            "enableDebugger": false,
+            "envInfo": "{\"mysql\": [\"MySQL\", \"<p><code>MySQL 8.0</code>.</p>\"], \"mssql\": [\"MS SQL Server\", \"<p><code>mssql server 2019</code>.</p>\"], \"oraclesql\": [\"Oracle\", \"<p><code>Oracle Sql 11.2</code>.</p>\"]}",
+            "libraryUrl": null,
+            "adminUrl": null,
+            "challengeQuestion": null,
+            "__typename": "QuestionNode"
+        }
+    }
+}

leetcode/originData/[no content]rolling-average-steps.json

@@ -0,0 +1,70 @@
+{
+    "data": {
+        "question": {
+            "questionId": "3156",
+            "questionFrontendId": "2854",
+            "boundTopicId": null,
+            "title": "Rolling Average Steps",
+            "titleSlug": "rolling-average-steps",
+            "content": null,
+            "translatedTitle": null,
+            "translatedContent": null,
+            "isPaidOnly": true,
+            "difficulty": "Medium",
+            "likes": 4,
+            "dislikes": 1,
+            "isLiked": null,
+            "similarQuestions": "[]",
+            "exampleTestcases": "{\"headers\": {\"Steps\": [\"user_id\", \"steps_count\", \"steps_date\"]}, \"rows\": {\"Steps\": [[1,687,\"2021-09-02\"],[1,395,\"2021-09-04\"],[1,499,\"2021-09-05\"],[1,712,\"2021-09-06\"],[1,576,\"2021-09-07\"],[2,153,\"2021-09-06\"],[2,171,\"2021-09-07\"],[2,530,\"2021-09-08\"],[3,945,\"2021-09-04\"],[3,120,\"2021-09-07\"],[3,557,\"2021-09-08\"],[3,840,\"2021-09-09\"],[3,627,\"2021-09-10\"],[5,382,\"2021-09-05\"],[6,480,\"2021-09-01\"],[6,191,\"2021-09-02\"],[6,303,\"2021-09-05\"]]}}",
+            "categoryTitle": "Database",
+            "contributors": [],
+            "topicTags": [
+                {
+                    "name": "Database",
+                    "slug": "database",
+                    "translatedName": null,
+                    "__typename": "TopicTagNode"
+                }
+            ],
+            "companyTagStats": null,
+            "codeSnippets": null,
+            "stats": "{\"totalAccepted\": \"121\", \"totalSubmission\": \"208\", \"totalAcceptedRaw\": 121, \"totalSubmissionRaw\": 208, \"acRate\": \"58.2%\"}",
+            "hints": [],
+            "solution": null,
+            "status": null,
+            "sampleTestCase": "{\"headers\": {\"Steps\": [\"user_id\", \"steps_count\", \"steps_date\"]}, \"rows\": {\"Steps\": [[1,687,\"2021-09-02\"],[1,395,\"2021-09-04\"],[1,499,\"2021-09-05\"],[1,712,\"2021-09-06\"],[1,576,\"2021-09-07\"],[2,153,\"2021-09-06\"],[2,171,\"2021-09-07\"],[2,530,\"2021-09-08\"],[3,945,\"2021-09-04\"],[3,120,\"2021-09-07\"],[3,557,\"2021-09-08\"],[3,840,\"2021-09-09\"],[3,627,\"2021-09-10\"],[5,382,\"2021-09-05\"],[6,480,\"2021-09-01\"],[6,191,\"2021-09-02\"],[6,303,\"2021-09-05\"]]}}",
+            "metaData": "{\"mysql\": [\"Create table if not exists Steps(user_id int, steps_count int, steps_date date)\"], \"mssql\": [\"Create table Steps(user_id int, steps_count int, steps_date date)\"], \"oraclesql\": [\"Create table Steps(user_id int, steps_count int, steps_date date)\", \"ALTER SESSION SET nls_date_format='YYYY-MM-DD'\"], \"database\": true, \"name\": \"rolling_average\", \"pythondata\": [\"Steps = pd.DataFrame([], columns=['user_id', 'steps_count', 'steps_date']).astype({'user_id':'Int64', 'steps_count':'Int64', 'steps_date':'datetime64[ns]'})\"], \"database_schema\": {\"Steps\": {\"user_id\": \"INT\", \"steps_count\": \"INT\", \"steps_date\": \"DATE\"}}}",
+            "judgerAvailable": true,
+            "judgeType": "large",
+            "mysqlSchemas": [
+                "Create table if not exists Steps(user_id int, steps_count int, steps_date date)",
+                "Truncate table Steps",
+                "insert into Steps (user_id, steps_count, steps_date) values ('1', '687', '2021-09-02')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('1', '395', '2021-09-04')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('1', '499', '2021-09-05')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('1', '712', '2021-09-06')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('1', '576', '2021-09-07')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('2', '153', '2021-09-06')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('2', '171', '2021-09-07')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('2', '530', '2021-09-08')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('3', '945', '2021-09-04')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('3', '120', '2021-09-07')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('3', '557', '2021-09-08')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('3', '840', '2021-09-09')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('3', '627', '2021-09-10')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('5', '382', '2021-09-05')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('6', '480', '2021-09-01')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('6', '191', '2021-09-02')",
+                "insert into Steps (user_id, steps_count, steps_date) values ('6', '303', '2021-09-05')"
+            ],
+            "enableRunCode": true,
+            "enableTestMode": false,
+            "enableDebugger": false,
+            "envInfo": "{\"mysql\": [\"MySQL\", \"<p><code>MySQL 8.0</code>.</p>\"], \"mssql\": [\"MS SQL Server\", \"<p><code>mssql server 2019</code>.</p>\"], \"oraclesql\": [\"Oracle\", \"<p><code>Oracle Sql 11.2</code>.</p>\"], \"pythondata\": [\"Pandas\", \"<p>Python 3.10 with Pandas 2.0.2 and NumPy 1.25.0</p>\"]}",
+            "libraryUrl": null,
+            "adminUrl": null,
+            "challengeQuestion": null,
+            "__typename": "QuestionNode"
+        }
+    }
+}

leetcode/problem/count-pairs-of-points-with-distance-k.html

@@ -0,0 +1,33 @@
+<p>You are given a <strong>2D</strong> integer array <code>coordinates</code> and an integer <code>k</code>, where <code>coordinates[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> are the coordinates of the <code>i<sup>th</sup></code> point in a 2D plane.</p>
+
+<p>We define the <strong>distance</strong> between two points <code>(x<sub>1</sub>, y<sub>1</sub>)</code> and <code>(x<sub>2</sub>, y<sub>2</sub>)</code> as <code>(x1 XOR x2) + (y1 XOR y2)</code> where <code>XOR</code> is the bitwise <code>XOR</code> operation.</p>
+
+<p>Return <em>the number of pairs </em><code>(i, j)</code><em> such that </em><code>i &lt; j</code><em> and the distance between points </em><code>i</code><em> and </em><code>j</code><em> is equal to </em><code>k</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> We can choose the following pairs:
+- (0,1): Because we have (1 XOR 4) + (2 XOR 2) = 5.
+- (2,3): Because we have (1 XOR 5) + (3 XOR 2) = 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> Any two chosen pairs will have a distance of 0. There are 10 ways to choose two pairs.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= coordinates.length &lt;= 50000</code></li>
+	<li><code>0 &lt;= x<sub>i</sub>, y<sub>i</sub> &lt;= 10<sup>6</sup></code></li>
+	<li><code>0 &lt;= k &lt;= 100</code></li>
+</ul>

leetcode/problem/determine-if-a-cell-is-reachable-at-a-given-time.html

@@ -0,0 +1,32 @@
+<p>You are given four integers <code>sx</code>, <code>sy</code>, <code>fx</code>, <code>fy</code>, and a <strong>non-negative</strong> integer <code>t</code>.</p>
+
+<p>In an infinite 2D grid, you start at the cell <code>(sx, sy)</code>. Each second, you <strong>must</strong> move to any of its adjacent cells.</p>
+
+<p>Return <code>true</code> <em>if you can reach cell </em><code>(fx, fy)</code> <em>after<strong> exactly</strong></em> <code>t</code> <strong><em>seconds</em></strong>, <em>or</em> <code>false</code> <em>otherwise</em>.</p>
+
+<p>A cell&#39;s <strong>adjacent cells</strong> are the 8 cells around it that share at least one corner with it. You can visit the same cell several times.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/08/05/example2.svg" style="width: 443px; height: 243px;" />
+<pre>
+<strong>Input:</strong> sx = 2, sy = 4, fx = 7, fy = 7, t = 6
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Starting at cell (2, 4), we can reach cell (7, 7) in exactly 6 seconds by going through the cells depicted in the picture above. 
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/08/05/example1.svg" style="width: 383px; height: 202px;" />
+<pre>
+<strong>Input:</strong> sx = 3, sy = 1, fx = 7, fy = 3, t = 3
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Starting at cell (3, 1), it takes at least 4 seconds to reach cell (7, 3) by going through the cells depicted in the picture above. Hence, we cannot reach cell (7, 3) at the third second.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= sx, sy, fx, fy &lt;= 10<sup>9</sup></code></li>
+	<li><code>0 &lt;= t &lt;= 10<sup>9</sup></code></li>
+</ul>

leetcode/problem/happy-students.html

@@ -0,0 +1,43 @@
+<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> of length <code>n</code> where <code>n</code> is the total number of students in the class. The class teacher tries to select a group of students so that all the students remain happy.</p>
+
+<p>The <code>i<sup>th</sup></code> student will become happy if one of these two conditions is met:</p>
+
+<ul>
+	<li>The student is selected and the total number of selected students is<strong> strictly greater than</strong> <code>nums[i]</code>.</li>
+	<li>The student is not selected and the total number of selected students is <strong>strictly</strong> <strong>less than</strong> <code>nums[i]</code>.</li>
+</ul>
+
+<p>Return <em>the number of ways to select a group of students so that everyone remains happy.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 
+The two possible ways are:
+The class teacher selects no student.
+The class teacher selects both students to form the group. 
+If the class teacher selects just one student to form a group then the both students will not be happy. Therefore, there are only two possible ways.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [6,0,3,3,6,7,2,7]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+The three possible ways are:
+The class teacher selects the student with index = 1 to form the group.
+The class teacher selects the students with index = 1, 2, 3, 6 to form the group.
+The class teacher selects all the students to form the group.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt; nums.length</code></li>
+</ul>

leetcode/problem/maximum-element-sum-of-a-complete-subset-of-indices.html

@@ -0,0 +1,43 @@
+<p>You are given a <strong>1</strong><strong>-indexed</strong> array <code>nums</code> of <code>n</code> integers.</p>
+
+<p>A set of numbers is <strong>complete</strong> if the product of every pair of its elements is a perfect square.</p>
+
+<p>For a subset of the indices set <code>{1, 2, ..., n}</code> represented as <code>{i<sub>1</sub>, i<sub>2</sub>, ..., i<sub>k</sub>}</code>, we define its <strong>element-sum</strong> as: <code>nums[i<sub>1</sub>] + nums[i<sub>2</sub>] + ... + nums[i<sub>k</sub>]</code>.</p>
+
+<p>Return <em>the <strong>maximum element-sum</strong> of a <strong>complete</strong> subset of the indices set</em> <code>{1, 2, ..., n}</code>.</p>
+
+<p>A perfect square is a number that can be expressed as the product of an integer by itself.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [8,7,3,5,7,2,4,9]
+<strong>Output:</strong> 16
+<strong>Explanation:</strong> Apart from the subsets consisting of a single index, there are two other complete subsets of indices: {1,4} and {2,8}.
+The sum of the elements corresponding to indices 1 and 4 is equal to nums[1] + nums[4] = 8 + 5 = 13.
+The sum of the elements corresponding to indices 2 and 8 is equal to nums[2] + nums[8] = 7 + 9 = 16.
+Hence, the maximum element-sum of a complete subset of indices is 16.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5,10,3,10,1,13,7,9,4]
+<strong>Output:</strong> 19
+<strong>Explanation:</strong> Apart from the subsets consisting of a single index, there are four other complete subsets of indices: {1,4}, {1,9}, {2,8}, {4,9}, and {1,4,9}.
+The sum of the elements corresponding to indices 1 and 4 is equal to nums[1] + nums[4] = 5 + 10 = 15.
+The sum of the elements corresponding to indices 1 and 9 is equal to nums[1] + nums[9] = 5 + 4 = 9.
+The sum of the elements corresponding to indices 2 and 8 is equal to nums[2] + nums[8] = 10 + 9 = 19.
+The sum of the elements corresponding to indices 4 and 9 is equal to nums[4] + nums[9] = 10 + 4 = 14.
+The sum of the elements corresponding to indices 1, 4, and 9 is equal to nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
+Hence, the maximum element-sum of a complete subset of indices is 19.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n == nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>

leetcode/problem/maximum-number-of-alloys.html

@@ -0,0 +1,66 @@
+<p>You are the owner of a company that creates alloys using various types of metals. There are <code>n</code> different types of metals available, and you have access to <code>k</code> machines that can be used to create alloys. Each machine requires a specific amount of each metal type to create an alloy.</p>
+
+<p>For the <code>i<sup>th</sup></code> machine to create an alloy, it needs <code>composition[i][j]</code> units of metal of type <code>j</code>. Initially, you have <code>stock[i]</code> units of metal type <code>i</code>, and purchasing one unit of metal type <code>i</code> costs <code>cost[i]</code> coins.</p>
+
+<p>Given integers <code>n</code>, <code>k</code>, <code>budget</code>, a <strong>1-indexed</strong> 2D array <code>composition</code>, and <strong>1-indexed</strong> arrays <code>stock</code> and <code>cost</code>, your goal is to <strong>maximize</strong> the number of alloys the company can create while staying within the budget of <code>budget</code> coins.</p>
+
+<p><strong>All alloys must be created with the same machine.</strong></p>
+
+<p>Return <em>the maximum number of alloys that the company can create</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,10]], stock = [0,0,0], cost = [1,2,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> It is optimal to use the 1<sup>st</sup> machine to create alloys.
+To create 2 alloys we need to buy the:
+- 2 units of metal of the 1<sup>st</sup> type.
+- 2 units of metal of the 2<sup>nd</sup> type.
+- 2 units of metal of the 3<sup>rd</sup> type.
+In total, we need 2 * 1 + 2 * 2 + 2 * 3 = 12 coins, which is smaller than or equal to budget = 15.
+Notice that we have 0 units of metal of each type and we have to buy all the required units of metal.
+It can be proven that we can create at most 2 alloys.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,10]], stock = [0,0,100], cost = [1,2,3]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> It is optimal to use the 2<sup>nd</sup> machine to create alloys.
+To create 5 alloys we need to buy:
+- 5 units of metal of the 1<sup>st</sup> type.
+- 5 units of metal of the 2<sup>nd</sup> type.
+- 0 units of metal of the 3<sup>rd</sup> type.
+In total, we need 5 * 1 + 5 * 2 + 0 * 3 = 15 coins, which is smaller than or equal to budget = 15.
+It can be proven that we can create at most 5 alloys.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2, k = 3, budget = 10, composition = [[2,1],[1,2],[1,1]], stock = [1,1], cost = [5,5]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> It is optimal to use the 3<sup>rd</sup> machine to create alloys.
+To create 2 alloys we need to buy the:
+- 1 unit of metal of the 1<sup>st</sup> type.
+- 1 unit of metal of the 2<sup>nd</sup> type.
+In total, we need 1 * 5 + 1 * 5 = 10 coins, which is smaller than or equal to budget = 10.
+It can be proven that we can create at most 2 alloys.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n, k &lt;= 100</code></li>
+	<li><code>0 &lt;= budget &lt;= 10<sup>8</sup></code></li>
+	<li><code>composition.length == k</code></li>
+	<li><code>composition[i].length == n</code></li>
+	<li><code>1 &lt;= composition[i][j] &lt;= 100</code></li>
+	<li><code>stock.length == cost.length == n</code></li>
+	<li><code>0 &lt;= stock[i] &lt;= 10<sup>8</sup></code></li>
+	<li><code>1 &lt;= cost[i] &lt;= 100</code></li>
+</ul>

leetcode/problem/minimum-array-length-after-pair-removals.html

@@ -0,0 +1,59 @@
+<p>You are given a <strong>0-indexed</strong> <strong>sorted</strong> array of integers <code>nums</code>.</p>
+
+<p>You can perform the following operation any number of times:</p>
+
+<ul>
+	<li>Choose <strong>two</strong> indices, <code>i</code> and <code>j</code>, where <code>i &lt; j</code>, such that <code>nums[i] &lt; nums[j]</code>.</li>
+	<li>Then, remove the elements at indices <code>i</code> and <code>j</code> from <code>nums</code>. The remaining elements retain their original order, and the array is re-indexed.</li>
+</ul>
+
+<p>Return <em>an integer that denotes the <strong>minimum</strong> length of </em><code>nums</code><em> after performing the operation any number of times (<strong>including zero</strong>).</em></p>
+
+<p>Note that <code>nums</code> is sorted in <strong>non-decreasing</strong> order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,4,9]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Initially, nums = [1, 3, 4, 9].
+In the first operation, we can choose index 0 and 1 because nums[0] &lt; nums[1] &lt;=&gt; 1 &lt; 3.
+Remove indices 0 and 1, and nums becomes [4, 9].
+For the next operation, we can choose index 0 and 1 because nums[0] &lt; nums[1] &lt;=&gt; 4 &lt; 9.
+Remove indices 0 and 1, and nums becomes an empty array [].
+Hence, the minimum length achievable is 0.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,6,9]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Initially, nums = [2, 3, 6, 9]. 
+In the first operation, we can choose index 0 and 2 because nums[0] &lt; nums[2] &lt;=&gt; 2 &lt; 6. 
+Remove indices 0 and 2, and nums becomes [3, 9]. 
+For the next operation, we can choose index 0 and 1 because nums[0] &lt; nums[1] &lt;=&gt; 3 &lt; 9. 
+Remove indices 0 and 1, and nums becomes an empty array []. 
+Hence, the minimum length achievable is 0.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,1,2]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Initially, nums = [1, 1, 2].
+In an operation, we can choose index 0 and 2 because nums[0] &lt; nums[2] &lt;=&gt; 1 &lt; 2. 
+Remove indices 0 and 2, and nums becomes [1]. 
+It is no longer possible to perform an operation on the array. 
+Hence, the minimum achievable length is 1. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>nums</code> is sorted in <strong>non-decreasing</strong> order.</li>
+</ul>

leetcode/problem/minimum-edge-reversals-so-every-node-is-reachable.html

@@ -0,0 +1,57 @@
+<p>There is a <strong>simple directed graph</strong> with <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>. The graph would form a <strong>tree</strong> if its edges were bi-directional.</p>
+
+<p>You are given an integer <code>n</code> and a <strong>2D</strong> integer array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> represents a <strong>directed edge</strong> going from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code>.</p>
+
+<p>An <strong>edge reversal</strong> changes the direction of an edge, i.e., a directed edge going from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code> becomes a directed edge going from node <code>v<sub>i</sub></code> to node <code>u<sub>i</sub></code>.</p>
+
+<p>For every node <code>i</code> in the range <code>[0, n - 1]</code>, your task is to <strong>independently</strong> calculate the <strong>minimum</strong> number of <strong>edge reversals</strong> required so it is possible to reach any other node starting from node <code>i</code> through a <strong>sequence</strong> of <strong>directed edges</strong>.</p>
+
+<p>Return <em>an integer array </em><code>answer</code><em>, where </em><code>answer[i]</code><em> is the</em><em> </em> <em><strong>minimum</strong> number of <strong>edge reversals</strong> required so it is possible to reach any other node starting from node </em><code>i</code><em> through a <strong>sequence</strong> of <strong>directed edges</strong>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<p><img height="246" src="https://assets.leetcode.com/uploads/2023/08/26/image-20230826221104-3.png" width="312" /></p>
+
+<pre>
+<strong>Input:</strong> n = 4, edges = [[2,0],[2,1],[1,3]]
+<strong>Output:</strong> [1,1,0,2]
+<strong>Explanation:</strong> The image above shows the graph formed by the edges.
+For node 0: after reversing the edge [2,0], it is possible to reach any other node starting from node 0.
+So, answer[0] = 1.
+For node 1: after reversing the edge [2,1], it is possible to reach any other node starting from node 1.
+So, answer[1] = 1.
+For node 2: it is already possible to reach any other node starting from node 2.
+So, answer[2] = 0.
+For node 3: after reversing the edges [1,3] and [2,1], it is possible to reach any other node starting from node 3.
+So, answer[3] = 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<p><img height="217" src="https://assets.leetcode.com/uploads/2023/08/26/image-20230826225541-2.png" width="322" /></p>
+
+<pre>
+<strong>Input:</strong> n = 3, edges = [[1,2],[2,0]]
+<strong>Output:</strong> [2,0,1]
+<strong>Explanation:</strong> The image above shows the graph formed by the edges.
+For node 0: after reversing the edges [2,0] and [1,2], it is possible to reach any other node starting from node 0.
+So, answer[0] = 2.
+For node 1: it is already possible to reach any other node starting from node 1.
+So, answer[1] = 0.
+For node 2: after reversing the edge [1, 2], it is possible to reach any other node starting from node 2.
+So, answer[2] = 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges.length == n - 1</code></li>
+	<li><code>edges[i].length == 2</code></li>
+	<li><code>0 &lt;= u<sub>i</sub> == edges[i][0] &lt; n</code></li>
+	<li><code>0 &lt;= v<sub>i</sub> == edges[i][1] &lt; n</code></li>
+	<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
+	<li>The input is generated such&nbsp;that if the edges were bi-directional, the graph would be a tree.</li>
+</ul>

leetcode/problem/minimum-moves-to-spread-stones-over-grid.html

@@ -0,0 +1,42 @@
+<p>You are given a <strong>0-indexed</strong> 2D integer matrix <code>grid</code> of size <code>3 * 3</code>, representing the number of stones in each cell. The grid contains exactly <code>9</code> stones, and there can be <strong>multiple</strong> stones in a single cell.</p>
+
+<p>In one move, you can move a single stone from its current cell to any other cell if the two cells share a side.</p>
+
+<p>Return <em>the <strong>minimum number of moves</strong> required to place one stone in each cell</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/08/23/example1-3.svg" style="width: 401px; height: 281px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,1,0],[1,1,1],[1,2,1]]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> One possible sequence of moves to place one stone in each cell is: 
+1- Move one stone from cell (2,1) to cell (2,2).
+2- Move one stone from cell (2,2) to cell (1,2).
+3- Move one stone from cell (1,2) to cell (0,2).
+In total, it takes 3 moves to place one stone in each cell of the grid.
+It can be shown that 3 is the minimum number of moves required to place one stone in each cell.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/08/23/example2-2.svg" style="width: 401px; height: 281px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,3,0],[1,0,0],[1,0,3]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One possible sequence of moves to place one stone in each cell is:
+1- Move one stone from cell (0,1) to cell (0,2).
+2- Move one stone from cell (0,1) to cell (1,1).
+3- Move one stone from cell (2,2) to cell (1,2).
+4- Move one stone from cell (2,2) to cell (2,1).
+In total, it takes 4 moves to place one stone in each cell of the grid.
+It can be shown that 4 is the minimum number of moves required to place one stone in each cell.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>grid.length == grid[i].length == 3</code></li>
+	<li><code>0 &lt;= grid[i][j] &lt;= 9</code></li>
+	<li>Sum of <code>grid</code> is equal to <code>9</code>.</li>
+</ul>

leetcode/problem/minimum-right-shifts-to-sort-the-array.html

@@ -0,0 +1,39 @@
+<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of length <code>n</code> containing <strong>distinct</strong> positive integers. Return <em>the <strong>minimum</strong> number of <strong>right shifts</strong> required to sort </em><code>nums</code><em> and </em><code>-1</code><em> if this is not possible.</em></p>
+
+<p>A <strong>right shift</strong> is defined as shifting the element at index <code>i</code> to index <code>(i + 1) % n</code>, for all indices.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,4,5,1,2]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 
+After the first right shift, nums = [2,3,4,5,1].
+After the second right shift, nums = [1,2,3,4,5].
+Now nums is sorted; therefore the answer is 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,5]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> nums is already sorted therefore, the answer is 0.</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,1,4]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> It&#39;s impossible to sort the array using right shifts.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+	<li><code>nums</code> contains distinct integers.</li>
+</ul>

leetcode/problem/points-that-intersect-with-cars.html

@@ -0,0 +1,29 @@
+<p>You are given a <strong>0-indexed</strong> 2D integer array <code>nums</code> representing the coordinates of the cars parking on a number line. For any index <code>i</code>, <code>nums[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> where <code>start<sub>i</sub></code> is the starting point of the <code>i<sup>th</sup></code> car and <code>end<sub>i</sub></code> is the ending point of the <code>i<sup>th</sup></code> car.</p>
+
+<p>Return <em>the number of integer points on the line that are covered with <strong>any part</strong> of a car.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [[3,6],[1,5],[4,7]]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> All the points from 1 to 7 intersect at least one car, therefore the answer would be 7.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [[1,3],[5,8]]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Points intersecting at least one car are 1, 2, 3, 5, 6, 7, 8. There are a total of 7 points, therefore the answer would be 7.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>nums[i].length == 2</code></li>
+	<li><code><font face="monospace">1 &lt;= start<sub>i</sub>&nbsp;&lt;= end<sub>i</sub>&nbsp;&lt;= 100</font></code></li>
+</ul>

leetcode/problem/string-transformation.html

@@ -0,0 +1,49 @@
+<p>You are given two strings <code>s</code> and <code>t</code> of equal length <code>n</code>. You can perform the following operation on the string <code>s</code>:</p>
+
+<ul>
+	<li>Remove a <strong>suffix</strong> of <code>s</code> of length <code>l</code> where <code>0 &lt; l &lt; n</code> and append it at the start of <code>s</code>.<br />
+	For example, let <code>s = &#39;abcd&#39;</code> then in one operation you can remove the suffix <code>&#39;cd&#39;</code> and append it in front of <code>s</code> making <code>s = &#39;cdab&#39;</code>.</li>
+</ul>
+
+<p>You are also given an integer <code>k</code>. Return <em>the number of ways in which </em><code>s</code> <em>can be transformed into </em><code>t</code><em> in <strong>exactly</strong> </em><code>k</code><em> operations.</em></p>
+
+<p>Since the answer can be large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcd&quot;, t = &quot;cdab&quot;, k = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 
+First way:
+In first operation, choose suffix from index = 3, so resulting s = &quot;dabc&quot;.
+In second operation, choose suffix from index = 3, so resulting s = &quot;cdab&quot;.
+
+Second way:
+In first operation, choose suffix from index = 1, so resulting s = &quot;bcda&quot;.
+In second operation, choose suffix from index = 1, so resulting s = &quot;cdab&quot;.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;ababab&quot;, t = &quot;ababab&quot;, k = 1
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 
+First way:
+Choose suffix from index = 2, so resulting s = &quot;ababab&quot;.
+
+Second way:
+Choose suffix from index = 4, so resulting s = &quot;ababab&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= s.length &lt;= 5 * 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>15</sup></code></li>
+	<li><code>s.length == t.length</code></li>
+	<li><code>s</code> and <code>t</code> consist of only lowercase English alphabets.</li>
+</ul>

leetcode/problem/sum-of-values-at-indices-with-k-set-bits.html

@@ -0,0 +1,47 @@
+<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>.</p>
+
+<p>Return <em>an integer that denotes the <strong>sum</strong> of elements in </em><code>nums</code><em> whose corresponding <strong>indices</strong> have <strong>exactly</strong> </em><code>k</code><em> set bits in their binary representation.</em></p>
+
+<p>The <strong>set bits</strong> in an integer are the <code>1</code>&#39;s present when it is written in binary.</p>
+
+<ul>
+	<li>For example, the binary representation of <code>21</code> is <code>10101</code>, which has <code>3</code> set bits.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5,10,1,5,2], k = 1
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> The binary representation of the indices are: 
+0 = 000<sub>2</sub>
+1 = 001<sub>2</sub>
+2 = 010<sub>2</sub>
+3 = 011<sub>2</sub>
+4 = 100<sub>2 
+</sub>Indices 1, 2, and 4 have k = 1 set bits in their binary representation.
+Hence, the answer is nums[1] + nums[2] + nums[4] = 13.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [4,3,2,1], k = 2
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The binary representation of the indices are:
+0 = 00<sub>2</sub>
+1 = 01<sub>2</sub>
+2 = 10<sub>2</sub>
+3 = 11<sub>2
+</sub>Only index 3 has k = 2 set bits in its binary representation.
+Hence, the answer is nums[3] = 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= k &lt;= 10</code></li>
+</ul>