update

leetcode/originData/[no content]product-sales-analysis-iv.json

@@ -0,0 +1,64 @@
+{
+    "data": {
+        "question": {
+            "questionId": "2451",
+            "questionFrontendId": "2324",
+            "boundTopicId": null,
+            "title": "Product Sales Analysis IV",
+            "titleSlug": "product-sales-analysis-iv",
+            "content": null,
+            "translatedTitle": null,
+            "translatedContent": null,
+            "isPaidOnly": true,
+            "difficulty": "Medium",
+            "likes": 3,
+            "dislikes": 1,
+            "isLiked": null,
+            "similarQuestions": "[{\"title\": \"Product Sales Analysis I\", \"titleSlug\": \"product-sales-analysis-i\", \"difficulty\": \"Easy\", \"translatedTitle\": null}, {\"title\": \"Product Sales Analysis II\", \"titleSlug\": \"product-sales-analysis-ii\", \"difficulty\": \"Easy\", \"translatedTitle\": null}, {\"title\": \"Product Sales Analysis III\", \"titleSlug\": \"product-sales-analysis-iii\", \"difficulty\": \"Medium\", \"translatedTitle\": null}]",
+            "exampleTestcases": null,
+            "categoryTitle": "Database",
+            "contributors": [],
+            "topicTags": [
+                {
+                    "name": "Database",
+                    "slug": "database",
+                    "translatedName": null,
+                    "__typename": "TopicTagNode"
+                }
+            ],
+            "companyTagStats": null,
+            "codeSnippets": null,
+            "stats": "{\"totalAccepted\": \"439\", \"totalSubmission\": \"501\", \"totalAcceptedRaw\": 439, \"totalSubmissionRaw\": 501, \"acRate\": \"87.6%\"}",
+            "hints": [],
+            "solution": null,
+            "status": null,
+            "sampleTestCase": "{\"headers\": {\"Sales\": [\"sale_id\", \"product_id\", \"user_id\", \"quantity\"], \"Product\": [\"product_id\", \"price\"]}, \"rows\": {\"Sales\": [[1, 1, 101, 10], [2, 3, 101, 7], [3, 1, 102, 9], [4, 2, 102, 6], [5, 3, 102, 10], [6, 1, 102, 6]], \"Product\": [[1, 10], [2, 25], [3, 15]]}}",
+            "metaData": "{\n  \"mysql\": [\n    \"Create table If Not Exists Sales (sale_id int, product_id int, user_id int, quantity int)\",\n    \"Create table If Not Exists Product (product_id int, price int)\"\n  ],\n  \"mssql\": [\n    \"Create table Sales (sale_id int, product_id int, user_id int, quantity int)\",\n    \"Create table Product (product_id int, price int)\"\n  ],\n  \"oraclesql\": [\n    \"Create table Sales (sale_id int, product_id int, user_id int, quantity int)\",\n    \"Create table Product (product_id int, price int)\"\n  ],\n  \"database\": true\n}",
+            "judgerAvailable": true,
+            "judgeType": "large",
+            "mysqlSchemas": [
+                "Create table If Not Exists Sales (sale_id int, product_id int, user_id int, quantity int)",
+                "Create table If Not Exists Product (product_id int, price int)",
+                "Truncate table Sales",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('1', '1', '101', '10')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('2', '3', '101', '7')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('3', '1', '102', '9')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('4', '2', '102', '6')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('5', '3', '102', '10')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('6', '1', '102', '6')",
+                "Truncate table Product",
+                "insert into Product (product_id, price) values ('1', '10')",
+                "insert into Product (product_id, price) values ('2', '25')",
+                "insert into Product (product_id, price) values ('3', '15')"
+            ],
+            "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]product-sales-analysis-v.json

@@ -0,0 +1,56 @@
+{
+    "data": {
+        "question": {
+            "questionId": "2452",
+            "questionFrontendId": "2329",
+            "boundTopicId": null,
+            "title": "Product Sales Analysis V",
+            "titleSlug": "product-sales-analysis-v",
+            "content": null,
+            "translatedTitle": null,
+            "translatedContent": null,
+            "isPaidOnly": true,
+            "difficulty": "Medium",
+            "likes": 0,
+            "dislikes": 5,
+            "isLiked": null,
+            "similarQuestions": "[{\"title\": \"Product Sales Analysis I\", \"titleSlug\": \"product-sales-analysis-i\", \"difficulty\": \"Easy\", \"translatedTitle\": null}, {\"title\": \"Product Sales Analysis II\", \"titleSlug\": \"product-sales-analysis-ii\", \"difficulty\": \"Easy\", \"translatedTitle\": null}, {\"title\": \"Product Sales Analysis III\", \"titleSlug\": \"product-sales-analysis-iii\", \"difficulty\": \"Medium\", \"translatedTitle\": null}]",
+            "exampleTestcases": "{\"headers\": {\"Sales\": [\"sale_id\", \"product_id\", \"user_id\", \"quantity\"], \"Product\": [\"product_id\", \"price\"]}, \"rows\": {\"Sales\": [[1, 1, 101, 10], [2, 2, 101, 1], [3, 3, 102, 3], [4, 3, 102, 2], [5, 2, 103, 3]], \"Product\": [[1, 10], [2, 25], [3, 15]]}}",
+            "categoryTitle": "Database",
+            "contributors": [],
+            "topicTags": [],
+            "companyTagStats": null,
+            "codeSnippets": null,
+            "stats": "{\"totalAccepted\": \"337\", \"totalSubmission\": \"408\", \"totalAcceptedRaw\": 337, \"totalSubmissionRaw\": 408, \"acRate\": \"82.6%\"}",
+            "hints": [],
+            "solution": null,
+            "status": null,
+            "sampleTestCase": "{\"headers\": {\"Sales\": [\"sale_id\", \"product_id\", \"user_id\", \"quantity\"], \"Product\": [\"product_id\", \"price\"]}, \"rows\": {\"Sales\": [[1, 1, 101, 10], [2, 2, 101, 1], [3, 3, 102, 3], [4, 3, 102, 2], [5, 2, 103, 3]], \"Product\": [[1, 10], [2, 25], [3, 15]]}}",
+            "metaData": "{\n  \"mysql\": [\n    \"Create table If Not Exists Sales (sale_id int, product_id int, user_id int, quantity int)\",\n    \"Create table If Not Exists Product (product_id int, price int)\"\n  ],\n  \"mssql\": [\n    \"Create table Sales (sale_id int, product_id int, user_id int, quantity int)\",\n    \"Create table Product (product_id int, price int)\"\n  ],\n  \"oraclesql\": [\n    \"Create table Sales (sale_id int, product_id int, user_id int, quantity int)\",\n    \"Create table Product (product_id int, price int)\"\n  ],\n  \"database\": true\n}",
+            "judgerAvailable": true,
+            "judgeType": "large",
+            "mysqlSchemas": [
+                "Create table If Not Exists Sales (sale_id int, product_id int, user_id int, quantity int)",
+                "Create table If Not Exists Product (product_id int, price int)",
+                "Truncate table Sales",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('1', '1', '101', '10')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('2', '2', '101', '1')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('3', '3', '102', '3')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('4', '3', '102', '2')",
+                "insert into Sales (sale_id, product_id, user_id, quantity) values ('5', '2', '103', '3')",
+                "Truncate table Product",
+                "insert into Product (product_id, price) values ('1', '10')",
+                "insert into Product (product_id, price) values ('2', '25')",
+                "insert into Product (product_id, price) values ('3', '15')"
+            ],
+            "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/problem/array-partition.html

@@ -0,0 +1,30 @@
+<p>Given an integer array <code>nums</code> of <code>2n</code> integers, group these integers into <code>n</code> pairs <code>(a<sub>1</sub>, b<sub>1</sub>), (a<sub>2</sub>, b<sub>2</sub>), ..., (a<sub>n</sub>, b<sub>n</sub>)</code> such that the sum of <code>min(a<sub>i</sub>, b<sub>i</sub>)</code> for all <code>i</code> is <strong>maximized</strong>. Return<em> the maximized sum</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,4,3,2]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> All possible pairings (ignoring the ordering of elements) are:
+1. (1, 4), (2, 3) -&gt; min(1, 4) + min(2, 3) = 1 + 2 = 3
+2. (1, 3), (2, 4) -&gt; min(1, 3) + min(2, 4) = 1 + 2 = 3
+3. (1, 2), (3, 4) -&gt; min(1, 2) + min(3, 4) = 1 + 3 = 4
+So the maximum possible sum is 4.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [6,2,6,5,1,2]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> The optimal pairing is (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums.length == 2 * n</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>

leetcode/problem/count-the-number-of-ideal-arrays.html

@@ -0,0 +1,48 @@
+<p>You are given two integers <code>n</code> and <code>maxValue</code>, which are used to describe an <strong>ideal</strong> array.</p>
+
+<p>A <strong>0-indexed</strong> integer array <code>arr</code> of length <code>n</code> is considered <strong>ideal</strong> if the following conditions hold:</p>
+
+<ul>
+	<li>Every <code>arr[i]</code> is a value from <code>1</code> to <code>maxValue</code>, for <code>0 &lt;= i &lt; n</code>.</li>
+	<li>Every <code>arr[i]</code> is divisible by <code>arr[i - 1]</code>, for <code>0 &lt; i &lt; n</code>.</li>
+</ul>
+
+<p>Return <em>the number of <strong>distinct</strong> ideal arrays of length </em><code>n</code>. Since the answer may be very large, return it modulo <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2, maxValue = 5
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> The following are the possible ideal arrays:
+- Arrays starting with the value 1 (5 arrays): [1,1], [1,2], [1,3], [1,4], [1,5]
+- Arrays starting with the value 2 (2 arrays): [2,2], [2,4]
+- Arrays starting with the value 3 (1 array): [3,3]
+- Arrays starting with the value 4 (1 array): [4,4]
+- Arrays starting with the value 5 (1 array): [5,5]
+There are a total of 5 + 2 + 1 + 1 + 1 = 10 distinct ideal arrays.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 5, maxValue = 3
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> The following are the possible ideal arrays:
+- Arrays starting with the value 1 (9 arrays): 
+   - With no other distinct values (1 array): [1,1,1,1,1] 
+   - With 2<sup>nd</sup> distinct value 2 (4 arrays): [1,1,1,1,2], [1,1,1,2,2], [1,1,2,2,2], [1,2,2,2,2]
+   - With 2<sup>nd</sup> distinct value 3 (4 arrays): [1,1,1,1,3], [1,1,1,3,3], [1,1,3,3,3], [1,3,3,3,3]
+- Arrays starting with the value 2 (1 array): [2,2,2,2,2]
+- Arrays starting with the value 3 (1 array): [3,3,3,3,3]
+There are a total of 9 + 1 + 1 = 11 distinct ideal arrays.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= maxValue &lt;= 10<sup>4</sup></code></li>
+</ul>

leetcode/problem/decode-the-message.html

@@ -0,0 +1,44 @@
+<p>You are given the strings <code>key</code> and <code>message</code>, which represent a cipher key and a secret message, respectively. The steps to decode <code>message</code> are as follows:</p>
+
+<ol>
+	<li>Use the <strong>first</strong> appearance of all 26 lowercase English letters in <code>key</code> as the <strong>order</strong> of the substitution table.</li>
+	<li>Align the substitution table with the regular English alphabet.</li>
+	<li>Each letter in <code>message</code> is then <strong>substituted</strong> using the table.</li>
+	<li>Spaces <code>&#39; &#39;</code> are transformed to themselves.</li>
+</ol>
+
+<ul>
+	<li>For example, given <code>key = &quot;<u><strong>hap</strong></u>p<u><strong>y</strong></u> <u><strong>bo</strong></u>y&quot;</code> (actual key would have <strong>at least one</strong> instance of each letter in the alphabet), we have the partial substitution table of (<code>&#39;h&#39; -&gt; &#39;a&#39;</code>, <code>&#39;a&#39; -&gt; &#39;b&#39;</code>, <code>&#39;p&#39; -&gt; &#39;c&#39;</code>, <code>&#39;y&#39; -&gt; &#39;d&#39;</code>, <code>&#39;b&#39; -&gt; &#39;e&#39;</code>, <code>&#39;o&#39; -&gt; &#39;f&#39;</code>).</li>
+</ul>
+
+<p>Return <em>the decoded message</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/05/08/ex1new4.jpg" style="width: 752px; height: 150px;" />
+<pre>
+<strong>Input:</strong> key = &quot;the quick brown fox jumps over the lazy dog&quot;, message = &quot;vkbs bs t suepuv&quot;
+<strong>Output:</strong> &quot;this is a secret&quot;
+<strong>Explanation:</strong> The diagram above shows the substitution table.
+It is obtained by taking the first appearance of each letter in &quot;<u><strong>the</strong></u> <u><strong>quick</strong></u> <u><strong>brown</strong></u> <u><strong>f</strong></u>o<u><strong>x</strong></u> <u><strong>j</strong></u>u<u><strong>mps</strong></u> o<u><strong>v</strong></u>er the <u><strong>lazy</strong></u> <u><strong>d</strong></u>o<u><strong>g</strong></u>&quot;.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/05/08/ex2new.jpg" style="width: 754px; height: 150px;" />
+<pre>
+<strong>Input:</strong> key = &quot;eljuxhpwnyrdgtqkviszcfmabo&quot;, message = &quot;zwx hnfx lqantp mnoeius ycgk vcnjrdb&quot;
+<strong>Output:</strong> &quot;the five boxing wizards jump quickly&quot;
+<strong>Explanation:</strong> The diagram above shows the substitution table.
+It is obtained by taking the first appearance of each letter in &quot;<u><strong>eljuxhpwnyrdgtqkviszcfmabo</strong></u>&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>26 &lt;= key.length &lt;= 2000</code></li>
+	<li><code>key</code> consists of lowercase English letters and <code>&#39; &#39;</code>.</li>
+	<li><code>key</code> contains every letter in the English alphabet (<code>&#39;a&#39;</code> to <code>&#39;z&#39;</code>) <strong>at least once</strong>.</li>
+	<li><code>1 &lt;= message.length &lt;= 2000</code></li>
+	<li><code>message</code> consists of lowercase English letters and <code>&#39; &#39;</code>.</li>
+</ul>

leetcode/problem/evaluate-boolean-binary-tree.html

@@ -0,0 +1,49 @@
+<p>You are given the <code>root</code> of a <strong>full binary tree</strong> with the following properties:</p>
+
+<ul>
+	<li><strong>Leaf nodes</strong> have either the value <code>0</code> or <code>1</code>, where <code>0</code> represents <code>False</code> and <code>1</code> represents <code>True</code>.</li>
+	<li><strong>Non-leaf nodes</strong> have either the value <code>2</code> or <code>3</code>, where <code>2</code> represents the boolean <code>OR</code> and <code>3</code> represents the boolean <code>AND</code>.</li>
+</ul>
+
+<p>The <strong>evaluation</strong> of a node is as follows:</p>
+
+<ul>
+	<li>If the node is a leaf node, the evaluation is the <strong>value</strong> of the node, i.e. <code>True</code> or <code>False</code>.</li>
+	<li>Otherwise, <strong>evaluate</strong> the node&#39;s two children and <strong>apply</strong> the boolean operation of its value with the children&#39;s evaluations.</li>
+</ul>
+
+<p>Return<em> the boolean result of <strong>evaluating</strong> the </em><code>root</code><em> node.</em></p>
+
+<p>A <strong>full binary tree</strong> is a binary tree where each node has either <code>0</code> or <code>2</code> children.</p>
+
+<p>A <strong>leaf node</strong> is a node that has zero children.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/05/16/example1drawio1.png" style="width: 700px; height: 252px;" />
+<pre>
+<strong>Input:</strong> root = [2,1,3,null,null,0,1]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The above diagram illustrates the evaluation process.
+The AND node evaluates to False AND True = False.
+The OR node evaluates to True OR False = True.
+The root node evaluates to True, so we return true.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [0]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The root node is a leaf node and it evaluates to false, so we return false.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 3</code></li>
+	<li>Every node has either <code>0</code> or <code>2</code> children.</li>
+	<li>Leaf nodes have a value of <code>0</code> or <code>1</code>.</li>
+	<li>Non-leaf nodes have a value of <code>2</code> or <code>3</code>.</li>
+</ul>

leetcode/problem/minimum-amount-of-time-to-fill-cups.html

@@ -0,0 +1,48 @@
+<p>You have a water dispenser that can dispense cold, warm, and hot water. Every second, you can either fill up <code>2</code> cups with <strong>different</strong> types of water, or <code>1</code> cup of any type of water.</p>
+
+<p>You are given a <strong>0-indexed</strong> integer array <code>amount</code> of length <code>3</code> where <code>amount[0]</code>, <code>amount[1]</code>, and <code>amount[2]</code> denote the number of cold, warm, and hot water cups you need to fill respectively. Return <em>the <strong>minimum</strong> number of seconds needed to fill up all the cups</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> amount = [1,4,2]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One way to fill up the cups is:
+Second 1: Fill up a cold cup and a warm cup.
+Second 2: Fill up a warm cup and a hot cup.
+Second 3: Fill up a warm cup and a hot cup.
+Second 4: Fill up a warm cup.
+It can be proven that 4 is the minimum number of seconds needed.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> amount = [5,4,4]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> One way to fill up the cups is:
+Second 1: Fill up a cold cup, and a hot cup.
+Second 2: Fill up a cold cup, and a warm cup.
+Second 3: Fill up a cold cup, and a warm cup.
+Second 4: Fill up a warm cup, and a hot cup.
+Second 5: Fill up a cold cup, and a hot cup.
+Second 6: Fill up a cold cup, and a warm cup.
+Second 7: Fill up a hot cup.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> amount = [5,0,0]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Every second, we fill up a cold cup.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>amount.length == 3</code></li>
+	<li><code>0 &lt;= amount[i] &lt;= 100</code></li>
+</ul>

leetcode/problem/minimum-sum-of-squared-difference.html

@@ -0,0 +1,41 @@
+<p>You are given two positive <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, both of length <code>n</code>.</p>
+
+<p>The <strong>sum of squared difference</strong> of arrays <code>nums1</code> and <code>nums2</code> is defined as the <strong>sum</strong> of <code>(nums1[i] - nums2[i])<sup>2</sup></code> for each <code>0 &lt;= i &lt; n</code>.</p>
+
+<p>You are also given two positive integers <code>k1</code> and <code>k2</code>. You can modify any of the elements of <code>nums1</code> by <code>+1</code> or <code>-1</code> at most <code>k1</code> times. Similarly, you can modify any of the elements of <code>nums2</code> by <code>+1</code> or <code>-1</code> at most <code>k2</code> times.</p>
+
+<p>Return <em>the minimum <strong>sum of squared difference</strong> after modifying array </em><code>nums1</code><em> at most </em><code>k1</code><em> times and modifying array </em><code>nums2</code><em> at most </em><code>k2</code><em> times</em>.</p>
+
+<p><strong>Note</strong>: You are allowed to modify the array elements to become <strong>negative</strong> integers.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [1,2,3,4], nums2 = [2,10,20,19], k1 = 0, k2 = 0
+<strong>Output:</strong> 579
+<strong>Explanation:</strong> The elements in nums1 and nums2 cannot be modified because k1 = 0 and k2 = 0. 
+The sum of square difference will be: (1 - 2)<sup>2 </sup>+ (2 - 10)<sup>2 </sup>+ (3 - 20)<sup>2 </sup>+ (4 - 19)<sup>2</sup>&nbsp;= 579.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [1,4,10,12], nums2 = [5,8,6,9], k1 = 1, k2 = 1
+<strong>Output:</strong> 43
+<strong>Explanation:</strong> One way to obtain the minimum sum of square difference is: 
+- Increase nums1[0] once.
+- Increase nums2[2] once.
+The minimum of the sum of square difference will be: 
+(2 - 5)<sup>2 </sup>+ (4 - 8)<sup>2 </sup>+ (10 - 7)<sup>2 </sup>+ (12 - 9)<sup>2</sup>&nbsp;= 43.
+Note that, there are other ways to obtain the minimum of the sum of square difference, but there is no way to obtain a sum smaller than 43.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums1.length == nums2.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= k1, k2 &lt;= 10<sup>9</sup></code></li>
+</ul>

leetcode/problem/move-pieces-to-obtain-a-string.html

@@ -0,0 +1,46 @@
+<p>You are given two strings <code>start</code> and <code>target</code>, both of length <code>n</code>. Each string consists <strong>only</strong> of the characters <code>&#39;L&#39;</code>, <code>&#39;R&#39;</code>, and <code>&#39;_&#39;</code> where:</p>
+
+<ul>
+	<li>The characters <code>&#39;L&#39;</code> and <code>&#39;R&#39;</code> represent pieces, where a piece <code>&#39;L&#39;</code> can move to the <strong>left</strong> only if there is a <strong>blank</strong> space directly to its left, and a piece <code>&#39;R&#39;</code> can move to the <strong>right</strong> only if there is a <strong>blank</strong> space directly to its right.</li>
+	<li>The character <code>&#39;_&#39;</code> represents a blank space that can be occupied by <strong>any</strong> of the <code>&#39;L&#39;</code> or <code>&#39;R&#39;</code> pieces.</li>
+</ul>
+
+<p>Return <code>true</code> <em>if it is possible to obtain the string</em> <code>target</code><em> by moving the pieces of the string </em><code>start</code><em> <strong>any</strong> number of times</em>. Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> start = &quot;_L__R__R_&quot;, target = &quot;L______RR&quot;
+<strong>Output:</strong> true
+<strong>Explanation:</strong> We can obtain the string target from start by doing the following moves:
+- Move the first piece one step to the left, start becomes equal to &quot;<strong>L</strong>___R__R_&quot;.
+- Move the last piece one step to the right, start becomes equal to &quot;L___R___<strong>R</strong>&quot;.
+- Move the second piece three steps to the right, start becomes equal to &quot;L______<strong>R</strong>R&quot;.
+Since it is possible to get the string target from start, we return true.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> start = &quot;R_L_&quot;, target = &quot;__LR&quot;
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The &#39;R&#39; piece in the string start can move one step to the right to obtain &quot;_<strong>R</strong>L_&quot;.
+After that, no pieces can move anymore, so it is impossible to obtain the string target from start.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> start = &quot;_R&quot;, target = &quot;R_&quot;
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The piece in the string start can move only to the right, so it is impossible to obtain the string target from start.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == start.length == target.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>start</code> and <code>target</code> consist of the characters <code>&#39;L&#39;</code>, <code>&#39;R&#39;</code>, and <code>&#39;_&#39;</code>.</li>
+</ul>

leetcode/problem/number-of-increasing-paths-in-a-grid.html

@@ -0,0 +1,40 @@
+<p>You are given an <code>m x n</code> integer matrix <code>grid</code>, where you can move from a cell to any adjacent cell in all <code>4</code> directions.</p>
+
+<p>Return <em>the number of <strong>strictly</strong> <strong>increasing</strong> paths in the grid such that you can start from <strong>any</strong> cell and end at <strong>any</strong> cell. </em>Since the answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>Two paths are considered different if they do not have exactly the same sequence of visited cells.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/05/10/griddrawio-4.png" style="width: 181px; height: 121px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,1],[3,4]]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> The strictly increasing paths are:
+- Paths with length 1: [1], [1], [3], [4].
+- Paths with length 2: [1 -&gt; 3], [1 -&gt; 4], [3 -&gt; 4].
+- Paths with length 3: [1 -&gt; 3 -&gt; 4].
+The total number of paths is 4 + 3 + 1 = 8.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[1],[2]]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The strictly increasing paths are:
+- Paths with length 1: [1], [2].
+- Paths with length 2: [1 -&gt; 2].
+The total number of paths is 2 + 1 = 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 1000</code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
+</ul>

leetcode/problem/number-of-people-aware-of-a-secret.html

@@ -0,0 +1,40 @@
+<p>On day <code>1</code>, one person discovers a secret.</p>
+
+<p>You are given an integer <code>delay</code>, which means that each person will <strong>share</strong> the secret with a new person <strong>every day</strong>, starting from <code>delay</code> days after discovering the secret. You are also given an integer <code>forget</code>, which means that each person will <strong>forget</strong> the secret <code>forget</code> days after discovering it. A person <strong>cannot</strong> share the secret on the same day they forgot it, or on any day afterwards.</p>
+
+<p>Given an integer <code>n</code>, return<em> the number of people who know the secret at the end of day </em><code>n</code>. Since the answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 6, delay = 2, forget = 4
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+Day 1: Suppose the first person is named A. (1 person)
+Day 2: A is the only person who knows the secret. (1 person)
+Day 3: A shares the secret with a new person, B. (2 people)
+Day 4: A shares the secret with a new person, C. (3 people)
+Day 5: A forgets the secret, and B shares the secret with a new person, D. (3 people)
+Day 6: B shares the secret with E, and C shares the secret with F. (5 people)
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 4, delay = 1, forget = 3
+<strong>Output:</strong> 6
+<strong>Explanation:</strong>
+Day 1: The first person is named A. (1 person)
+Day 2: A shares the secret with B. (2 people)
+Day 3: A and B share the secret with 2 new people, C and D. (4 people)
+Day 4: A forgets the secret. B, C, and D share the secret with 3 new people. (6 people)
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= delay &lt; forget &lt;= n</code></li>
+</ul>

leetcode/problem/smallest-number-in-infinite-set.html

@@ -0,0 +1,40 @@
+<p>You have a set which contains all positive integers <code>[1, 2, 3, 4, 5, ...]</code>.</p>
+
+<p>Implement the <code>SmallestInfiniteSet</code> class:</p>
+
+<ul>
+	<li><code>SmallestInfiniteSet()</code> Initializes the <strong>SmallestInfiniteSet</strong> object to contain <strong>all</strong> positive integers.</li>
+	<li><code>int popSmallest()</code> <strong>Removes</strong> and returns the smallest integer contained in the infinite set.</li>
+	<li><code>void addBack(int num)</code> <strong>Adds</strong> a positive integer <code>num</code> back into the infinite set, if it is <strong>not</strong> already in the infinite set.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;SmallestInfiniteSet&quot;, &quot;addBack&quot;, &quot;popSmallest&quot;, &quot;popSmallest&quot;, &quot;popSmallest&quot;, &quot;addBack&quot;, &quot;popSmallest&quot;, &quot;popSmallest&quot;, &quot;popSmallest&quot;]
+[[], [2], [], [], [], [1], [], [], []]
+<strong>Output</strong>
+[null, null, 1, 2, 3, null, 1, 4, 5]
+
+<strong>Explanation</strong>
+SmallestInfiniteSet smallestInfiniteSet = new SmallestInfiniteSet();
+smallestInfiniteSet.addBack(2);    // 2 is already in the set, so no change is made.
+smallestInfiniteSet.popSmallest(); // return 1, since 1 is the smallest number, and remove it from the set.
+smallestInfiniteSet.popSmallest(); // return 2, and remove it from the set.
+smallestInfiniteSet.popSmallest(); // return 3, and remove it from the set.
+smallestInfiniteSet.addBack(1);    // 1 is added back to the set.
+smallestInfiniteSet.popSmallest(); // return 1, since 1 was added back to the set and
+                                   // is the smallest number, and remove it from the set.
+smallestInfiniteSet.popSmallest(); // return 4, and remove it from the set.
+smallestInfiniteSet.popSmallest(); // return 5, and remove it from the set.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num &lt;= 1000</code></li>
+	<li>At most <code>1000</code> calls will be made <strong>in total</strong> to <code>popSmallest</code> and <code>addBack</code>.</li>
+</ul>

leetcode/problem/spiral-matrix-iv.html

@@ -0,0 +1,35 @@
+<p>You are given two integers <code>m</code> and <code>n</code>, which represent the dimensions of a matrix.</p>
+
+<p>You are also given the <code>head</code> of a linked list of integers.</p>
+
+<p>Generate an <code>m x n</code> matrix that contains the integers in the linked list presented in <strong>spiral</strong> order <strong>(clockwise)</strong>, starting from the <strong>top-left</strong> of the matrix. If there are remaining empty spaces, fill them with <code>-1</code>.</p>
+
+<p>Return <em>the generated matrix</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/05/09/ex1new.jpg" style="width: 240px; height: 150px;" />
+<pre>
+<strong>Input:</strong> m = 3, n = 5, head = [3,0,2,6,8,1,7,9,4,2,5,5,0]
+<strong>Output:</strong> [[3,0,2,6,8],[5,0,-1,-1,1],[5,2,4,9,7]]
+<strong>Explanation:</strong> The diagram above shows how the values are printed in the matrix.
+Note that the remaining spaces in the matrix are filled with -1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/05/11/ex2.jpg" style="width: 221px; height: 60px;" />
+<pre>
+<strong>Input:</strong> m = 1, n = 4, head = [0,1,2]
+<strong>Output:</strong> [[0,1,2,-1]]
+<strong>Explanation:</strong> The diagram above shows how the values are printed from left to right in the matrix.
+The last space in the matrix is set to -1.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li>The number of nodes in the list is in the range <code>[1, m * n]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+</ul>

leetcode/problem/subarray-with-elements-greater-than-varying-threshold.html

@@ -0,0 +1,35 @@
+<p>You are given an integer array <code>nums</code> and an integer <code>threshold</code>.</p>
+
+<p>Find any subarray of <code>nums</code> of length <code>k</code> such that <strong>every</strong> element in the subarray is <strong>greater</strong> than <code>threshold / k</code>.</p>
+
+<p>Return<em> the <strong>size</strong> of <strong>any</strong> such subarray</em>. If there is no such subarray, return <code>-1</code>.</p>
+
+<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,4,3,1], threshold = 6
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The subarray [3,4,3] has a size of 3, and every element is greater than 6 / 3 = 2.
+Note that this is the only valid subarray.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [6,5,6,5,8], threshold = 7
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The subarray [8] has a size of 1, and 8 &gt; 7 / 1 = 7. So 1 is returned.
+Note that the subarray [6,5] has a size of 2, and every element is greater than 7 / 2 = 3.5. 
+Similarly, the subarrays [6,5,6], [6,5,6,5], [6,5,6,5,8] also satisfy the given conditions.
+Therefore, 2, 3, 4, or 5 may also be returned.</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], threshold &lt;= 10<sup>9</sup></code></li>
+</ul>

leetcode/problem/the-latest-time-to-catch-a-bus.html

@@ -0,0 +1,43 @@
+<p>You are given a <strong>0-indexed</strong> integer array <code>buses</code> of length <code>n</code>, where <code>buses[i]</code> represents the departure time of the <code>i<sup>th</sup></code> bus. You are also given a <strong>0-indexed</strong> integer array <code>passengers</code> of length <code>m</code>, where <code>passengers[j]</code> represents the arrival time of the <code>j<sup>th</sup></code> passenger. All bus departure times are unique. All passenger arrival times are unique.</p>
+
+<p>You are given an integer <code>capacity</code>, which represents the <strong>maximum</strong> number of passengers that can get on each bus.</p>
+
+<p>The passengers will get on the next available bus. You can get on a bus that will depart at <code>x</code> minutes if you arrive at <code>y</code> minutes where <code>y &lt;= x</code>, and the bus is not full. Passengers with the <strong>earliest</strong> arrival times get on the bus first.</p>
+
+<p>Return <em>the latest time you may arrive at the bus station to catch a bus</em>. You <strong>cannot</strong> arrive at the same time as another passenger.</p>
+
+<p><strong>Note: </strong>The arrays <code>buses</code> and <code>passengers</code> are not necessarily sorted.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> buses = [10,20], passengers = [2,17,18,19], capacity = 2
+<strong>Output:</strong> 16
+<strong>Explanation:</strong> 
+The 1<sup>st</sup> bus departs with the 1<sup>st</sup> passenger. 
+The 2<sup>nd</sup> bus departs with you and the 2<sup>nd</sup> passenger.
+Note that you must not arrive at the same time as the passengers, which is why you must arrive before the 2<sup>nd</sup><sup> </sup>passenger to catch the bus.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> buses = [20,30,10], passengers = [19,13,26,4,25,11,21], capacity = 2
+<strong>Output:</strong> 20
+<strong>Explanation:</strong> 
+The 1<sup>st</sup> bus departs with the 4<sup>th</sup> passenger. 
+The 2<sup>nd</sup> bus departs with the 6<sup>th</sup>&nbsp;and 2<sup>nd</sup><sup> </sup>passengers.
+The 3<sup>rd</sup> bus departs with the 1<sup>s</sup><sup>t</sup> passenger and you.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == buses.length</code></li>
+	<li><code>m == passengers.length</code></li>
+	<li><code>1 &lt;= n, m, capacity &lt;= 10<sup>5</sup></code></li>
+	<li><code>2 &lt;= buses[i], passengers[i] &lt;= 10<sup>9</sup></code></li>
+	<li>Each element in <code>buses</code> is <strong>unique</strong>.</li>
+	<li>Each element in <code>passengers</code> is <strong>unique</strong>.</li>
+</ul>