mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-10-19 20:16:48 +08:00
update
This commit is contained in:
@@ -0,0 +1,25 @@
|
||||
<p>Given an array filled with letters and numbers, find the longest subarray with an equal number of letters and numbers.</p>
|
||||
|
||||
<p>Return the subarray. If there are more than one answer, return the one which has the smallest index of its left endpoint. If there is no answer, return an empty arrary.</p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input: </strong>["A","1","B","C","D","2","3","4","E","5","F","G","6","7","H","I","J","K","L","M"]
|
||||
|
||||
<strong>Output: </strong>["A","1","B","C","D","2","3","4","E","5","F","G","6","7"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input: </strong>["A","A"]
|
||||
|
||||
<strong>Output: </strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>Note: </strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>array.length <= 100000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1 @@
|
||||
<p>English description is not available for the problem. Please switch to Chinese.</p>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>Given an <code>m x n</code> binary matrix <code>mat</code>, return <em>the distance of the nearest </em><code>0</code><em> for each cell</em>.</p>
|
||||
|
||||
<p>The distance between two adjacent cells is <code>1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/24/01-1-grid.jpg" style="width: 253px; height: 253px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,0,0],[0,1,0],[0,0,0]]
|
||||
<strong>Output:</strong> [[0,0,0],[0,1,0],[0,0,0]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/24/01-2-grid.jpg" style="width: 253px; height: 253px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,0,0],[0,1,0],[1,1,1]]
|
||||
<strong>Output:</strong> [[0,0,0],[0,1,0],[1,2,1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == mat.length</code></li>
|
||||
<li><code>n == mat[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>4</sup></code></li>
|
||||
<li><code>mat[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
<li>There is at least one <code>0</code> in <code>mat</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1 @@
|
||||
English description is not available for the problem. Please switch to Chinese.
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>We have two special characters:</p>
|
||||
|
||||
<ul>
|
||||
<li>The first character can be represented by one bit <code>0</code>.</li>
|
||||
<li>The second character can be represented by two bits (<code>10</code> or <code>11</code>).</li>
|
||||
</ul>
|
||||
|
||||
<p>Given a binary array <code>bits</code> that ends with <code>0</code>, return <code>true</code> if the last character must be a one-bit character.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bits = [1,0,0]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> The only way to decode it is two-bit character and one-bit character.
|
||||
So the last character is one-bit character.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bits = [1,1,1,0]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> The only way to decode it is two-bit character and two-bit character.
|
||||
So the last character is not one-bit character.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= bits.length <= 1000</code></li>
|
||||
<li><code>bits[i]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given an array of <code>n</code> integers <code>nums</code>, a <strong>132 pattern</strong> is a subsequence of three integers <code>nums[i]</code>, <code>nums[j]</code> and <code>nums[k]</code> such that <code>i < j < k</code> and <code>nums[i] < nums[k] < nums[j]</code>.</p>
|
||||
|
||||
<p>Return <em><code>true</code> if there is a <strong>132 pattern</strong> in <code>nums</code>, otherwise, return <code>false</code>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> There is no 132 pattern in the sequence.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,1,4,2]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> There is a 132 pattern in the sequence: [1, 4, 2].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-1,3,2,0]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 2 * 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1 @@
|
||||
English description is not available for the problem. Please switch to Chinese.
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of two. Otherwise, return <code>false</code></em>.</p>
|
||||
|
||||
<p>An integer <code>n</code> is a power of two, if there exists an integer <code>x</code> such that <code>n == 2<sup>x</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>2<sup>0</sup> = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 16
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>2<sup>4</sup> = 16
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you solve it without loops/recursion?
|
||||
@@ -0,0 +1,54 @@
|
||||
<p>Table: <code>Logins</code></p>
|
||||
|
||||
<pre>
|
||||
+----------------+----------+
|
||||
| Column Name | Type |
|
||||
+----------------+----------+
|
||||
| user_id | int |
|
||||
| time_stamp | datetime |
|
||||
+----------------+----------+
|
||||
(user_id, time_stamp) is the primary key for this table.
|
||||
Each row contains information about the login time for the user with ID user_id.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to report the <strong>latest</strong> login for all users in the year <code>2020</code>. Do <strong>not</strong> include the users who did not login in <code>2020</code>.</p>
|
||||
|
||||
<p>Return the result table <strong>in any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Logins table:
|
||||
+---------+---------------------+
|
||||
| user_id | time_stamp |
|
||||
+---------+---------------------+
|
||||
| 6 | 2020-06-30 15:06:07 |
|
||||
| 6 | 2021-04-21 14:06:06 |
|
||||
| 6 | 2019-03-07 00:18:15 |
|
||||
| 8 | 2020-02-01 05:10:53 |
|
||||
| 8 | 2020-12-30 00:46:50 |
|
||||
| 2 | 2020-01-16 02:49:50 |
|
||||
| 2 | 2019-08-25 07:59:08 |
|
||||
| 14 | 2019-07-14 09:00:00 |
|
||||
| 14 | 2021-01-06 11:59:59 |
|
||||
+---------+---------------------+
|
||||
<strong>Output:</strong>
|
||||
+---------+---------------------+
|
||||
| user_id | last_stamp |
|
||||
+---------+---------------------+
|
||||
| 6 | 2020-06-30 15:06:07 |
|
||||
| 8 | 2020-12-30 00:46:50 |
|
||||
| 2 | 2020-01-16 02:49:50 |
|
||||
+---------+---------------------+
|
||||
<strong>Explanation:</strong>
|
||||
User 6 logged into their account 3 times but only once in 2020, so we include this login in the result table.
|
||||
User 8 logged into their account 2 times in 2020, once in February and once in December. We include only the latest one (December) in the result table.
|
||||
User 2 logged into their account 2 times but only once in 2020, so we include this login in the result table.
|
||||
User 14 did not login in 2020, so we do not include them in the result table.
|
||||
</pre>
|
||||
48
leetcode-cn/problem (English)/24 点游戏(English) [24-game].html
Normal file
48
leetcode-cn/problem (English)/24 点游戏(English) [24-game].html
Normal file
@@ -0,0 +1,48 @@
|
||||
<p>You are given an integer array <code>cards</code> of length <code>4</code>. You have four cards, each containing a number in the range <code>[1, 9]</code>. You should arrange the numbers on these cards in a mathematical expression using the operators <code>['+', '-', '*', '/']</code> and the parentheses <code>'('</code> and <code>')'</code> to get the value 24.</p>
|
||||
|
||||
<p>You are restricted with the following rules:</p>
|
||||
|
||||
<ul>
|
||||
<li>The division operator <code>'/'</code> represents real division, not integer division.
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>4 / (1 - 2 / 3) = 4 / (1 / 3) = 12</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Every operation done is between two numbers. In particular, we cannot use <code>'-'</code> as a unary operator.
|
||||
<ul>
|
||||
<li>For example, if <code>cards = [1, 1, 1, 1]</code>, the expression <code>"-1 - 1 - 1 - 1"</code> is <strong>not allowed</strong>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>You cannot concatenate numbers together
|
||||
<ul>
|
||||
<li>For example, if <code>cards = [1, 2, 1, 2]</code>, the expression <code>"12 + 12"</code> is not valid.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <code>true</code> if you can get such expression that evaluates to <code>24</code>, and <code>false</code> otherwise.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cards = [4,1,8,7]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> (8-4) * (7-1) = 24
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cards = [1,2,1,2]
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>cards.length == 4</code></li>
|
||||
<li><code>1 <= cards[i] <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,14 @@
|
||||
<p>Write a method to count the number of 2s that appear in all the numbers between 0 and n (inclusive).</p>
|
||||
|
||||
<p><strong>Example:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input: </strong>25
|
||||
<strong>Output: </strong>9
|
||||
<strong>Explanation: </strong>(2, 12, 20, 21, 22, 23, 24, 25)(Note that 22 counts for two 2s.)</pre>
|
||||
|
||||
<p>Note:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>n <= 10^9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of three. Otherwise, return <code>false</code></em>.</p>
|
||||
|
||||
<p>An integer <code>n</code> is a power of three, if there exists an integer <code>x</code> such that <code>n == 3<sup>x</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 27
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 0
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 9
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you solve it without loops/recursion?
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>There is a pizza with <code>3n</code> slices of varying size, you and your friends will take slices of pizza as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li>You will pick <strong>any</strong> pizza slice.</li>
|
||||
<li>Your friend Alice will pick the next slice in the anti-clockwise direction of your pick.</li>
|
||||
<li>Your friend Bob will pick the next slice in the clockwise direction of your pick.</li>
|
||||
<li>Repeat until there are no more slices of pizzas.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an integer array <code>slices</code> that represent the sizes of the pizza slices in a clockwise direction, return <em>the maximum possible sum of slice sizes that you can pick</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/18/sample_3_1723.png" style="width: 500px; height: 266px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> slices = [1,2,3,4,5,6]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> Pick pizza slice of size 4, Alice and Bob will pick slices with size 3 and 5 respectively. Then Pick slices with size 6, finally Alice and Bob will pick slice of size 2 and 1 respectively. Total = 4 + 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/18/sample_4_1723.png" style="width: 500px; height: 299px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> slices = [8,9,8,6,1,1]
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> Pick pizza slice of size 8 in each turn. If you pick slice with size 9 your partners will pick slices of size 8.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 * n == slices.length</code></li>
|
||||
<li><code>1 <= slices.length <= 500</code></li>
|
||||
<li><code>1 <= slices[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,24 @@
|
||||
<p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of four. Otherwise, return <code>false</code></em>.</p>
|
||||
|
||||
<p>An integer <code>n</code> is a power of four, if there exists an integer <code>x</code> such that <code>n == 4<sup>x</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 16
|
||||
<strong>Output:</strong> true
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> false
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you solve it without loops/recursion?
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given a positive integer <code>num</code> consisting only of digits <code>6</code> and <code>9</code>.</p>
|
||||
|
||||
<p>Return <em>the maximum number you can get by changing <strong>at most</strong> one digit (</em><code>6</code><em> becomes </em><code>9</code><em>, and </em><code>9</code><em> becomes </em><code>6</code><em>)</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 9669
|
||||
<strong>Output:</strong> 9969
|
||||
<strong>Explanation:</strong>
|
||||
Changing the first digit results in 6669.
|
||||
Changing the second digit results in 9969.
|
||||
Changing the third digit results in 9699.
|
||||
Changing the fourth digit results in 9666.
|
||||
The maximum number is 9969.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 9996
|
||||
<strong>Output:</strong> 9999
|
||||
<strong>Explanation:</strong> Changing the last digit 6 to 9 results in the maximum number.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 9999
|
||||
<strong>Output:</strong> 9999
|
||||
<strong>Explanation:</strong> It is better not to apply any change.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num <= 10<sup>4</sup></code></li>
|
||||
<li><code>num</code> consists of only <code>6</code> and <code>9</code> digits.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,20 @@
|
||||
<p>The data structure <code>TreeNode</code> is used for binary tree, but it can also used to represent a single linked list (where left is null, and right is the next node in the list). Implement a method to convert a binary search tree (implemented with <code>TreeNode</code>) into a single linked list. The values should be kept in order and the operation should be performed in place (that is, on the original data structure).</p>
|
||||
|
||||
<p>Return the head node of the linked list after converting.</p>
|
||||
|
||||
<p><b>Note: </b>This problem is slightly different from the original one in the book.</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example: </strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input: </strong> [4,2,5,1,3,null,6,0]
|
||||
<strong>Output: </strong> [0,null,1,null,2,null,3,null,4,null,5,null,6]
|
||||
</pre>
|
||||
|
||||
<p><strong>Note: </strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes will not exceed 100000.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,22 @@
|
||||
<p>Given two strings <code>first</code> and <code>second</code>, consider occurrences in some text of the form <code>"first second third"</code>, where <code>second</code> comes immediately after <code>first</code>, and <code>third</code> comes immediately after <code>second</code>.</p>
|
||||
|
||||
<p>Return <em>an array of all the words</em> <code>third</code> <em>for each occurrence of</em> <code>"first second third"</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> text = "alice is a good girl she is a good student", first = "a", second = "good"
|
||||
<strong>Output:</strong> ["girl","student"]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> text = "we will we will rock you", first = "we", second = "will"
|
||||
<strong>Output:</strong> ["we","rock"]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 1000</code></li>
|
||||
<li><code>text</code> consists of lowercase English letters and spaces.</li>
|
||||
<li>All the words in <code>text</code> a separated by <strong>a single space</strong>.</li>
|
||||
<li><code>1 <= first.length, second.length <= 10</code></li>
|
||||
<li><code>first</code> and <code>second</code> consist of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given a string <code>s</code> of length <code>n</code> where <code>s[i]</code> is either:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>'D'</code> means decreasing, or</li>
|
||||
<li><code>'I'</code> means increasing.</li>
|
||||
</ul>
|
||||
|
||||
<p>A permutation <code>perm</code> of <code>n + 1</code> integers of all the integers in the range <code>[0, n]</code> is called a <strong>valid permutation</strong> if for all valid <code>i</code>:</p>
|
||||
|
||||
<ul>
|
||||
<li>If <code>s[i] == 'D'</code>, then <code>perm[i] > perm[i + 1]</code>, and</li>
|
||||
<li>If <code>s[i] == 'I'</code>, then <code>perm[i] < perm[i + 1]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the number of <strong>valid permutations</strong> </em><code>perm</code>. Since the answer may be large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "DID"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The 5 valid permutations of (0, 1, 2, 3) are:
|
||||
(1, 0, 3, 2)
|
||||
(2, 0, 3, 1)
|
||||
(2, 1, 3, 0)
|
||||
(3, 0, 2, 1)
|
||||
(3, 1, 2, 0)
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "D"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == s.length</code></li>
|
||||
<li><code>1 <= n <= 200</code></li>
|
||||
<li><code>s[i]</code> is either <code>'I'</code> or <code>'D'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>In the world of Dota2, there are two parties: the Radiant and the Dire.</p>
|
||||
|
||||
<p>The Dota2 senate consists of senators coming from two parties. Now the Senate wants to decide on a change in the Dota2 game. The voting for this change is a round-based procedure. In each round, each senator can exercise <strong>one</strong> of the two rights:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Ban one senator's right:</strong> A senator can make another senator lose all his rights in this and all the following rounds.</li>
|
||||
<li><strong>Announce the victory:</strong> If this senator found the senators who still have rights to vote are all from the same party, he can announce the victory and decide on the change in the game.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given a string <code>senate</code> representing each senator's party belonging. The character <code>'R'</code> and <code>'D'</code> represent the Radiant party and the Dire party. Then if there are <code>n</code> senators, the size of the given string will be <code>n</code>.</p>
|
||||
|
||||
<p>The round-based procedure starts from the first senator to the last senator in the given order. This procedure will last until the end of voting. All the senators who have lost their rights will be skipped during the procedure.</p>
|
||||
|
||||
<p>Suppose every senator is smart enough and will play the best strategy for his own party. Predict which party will finally announce the victory and change the Dota2 game. The output should be <code>"Radiant"</code> or <code>"Dire"</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> senate = "RD"
|
||||
<strong>Output:</strong> "Radiant"
|
||||
<strong>Explanation:</strong>
|
||||
The first senator comes from Radiant and he can just ban the next senator's right in round 1.
|
||||
And the second senator can't exercise any rights anymore since his right has been banned.
|
||||
And in round 2, the first senator can just announce the victory since he is the only guy in the senate who can vote.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> senate = "RDD"
|
||||
<strong>Output:</strong> "Dire"
|
||||
<strong>Explanation:</strong>
|
||||
The first senator comes from Radiant and he can just ban the next senator's right in round 1.
|
||||
And the second senator can't exercise any rights anymore since his right has been banned.
|
||||
And the third senator comes from Dire and he can ban the first senator's right in round 1.
|
||||
And in round 2, the third senator can just announce the victory since he is the only guy in the senate who can vote.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == senate.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>senate[i]</code> is either <code>'R'</code> or <code>'D'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>A cell <code>(r, c)</code> of an excel sheet is represented as a string <code>"<col><row>"</code> where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code><col></code> denotes the column number <code>c</code> of the cell. It is represented by <strong>alphabetical letters</strong>.
|
||||
|
||||
<ul>
|
||||
<li>For example, the <code>1<sup>st</sup></code> column is denoted by <code>'A'</code>, the <code>2<sup>nd</sup></code> by <code>'B'</code>, the <code>3<sup>rd</sup></code> by <code>'C'</code>, and so on.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><code><row></code> is the row number <code>r</code> of the cell. The <code>r<sup>th</sup></code> row is represented by the <strong>integer</strong> <code>r</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are given a string <code>s</code> in the format <code>"<col1><row1>:<col2><row2>"</code>, where <code><col1></code> represents the column <code>c1</code>, <code><row1></code> represents the row <code>r1</code>, <code><col2></code> represents the column <code>c2</code>, and <code><row2></code> represents the row <code>r2</code>, such that <code>r1 <= r2</code> and <code>c1 <= c2</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>list of cells</strong></em> <code>(x, y)</code> <em>such that</em> <code>r1 <= x <= r2</code> <em>and</em> <code>c1 <= y <= c2</code>. The cells should be represented as <strong>strings</strong> in the format mentioned above and be sorted in <strong>non-decreasing</strong> order first by columns and then by rows.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/02/08/ex1drawio.png" style="width: 250px; height: 160px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "K1:L2"
|
||||
<strong>Output:</strong> ["K1","K2","L1","L2"]
|
||||
<strong>Explanation:</strong>
|
||||
The above diagram shows the cells which should be present in the list.
|
||||
The red arrows denote the order in which the cells should be presented.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/02/09/exam2drawio.png" style="width: 500px; height: 50px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "A1:F1"
|
||||
<strong>Output:</strong> ["A1","B1","C1","D1","E1","F1"]
|
||||
<strong>Explanation:</strong>
|
||||
The above diagram shows the cells which should be present in the list.
|
||||
The red arrow denotes the order in which the cells should be presented.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>s.length == 5</code></li>
|
||||
<li><code>'A' <= s[0] <= s[3] <= 'Z'</code></li>
|
||||
<li><code>'1' <= s[1] <= s[4] <= '9'</code></li>
|
||||
<li><code>s</code> consists of uppercase English letters, digits and <code>':'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>Given a string <code>columnTitle</code> that represents the column title as appear in an Excel sheet, return <em>its corresponding column number</em>.</p>
|
||||
|
||||
<p>For example:</p>
|
||||
|
||||
<pre>
|
||||
A -> 1
|
||||
B -> 2
|
||||
C -> 3
|
||||
...
|
||||
Z -> 26
|
||||
AA -> 27
|
||||
AB -> 28
|
||||
...
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnTitle = "A"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnTitle = "AB"
|
||||
<strong>Output:</strong> 28
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnTitle = "ZY"
|
||||
<strong>Output:</strong> 701
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= columnTitle.length <= 7</code></li>
|
||||
<li><code>columnTitle</code> consists only of uppercase English letters.</li>
|
||||
<li><code>columnTitle</code> is in the range <code>["A", "FXSHRXW"]</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>Given an integer <code>columnNumber</code>, return <em>its corresponding column title as it appears in an Excel sheet</em>.</p>
|
||||
|
||||
<p>For example:</p>
|
||||
|
||||
<pre>
|
||||
A -> 1
|
||||
B -> 2
|
||||
C -> 3
|
||||
...
|
||||
Z -> 26
|
||||
AA -> 27
|
||||
AB -> 28
|
||||
...
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnNumber = 1
|
||||
<strong>Output:</strong> "A"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnNumber = 28
|
||||
<strong>Output:</strong> "AB"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnNumber = 701
|
||||
<strong>Output:</strong> "ZY"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= columnNumber <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Given an integer <code>n</code>, return <em>a string array </em><code>answer</code><em> (<strong>1-indexed</strong>) where</em>:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>answer[i] == "FizzBuzz"</code> if <code>i</code> is divisible by <code>3</code> and <code>5</code>.</li>
|
||||
<li><code>answer[i] == "Fizz"</code> if <code>i</code> is divisible by <code>3</code>.</li>
|
||||
<li><code>answer[i] == "Buzz"</code> if <code>i</code> is divisible by <code>5</code>.</li>
|
||||
<li><code>answer[i] == i</code> (as a string) if none of the above conditions are true.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> ["1","2","Fizz"]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> ["1","2","Fizz","4","Buzz"]
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 15
|
||||
<strong>Output:</strong> ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given an array of integers <code>citations</code> where <code>citations[i]</code> is the number of citations a researcher received for their <code>i<sup>th</sup></code> paper and <code>citations</code> is sorted in an <strong>ascending order</strong>, return compute the researcher's <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p>According to the <a href="https://en.wikipedia.org/wiki/H-index" target="_blank">definition of h-index on Wikipedia</a>: A scientist has an index <code>h</code> if <code>h</code> of their <code>n</code> papers have at least <code>h</code> citations each, and the other <code>n − h</code> papers have no more than <code>h</code> citations each.</p>
|
||||
|
||||
<p>If there are several possible values for <code>h</code>, the maximum one is taken as the <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p>You must write an algorithm that runs in logarithmic time.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [0,1,3,5,6]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> [0,1,3,5,6] means the researcher has 5 papers in total and each of them had received 0, 1, 3, 5, 6 citations respectively.
|
||||
Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [1,2,100]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == citations.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= citations[i] <= 1000</code></li>
|
||||
<li><code>citations</code> is sorted in <strong>ascending order</strong>.</li>
|
||||
</ul>
|
||||
31
leetcode-cn/problem (English)/H 指数(English) [h-index].html
Normal file
31
leetcode-cn/problem (English)/H 指数(English) [h-index].html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given an array of integers <code>citations</code> where <code>citations[i]</code> is the number of citations a researcher received for their <code>i<sup>th</sup></code> paper, return compute the researcher's <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p>According to the <a href="https://en.wikipedia.org/wiki/H-index" target="_blank">definition of h-index on Wikipedia</a>: A scientist has an index <code>h</code> if <code>h</code> of their <code>n</code> papers have at least <code>h</code> citations each, and the other <code>n − h</code> papers have no more than <code>h</code> citations each.</p>
|
||||
|
||||
<p>If there are several possible values for <code>h</code>, the maximum one is taken as the <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [3,0,6,1,5]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> [3,0,6,1,5] means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively.
|
||||
Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [1,3,1]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == citations.length</code></li>
|
||||
<li><code>1 <= n <= 5000</code></li>
|
||||
<li><code>0 <= citations[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>There are two kinds of threads: <code>oxygen</code> and <code>hydrogen</code>. Your goal is to group these threads to form water molecules.</p>
|
||||
|
||||
<p>There is a barrier where each thread has to wait until a complete molecule can be formed. Hydrogen and oxygen threads will be given <code>releaseHydrogen</code> and <code>releaseOxygen</code> methods respectively, which will allow them to pass the barrier. These threads should pass the barrier in groups of three, and they must immediately bond with each other to form a water molecule. You must guarantee that all the threads from one molecule bond before any other threads from the next molecule do.</p>
|
||||
|
||||
<p>In other words:</p>
|
||||
|
||||
<ul>
|
||||
<li>If an oxygen thread arrives at the barrier when no hydrogen threads are present, it must wait for two hydrogen threads.</li>
|
||||
<li>If a hydrogen thread arrives at the barrier when no other threads are present, it must wait for an oxygen thread and another hydrogen thread.</li>
|
||||
</ul>
|
||||
|
||||
<p>We do not have to worry about matching the threads up explicitly; the threads do not necessarily know which other threads they are paired up with. The key is that threads pass the barriers in complete sets; thus, if we examine the sequence of threads that bind and divide them into groups of three, each group should contain one oxygen and two hydrogen threads.</p>
|
||||
|
||||
<p>Write synchronization code for oxygen and hydrogen molecules that enforces these constraints.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> water = "HOH"
|
||||
<strong>Output:</strong> "HHO"
|
||||
<strong>Explanation:</strong> "HOH" and "OHH" are also valid answers.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> water = "OOHHHH"
|
||||
<strong>Output:</strong> "HHOHHO"
|
||||
<strong>Explanation:</strong> "HOHHHO", "OHHHHO", "HHOHOH", "HOHHOH", "OHHHOH", "HHOOHH", "HOHOHH" and "OHHOHH" are also valid answers.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 * n == water.length</code></li>
|
||||
<li><code>1 <= n <= 20</code></li>
|
||||
<li><code>water[i]</code> is either <code>'H'</code> or <code>'O'</code>.</li>
|
||||
<li>There will be exactly <code>2 * n</code> <code>'H'</code> in <code>water</code>.</li>
|
||||
<li>There will be exactly <code>n</code> <code>'O'</code> in <code>water</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p><strong>HTML entity parser</strong> is the parser that takes HTML code as input and replace all the entities of the special characters by the characters itself.</p>
|
||||
|
||||
<p>The special characters and their entities for HTML are:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Quotation Mark:</strong> the entity is <code>&quot;</code> and symbol character is <code>"</code>.</li>
|
||||
<li><strong>Single Quote Mark:</strong> the entity is <code>&apos;</code> and symbol character is <code>'</code>.</li>
|
||||
<li><strong>Ampersand:</strong> the entity is <code>&amp;</code> and symbol character is <code>&</code>.</li>
|
||||
<li><strong>Greater Than Sign:</strong> the entity is <code>&gt;</code> and symbol character is <code>></code>.</li>
|
||||
<li><strong>Less Than Sign:</strong> the entity is <code>&lt;</code> and symbol character is <code><</code>.</li>
|
||||
<li><strong>Slash:</strong> the entity is <code>&frasl;</code> and symbol character is <code>/</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given the input <code>text</code> string to the HTML parser, you have to implement the entity parser.</p>
|
||||
|
||||
<p>Return <em>the text after replacing the entities by the special characters</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "&amp; is an HTML entity but &ambassador; is not."
|
||||
<strong>Output:</strong> "& is an HTML entity but &ambassador; is not."
|
||||
<strong>Explanation:</strong> The parser will replace the &amp; entity by &
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "and I quote: &quot;...&quot;"
|
||||
<strong>Output:</strong> "and I quote: \"...\""
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 10<sup>5</sup></code></li>
|
||||
<li>The string may contain any possible characters out of all the 256 ASCII characters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,18 @@
|
||||
<p>Given a valid (IPv4) IP <code>address</code>, return a defanged version of that IP address.</p>
|
||||
|
||||
|
||||
|
||||
<p>A <em>defanged IP address</em> replaces every period <code>"."</code> with <code>"[.]"</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre><strong>Input:</strong> address = "1.1.1.1"
|
||||
|
||||
<strong>Output:</strong> "1[.]1[.]1[.]1"
|
||||
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
|
||||
42
leetcode-cn/problem (English)/IPO(English) [ipo].html
Normal file
42
leetcode-cn/problem (English)/IPO(English) [ipo].html
Normal file
@@ -0,0 +1,42 @@
|
||||
<p>Suppose LeetCode will start its <strong>IPO</strong> soon. In order to sell a good price of its shares to Venture Capital, LeetCode would like to work on some projects to increase its capital before the <strong>IPO</strong>. Since it has limited resources, it can only finish at most <code>k</code> distinct projects before the <strong>IPO</strong>. Help LeetCode design the best way to maximize its total capital after finishing at most <code>k</code> distinct projects.</p>
|
||||
|
||||
<p>You are given <code>n</code> projects where the <code>i<sup>th</sup></code> project has a pure profit <code>profits[i]</code> and a minimum capital of <code>capital[i]</code> is needed to start it.</p>
|
||||
|
||||
<p>Initially, you have <code>w</code> capital. When you finish a project, you will obtain its pure profit and the profit will be added to your total capital.</p>
|
||||
|
||||
<p>Pick a list of <strong>at most</strong> <code>k</code> distinct projects from given projects to <strong>maximize your final capital</strong>, and return <em>the final maximized capital</em>.</p>
|
||||
|
||||
<p>The answer is guaranteed to fit in a 32-bit signed integer.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Since your initial capital is 0, you can only start the project indexed 0.
|
||||
After finishing it you will obtain profit 1 and your capital becomes 1.
|
||||
With capital 1, you can either start the project indexed 1 or the project indexed 2.
|
||||
Since you can choose at most 2 projects, you need to finish the project indexed 2 to get the maximum capital.
|
||||
Therefore, output the final maximized capital, which is 0 + 1 + 3 = 4.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]
|
||||
<strong>Output:</strong> 6
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= w <= 10<sup>9</sup></code></li>
|
||||
<li><code>n == profits.length</code></li>
|
||||
<li><code>n == capital.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= profits[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= capital[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>Given the <code>head</code> of a linked list, reverse the nodes of the list <code>k</code> at a time, and return <em>the modified list</em>.</p>
|
||||
|
||||
<p><code>k</code> is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of <code>k</code> then left-out nodes, in the end, should remain as it is.</p>
|
||||
|
||||
<p>You may not alter the values in the list's nodes, only nodes themselves may be changed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,4,5], k = 2
|
||||
<strong>Output:</strong> [2,1,4,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,4,5], k = 3
|
||||
<strong>Output:</strong> [3,2,1,4,5]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is <code>n</code>.</li>
|
||||
<li><code>1 <= k <= n <= 5000</code></li>
|
||||
<li><code>0 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow-up:</strong> Can you solve the problem in <code>O(1)</code> extra memory space?</p>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the number of <strong>good subarrays</strong> of </em><code>nums</code>.</p>
|
||||
|
||||
<p>A <strong>good array</strong> is an array where the number of different integers in that array is exactly <code>k</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>[1,2,3,1,2]</code> has <code>3</code> different integers: <code>1</code>, <code>2</code>, and <code>3</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>A <strong>subarray</strong> is a <strong>contiguous</strong> part of an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,2,3], k = 2
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,3,4], k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= nums[i], k <= nums.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>You are given an integer array <code>nums</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>In one operation, you can pick two numbers from the array whose sum equals <code>k</code> and remove them from the array.</p>
|
||||
|
||||
<p>Return <em>the maximum number of operations you can perform on the array</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4], k = 5
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Starting with nums = [1,2,3,4]:
|
||||
- Remove numbers 1 and 4, then nums = [2,3]
|
||||
- Remove numbers 2 and 3, then nums = []
|
||||
There are no more pairs that sum up to 5, hence a total of 2 operations.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,1,3,4,3], k = 6
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Starting with nums = [3,1,3,4,3]:
|
||||
- Remove the first two 3's, then nums = [1,4,3]
|
||||
There are no more pairs that sum up to 6, hence a total of 1 operation.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given an integer array <code>arr</code> and an integer <code>k</code>, modify the array by repeating it <code>k</code> times.</p>
|
||||
|
||||
<p>For example, if <code>arr = [1, 2]</code> and <code>k = 3 </code>then the modified array will be <code>[1, 2, 1, 2, 1, 2]</code>.</p>
|
||||
|
||||
<p>Return the maximum sub-array sum in the modified array. Note that the length of the sub-array can be <code>0</code> and its sum in that case is <code>0</code>.</p>
|
||||
|
||||
<p>As the answer can be very large, return the answer <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,2], k = 3
|
||||
<strong>Output:</strong> 9
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,-2,1], k = 5
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [-1,-2], k = 7
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= arr[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>Given an integer array <code>nums</code> and an integer <code>k</code>, modify the array in the following way:</p>
|
||||
|
||||
<ul>
|
||||
<li>choose an index <code>i</code> and replace <code>nums[i]</code> with <code>-nums[i]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>You should apply this process exactly <code>k</code> times. You may choose the same index <code>i</code> multiple times.</p>
|
||||
|
||||
<p>Return <em>the largest possible sum of the array after modifying it in this way</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,2,3], k = 1
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> Choose index 1 and nums becomes [4,-2,3].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,-1,0,2], k = 3
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Choose indices (1, 2, 2) and nums becomes [3,1,0,2].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,-3,-1,5,-4], k = 2
|
||||
<strong>Output:</strong> 13
|
||||
<strong>Explanation:</strong> Choose indices (1, 4) and nums becomes [2,3,-1,5,4].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-100 <= nums[i] <= 100</code></li>
|
||||
<li><code>1 <= k <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> representing the contents of a <b>pile</b>, where <code>nums[0]</code> is the topmost element of the pile.</p>
|
||||
|
||||
<p>In one move, you can perform <strong>either</strong> of the following:</p>
|
||||
|
||||
<ul>
|
||||
<li>If the pile is not empty, <strong>remove</strong> the topmost element of the pile.</li>
|
||||
<li>If there are one or more removed elements, <strong>add</strong> any one of them back onto the pile. This element becomes the new topmost element.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are also given an integer <code>k</code>, which denotes the total number of moves to be made.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum value</strong> of the topmost element of the pile possible after <strong>exactly</strong></em> <code>k</code> <em>moves</em>. In case it is not possible to obtain a non-empty pile after <code>k</code> moves, return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,2,2,4,0,6], k = 4
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
One of the ways we can end with 5 at the top of the pile after 4 moves is as follows:
|
||||
- Step 1: Remove the topmost element = 5. The pile becomes [2,2,4,0,6].
|
||||
- Step 2: Remove the topmost element = 2. The pile becomes [2,4,0,6].
|
||||
- Step 3: Remove the topmost element = 2. The pile becomes [4,0,6].
|
||||
- Step 4: Add 5 back onto the pile. The pile becomes [5,4,0,6].
|
||||
Note that this is not the only way to end with 5 at the top of the pile. It can be shown that 5 is the largest answer possible after 4 moves.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2], k = 1
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong>
|
||||
In the first move, our only option is to pop the topmost element of the pile.
|
||||
Since it is not possible to obtain a non-empty pile after one move, we return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i], k <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>Given two strings <code>s</code> and <code>t</code>, your goal is to convert <code>s</code> into <code>t</code> in <code>k</code><strong> </strong>moves or less.</p>
|
||||
|
||||
<p>During the <code>i<sup>th</sup></code> (<font face="monospace"><code>1 <= i <= k</code>) </font>move you can:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose any index <code>j</code> (1-indexed) from <code>s</code>, such that <code>1 <= j <= s.length</code> and <code>j</code> has not been chosen in any previous move, and shift the character at that index <code>i</code> times.</li>
|
||||
<li>Do nothing.</li>
|
||||
</ul>
|
||||
|
||||
<p>Shifting a character means replacing it by the next letter in the alphabet (wrapping around so that <code>'z'</code> becomes <code>'a'</code>). Shifting a character by <code>i</code> means applying the shift operations <code>i</code> times.</p>
|
||||
|
||||
<p>Remember that any index <code>j</code> can be picked at most once.</p>
|
||||
|
||||
<p>Return <code>true</code> if it's possible to convert <code>s</code> into <code>t</code> in no more than <code>k</code> moves, otherwise return <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "input", t = "ouput", k = 9
|
||||
<strong>Output:</strong> true
|
||||
<b>Explanation: </b>In the 6th move, we shift 'i' 6 times to get 'o'. And in the 7th move we shift 'n' to get 'u'.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abc", t = "bcd", k = 10
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation: </strong>We need to shift each character in s one time to convert it into t. We can shift 'a' to 'b' during the 1st move. However, there is no way to shift the other characters in the remaining moves to obtain t from s.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aab", t = "bbb", k = 27
|
||||
<strong>Output:</strong> true
|
||||
<b>Explanation: </b>In the 1st move, we shift the first 'a' 1 time to get 'b'. In the 27th move, we shift the second 'a' 27 times to get 'b'.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length, t.length <= 10^5</code></li>
|
||||
<li><code>0 <= k <= 10^9</code></li>
|
||||
<li><code>s</code>, <code>t</code> contain only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>You are currently designing a dynamic array. You are given a <strong>0-indexed</strong> integer array <code>nums</code>, where <code>nums[i]</code> is the number of elements that will be in the array at time <code>i</code>. In addition, you are given an integer <code>k</code>, the <strong>maximum</strong> number of times you can <strong>resize</strong> the array (to<strong> any</strong> size).</p>
|
||||
|
||||
<p>The size of the array at time <code>t</code>, <code>size<sub>t</sub></code>, must be at least <code>nums[t]</code> because there needs to be enough space in the array to hold all the elements. The <strong>space wasted</strong> at time <code>t</code> is defined as <code>size<sub>t</sub> - nums[t]</code>, and the <strong>total</strong> space wasted is the <strong>sum</strong> of the space wasted across every time <code>t</code> where <code>0 <= t < nums.length</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> <strong>total space wasted</strong> if you can resize the array at most</em> <code>k</code> <em>times</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong> The array can have <strong>any size</strong> at the start and does<strong> not </strong>count towards the number of resizing operations.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,20], k = 0
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> size = [20,20].
|
||||
We can set the initial size to be 20.
|
||||
The total wasted space is (20 - 10) + (20 - 20) = 10.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,20,30], k = 1
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> size = [20,20,30].
|
||||
We can set the initial size to be 20 and resize to 30 at time 2.
|
||||
The total wasted space is (20 - 10) + (20 - 20) + (30 - 30) = 10.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,20,15,30,20], k = 2
|
||||
<strong>Output:</strong> 15
|
||||
<strong>Explanation:</strong> size = [10,20,20,30,30].
|
||||
We can set the initial size to 10, resize to 20 at time 1, and resize to 30 at time 3.
|
||||
The total wasted space is (10 - 10) + (20 - 20) + (20 - 15) + (30 - 30) + (30 - 20) = 15.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 200</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>0 <= k <= nums.length - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>There are <code>n</code> cities connected by some number of flights. You are given an array <code>flights</code> where <code>flights[i] = [from<sub>i</sub>, to<sub>i</sub>, price<sub>i</sub>]</code> indicates that there is a flight from city <code>from<sub>i</sub></code> to city <code>to<sub>i</sub></code> with cost <code>price<sub>i</sub></code>.</p>
|
||||
|
||||
<p>You are also given three integers <code>src</code>, <code>dst</code>, and <code>k</code>, return <em><strong>the cheapest price</strong> from </em><code>src</code><em> to </em><code>dst</code><em> with at most </em><code>k</code><em> stops. </em>If there is no such route, return<em> </em><code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-3drawio.png" style="width: 332px; height: 392px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1
|
||||
<strong>Output:</strong> 700
|
||||
<strong>Explanation:</strong>
|
||||
The graph is shown above.
|
||||
The optimal path with at most 1 stop from city 0 to 3 is marked in red and has cost 100 + 600 = 700.
|
||||
Note that the path through cities [0,1,2,3] is cheaper but is invalid because it uses 2 stops.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-1drawio.png" style="width: 332px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1
|
||||
<strong>Output:</strong> 200
|
||||
<strong>Explanation:</strong>
|
||||
The graph is shown above.
|
||||
The optimal path with at most 1 stop from city 0 to 2 is marked in red and has cost 100 + 100 = 200.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-2drawio.png" style="width: 332px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0
|
||||
<strong>Output:</strong> 500
|
||||
<strong>Explanation:</strong>
|
||||
The graph is shown above.
|
||||
The optimal path with no stops from city 0 to 2 is marked in red and has cost 500.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>0 <= flights.length <= (n * (n - 1) / 2)</code></li>
|
||||
<li><code>flights[i].length == 3</code></li>
|
||||
<li><code>0 <= from<sub>i</sub>, to<sub>i</sub> < n</code></li>
|
||||
<li><code>from<sub>i</sub> != to<sub>i</sub></code></li>
|
||||
<li><code>1 <= price<sub>i</sub> <= 10<sup>4</sup></code></li>
|
||||
<li>There will not be any multiple flights between two cities.</li>
|
||||
<li><code>0 <= src, dst, k < n</code></li>
|
||||
<li><code>src != dst</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>Given an integer <code>n</code> (in base <code>10</code>) and a base <code>k</code>, return <em>the <strong>sum</strong> of the digits of </em><code>n</code><em> <strong>after</strong> converting </em><code>n</code><em> from base </em><code>10</code><em> to base </em><code>k</code>.</p>
|
||||
|
||||
<p>After converting, each digit should be interpreted as a base <code>10</code> number, and the sum should be returned in base <code>10</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 34, k = 6
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation: </strong>34 (base 10) expressed in base 6 is 54. 5 + 4 = 9.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 10, k = 10
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation: </strong>n is already in base 10. 1 + 0 = 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>2 <= k <= 10</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>You are given a binary array <code>nums</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>A <strong>k-bit flip</strong> is choosing a <strong>subarray</strong> of length <code>k</code> from <code>nums</code> and simultaneously changing every <code>0</code> in the subarray to <code>1</code>, and every <code>1</code> in the subarray to <code>0</code>.</p>
|
||||
|
||||
<p>Return <em>the minimum number of <strong>k-bit flips</strong> required so that there is no </em><code>0</code><em> in the array</em>. If it is not possible, return <code>-1</code>.</p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a <strong>contiguous</strong> part of an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,1,0], k = 1
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Flip nums[0], then flip nums[2].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,0], k = 2
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> No matter how we flip subarrays of size 2, we cannot make the array become [1,1,1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,0,1,0,1,1,0], k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong>
|
||||
Flip nums[0],nums[1],nums[2]: nums becomes [1,1,1,1,0,1,1,0]
|
||||
Flip nums[4],nums[5],nums[6]: nums becomes [1,1,1,1,1,0,0,0]
|
||||
Flip nums[5],nums[6],nums[7]: nums becomes [1,1,1,1,1,1,1,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= nums.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>For an integer array <code>nums</code>, an <strong>inverse pair</strong> is a pair of integers <code>[i, j]</code> where <code>0 <= i < j < nums.length</code> and <code>nums[i] > nums[j]</code>.</p>
|
||||
|
||||
<p>Given two integers n and k, return the number of different arrays consist of numbers from <code>1</code> to <code>n</code> such that there are exactly <code>k</code> <strong>inverse pairs</strong>. Since the answer can be huge, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, k = 0
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inverse pairs.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, k = 1
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
<li><code>0 <= k <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,60 @@
|
||||
<p>Design and implement a data structure for a <a href="https://en.wikipedia.org/wiki/Least_frequently_used" target="_blank">Least Frequently Used (LFU)</a> cache.</p>
|
||||
|
||||
<p>Implement the <code>LFUCache</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>LFUCache(int capacity)</code> Initializes the object with the <code>capacity</code> of the data structure.</li>
|
||||
<li><code>int get(int key)</code> Gets the value of the <code>key</code> if the <code>key</code> exists in the cache. Otherwise, returns <code>-1</code>.</li>
|
||||
<li><code>void put(int key, int value)</code> Update the value of the <code>key</code> if present, or inserts the <code>key</code> if not already present. When the cache reaches its <code>capacity</code>, it should invalidate and remove the <strong>least frequently used</strong> key before inserting a new item. For this problem, when there is a <strong>tie</strong> (i.e., two or more keys with the same frequency), the <strong>least recently used</strong> <code>key</code> would be invalidated.</li>
|
||||
</ul>
|
||||
|
||||
<p>To determine the least frequently used key, a <strong>use counter</strong> is maintained for each key in the cache. The key with the smallest <strong>use counter</strong> is the least frequently used key.</p>
|
||||
|
||||
<p>When a key is first inserted into the cache, its <strong>use counter</strong> is set to <code>1</code> (due to the <code>put</code> operation). The <strong>use counter</strong> for a key in the cache is incremented either a <code>get</code> or <code>put</code> operation is called on it.</p>
|
||||
|
||||
<p>The functions <code data-stringify-type="code">get</code> and <code data-stringify-type="code">put</code> must each run in <code>O(1)</code> average time complexity.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]
|
||||
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]
|
||||
<strong>Output</strong>
|
||||
[null, null, null, 1, null, -1, 3, null, -1, 3, 4]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
// cnt(x) = the use counter for key x
|
||||
// cache=[] will show the last used order for tiebreakers (leftmost element is most recent)
|
||||
LFUCache lfu = new LFUCache(2);
|
||||
lfu.put(1, 1); // cache=[1,_], cnt(1)=1
|
||||
lfu.put(2, 2); // cache=[2,1], cnt(2)=1, cnt(1)=1
|
||||
lfu.get(1); // return 1
|
||||
// cache=[1,2], cnt(2)=1, cnt(1)=2
|
||||
lfu.put(3, 3); // 2 is the LFU key because cnt(2)=1 is the smallest, invalidate 2.
|
||||
// cache=[3,1], cnt(3)=1, cnt(1)=2
|
||||
lfu.get(2); // return -1 (not found)
|
||||
lfu.get(3); // return 3
|
||||
// cache=[3,1], cnt(3)=2, cnt(1)=2
|
||||
lfu.put(4, 4); // Both 1 and 3 have the same cnt, but 1 is LRU, invalidate 1.
|
||||
// cache=[4,3], cnt(4)=1, cnt(3)=2
|
||||
lfu.get(1); // return -1 (not found)
|
||||
lfu.get(3); // return 3
|
||||
// cache=[3,4], cnt(4)=1, cnt(3)=3
|
||||
lfu.get(4); // return 4
|
||||
// cache=[4,3], cnt(4)=2, cnt(3)=3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= capacity <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= key <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= value <= 10<sup>9</sup></code></li>
|
||||
<li>At most <code>2 * 10<sup>5</sup></code> calls will be made to <code>get</code> and <code>put</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<span style="display: none;"> </span>
|
||||
@@ -0,0 +1,22 @@
|
||||
<p>Design and build a "least recently used" cache, which evicts the least recently used item. The cache should map from keys to values (allowing you to insert and retrieve a value associ­ated with a particular key) and be initialized with a max size. When it is full, it should evict the least recently used item.</p>
|
||||
|
||||
<p>You should implement following operations: <code>get</code> and <code>put</code>.</p>
|
||||
|
||||
<p>Get a value by key: <code>get(key)</code> - If key is in the cache, return the value, otherwise return -1.<br />
|
||||
Write a key-value pair to the cache: <code>put(key, value)</code> - If the key is not in the cache, then write its value to the cache. Evict the least recently used item before writing if necessary.</p>
|
||||
|
||||
<p><strong>Example:</strong></p>
|
||||
|
||||
<pre>
|
||||
LRUCache cache = new LRUCache( 2 /* capacity */ );
|
||||
|
||||
cache.put(1, 1);
|
||||
cache.put(2, 2);
|
||||
cache.get(1); // returns 1
|
||||
cache.put(3, 3); // evicts key 2
|
||||
cache.get(2); // returns -1 (not found)
|
||||
cache.put(4, 4); // evicts key 1
|
||||
cache.get(1); // returns -1 (not found)
|
||||
cache.get(3); // returns 3
|
||||
cache.get(4); // returns 4
|
||||
</pre>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>Design a data structure that follows the constraints of a <strong><a href="https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU" target="_blank">Least Recently Used (LRU) cache</a></strong>.</p>
|
||||
|
||||
<p>Implement the <code>LRUCache</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>LRUCache(int capacity)</code> Initialize the LRU cache with <strong>positive</strong> size <code>capacity</code>.</li>
|
||||
<li><code>int get(int key)</code> Return the value of the <code>key</code> if the key exists, otherwise return <code>-1</code>.</li>
|
||||
<li><code>void put(int key, int value)</code> Update the value of the <code>key</code> if the <code>key</code> exists. Otherwise, add the <code>key-value</code> pair to the cache. If the number of keys exceeds the <code>capacity</code> from this operation, <strong>evict</strong> the least recently used key.</li>
|
||||
</ul>
|
||||
|
||||
<p>The functions <code data-stringify-type="code">get</code> and <code data-stringify-type="code">put</code> must each run in <code>O(1)</code> average time complexity.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
|
||||
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
|
||||
<strong>Output</strong>
|
||||
[null, null, null, 1, null, -1, null, -1, 3, 4]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
LRUCache lRUCache = new LRUCache(2);
|
||||
lRUCache.put(1, 1); // cache is {1=1}
|
||||
lRUCache.put(2, 2); // cache is {1=1, 2=2}
|
||||
lRUCache.get(1); // return 1
|
||||
lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
|
||||
lRUCache.get(2); // returns -1 (not found)
|
||||
lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
|
||||
lRUCache.get(1); // return -1 (not found)
|
||||
lRUCache.get(3); // return 3
|
||||
lRUCache.get(4); // return 4
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= capacity <= 3000</code></li>
|
||||
<li><code>0 <= key <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= value <= 10<sup>5</sup></code></li>
|
||||
<li>At most 2<code> * 10<sup>5</sup></code> calls will be made to <code>get</code> and <code>put</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>You are given a string expression representing a Lisp-like expression to return the integer value of.</p>
|
||||
|
||||
<p>The syntax for these expressions is given as follows.</p>
|
||||
|
||||
<ul>
|
||||
<li>An expression is either an integer, let expression, add expression, mult expression, or an assigned variable. Expressions always evaluate to a single integer.</li>
|
||||
<li>(An integer could be positive or negative.)</li>
|
||||
<li>A let expression takes the form <code>"(let v<sub>1</sub> e<sub>1</sub> v<sub>2</sub> e<sub>2</sub> ... v<sub>n</sub> e<sub>n</sub> expr)"</code>, where let is always the string <code>"let"</code>, then there are one or more pairs of alternating variables and expressions, meaning that the first variable <code>v<sub>1</sub></code> is assigned the value of the expression <code>e<sub>1</sub></code>, the second variable <code>v<sub>2</sub></code> is assigned the value of the expression <code>e<sub>2</sub></code>, and so on sequentially; and then the value of this let expression is the value of the expression <code>expr</code>.</li>
|
||||
<li>An add expression takes the form <code>"(add e<sub>1</sub> e<sub>2</sub>)"</code> where add is always the string <code>"add"</code>, there are always two expressions <code>e<sub>1</sub></code>, <code>e<sub>2</sub></code> and the result is the addition of the evaluation of <code>e<sub>1</sub></code> and the evaluation of <code>e<sub>2</sub></code>.</li>
|
||||
<li>A mult expression takes the form <code>"(mult e<sub>1</sub> e<sub>2</sub>)"</code> where mult is always the string <code>"mult"</code>, there are always two expressions <code>e<sub>1</sub></code>, <code>e<sub>2</sub></code> and the result is the multiplication of the evaluation of e1 and the evaluation of e2.</li>
|
||||
<li>For this question, we will use a smaller subset of variable names. A variable starts with a lowercase letter, then zero or more lowercase letters or digits. Additionally, for your convenience, the names <code>"add"</code>, <code>"let"</code>, and <code>"mult"</code> are protected and will never be used as variable names.</li>
|
||||
<li>Finally, there is the concept of scope. When an expression of a variable name is evaluated, within the context of that evaluation, the innermost scope (in terms of parentheses) is checked first for the value of that variable, and then outer scopes are checked sequentially. It is guaranteed that every expression is legal. Please see the examples for more details on the scope.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))"
|
||||
<strong>Output:</strong> 14
|
||||
<strong>Explanation:</strong> In the expression (add x y), when checking for the value of the variable x,
|
||||
we check from the innermost scope to the outermost in the context of the variable we are trying to evaluate.
|
||||
Since x = 3 is found first, the value of x is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "(let x 3 x 2 x)"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Assignment in let statements is processed sequentially.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "(let x 1 y 2 x (add x y) (add x y))"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The first (add x y) evaluates as 3, and is assigned to x.
|
||||
The second (add x y) evaluates as 3+2 = 5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= expression.length <= 2000</code></li>
|
||||
<li>There are no leading or trailing spaces in <code>expression</code>.</li>
|
||||
<li>All tokens are separated by a single space in <code>expression</code>.</li>
|
||||
<li>The answer and all intermediate calculations of that answer are guaranteed to fit in a <strong>32-bit</strong> integer.</li>
|
||||
<li>The expression is guaranteed to be legal and evaluate to an integer.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of an n-ary tree, return <em>the preorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p>Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
|
||||
<strong>Output:</strong> [1,3,5,6,2,4]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
|
||||
<strong>Output:</strong> [1,2,3,6,7,11,14,4,8,12,5,9,13,10]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
<li>The height of the n-ary tree is less than or equal to <code>1000</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>Given the <code>root</code> of an n-ary tree, return <em>the postorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p>Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
|
||||
<strong>Output:</strong> [5,6,3,2,4,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
|
||||
<strong>Output:</strong> [2,6,14,11,7,3,12,8,4,13,9,10,5,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
<li>The height of the n-ary tree is less than or equal to <code>1000</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>Given an n-ary tree, return the <em>level order</em> traversal of its nodes' values.</p>
|
||||
|
||||
<p><em>Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
|
||||
<strong>Output:</strong> [[1],[3,2,4],[5,6]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
|
||||
<strong>Output:</strong> [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The height of the n-ary tree is less than or equal to <code>1000</code></li>
|
||||
<li>The total number of nodes is between <code>[0, 10<sup>4</sup>]</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>Given a n-ary tree, find its maximum depth.</p>
|
||||
|
||||
<p>The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.</p>
|
||||
|
||||
<p><em>Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The total number of nodes is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
|
||||
<li>The depth of the n-ary tree is less than or equal to <code>1000</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>There are <code>8</code> prison cells in a row and each cell is either occupied or vacant.</p>
|
||||
|
||||
<p>Each day, whether the cell is occupied or vacant changes according to the following rules:</p>
|
||||
|
||||
<ul>
|
||||
<li>If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.</li>
|
||||
<li>Otherwise, it becomes vacant.</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note</strong> that because the prison is a row, the first and the last cells in the row can't have two adjacent neighbors.</p>
|
||||
|
||||
<p>You are given an integer array <code>cells</code> where <code>cells[i] == 1</code> if the <code>i<sup>th</sup></code> cell is occupied and <code>cells[i] == 0</code> if the <code>i<sup>th</sup></code> cell is vacant, and you are given an integer <code>n</code>.</p>
|
||||
|
||||
<p>Return the state of the prison after <code>n</code> days (i.e., <code>n</code> such changes described above).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cells = [0,1,0,1,1,0,0,1], n = 7
|
||||
<strong>Output:</strong> [0,0,1,1,0,0,0,0]
|
||||
<strong>Explanation:</strong> The following table summarizes the state of the prison on each day:
|
||||
Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
|
||||
Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
|
||||
Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
|
||||
Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
|
||||
Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
|
||||
Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
|
||||
Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
|
||||
Day 7: [0, 0, 1, 1, 0, 0, 0, 0]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cells = [1,0,0,1,0,0,1,0], n = 1000000000
|
||||
<strong>Output:</strong> [0,0,1,1,1,1,1,0]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>cells.length == 8</code></li>
|
||||
<li><code>cells[i]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>You are given <code>nums</code>, an array of positive integers of size <code>2 * n</code>. You must perform <code>n</code> operations on this array.</p>
|
||||
|
||||
<p>In the <code>i<sup>th</sup></code> operation <strong>(1-indexed)</strong>, you will:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose two elements, <code>x</code> and <code>y</code>.</li>
|
||||
<li>Receive a score of <code>i * gcd(x, y)</code>.</li>
|
||||
<li>Remove <code>x</code> and <code>y</code> from <code>nums</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the maximum score you can receive after performing </em><code>n</code><em> operations.</em></p>
|
||||
|
||||
<p>The function <code>gcd(x, y)</code> is the greatest common divisor of <code>x</code> and <code>y</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The optimal choice of operations is:
|
||||
(1 * gcd(1, 2)) = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,4,6,8]
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> The optimal choice of operations is:
|
||||
(1 * gcd(3, 6)) + (2 * gcd(4, 8)) = 3 + 8 = 11
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5,6]
|
||||
<strong>Output:</strong> 14
|
||||
<strong>Explanation:</strong> The optimal choice of operations is:
|
||||
(1 * gcd(1, 5)) + (2 * gcd(2, 4)) + (3 * gcd(3, 6)) = 1 + 4 + 9 = 14
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 7</code></li>
|
||||
<li><code>nums.length == 2 * n</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
28
leetcode-cn/problem (English)/N 皇后(English) [n-queens].html
Normal file
28
leetcode-cn/problem (English)/N 皇后(English) [n-queens].html
Normal file
@@ -0,0 +1,28 @@
|
||||
<p>The <strong>n-queens</strong> puzzle is the problem of placing <code>n</code> queens on an <code>n x n</code> chessboard such that no two queens attack each other.</p>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>all distinct solutions to the <strong>n-queens puzzle</strong></em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p>Each solution contains a distinct board configuration of the n-queens' placement, where <code>'Q'</code> and <code>'.'</code> both indicate a queen and an empty space, respectively.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
|
||||
<strong>Explanation:</strong> There exist two distinct solutions to the 4-queens puzzle as shown above
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> [["Q"]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are playing the following Nim Game with your friend:</p>
|
||||
|
||||
<ul>
|
||||
<li>Initially, there is a heap of stones on the table.</li>
|
||||
<li>You and your friend will alternate taking turns, and <strong>you go first</strong>.</li>
|
||||
<li>On each turn, the person whose turn it is will remove 1 to 3 stones from the heap.</li>
|
||||
<li>The one who removes the last stone is the winner.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given <code>n</code>, the number of stones in the heap, return <code>true</code><em> if you can win the game assuming both you and your friend play optimally, otherwise return </em><code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> These are the possible outcomes:
|
||||
1. You remove 1 stone. Your friend removes 3 stones, including the last stone. Your friend wins.
|
||||
2. You remove 2 stones. Your friend removes 2 stones, including the last stone. Your friend wins.
|
||||
3. You remove 3 stones. Your friend removes the last stone. Your friend wins.
|
||||
In all outcomes, your friend wins.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>The <strong>n-queens</strong> puzzle is the problem of placing <code>n</code> queens on an <code>n x n</code> chessboard such that no two queens attack each other.</p>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>the number of distinct solutions to the <strong>n-queens puzzle</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> There are two distinct solutions to the 4-queens puzzle as shown.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p><code>RandomizedCollection</code> is a data structure that contains a collection of numbers, possibly duplicates (i.e., a multiset). It should support inserting and removing specific elements and also removing a random element.</p>
|
||||
|
||||
<p>Implement the <code>RandomizedCollection</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RandomizedCollection()</code> Initializes the empty <code>RandomizedCollection</code> object.</li>
|
||||
<li><code>bool insert(int val)</code> Inserts an item <code>val</code> into the multiset, even if the item is already present. Returns <code>true</code> if the item is not present, <code>false</code> otherwise.</li>
|
||||
<li><code>bool remove(int val)</code> Removes an item <code>val</code> from the multiset if present. Returns <code>true</code> if the item is present, <code>false</code> otherwise. Note that if <code>val</code> has multiple occurrences in the multiset, we only remove one of them.</li>
|
||||
<li><code>int getRandom()</code> Returns a random element from the current multiset of elements. The probability of each element being returned is <strong>linearly related</strong> to the number of same values the multiset contains.</li>
|
||||
</ul>
|
||||
|
||||
<p>You must implement the functions of the class such that each function works on <strong>average</strong> <code>O(1)</code> time complexity.</p>
|
||||
|
||||
<p><strong>Note:</strong> The test cases are generated such that <code>getRandom</code> will only be called if there is <strong>at least one</strong> item in the <code>RandomizedCollection</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RandomizedCollection", "insert", "insert", "insert", "getRandom", "remove", "getRandom"]
|
||||
[[], [1], [1], [2], [], [1], []]
|
||||
<strong>Output</strong>
|
||||
[null, true, false, true, 2, true, 1]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RandomizedCollection randomizedCollection = new RandomizedCollection();
|
||||
randomizedCollection.insert(1); // return true since the collection does not contain 1.
|
||||
// Inserts 1 into the collection.
|
||||
randomizedCollection.insert(1); // return false since the collection contains 1.
|
||||
// Inserts another 1 into the collection. Collection now contains [1,1].
|
||||
randomizedCollection.insert(2); // return true since the collection does not contain 2.
|
||||
// Inserts 2 into the collection. Collection now contains [1,1,2].
|
||||
randomizedCollection.getRandom(); // getRandom should:
|
||||
// - return 1 with probability 2/3, or
|
||||
// - return 2 with probability 1/3.
|
||||
randomizedCollection.remove(1); // return true since the collection contains 1.
|
||||
// Removes 1 from the collection. Collection now contains [1,2].
|
||||
randomizedCollection.getRandom(); // getRandom should return 1 or 2, both equally likely.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>
|
||||
<li>At most <code>2 * 10<sup>5</sup></code> calls <strong>in total</strong> will be made to <code>insert</code>, <code>remove</code>, and <code>getRandom</code>.</li>
|
||||
<li>There will be <strong>at least one</strong> element in the data structure when <code>getRandom</code> is called.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>Implement the <code>RandomizedSet</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RandomizedSet()</code> Initializes the <code>RandomizedSet</code> object.</li>
|
||||
<li><code>bool insert(int val)</code> Inserts an item <code>val</code> into the set if not present. Returns <code>true</code> if the item was not present, <code>false</code> otherwise.</li>
|
||||
<li><code>bool remove(int val)</code> Removes an item <code>val</code> from the set if present. Returns <code>true</code> if the item was present, <code>false</code> otherwise.</li>
|
||||
<li><code>int getRandom()</code> Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the <b>same probability</b> of being returned.</li>
|
||||
</ul>
|
||||
|
||||
<p>You must implement the functions of the class such that each function works in <strong>average</strong> <code>O(1)</code> time complexity.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
|
||||
[[], [1], [2], [2], [], [1], [2], []]
|
||||
<strong>Output</strong>
|
||||
[null, true, false, true, 2, true, false, 2]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RandomizedSet randomizedSet = new RandomizedSet();
|
||||
randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully.
|
||||
randomizedSet.remove(2); // Returns false as 2 does not exist in the set.
|
||||
randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2].
|
||||
randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly.
|
||||
randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2].
|
||||
randomizedSet.insert(2); // 2 was already in the set, so return false.
|
||||
randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>
|
||||
<li>At most <code>2 * </code><code>10<sup>5</sup></code> calls will be made to <code>insert</code>, <code>remove</code>, and <code>getRandom</code>.</li>
|
||||
<li>There will be <strong>at least one</strong> element in the data structure when <code>getRandom</code> is called.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>Implement <a href="http://www.cplusplus.com/reference/valarray/pow/" target="_blank">pow(x, n)</a>, which calculates <code>x</code> raised to the power <code>n</code> (i.e., <code>x<sup>n</sup></code>).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 2.00000, n = 10
|
||||
<strong>Output:</strong> 1024.00000
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 2.10000, n = 3
|
||||
<strong>Output:</strong> 9.26100
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 2.00000, n = -2
|
||||
<strong>Output:</strong> 0.25000
|
||||
<strong>Explanation:</strong> 2<sup>-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-100.0 < x < 100.0</code></li>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code></li>
|
||||
<li><code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>We can use run-length encoding (i.e., <strong>RLE</strong>) to encode a sequence of integers. In a run-length encoded array of even length <code>encoding</code> (<strong>0-indexed</strong>), for all even <code>i</code>, <code>encoding[i]</code> tells us the number of times that the non-negative integer value <code>encoding[i + 1]</code> is repeated in the sequence.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, the sequence <code>arr = [8,8,8,5,5]</code> can be encoded to be <code>encoding = [3,8,2,5]</code>. <code>encoding = [3,8,0,9,2,5]</code> and <code>encoding = [2,8,1,8,2,5]</code> are also valid <strong>RLE</strong> of <code>arr</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given a run-length encoded array, design an iterator that iterates through it.</p>
|
||||
|
||||
<p>Implement the <code>RLEIterator</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RLEIterator(int[] encoded)</code> Initializes the object with the encoded array <code>encoded</code>.</li>
|
||||
<li><code>int next(int n)</code> Exhausts the next <code>n</code> elements and returns the last element exhausted in this way. If there is no element left to exhaust, return <code>-1</code> instead.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RLEIterator", "next", "next", "next", "next"]
|
||||
[[[3, 8, 0, 9, 2, 5]], [2], [1], [1], [2]]
|
||||
<strong>Output</strong>
|
||||
[null, 8, 8, 5, -1]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RLEIterator rLEIterator = new RLEIterator([3, 8, 0, 9, 2, 5]); // This maps to the sequence [8,8,8,5,5].
|
||||
rLEIterator.next(2); // exhausts 2 terms of the sequence, returning 8. The remaining sequence is now [8, 5, 5].
|
||||
rLEIterator.next(1); // exhausts 1 term of the sequence, returning 8. The remaining sequence is now [5, 5].
|
||||
rLEIterator.next(1); // exhausts 1 term of the sequence, returning 5. The remaining sequence is now [5].
|
||||
rLEIterator.next(2); // exhausts 2 terms, returning -1. This is because the first term exhausted was 5,
|
||||
but the second term did not exist. Since the last term exhausted does not exist, we return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= encoding.length <= 1000</code></li>
|
||||
<li><code>encoding.length</code> is even.</li>
|
||||
<li><code>0 <= encoding[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
<li>At most <code>1000</code> calls will be made to <code>next</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>A Range Module is a module that tracks ranges of numbers. Design a data structure to track the ranges represented as <strong>half-open intervals</strong> and query about them.</p>
|
||||
|
||||
<p>A <strong>half-open interval</strong> <code>[left, right)</code> denotes all the real numbers <code>x</code> where <code>left <= x < right</code>.</p>
|
||||
|
||||
<p>Implement the <code>RangeModule</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RangeModule()</code> Initializes the object of the data structure.</li>
|
||||
<li><code>void addRange(int left, int right)</code> Adds the <strong>half-open interval</strong> <code>[left, right)</code>, tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval <code>[left, right)</code> that are not already tracked.</li>
|
||||
<li><code>boolean queryRange(int left, int right)</code> Returns <code>true</code> if every real number in the interval <code>[left, right)</code> is currently being tracked, and <code>false</code> otherwise.</li>
|
||||
<li><code>void removeRange(int left, int right)</code> Stops tracking every real number currently being tracked in the <strong>half-open interval</strong> <code>[left, right)</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RangeModule", "addRange", "removeRange", "queryRange", "queryRange", "queryRange"]
|
||||
[[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]]
|
||||
<strong>Output</strong>
|
||||
[null, null, null, true, false, true]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RangeModule rangeModule = new RangeModule();
|
||||
rangeModule.addRange(10, 20);
|
||||
rangeModule.removeRange(14, 16);
|
||||
rangeModule.queryRange(10, 14); // return True,(Every number in [10, 14) is being tracked)
|
||||
rangeModule.queryRange(13, 15); // return False,(Numbers like 14, 14.03, 14.17 in [13, 15) are not being tracked)
|
||||
rangeModule.queryRange(16, 17); // return True, (The number 16 in [16, 17) is still being tracked, despite the remove operation)
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= left < right <= 10<sup>9</sup></code></li>
|
||||
<li>At most <code>10<sup>4</sup></code> calls will be made to <code>addRange</code>, <code>queryRange</code>, and <code>removeRange</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an undirected tree consisting of <code>n</code> vertices numbered from <code>1</code> to <code>n</code>. A frog starts jumping from <strong>vertex 1</strong>. In one second, the frog jumps from its current vertex to another <strong>unvisited</strong> vertex if they are directly connected. The frog can not jump back to a visited vertex. In case the frog can jump to several vertices, it jumps randomly to one of them with the same probability. Otherwise, when the frog can not jump to any unvisited vertex, it jumps forever on the same vertex.</p>
|
||||
|
||||
<p>The edges of the undirected tree are given in the array <code>edges</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> means that exists an edge connecting the vertices <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.</p>
|
||||
|
||||
<p><em>Return the probability that after <code>t</code> seconds the frog is on the vertex <code>target</code>. </em>Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/21/frog1.jpg" style="width: 338px; height: 304px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 2, target = 4
|
||||
<strong>Output:</strong> 0.16666666666666666
|
||||
<strong>Explanation:</strong> The figure above shows the given graph. The frog starts at vertex 1, jumping with 1/3 probability to the vertex 2 after <strong>second 1</strong> and then jumping with 1/2 probability to vertex 4 after <strong>second 2</strong>. Thus the probability for the frog is on the vertex 4 after 2 seconds is 1/3 * 1/2 = 1/6 = 0.16666666666666666.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<strong><img alt="" src="https://assets.leetcode.com/uploads/2021/12/21/frog2.jpg" style="width: 304px; height: 304px;" /></strong>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 1, target = 7
|
||||
<strong>Output:</strong> 0.3333333333333333
|
||||
<strong>Explanation: </strong>The figure above shows the given graph. The frog starts at vertex 1, jumping with 1/3 = 0.3333333333333333 probability to the vertex 7 after <strong>second 1</strong>.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>1 <= a<sub>i</sub>, b<sub>i</sub> <= n</code></li>
|
||||
<li><code>1 <= t <= 50</code></li>
|
||||
<li><code>1 <= target <= n</code></li>
|
||||
</ul>
|
||||
25
leetcode-cn/problem (English)/T9键盘(English) [t9-lcci].html
Normal file
25
leetcode-cn/problem (English)/T9键盘(English) [t9-lcci].html
Normal file
@@ -0,0 +1,25 @@
|
||||
<p>On old cell phones, users typed on a numeric keypad and the phone would provide a list of words that matched these numbers. Each digit mapped to a set of 0 - 4 letters. Implement an algo­rithm to return a list of matching words, given a sequence of digits. You are provided a list of valid words. The mapping is shown in the diagram below:</p>
|
||||
|
||||
<p><img src="https://assets.leetcode-cn.com/aliyun-lc-upload/original_images/17_telephone_keypad.png" style="width: 200px;" /></p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = "8733", words = ["tree", "used"]
|
||||
<strong>Output:</strong> ["tree", "used"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = "2", words = ["a", "b", "c", "d"]
|
||||
<strong>Output:</strong> ["a", "b", "c"]</pre>
|
||||
|
||||
<p>Note:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>num.length <= 1000</code></li>
|
||||
<li><code>words.length <= 500</code></li>
|
||||
<li><code>words[i].length == num.length</code></li>
|
||||
<li><code>There are no number 0 and 1 in num</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<blockquote>Note: This is a companion problem to the <a href="https://leetcode.com/discuss/interview-question/system-design/" target="_blank">System Design</a> problem: <a href="https://leetcode.com/discuss/interview-question/124658/Design-a-URL-Shortener-(-TinyURL-)-System/" target="_blank">Design TinyURL</a>.</blockquote>
|
||||
|
||||
<p>TinyURL is a URL shortening service where you enter a URL such as <code>https://leetcode.com/problems/design-tinyurl</code> and it returns a short URL such as <code>http://tinyurl.com/4e9iAk</code>. Design a class to encode a URL and decode a tiny URL.</p>
|
||||
|
||||
<p>There is no restriction on how your encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL and the tiny URL can be decoded to the original URL.</p>
|
||||
|
||||
<p>Implement the <code>Solution</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>Solution()</code> Initializes the object of the system.</li>
|
||||
<li><code>String encode(String longUrl)</code> Returns a tiny URL for the given <code>longUrl</code>.</li>
|
||||
<li><code>String decode(String shortUrl)</code> Returns the original long URL for the given <code>shortUrl</code>. It is guaranteed that the given <code>shortUrl</code> was encoded by the same object.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> url = "https://leetcode.com/problems/design-tinyurl"
|
||||
<strong>Output:</strong> "https://leetcode.com/problems/design-tinyurl"
|
||||
|
||||
<strong>Explanation:</strong>
|
||||
Solution obj = new Solution();
|
||||
string tiny = obj.encode(url); // returns the encoded tiny url.
|
||||
string ans = obj.decode(tiny); // returns the original url after deconding it.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= url.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>url</code> is guranteed to be a valid URL.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,23 @@
|
||||
<p>Write a method to replace all spaces in a string with '%20'. You may assume that the string has sufficient space at the end to hold the additional characters,and that you are given the "true" length of the string. (Note: If implementing in Java,please use a character array so that you can perform this operation in place.)</p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input: </strong>"Mr John Smith ", 13
|
||||
<strong>Output: </strong>"Mr%20John%20Smith"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input: </strong>" ", 5
|
||||
<strong>Output: </strong>"%20%20%20%20%20"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Note:</strong></p>
|
||||
|
||||
<ol>
|
||||
<li><code>0 <= S.length <= 500000</code></li>
|
||||
</ol>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>Given an integer array <code>data</code> representing the data, return whether it is a valid <strong>UTF-8</strong> encoding.</p>
|
||||
|
||||
<p>A character in <strong>UTF8</strong> can be from <b>1 to 4 bytes</b> long, subjected to the following rules:</p>
|
||||
|
||||
<ol>
|
||||
<li>For a <strong>1-byte</strong> character, the first bit is a <code>0</code>, followed by its Unicode code.</li>
|
||||
<li>For an <strong>n-bytes</strong> character, the first <code>n</code> bits are all one's, the <code>n + 1</code> bit is <code>0</code>, followed by <code>n - 1</code> bytes with the most significant <code>2</code> bits being <code>10</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>This is how the UTF-8 encoding would work:</p>
|
||||
|
||||
<pre>
|
||||
<code> Char. number range | UTF-8 octet sequence
|
||||
(hexadecimal) | (binary)
|
||||
--------------------+---------------------------------------------
|
||||
0000 0000-0000 007F | 0xxxxxxx
|
||||
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
||||
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
||||
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx</code>
|
||||
</pre>
|
||||
|
||||
<p><b>Note: </b>The input is an array of integers. Only the <b>least significant 8 bits</b> of each integer is used to store the data. This means each integer represents only 1 byte of data.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> data = [197,130,1]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> data represents the octet sequence: 11000101 10000010 00000001.
|
||||
It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> data = [235,140,4]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> data represented the octet sequence: 11101011 10001100 00000100.
|
||||
The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character.
|
||||
The next byte is a continuation byte which starts with 10 and that's correct.
|
||||
But the second continuation byte does not start with 10, so it is invalid.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= data.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= data[i] <= 255</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>The string <code>"PAYPALISHIRING"</code> is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)</p>
|
||||
|
||||
<pre>
|
||||
P A H N
|
||||
A P L S I I G
|
||||
Y I R
|
||||
</pre>
|
||||
|
||||
<p>And then read line by line: <code>"PAHNAPLSIIGYIR"</code></p>
|
||||
|
||||
<p>Write the code that will take a string and make this conversion given a number of rows:</p>
|
||||
|
||||
<pre>
|
||||
string convert(string s, int numRows);
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "PAYPALISHIRING", numRows = 3
|
||||
<strong>Output:</strong> "PAHNAPLSIIGYIR"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "PAYPALISHIRING", numRows = 4
|
||||
<strong>Output:</strong> "PINALSIGYAHRPI"
|
||||
<strong>Explanation:</strong>
|
||||
P I N
|
||||
A L S I G
|
||||
Y A H R
|
||||
P I
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "A", numRows = 1
|
||||
<strong>Output:</strong> "A"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> consists of English letters (lower-case and upper-case), <code>','</code> and <code>'.'</code>.</li>
|
||||
<li><code>1 <= numRows <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,60 @@
|
||||
<p>A <strong>k-mirror number</strong> is a <strong>positive</strong> integer <strong>without leading zeros</strong> that reads the same both forward and backward in base-10 <strong>as well as</strong> in base-k.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>9</code> is a 2-mirror number. The representation of <code>9</code> in base-10 and base-2 are <code>9</code> and <code>1001</code> respectively, which read the same both forward and backward.</li>
|
||||
<li>On the contrary, <code>4</code> is not a 2-mirror number. The representation of <code>4</code> in base-2 is <code>100</code>, which does not read the same both forward and backward.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given the base <code>k</code> and the number <code>n</code>, return <em>the <strong>sum</strong> of the</em> <code>n</code> <em><strong>smallest</strong> k-mirror numbers</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 2, n = 5
|
||||
<strong>Output:</strong> 25
|
||||
<strong>Explanation:
|
||||
</strong>The 5 smallest 2-mirror numbers and their representations in base-2 are listed as follows:
|
||||
base-10 base-2
|
||||
1 1
|
||||
3 11
|
||||
5 101
|
||||
7 111
|
||||
9 1001
|
||||
Their sum = 1 + 3 + 5 + 7 + 9 = 25.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 3, n = 7
|
||||
<strong>Output:</strong> 499
|
||||
<strong>Explanation:
|
||||
</strong>The 7 smallest 3-mirror numbers are and their representations in base-3 are listed as follows:
|
||||
base-10 base-3
|
||||
1 1
|
||||
2 2
|
||||
4 11
|
||||
8 22
|
||||
121 11111
|
||||
151 12121
|
||||
212 21212
|
||||
Their sum = 1 + 2 + 4 + 8 + 121 + 151 + 212 = 499.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 7, n = 17
|
||||
<strong>Output:</strong> 20379000
|
||||
<strong>Explanation:</strong> The 17 smallest 7-mirror numbers are:
|
||||
1, 2, 3, 4, 5, 6, 8, 121, 171, 242, 292, 16561, 65656, 2137312, 4602064, 6597956, 6958596
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= k <= 9</code></li>
|
||||
<li><code>1 <= n <= 30</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>You are given two positive integers <code>n</code> and <code>k</code>. A factor of an integer <code>n</code> is defined as an integer <code>i</code> where <code>n % i == 0</code>.</p>
|
||||
|
||||
<p>Consider a list of all factors of <code>n</code> sorted in <strong>ascending order</strong>, return <em>the </em><code>k<sup>th</sup></code><em> factor</em> in this list or return <code>-1</code> if <code>n</code> has less than <code>k</code> factors.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 12, k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Factors list is [1, 2, 3, 4, 6, 12], the 3<sup>rd</sup> factor is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, k = 2
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Factors list is [1, 7], the 2<sup>nd</sup> factor is 7.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, k = 4
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> Factors list is [1, 2, 4], there is only 3 factors. We should return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= n <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1 @@
|
||||
English description is not available for the problem. Please switch to Chinese.
|
||||
27
leetcode-cn/problem (English)/x 的平方根 (English) [sqrtx].html
Normal file
27
leetcode-cn/problem (English)/x 的平方根 (English) [sqrtx].html
Normal file
@@ -0,0 +1,27 @@
|
||||
<p>Given a non-negative integer <code>x</code>, compute and return <em>the square root of</em> <code>x</code>.</p>
|
||||
|
||||
<p>Since the return type is an integer, the decimal digits are <strong>truncated</strong>, and only <strong>the integer part</strong> of the result is returned.</p>
|
||||
|
||||
<p><strong>Note: </strong>You are not allowed to use any built-in exponent function or operator, such as <code>pow(x, 0.5)</code> or <code>x ** 0.5</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 4
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 8
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= x <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given a string <code>text</code>, you want to use the characters of <code>text</code> to form as many instances of the word <strong>"balloon"</strong> as possible.</p>
|
||||
|
||||
<p>You can use each character in <code>text</code> <strong>at most once</strong>. Return the maximum number of instances that can be formed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/09/05/1536_ex1_upd.JPG" style="width: 132px; height: 35px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "nlaebolko"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/09/05/1536_ex2_upd.JPG" style="width: 267px; height: 35px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "loonbalxballpoon"
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "leetcode"
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>text</code> consists of lower case English letters only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,62 @@
|
||||
<p>You are given two positive integers <code>left</code> and <code>right</code> with <code>left <= right</code>. Calculate the <strong>product</strong> of all integers in the <strong>inclusive</strong> range <code>[left, right]</code>.</p>
|
||||
|
||||
<p>Since the product may be very large, you will <strong>abbreviate</strong> it following these steps:</p>
|
||||
|
||||
<ol>
|
||||
<li>Count all <strong>trailing</strong> zeros in the product and <strong>remove</strong> them. Let us denote this count as <code>C</code>.
|
||||
|
||||
<ul>
|
||||
<li>For example, there are <code>3</code> trailing zeros in <code>1000</code>, and there are <code>0</code> trailing zeros in <code>546</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Denote the remaining number of digits in the product as <code>d</code>. If <code>d > 10</code>, then express the product as <code><pre>...<suf></code> where <code><pre></code> denotes the <strong>first</strong> <code>5</code> digits of the product, and <code><suf></code> denotes the <strong>last</strong> <code>5</code> digits of the product <strong>after</strong> removing all trailing zeros. If <code>d <= 10</code>, we keep it unchanged.
|
||||
<ul>
|
||||
<li>For example, we express <code>1234567654321</code> as <code>12345...54321</code>, but <code>1234567</code> is represented as <code>1234567</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Finally, represent the product as a <strong>string</strong> <code>"<pre>...<suf>eC"</code>.
|
||||
<ul>
|
||||
<li>For example, <code>12345678987600000</code> will be represented as <code>"12345...89876e5"</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>a string denoting the <strong>abbreviated product</strong> of all integers in the <strong>inclusive</strong> range</em> <code>[left, right]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> left = 1, right = 4
|
||||
<strong>Output:</strong> "24e0"
|
||||
<strong>Explanation:</strong> The product is 1 × 2 × 3 × 4 = 24.
|
||||
There are no trailing zeros, so 24 remains the same. The abbreviation will end with "e0".
|
||||
Since the number of digits is 2, which is less than 10, we do not have to abbreviate it further.
|
||||
Thus, the final representation is "24e0".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> left = 2, right = 11
|
||||
<strong>Output:</strong> "399168e2"
|
||||
<strong>Explanation:</strong> The product is 39916800.
|
||||
There are 2 trailing zeros, which we remove to get 399168. The abbreviation will end with "e2".
|
||||
The number of digits after removing the trailing zeros is 6, so we do not abbreviate it further.
|
||||
Hence, the abbreviated product is "399168e2".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> left = 371, right = 375
|
||||
<strong>Output:</strong> "7219856259e3"
|
||||
<strong>Explanation:</strong> The product is 7219856259000.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= left <= right <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given an undirected graph. You are given an integer <code>n</code> which is the number of nodes in the graph and an array <code>edges</code>, where each <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> indicates that there is an undirected edge between <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code>.</p>
|
||||
|
||||
<p>A <strong>connected trio</strong> is a set of <strong>three</strong> nodes where there is an edge between <b>every</b> pair of them.</p>
|
||||
|
||||
<p>The <strong>degree of a connected trio</strong> is the number of edges where one endpoint is in the trio, and the other is not.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> degree of a connected trio in the graph, or</em> <code>-1</code> <em>if the graph has no connected trios.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/26/trios1.png" style="width: 388px; height: 164px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 6, edges = [[1,2],[1,3],[3,2],[4,1],[5,2],[3,6]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> There is exactly one trio, which is [1,2,3]. The edges that form its degree are bolded in the figure above.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/26/trios2.png" style="width: 388px; height: 164px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[1,3],[4,1],[4,3],[2,5],[5,6],[6,7],[7,5],[2,6]]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> There are exactly three trios:
|
||||
1) [1,4,3] with degree 0.
|
||||
2) [2,5,6] with degree 2.
|
||||
3) [5,6,7] with degree 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 400</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>1 <= edges.length <= n * (n-1) / 2</code></li>
|
||||
<li><code>1 <= u<sub>i</sub>, v<sub>i</sub> <= n</code></li>
|
||||
<li><code>u<sub>i </sub>!= v<sub>i</sub></code></li>
|
||||
<li>There are no repeated edges.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given a date, return the corresponding day of the week for that date.</p>
|
||||
|
||||
<p>The input is given as three integers representing the <code>day</code>, <code>month</code> and <code>year</code> respectively.</p>
|
||||
|
||||
<p>Return the answer as one of the following values <code>{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> day = 31, month = 8, year = 2019
|
||||
<strong>Output:</strong> "Saturday"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> day = 18, month = 7, year = 1999
|
||||
<strong>Output:</strong> "Sunday"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> day = 15, month = 8, year = 1993
|
||||
<strong>Output:</strong> "Sunday"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The given dates are valid dates between the years <code>1971</code> and <code>2100</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>You are given an array of binary strings <code>strs</code> and two integers <code>m</code> and <code>n</code>.</p>
|
||||
|
||||
<p>Return <em>the size of the largest subset of <code>strs</code> such that there are <strong>at most</strong> </em><code>m</code><em> </em><code>0</code><em>'s and </em><code>n</code><em> </em><code>1</code><em>'s in the subset</em>.</p>
|
||||
|
||||
<p>A set <code>x</code> is a <strong>subset</strong> of a set <code>y</code> if all elements of <code>x</code> are also elements of <code>y</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> strs = ["10","0001","111001","1","0"], m = 5, n = 3
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The largest subset with at most 5 0's and 3 1's is {"10", "0001", "1", "0"}, so the answer is 4.
|
||||
Other valid but smaller subsets include {"0001", "1"} and {"10", "1", "0"}.
|
||||
{"111001"} is an invalid subset because it contains 4 1's, greater than the maximum of 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> strs = ["10","0","1"], m = 1, n = 1
|
||||
<strong>Output:</strong> 2
|
||||
<b>Explanation:</b> The largest subset is {"0", "1"}, so the answer is 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= strs.length <= 600</code></li>
|
||||
<li><code>1 <= strs[i].length <= 100</code></li>
|
||||
<li><code>strs[i]</code> consists only of digits <code>'0'</code> and <code>'1'</code>.</li>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Given a string <code>date</code> representing a <a href="https://en.wikipedia.org/wiki/Gregorian_calendar" target="_blank">Gregorian calendar</a> date formatted as <code>YYYY-MM-DD</code>, return <em>the day number of the year</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> date = "2019-01-09"
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> Given date is the 9th day of the year in 2019.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> date = "2019-02-10"
|
||||
<strong>Output:</strong> 41
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>date.length == 10</code></li>
|
||||
<li><code>date[4] == date[7] == '-'</code>, and all other <code>date[i]</code>'s are digits</li>
|
||||
<li><code>date</code> represents a calendar date between Jan 1<sup>st</sup>, 1900 and Dec 31<sup>th</sup>, 2019.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size <code>groupSize</code>, and consists of <code>groupSize</code> consecutive cards.</p>
|
||||
|
||||
<p>Given an integer array <code>hand</code> where <code>hand[i]</code> is the value written on the <code>i<sup>th</sup></code> card and an integer <code>groupSize</code>, return <code>true</code> if she can rearrange the cards, or <code>false</code> otherwise.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> hand = [1,2,3,4,5], groupSize = 4
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> Alice's hand can not be rearranged into groups of 4.
|
||||
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= hand.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= hand[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= groupSize <= hand.length</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Note:</strong> This question is the same as 1296: <a href="https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/" target="_blank">https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/</a></p>
|
||||
@@ -0,0 +1,21 @@
|
||||
<p>There are three types of edits that can be performed on strings: insert a character, remove a character, or replace a character. Given two strings, write a function to check if they are one edit (or zero edits) away.</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
first = "pale"
|
||||
second = "ple"
|
||||
<strong>Output:</strong> True
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
first = "pales"
|
||||
second = "pal"
|
||||
<strong>Output:</strong> False
|
||||
</pre>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>Given an array <code>nums</code>. We define a running sum of an array as <code>runningSum[i] = sum(nums[0]…nums[i])</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p>Return the running sum of <code>nums</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
|
||||
<strong>Output:</strong> [1,3,6,10]
|
||||
|
||||
<strong>Explanation:</strong> Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].</pre>
|
||||
|
||||
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> nums = [1,1,1,1,1]
|
||||
|
||||
<strong>Output:</strong> [1,2,3,4,5]
|
||||
16
leetcode-cn/problem (English)/七进制数(English) [base-7].html
Normal file
16
leetcode-cn/problem (English)/七进制数(English) [base-7].html
Normal file
@@ -0,0 +1,16 @@
|
||||
<p>Given an integer <code>num</code>, return <em>a string of its <strong>base 7</strong> representation</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> num = 100
|
||||
<strong>Output:</strong> "202"
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> num = -7
|
||||
<strong>Output:</strong> "-10"
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-10<sup>7</sup> <= num <= 10<sup>7</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,20 @@
|
||||
<p>Given an integer array <code>nums</code>, <em>find three numbers whose product is maximum and return the maximum product</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> 6
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> 24
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [-1,-2,-3]
|
||||
<strong>Output:</strong> -6
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-1000 <= nums[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>Given an integer array <code>nums</code> and an integer <code>k</code>, find three non-overlapping subarrays of length <code>k</code> with maximum sum and return them.</p>
|
||||
|
||||
<p>Return the result as a list of indices representing the starting position of each interval (<strong>0-indexed</strong>). If there are multiple answers, return the lexicographically smallest one.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,2,6,7,5,1], k = 2
|
||||
<strong>Output:</strong> [0,3,5]
|
||||
<strong>Explanation:</strong> Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5].
|
||||
We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically larger.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,2,1,2,1,2,1], k = 2
|
||||
<strong>Output:</strong> [0,2,4]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= nums[i] < 2<sup>16</sup></code></li>
|
||||
<li><code>1 <= k <= floor(nums.length / 3)</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Describe how you could use a single array to implement three stacks.</p>
|
||||
|
||||
<p>You should implement <code>push(stackNum, value)</code>、<code>pop(stackNum)</code>、<code>isEmpty(stackNum)</code>、<code>peek(stackNum)</code> methods. <code>stackNum<font face="sans-serif, Arial, Verdana, Trebuchet MS"> </font></code><font face="sans-serif, Arial, Verdana, Trebuchet MS">is the index of the stack. </font><code>value</code> is the value that pushed to the stack.</p>
|
||||
|
||||
<p>The constructor requires a <code>stackSize</code> parameter, which represents the size of each stack.</p>
|
||||
|
||||
<p><strong>Example1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> Input</strong>:
|
||||
["TripleInOne", "push", "push", "pop", "pop", "pop", "isEmpty"]
|
||||
[[1], [0, 1], [0, 2], [0], [0], [0], [0]]
|
||||
<strong> Output</strong>:
|
||||
[null, null, null, 1, -1, -1, true]
|
||||
<b>Explanation</b>: When the stack is empty, `pop, peek` return -1. When the stack is full, `push` does nothing.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> Input</strong>:
|
||||
["TripleInOne", "push", "push", "push", "pop", "pop", "pop", "peek"]
|
||||
[[2], [0, 1], [0, 2], [0, 3], [0], [0], [0], [0]]
|
||||
<strong> Output</strong>:
|
||||
[null, null, null, null, 2, 1, -1, -1]
|
||||
</pre>
|
||||
22
leetcode-cn/problem (English)/三数之和(English) [3sum].html
Normal file
22
leetcode-cn/problem (English)/三数之和(English) [3sum].html
Normal file
@@ -0,0 +1,22 @@
|
||||
<p>Given an integer array nums, return all the triplets <code>[nums[i], nums[j], nums[k]]</code> such that <code>i != j</code>, <code>i != k</code>, and <code>j != k</code>, and <code>nums[i] + nums[j] + nums[k] == 0</code>.</p>
|
||||
|
||||
<p>Notice that the solution set must not contain duplicate triplets.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [-1,0,1,2,-1,-4]
|
||||
<strong>Output:</strong> [[-1,-1,2],[-1,0,1]]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = []
|
||||
<strong>Output:</strong> []
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [0]
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= nums.length <= 3000</code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given an integer array <code>arr</code>, and an integer <code>target</code>, return the number of tuples <code>i, j, k</code> such that <code>i < j < k</code> and <code>arr[i] + arr[j] + arr[k] == target</code>.</p>
|
||||
|
||||
<p>As the answer can be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,1,2,2,3,3,4,4,5,5], target = 8
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation: </strong>
|
||||
Enumerating by the values (arr[i], arr[j], arr[k]):
|
||||
(1, 2, 5) occurs 8 times;
|
||||
(1, 3, 4) occurs 8 times;
|
||||
(2, 2, 4) occurs 2 times;
|
||||
(2, 3, 3) occurs 2 times.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,1,2,2,2,2], target = 5
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation: </strong>
|
||||
arr[i] = 1, arr[j] = arr[k] = 2 occurs 12 times:
|
||||
We choose one 1 from [1,1] in 2 ways,
|
||||
and two 2s from [2,2,2,2] in 6 ways.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= arr.length <= 3000</code></li>
|
||||
<li><code>0 <= arr[i] <= 100</code></li>
|
||||
<li><code>0 <= target <= 300</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>You are given an integer array <code>nums</code>. In one move, you can choose one element of <code>nums</code> and change it by <strong>any value</strong>.</p>
|
||||
|
||||
<p>Return <em>the minimum difference between the largest and smallest value of <code>nums</code> after performing <strong>at most three moves</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,3,2,4]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> Change the array [5,3,2,4] to [<strong>2</strong>,<strong>2</strong>,2,<strong>2</strong>].
|
||||
The difference between the maximum and minimum is 2-2 = 0.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,5,0,10,14]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Change the array [1,5,0,10,14] to [1,<strong>1</strong>,0,<strong>1</strong>,<strong>1</strong>].
|
||||
The difference between the maximum and minimum is 1-0 = 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,21 @@
|
||||
<p>A child is running up a staircase with n steps and can hop either 1 step, 2 steps, or 3 steps at a time. Implement a method to count how many possible ways the child can run up the stairs. The result may be large, so return it modulo 1000000007.</p>
|
||||
|
||||
<p><strong>Example1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> Input</strong>: n = 3
|
||||
<strong> Output</strong>: 4
|
||||
</pre>
|
||||
|
||||
<p><strong>Example2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> Input</strong>: n = 5
|
||||
<strong> Output</strong>: 13
|
||||
</pre>
|
||||
|
||||
<p><strong>Note:</strong></p>
|
||||
|
||||
<ol>
|
||||
<li><code>1 <= n <= 1000000</code></li>
|
||||
</ol>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>You are given an array <code>arr</code> which consists of only zeros and ones, divide the array into <strong>three non-empty parts</strong> such that all of these parts represent the same binary value.</p>
|
||||
|
||||
<p>If it is possible, return any <code>[i, j]</code> with <code>i + 1 < j</code>, such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>arr[0], arr[1], ..., arr[i]</code> is the first part,</li>
|
||||
<li><code>arr[i + 1], arr[i + 2], ..., arr[j - 1]</code> is the second part, and</li>
|
||||
<li><code>arr[j], arr[j + 1], ..., arr[arr.length - 1]</code> is the third part.</li>
|
||||
<li>All three parts have equal binary values.</li>
|
||||
</ul>
|
||||
|
||||
<p>If it is not possible, return <code>[-1, -1]</code>.</p>
|
||||
|
||||
<p>Note that the entire part is used when considering what binary value it represents. For example, <code>[1,1,0]</code> represents <code>6</code> in decimal, not <code>3</code>. Also, leading zeros <strong>are allowed</strong>, so <code>[0,1,1]</code> and <code>[1,1]</code> represent the same value.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> arr = [1,0,1,0,1]
|
||||
<strong>Output:</strong> [0,3]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> arr = [1,1,0,1,1]
|
||||
<strong>Output:</strong> [-1,-1]
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> arr = [1,1,0,0,1]
|
||||
<strong>Output:</strong> [0,2]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= arr.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>arr[i]</code> is <code>0</code> or <code>1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given an <code>n x n</code> <code>grid</code> where we place some <code>1 x 1 x 1</code> cubes that are axis-aligned with the <code>x</code>, <code>y</code>, and <code>z</code> axes.</p>
|
||||
|
||||
<p>Each value <code>v = grid[i][j]</code> represents a tower of <code>v</code> cubes placed on top of the cell <code>(i, j)</code>.</p>
|
||||
|
||||
<p>We view the projection of these cubes onto the <code>xy</code>, <code>yz</code>, and <code>zx</code> planes.</p>
|
||||
|
||||
<p>A <strong>projection</strong> is like a shadow, that maps our <strong>3-dimensional</strong> figure to a <strong>2-dimensional</strong> plane. We are viewing the "shadow" when looking at the cubes from the top, the front, and the side.</p>
|
||||
|
||||
<p>Return <em>the total area of all three projections</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/08/02/shadow.png" style="width: 800px; height: 214px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,2],[3,4]]
|
||||
<strong>Output:</strong> 17
|
||||
<strong>Explanation:</strong> Here are the three projections ("shadows") of the shape made with each axis-aligned plane.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[2]]
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,0],[0,2]]
|
||||
<strong>Output:</strong> 8
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == grid.length == grid[i].length</code></li>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
<li><code>0 <= grid[i][j] <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>You are given an <code>n x n</code> <code>grid</code> where you have placed some <code>1 x 1 x 1</code> cubes. Each value <code>v = grid[i][j]</code> represents a tower of <code>v</code> cubes placed on top of cell <code>(i, j)</code>.</p>
|
||||
|
||||
<p>After placing these cubes, you have decided to glue any directly adjacent cubes to each other, forming several irregular 3D shapes.</p>
|
||||
|
||||
<p>Return <em>the total surface area of the resulting shapes</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong> The bottom face of each shape counts toward its surface area.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/08/tmp-grid2.jpg" style="width: 162px; height: 162px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,2],[3,4]]
|
||||
<strong>Output:</strong> 34
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/08/tmp-grid4.jpg" style="width: 242px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,1,1],[1,0,1],[1,1,1]]
|
||||
<strong>Output:</strong> 32
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/08/tmp-grid5.jpg" style="width: 242px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[2,2,2],[2,1,2],[2,2,2]]
|
||||
<strong>Output:</strong> 46
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == grid.length == grid[i].length</code></li>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
<li><code>0 <= grid[i][j] <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1 @@
|
||||
<p>English description is not available for the problem. Please switch to Chinese.</p>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given a <code>triangle</code> array, return <em>the minimum path sum from top to bottom</em>.</p>
|
||||
|
||||
<p>For each step, you may move to an adjacent number of the row below. More formally, if you are on index <code>i</code> on the current row, you may move to either index <code>i</code> or index <code>i + 1</code> on the next row.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> The triangle looks like:
|
||||
<u>2</u>
|
||||
<u>3</u> 4
|
||||
6 <u>5</u> 7
|
||||
4 <u>1</u> 8 3
|
||||
The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> triangle = [[-10]]
|
||||
<strong>Output:</strong> -10
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= triangle.length <= 200</code></li>
|
||||
<li><code>triangle[0].length == 1</code></li>
|
||||
<li><code>triangle[i].length == triangle[i - 1].length + 1</code></li>
|
||||
<li><code>-10<sup>4</sup> <= triangle[i][j] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you do this using only <code>O(n)</code> extra space, where <code>n</code> is the total number of rows in the triangle?
|
||||
@@ -0,0 +1,24 @@
|
||||
<p>Given an integer array <code>nums</code>, return <em>the largest perimeter of a triangle with a non-zero area, formed from three of these lengths</em>. If it is impossible to form any triangle of a non-zero area, return <code>0</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,1,2]
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1]
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>Given an integer <code>n</code>, return <code>true</code><em> if </em><code>n</code><em> has <strong>exactly three positive divisors</strong>. Otherwise, return </em><code>false</code>.</p>
|
||||
|
||||
<p>An integer <code>m</code> is a <strong>divisor</strong> of <code>n</code> if there exists an integer <code>k</code> such that <code>n = k * m</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explantion:</strong> 2 has only two divisors: 1 and 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explantion:</strong> 4 has three divisors: 1, 2, and 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given a string <code>s</code>. Reorder the string using the following algorithm:</p>
|
||||
|
||||
<ol>
|
||||
<li>Pick the <strong>smallest</strong> character from <code>s</code> and <strong>append</strong> it to the result.</li>
|
||||
<li>Pick the <strong>smallest</strong> character from <code>s</code> which is greater than the last appended character to the result and <strong>append</strong> it.</li>
|
||||
<li>Repeat step 2 until you cannot pick more characters.</li>
|
||||
<li>Pick the <strong>largest</strong> character from <code>s</code> and <strong>append</strong> it to the result.</li>
|
||||
<li>Pick the <strong>largest</strong> character from <code>s</code> which is smaller than the last appended character to the result and <strong>append</strong> it.</li>
|
||||
<li>Repeat step 5 until you cannot pick more characters.</li>
|
||||
<li>Repeat the steps from 1 to 6 until you pick all characters from <code>s</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>In each step, If the smallest or the largest character appears more than once you can choose any occurrence and append it to the result.</p>
|
||||
|
||||
<p>Return <em>the result string after sorting </em><code>s</code><em> with this algorithm</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aaaabbbbcccc"
|
||||
<strong>Output:</strong> "abccbaabccba"
|
||||
<strong>Explanation:</strong> After steps 1, 2 and 3 of the first iteration, result = "abc"
|
||||
After steps 4, 5 and 6 of the first iteration, result = "abccba"
|
||||
First iteration is done. Now s = "aabbcc" and we go back to step 1
|
||||
After steps 1, 2 and 3 of the second iteration, result = "abccbaabc"
|
||||
After steps 4, 5 and 6 of the second iteration, result = "abccbaabccba"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "rat"
|
||||
<strong>Output:</strong> "art"
|
||||
<strong>Explanation:</strong> The word "rat" becomes "art" after re-ordering it with the mentioned algorithm.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 500</code></li>
|
||||
<li><code>s</code> consists of only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>Table: <code>Weather</code></p>
|
||||
|
||||
<pre>
|
||||
+---------------+---------+
|
||||
| Column Name | Type |
|
||||
+---------------+---------+
|
||||
| id | int |
|
||||
| recordDate | date |
|
||||
| temperature | int |
|
||||
+---------------+---------+
|
||||
id is the primary key for this table.
|
||||
This table contains information about the temperature on a certain day.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to find all dates' <code>Id</code> with higher temperatures compared to its previous dates (yesterday).</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Weather table:
|
||||
+----+------------+-------------+
|
||||
| id | recordDate | temperature |
|
||||
+----+------------+-------------+
|
||||
| 1 | 2015-01-01 | 10 |
|
||||
| 2 | 2015-01-02 | 25 |
|
||||
| 3 | 2015-01-03 | 20 |
|
||||
| 4 | 2015-01-04 | 30 |
|
||||
+----+------------+-------------+
|
||||
<strong>Output:</strong>
|
||||
+----+
|
||||
| id |
|
||||
+----+
|
||||
| 2 |
|
||||
| 4 |
|
||||
+----+
|
||||
<strong>Explanation:</strong>
|
||||
In 2015-01-02, the temperature was higher than the previous day (10 -> 25).
|
||||
In 2015-01-04, the temperature was higher than the previous day (20 -> 30).
|
||||
</pre>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>A <strong>permutation</strong> of an array of integers is an arrangement of its members into a sequence or linear order.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, for <code>arr = [1,2,3]</code>, the following are considered permutations of <code>arr</code>: <code>[1,2,3]</code>, <code>[1,3,2]</code>, <code>[3,1,2]</code>, <code>[2,3,1]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>next permutation</strong> of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the <strong>next permutation</strong> of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, the next permutation of <code>arr = [1,2,3]</code> is <code>[1,3,2]</code>.</li>
|
||||
<li>Similarly, the next permutation of <code>arr = [2,3,1]</code> is <code>[3,1,2]</code>.</li>
|
||||
<li>While the next permutation of <code>arr = [3,2,1]</code> is <code>[1,2,3]</code> because <code>[3,2,1]</code> does not have a lexicographical larger rearrangement.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an array of integers <code>nums</code>, <em>find the next permutation of</em> <code>nums</code>.</p>
|
||||
|
||||
<p>The replacement must be <strong><a href="http://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in place</a></strong> and use only constant extra memory.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> [1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,2,1]
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,5]
|
||||
<strong>Output:</strong> [1,5,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>0 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,22 @@
|
||||
<p>Given a positive integer, print the next smallest and the next largest number that have the same number of 1 bits in their binary representation.</p>
|
||||
|
||||
<p><strong>Example1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> Input</strong>: num = 2 (0b10)
|
||||
<strong> Output</strong>: [4, 1] ([0b100, 0b1])
|
||||
</pre>
|
||||
|
||||
<p><strong>Example2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> Input</strong>: num = 1
|
||||
<strong> Output</strong>: [2, -1]
|
||||
</pre>
|
||||
|
||||
<p><strong>Note:</strong></p>
|
||||
|
||||
<ol>
|
||||
<li><code>1 <= num <= 2147483647</code></li>
|
||||
<li>If there is no next smallest or next largest number, output -1.</li>
|
||||
</ol>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>The <strong>next greater element</strong> of some element <code>x</code> in an array is the <strong>first greater</strong> element that is <strong>to the right</strong> of <code>x</code> in the same array.</p>
|
||||
|
||||
<p>You are given two <strong>distinct 0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, where <code>nums1</code> is a subset of <code>nums2</code>.</p>
|
||||
|
||||
<p>For each <code>0 <= i < nums1.length</code>, find the index <code>j</code> such that <code>nums1[i] == nums2[j]</code> and determine the <strong>next greater element</strong> of <code>nums2[j]</code> in <code>nums2</code>. If there is no next greater element, then the answer for this query is <code>-1</code>.</p>
|
||||
|
||||
<p>Return <em>an array </em><code>ans</code><em> of length </em><code>nums1.length</code><em> such that </em><code>ans[i]</code><em> is the <strong>next greater element</strong> as described above.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [4,1,2], nums2 = [1,3,4,2]
|
||||
<strong>Output:</strong> [-1,3,-1]
|
||||
<strong>Explanation:</strong> The next greater element for each value of nums1 is as follows:
|
||||
- 4 is underlined in nums2 = [1,3,<u>4</u>,2]. There is no next greater element, so the answer is -1.
|
||||
- 1 is underlined in nums2 = [<u>1</u>,3,4,2]. The next greater element is 3.
|
||||
- 2 is underlined in nums2 = [1,3,4,<u>2</u>]. There is no next greater element, so the answer is -1.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [2,4], nums2 = [1,2,3,4]
|
||||
<strong>Output:</strong> [3,-1]
|
||||
<strong>Explanation:</strong> The next greater element for each value of nums1 is as follows:
|
||||
- 2 is underlined in nums2 = [1,<u>2</u>,3,4]. The next greater element is 3.
|
||||
- 4 is underlined in nums2 = [1,2,3,<u>4</u>]. There is no next greater element, so the answer is -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length <= nums2.length <= 1000</code></li>
|
||||
<li><code>0 <= nums1[i], nums2[i] <= 10<sup>4</sup></code></li>
|
||||
<li>All integers in <code>nums1</code> and <code>nums2</code> are <strong>unique</strong>.</li>
|
||||
<li>All the integers of <code>nums1</code> also appear in <code>nums2</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you find an <code>O(nums1.length + nums2.length)</code> solution?
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>Given a circular integer array <code>nums</code> (i.e., the next element of <code>nums[nums.length - 1]</code> is <code>nums[0]</code>), return <em>the <strong>next greater number</strong> for every element in</em> <code>nums</code>.</p>
|
||||
|
||||
<p>The <strong>next greater number</strong> of a number <code>x</code> is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn't exist, return <code>-1</code> for this number.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1]
|
||||
<strong>Output:</strong> [2,-1,2]
|
||||
Explanation: The first 1's next greater number is 2;
|
||||
The number 2 can't find next greater number.
|
||||
The second 1's next greater number needs to search circularly, which is also 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,3]
|
||||
<strong>Output:</strong> [2,3,4,-1,4]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,18 @@
|
||||
<p>Given a positive integer <code>n</code>, find <em>the smallest integer which has exactly the same digits existing in the integer</em> <code>n</code> <em>and is greater in value than</em> <code>n</code>. If no such positive integer exists, return <code>-1</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that the returned integer should fit in <strong>32-bit integer</strong>, if there is a valid answer but it does not fit in <strong>32-bit integer</strong>, return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 12
|
||||
<strong>Output:</strong> 21
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 21
|
||||
<strong>Output:</strong> -1
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user