mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-08 00:41:42 +08:00
update
This commit is contained in:
33
leetcode/problem/count-days-spent-together.html
Normal file
33
leetcode/problem/count-days-spent-together.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Alice and Bob are traveling to Rome for separate business meetings.</p>
|
||||
|
||||
<p>You are given 4 strings <code>arriveAlice</code>, <code>leaveAlice</code>, <code>arriveBob</code>, and <code>leaveBob</code>. Alice will be in the city from the dates <code>arriveAlice</code> to <code>leaveAlice</code> (<strong>inclusive</strong>), while Bob will be in the city from the dates <code>arriveBob</code> to <code>leaveBob</code> (<strong>inclusive</strong>). Each will be a 5-character string in the format <code>"MM-DD"</code>, corresponding to the month and day of the date.</p>
|
||||
|
||||
<p>Return<em> the total number of days that Alice and Bob are in Rome together.</em></p>
|
||||
|
||||
<p>You can assume that all dates occur in the <strong>same</strong> calendar year, which is <strong>not</strong> a leap year. Note that the number of days per month can be represented as: <code>[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arriveAlice = "08-15", leaveAlice = "08-18", arriveBob = "08-16", leaveBob = "08-19"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Alice will be in Rome from August 15 to August 18. Bob will be in Rome from August 16 to August 19. They are both in Rome together on August 16th, 17th, and 18th, so the answer is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arriveAlice = "10-01", leaveAlice = "10-31", arriveBob = "11-01", leaveBob = "12-31"
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> There is no day when Alice and Bob are in Rome together, so we return 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>All dates are provided in the format <code>"MM-DD"</code>.</li>
|
||||
<li>Alice and Bob's arrival dates are <strong>earlier than or equal to</strong> their leaving dates.</li>
|
||||
<li>The given dates are valid dates of a <strong>non-leap</strong> year.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>An <strong>alphabetical continuous string</strong> is a string consisting of consecutive letters in the alphabet. In other words, it is any substring of the string <code>"abcdefghijklmnopqrstuvwxyz"</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"abc"</code> is an alphabetical continuous string, while <code>"acb"</code> and <code>"za"</code> are not.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given a string <code>s</code> consisting of lowercase letters only, return the <em>length of the <strong>longest</strong> alphabetical continuous substring.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abacaba"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> There are 4 distinct continuous substrings: "a", "b", "c" and "ab".
|
||||
"ab" is the longest continuous substring.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abcde"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> "abcde" is the longest continuous substring.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists of only English lowercase letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>players</code>, where <code>players[i]</code> represents the <strong>ability</strong> of the <code>i<sup>th</sup></code> player. You are also given a <strong>0-indexed</strong> integer array <code>trainers</code>, where <code>trainers[j]</code> represents the <strong>training capacity </strong>of the <code>j<sup>th</sup></code> trainer.</p>
|
||||
|
||||
<p>The <code>i<sup>th</sup></code> player can <strong>match</strong> with the <code>j<sup>th</sup></code> trainer if the player's ability is <strong>less than or equal to</strong> the trainer's training capacity. Additionally, the <code>i<sup>th</sup></code> player can be matched with at most one trainer, and the <code>j<sup>th</sup></code> trainer can be matched with at most one player.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> number of matchings between </em><code>players</code><em> and </em><code>trainers</code><em> that satisfy these conditions.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> players = [4,7,9], trainers = [8,2,5,8]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong>
|
||||
One of the ways we can form two matchings is as follows:
|
||||
- players[0] can be matched with trainers[0] since 4 <= 8.
|
||||
- players[1] can be matched with trainers[3] since 7 <= 8.
|
||||
It can be proven that 2 is the maximum number of matchings that can be formed.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> players = [1,1,1], trainers = [10]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong>
|
||||
The trainer can be matched with any of the 3 players.
|
||||
Each player can only be matched with one trainer, so the maximum answer is 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= players.length, trainers.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= players[i], trainers[j] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D integer array <code><font face="monospace">transactions</font></code>, where <code>transactions[i] = [cost<sub>i</sub>, cashback<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>The array describes transactions, where each transaction must be completed exactly once in <strong>some order</strong>. At any given moment, you have a certain amount of <code>money</code>. In order to complete transaction <code>i</code>, <code>money >= cost<sub>i</sub></code> must hold true. After performing a transaction, <code>money</code> becomes <code>money - cost<sub>i</sub> + cashback<sub>i</sub></code>.</p>
|
||||
|
||||
<p>Return<em> the minimum amount of </em><code>money</code><em> required before any transaction so that all of the transactions can be completed <strong>regardless of the order</strong> of the transactions.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> transactions = [[2,1],[5,0],[4,2]]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:
|
||||
</strong>Starting with money = 10, the transactions can be performed in any order.
|
||||
It can be shown that starting with money < 10 will fail to complete all transactions in some order.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> transactions = [[3,0],[0,3]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong>
|
||||
- If transactions are in the order [[3,0],[0,3]], the minimum money required to complete the transactions is 3.
|
||||
- If transactions are in the order [[0,3],[3,0]], the minimum money required to complete the transactions is 0.
|
||||
Thus, starting with money = 3, the transactions can be performed in any order.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= transactions.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>transactions[i].length == 2</code></li>
|
||||
<li><code>0 <= cost<sub>i</sub>, cashback<sub>i</sub> <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
51
leetcode/problem/reverse-odd-levels-of-binary-tree.html
Normal file
51
leetcode/problem/reverse-odd-levels-of-binary-tree.html
Normal file
@@ -0,0 +1,51 @@
|
||||
<p>Given the <code>root</code> of a <strong>perfect</strong> binary tree, reverse the node values at each <strong>odd</strong> level of the tree.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, suppose the node values at level 3 are <code>[2,1,3,4,7,11,29,18]</code>, then it should become <code>[18,29,11,7,4,3,1,2]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the root of the reversed tree</em>.</p>
|
||||
|
||||
<p>A binary tree is <strong>perfect</strong> if all parent nodes have two children and all leaves are on the same level.</p>
|
||||
|
||||
<p>The <strong>level</strong> of a node is the number of edges along the path between it and the root node.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/07/28/first_case1.png" style="width: 626px; height: 191px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [2,3,5,8,13,21,34]
|
||||
<strong>Output:</strong> [2,5,3,8,13,21,34]
|
||||
<strong>Explanation:</strong>
|
||||
The tree has only one odd level.
|
||||
The nodes at level 1 are 3, 5 respectively, which are reversed and become 5, 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/07/28/second_case3.png" style="width: 591px; height: 111px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [7,13,11]
|
||||
<strong>Output:</strong> [7,11,13]
|
||||
<strong>Explanation:</strong>
|
||||
The nodes at level 1 are 13, 11, which are reversed and become 11, 13.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2]
|
||||
<strong>Output:</strong> [0,2,1,0,0,0,0,2,2,2,2,1,1,1,1]
|
||||
<strong>Explanation:</strong>
|
||||
The odd levels have non-zero values.
|
||||
The nodes at level 1 were 1, 2, and are 2, 1 after the reversal.
|
||||
The nodes at level 3 were 1, 1, 1, 1, 2, 2, 2, 2, and are 2, 2, 2, 2, 1, 1, 1, 1 after the reversal.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 2<sup>14</sup>]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 10<sup>5</sup></code></li>
|
||||
<li><code>root</code> is a <strong>perfect</strong> binary tree.</li>
|
||||
</ul>
|
||||
24
leetcode/problem/smallest-even-multiple.html
Normal file
24
leetcode/problem/smallest-even-multiple.html
Normal file
@@ -0,0 +1,24 @@
|
||||
Given a <strong>positive</strong> integer <code>n</code>, return <em>the smallest positive integer that is a multiple of <strong>both</strong> </em><code>2</code><em> and </em><code>n</code>.
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The smallest multiple of both 5 and 2 is 10.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 6
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The smallest multiple of both 6 and 2 is 6. Note that a number is a multiple of itself.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 150</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of length <code>n</code>, consisting of non-negative integers. For each index <code>i</code> from <code>0</code> to <code>n - 1</code>, you must determine the size of the <strong>minimum sized</strong> non-empty subarray of <code>nums</code> starting at <code>i</code> (<strong>inclusive</strong>) that has the <strong>maximum</strong> possible <strong>bitwise OR</strong>.</p>
|
||||
|
||||
<ul>
|
||||
<li>In other words, let <code>B<sub>ij</sub></code> be the bitwise OR of the subarray <code>nums[i...j]</code>. You need to find the smallest subarray starting at <code>i</code>, such that bitwise OR of this subarray is equal to <code>max(B<sub>ik</sub>)</code> where <code>i <= k <= n - 1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The bitwise OR of an array is the bitwise OR of all the numbers in it.</p>
|
||||
|
||||
<p>Return <em>an integer array </em><code>answer</code><em> of size </em><code>n</code><em> where </em><code>answer[i]</code><em> is the length of the <strong>minimum</strong> sized subarray starting at </em><code>i</code><em> with <strong>maximum</strong> bitwise OR.</em></p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,0,2,1,3]
|
||||
<strong>Output:</strong> [3,3,2,2,1]
|
||||
<strong>Explanation:</strong>
|
||||
The maximum possible bitwise OR starting at any index is 3.
|
||||
- Starting at index 0, the shortest subarray that yields it is [1,0,2].
|
||||
- Starting at index 1, the shortest subarray that yields the maximum bitwise OR is [0,2,1].
|
||||
- Starting at index 2, the shortest subarray that yields the maximum bitwise OR is [2,1].
|
||||
- Starting at index 3, the shortest subarray that yields the maximum bitwise OR is [1,3].
|
||||
- Starting at index 4, the shortest subarray that yields the maximum bitwise OR is [3].
|
||||
Therefore, we return [3,3,2,2,1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2]
|
||||
<strong>Output:</strong> [2,1]
|
||||
<strong>Explanation:
|
||||
</strong>Starting at index 0, the shortest subarray that yields the maximum bitwise OR is of length 2.
|
||||
Starting at index 1, the shortest subarray that yields the maximum bitwise OR is of length 1.
|
||||
Therefore, we return [2,1].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
51
leetcode/problem/sum-of-prefix-scores-of-strings.html
Normal file
51
leetcode/problem/sum-of-prefix-scores-of-strings.html
Normal file
@@ -0,0 +1,51 @@
|
||||
<p>You are given an array <code>words</code> of size <code>n</code> consisting of <strong>non-empty</strong> strings.</p>
|
||||
|
||||
<p>We define the <strong>score</strong> of a string <code>word</code> as the <strong>number</strong> of strings <code>words[i]</code> such that <code>word</code> is a <strong>prefix</strong> of <code>words[i]</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, if <code>words = ["a", "ab", "abc", "cab"]</code>, then the score of <code>"ab"</code> is <code>2</code>, since <code>"ab"</code> is a prefix of both <code>"ab"</code> and <code>"abc"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array </em><code>answer</code><em> of size </em><code>n</code><em> where </em><code>answer[i]</code><em> is the <strong>sum</strong> of scores of every <strong>non-empty</strong> prefix of </em><code>words[i]</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that a string is considered as a prefix of itself.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["abc","ab","bc","b"]
|
||||
<strong>Output:</strong> [5,4,3,2]
|
||||
<strong>Explanation:</strong> The answer for each string is the following:
|
||||
- "abc" has 3 prefixes: "a", "ab", and "abc".
|
||||
- There are 2 strings with the prefix "a", 2 strings with the prefix "ab", and 1 string with the prefix "abc".
|
||||
The total is answer[0] = 2 + 2 + 1 = 5.
|
||||
- "ab" has 2 prefixes: "a" and "ab".
|
||||
- There are 2 strings with the prefix "a", and 2 strings with the prefix "ab".
|
||||
The total is answer[1] = 2 + 2 = 4.
|
||||
- "bc" has 2 prefixes: "b" and "bc".
|
||||
- There are 2 strings with the prefix "b", and 1 string with the prefix "bc".
|
||||
The total is answer[2] = 2 + 1 = 3.
|
||||
- "b" has 1 prefix: "b".
|
||||
- There are 2 strings with the prefix "b".
|
||||
The total is answer[3] = 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["abcd"]
|
||||
<strong>Output:</strong> [4]
|
||||
<strong>Explanation:</strong>
|
||||
"abcd" has 4 prefixes: "a", "ab", "abc", and "abcd".
|
||||
Each prefix has a score of one, so the total is answer[0] = 1 + 1 + 1 + 1 = 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 1000</code></li>
|
||||
<li><code>1 <= words[i].length <= 1000</code></li>
|
||||
<li><code>words[i]</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user