mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 05:13:29 +08:00
update
This commit is contained in:
@@ -0,0 +1,41 @@
|
||||
<p>Given a <strong>0-indexed</strong> array of strings <code>words</code> where <code>words[i]</code> is either a positive integer represented as a string or the string <code>"prev"</code>.</p>
|
||||
|
||||
<p>Start iterating from the beginning of the array; for every <code>"prev"</code> string seen in <code>words</code>, find the <strong>last visited integer</strong> in <code>words</code> which is defined as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li>Let <code>k</code> be the number of consecutive <code>"prev"</code> strings seen so far (containing the current string). Let <code>nums</code> be the <strong>0-indexed </strong>array of <strong>integers</strong> seen so far and <code>nums_reverse</code> be the reverse of <code>nums</code>, then the integer at <code>(k - 1)<sup>th</sup></code> index of <code>nums_reverse</code> will be the <strong>last visited integer</strong> for this <code>"prev"</code>.</li>
|
||||
<li>If <code>k</code> is <strong>greater</strong> than the total visited integers, then the last visited integer will be <code>-1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer array containing the last visited integers.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["1","2","prev","prev","prev"]
|
||||
<strong>Output:</strong> [2,1,-1]
|
||||
<strong>Explanation:</strong>
|
||||
For "prev" at index = 2, last visited integer will be 2 as here the number of consecutive "prev" strings is 1, and in the array reverse_nums, 2 will be the first element.
|
||||
For "prev" at index = 3, last visited integer will be 1 as there are a total of two consecutive "prev" strings including this "prev" which are visited, and 1 is the second last visited integer.
|
||||
For "prev" at index = 4, last visited integer will be -1 as there are a total of three consecutive "prev" strings including this "prev" which are visited, but the total number of integers visited is two.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["1","prev","2","prev","prev"]
|
||||
<strong>Output:</strong> [1,2,1]
|
||||
<strong>Explanation:</strong>
|
||||
For "prev" at index = 1, last visited integer will be 1.
|
||||
For "prev" at index = 3, last visited integer will be 2.
|
||||
For "prev" at index = 4, last visited integer will be 1 as there are a total of two consecutive "prev" strings including this "prev" which are visited, and 1 is the second last visited integer.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 100</code></li>
|
||||
<li><code>words[i] == "prev"</code> or <code>1 <= int(words[i]) <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>You are given positive integers <code>n</code> and <code>m</code>.</p>
|
||||
|
||||
<p>Define two integers, <code>num1</code> and <code>num2</code>, as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>num1</code>: The sum of all integers in the range <code>[1, n]</code> that are <strong>not divisible</strong> by <code>m</code>.</li>
|
||||
<li><code>num2</code>: The sum of all integers in the range <code>[1, n]</code> that are <strong>divisible</strong> by <code>m</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the integer</em> <code>num1 - num2</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 10, m = 3
|
||||
<strong>Output:</strong> 19
|
||||
<strong>Explanation:</strong> In the given example:
|
||||
- Integers in the range [1, 10] that are not divisible by 3 are [1,2,4,5,7,8,10], num1 is the sum of those integers = 37.
|
||||
- Integers in the range [1, 10] that are divisible by 3 are [3,6,9], num2 is the sum of those integers = 18.
|
||||
We return 37 - 18 = 19 as the answer.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, m = 6
|
||||
<strong>Output:</strong> 15
|
||||
<strong>Explanation:</strong> In the given example:
|
||||
- Integers in the range [1, 5] that are not divisible by 6 are [1,2,3,4,5], num1 is the sum of those integers = 15.
|
||||
- Integers in the range [1, 5] that are divisible by 6 are [], num2 is the sum of those integers = 0.
|
||||
We return 15 - 0 = 15 as the answer.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, m = 1
|
||||
<strong>Output:</strong> -15
|
||||
<strong>Explanation:</strong> In the given example:
|
||||
- Integers in the range [1, 5] that are not divisible by 1 are [], num1 is the sum of those integers = 0.
|
||||
- Integers in the range [1, 5] that are divisible by 1 are [1,2,3,4,5], num2 is the sum of those integers = 15.
|
||||
We return 0 - 15 = -15 as the answer.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n, m <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of non-negative integers, and two integers <code>l</code> and <code>r</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>count of sub-multisets</strong> within</em> <code>nums</code> <em>where the sum of elements in each subset falls within the inclusive range of</em> <code>[l, r]</code>.</p>
|
||||
|
||||
<p>Since the answer may be large, return it modulo <code>10<sup>9 </sup>+ 7</code>.</p>
|
||||
|
||||
<p>A <strong>sub-multiset</strong> is an <strong>unordered</strong> collection of elements of the array in which a given value <code>x</code> can occur <code>0, 1, ..., occ[x]</code> times, where <code>occ[x]</code> is the number of occurrences of <code>x</code> in the array.</p>
|
||||
|
||||
<p><strong>Note</strong> that:</p>
|
||||
|
||||
<ul>
|
||||
<li>Two <strong>sub-multisets</strong> are the same if sorting both sub-multisets results in identical multisets.</li>
|
||||
<li>The sum of an <strong>empty</strong> multiset is <code>0</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,2,3], l = 6, r = 6
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The only subset of nums that has a sum of 6 is {1, 2, 3}.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,1,4,2,7], l = 1, r = 5
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> The subsets of nums that have a sum within the range [1, 5] are {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4}, and {1, 2, 2}.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,3,5,2], l = 3, r = 5
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> The subsets of nums that have a sum within the range [3, 5] are {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3}, and {1, 2, 2}.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 2 * 10<sup>4</sup></code></li>
|
||||
<li>Sum of <code>nums</code> does not exceed <code>2 * 10<sup>4</sup></code>.</li>
|
||||
<li><code>0 <= l <= r <= 2 * 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a <strong>positive</strong> integer <code>k</code>.</p>
|
||||
|
||||
<p>You can do the following operation on the array <strong>any</strong> number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose any two distinct indices <code>i</code> and <code>j</code> and <strong>simultaneously</strong> update the values of <code>nums[i]</code> to <code>(nums[i] AND nums[j])</code> and <code>nums[j]</code> to <code>(nums[i] OR nums[j])</code>. Here, <code>OR</code> denotes the bitwise <code>OR</code> operation, and <code>AND</code> denotes the bitwise <code>AND</code> operation.</li>
|
||||
</ul>
|
||||
|
||||
<p>You have to choose <code>k</code> elements from the final array and calculate the sum of their <strong>squares</strong>.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> sum of squares you can achieve</em>.</p>
|
||||
|
||||
<p>Since the answer can be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,6,5,8], k = 2
|
||||
<strong>Output:</strong> 261
|
||||
<strong>Explanation:</strong> We can do the following operations on the array:
|
||||
- Choose i = 0 and j = 3, then change nums[0] to (2 AND 8) = 0 and nums[3] to (2 OR 8) = 10. The resulting array is nums = [0,6,5,10].
|
||||
- Choose i = 2 and j = 3, then change nums[2] to (5 AND 10) = 0 and nums[3] to (5 OR 10) = 15. The resulting array is nums = [0,6,0,15].
|
||||
We can choose the elements 15 and 6 from the final array. The sum of squares is 15<sup>2</sup> + 6<sup>2</sup> = 261.
|
||||
It can be shown that this is the maximum value we can get.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,5,4,7], k = 3
|
||||
<strong>Output:</strong> 90
|
||||
<strong>Explanation:</strong> We do not need to apply any operations.
|
||||
We can choose the elements 7, 5, and 4 with a sum of squares: 7<sup>2</sup> + 5<sup>2</sup> + 4<sup>2</sup> = 90.
|
||||
It can be shown that this is the maximum value we can get.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>You are given two <strong>0-indexed</strong> binary strings <code>s1</code> and <code>s2</code>, both of length <code>n</code>, and a positive integer <code>x</code>.</p>
|
||||
|
||||
<p>You can perform any of the following operations on the string <code>s1</code> <strong>any</strong> number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose two indices <code>i</code> and <code>j</code>, and flip both <code>s1[i]</code> and <code>s1[j]</code>. The cost of this operation is <code>x</code>.</li>
|
||||
<li>Choose an index <code>i</code> such that <code>i < n - 1</code> and flip both <code>s1[i]</code> and <code>s1[i + 1]</code>. The cost of this operation is <code>1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> cost needed to make the strings </em><code>s1</code><em> and </em><code>s2</code><em> equal, or return </em><code>-1</code><em> if it is impossible.</em></p>
|
||||
|
||||
<p><strong>Note</strong> that flipping a character means changing it from <code>0</code> to <code>1</code> or vice-versa.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "1100011000", s2 = "0101001010", x = 2
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> We can do the following operations:
|
||||
- Choose i = 3 and apply the second operation. The resulting string is s1 = "110<u><strong>11</strong></u>11000".
|
||||
- Choose i = 4 and apply the second operation. The resulting string is s1 = "1101<strong><u>00</u></strong>1000".
|
||||
- Choose i = 0 and j = 8 and apply the first operation. The resulting string is s1 = "<u><strong>0</strong></u>1010010<u><strong>1</strong></u>0" = s2.
|
||||
The total cost is 1 + 1 + 2 = 4. It can be shown that it is the minimum cost possible.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "10110", s2 = "00011", x = 4
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It is not possible to make the two strings equal.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == s1.length == s2.length</code></li>
|
||||
<li><code>1 <= n, x <= 500</code></li>
|
||||
<li><code>s1</code> and <code>s2</code> consist only of the characters <code>'0'</code> and <code>'1'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> having length <code>n</code>, an integer <code>indexDifference</code>, and an integer <code>valueDifference</code>.</p>
|
||||
|
||||
<p>Your task is to find <strong>two</strong> indices <code>i</code> and <code>j</code>, both in the range <code>[0, n - 1]</code>, that satisfy the following conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>abs(i - j) >= indexDifference</code>, and</li>
|
||||
<li><code>abs(nums[i] - nums[j]) >= valueDifference</code></li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer array</em> <code>answer</code>, <em>where</em> <code>answer = [i, j]</code> <em>if there are two such indices</em>, <em>and</em> <code>answer = [-1, -1]</code> <em>otherwise</em>. If there are multiple choices for the two indices, return <em>any of them</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong> <code>i</code> and <code>j</code> may be <strong>equal</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
|
||||
<strong>Output:</strong> [0,3]
|
||||
<strong>Explanation:</strong> In this example, i = 0 and j = 3 can be selected.
|
||||
abs(0 - 3) >= 2 and abs(nums[0] - nums[3]) >= 4.
|
||||
Hence, a valid answer is [0,3].
|
||||
[3,0] is also a valid answer.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,1], indexDifference = 0, valueDifference = 0
|
||||
<strong>Output:</strong> [0,0]
|
||||
<strong>Explanation:</strong> In this example, i = 0 and j = 0 can be selected.
|
||||
abs(0 - 0) >= 0 and abs(nums[0] - nums[0]) >= 0.
|
||||
Hence, a valid answer is [0,0].
|
||||
Other valid answers are [0,1], [1,0], and [1,1].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3], indexDifference = 2, valueDifference = 4
|
||||
<strong>Output:</strong> [-1,-1]
|
||||
<strong>Explanation:</strong> In this example, it can be shown that it is impossible to find two indices that satisfy both conditions.
|
||||
Hence, [-1,-1] is returned.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 100</code></li>
|
||||
<li><code>0 <= nums[i] <= 50</code></li>
|
||||
<li><code>0 <= indexDifference <= 100</code></li>
|
||||
<li><code>0 <= valueDifference <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> having length <code>n</code>, an integer <code>indexDifference</code>, and an integer <code>valueDifference</code>.</p>
|
||||
|
||||
<p>Your task is to find <strong>two</strong> indices <code>i</code> and <code>j</code>, both in the range <code>[0, n - 1]</code>, that satisfy the following conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>abs(i - j) >= indexDifference</code>, and</li>
|
||||
<li><code>abs(nums[i] - nums[j]) >= valueDifference</code></li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer array</em> <code>answer</code>, <em>where</em> <code>answer = [i, j]</code> <em>if there are two such indices</em>, <em>and</em> <code>answer = [-1, -1]</code> <em>otherwise</em>. If there are multiple choices for the two indices, return <em>any of them</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong> <code>i</code> and <code>j</code> may be <strong>equal</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
|
||||
<strong>Output:</strong> [0,3]
|
||||
<strong>Explanation:</strong> In this example, i = 0 and j = 3 can be selected.
|
||||
abs(0 - 3) >= 2 and abs(nums[0] - nums[3]) >= 4.
|
||||
Hence, a valid answer is [0,3].
|
||||
[3,0] is also a valid answer.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,1], indexDifference = 0, valueDifference = 0
|
||||
<strong>Output:</strong> [0,0]
|
||||
<strong>Explanation:</strong> In this example, i = 0 and j = 0 can be selected.
|
||||
abs(0 - 0) >= 0 and abs(nums[0] - nums[0]) >= 0.
|
||||
Hence, a valid answer is [0,0].
|
||||
Other valid answers are [0,1], [1,0], and [1,1].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3], indexDifference = 2, valueDifference = 4
|
||||
<strong>Output:</strong> [-1,-1]
|
||||
<strong>Explanation:</strong> In this example, it can be shown that it is impossible to find two indices that satisfy both conditions.
|
||||
Hence, [-1,-1] is returned.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= indexDifference <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= valueDifference <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You have <code>n</code> processors each having <code>4</code> cores and <code>n * 4</code> tasks that need to be executed such that each core should perform only <strong>one</strong> task.</p>
|
||||
|
||||
<p>Given a <strong>0-indexed</strong> integer array <code>processorTime</code> representing the time at which each processor becomes available for the first time and a <strong>0-indexed </strong>integer array <code>tasks</code> representing the time it takes to execute each task, return <em>the <strong>minimum</strong> time when all of the tasks have been executed by the processors.</em></p>
|
||||
|
||||
<p><strong>Note: </strong>Each core executes the task independently of the others.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong>
|
||||
It's optimal to assign the tasks at indexes 4, 5, 6, 7 to the first processor which becomes available at time = 8, and the tasks at indexes 0, 1, 2, 3 to the second processor which becomes available at time = 10.
|
||||
Time taken by the first processor to finish execution of all tasks = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
|
||||
Time taken by the second processor to finish execution of all tasks = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
|
||||
Hence, it can be shown that the minimum time taken to execute all the tasks is 16.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
|
||||
<strong>Output:</strong> 23
|
||||
<strong>Explanation:</strong>
|
||||
It's optimal to assign the tasks at indexes 1, 4, 5, 6 to the first processor which becomes available at time = 10, and the tasks at indexes 0, 2, 3, 7 to the second processor which becomes available at time = 20.
|
||||
Time taken by the first processor to finish execution of all tasks = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
|
||||
Time taken by the second processor to finish execution of all tasks = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
|
||||
Hence, it can be shown that the minimum time taken to execute all the tasks is 23.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == processorTime.length <= 25000</code></li>
|
||||
<li><code>1 <= tasks.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= processorTime[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= tasks[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>tasks.length == 4 * n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,60 @@
|
||||
<p>You are given a binary string <code>s</code> and a positive integer <code>k</code>.</p>
|
||||
|
||||
<p>A substring of <code>s</code> is <strong>beautiful</strong> if the number of <code>1</code>'s in it is exactly <code>k</code>.</p>
|
||||
|
||||
<p>Let <code>len</code> be the length of the <strong>shortest</strong> beautiful substring.</p>
|
||||
|
||||
<p>Return <em>the lexicographically <strong>smallest</strong> beautiful substring of string </em><code>s</code><em> with length equal to </em><code>len</code>. If <code>s</code> doesn't contain a beautiful substring, return <em>an <strong>empty</strong> string</em>.</p>
|
||||
|
||||
<p>A string <code>a</code> is lexicographically <strong>larger</strong> than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, <code>a</code> has a character strictly larger than the corresponding character in <code>b</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"abcd"</code> is lexicographically larger than <code>"abcc"</code> because the first position they differ is at the fourth character, and <code>d</code> is greater than <code>c</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "100011001", k = 3
|
||||
<strong>Output:</strong> "11001"
|
||||
<strong>Explanation:</strong> There are 7 beautiful substrings in this example:
|
||||
1. The substring "<u>100011</u>001".
|
||||
2. The substring "<u>1000110</u>01".
|
||||
3. The substring "<u>10001100</u>1".
|
||||
4. The substring "1<u>00011001</u>".
|
||||
5. The substring "10<u>0011001</u>".
|
||||
6. The substring "100<u>011001</u>".
|
||||
7. The substring "1000<u>11001</u>".
|
||||
The length of the shortest beautiful substring is 5.
|
||||
The lexicographically smallest beautiful substring with length 5 is the substring "11001".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "1011", k = 2
|
||||
<strong>Output:</strong> "11"
|
||||
<strong>Explanation:</strong> There are 3 beautiful substrings in this example:
|
||||
1. The substring "<u>101</u>1".
|
||||
2. The substring "1<u>011</u>".
|
||||
3. The substring "10<u>11</u>".
|
||||
The length of the shortest beautiful substring is 2.
|
||||
The lexicographically smallest beautiful substring with length 2 is the substring "11".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "000", k = 1
|
||||
<strong>Output:</strong> ""
|
||||
<strong>Explanation:</strong> There are no beautiful substrings in this example.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>1 <= k <= s.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given an integer <code>n</code>, a <strong>0-indexed</strong> string array <code>words</code>, and a <strong>0-indexed</strong> <strong>binary</strong> array <code>groups</code>, both arrays having length <code>n</code>.</p>
|
||||
|
||||
<p>You need to select the <strong>longest</strong> <strong>subsequence</strong> from an array of indices <code>[0, 1, ..., n - 1]</code>, such that for the subsequence denoted as <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> having length <code>k</code>, <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code>, for each <code>j</code> where <code>0 < j + 1 < k</code>.</p>
|
||||
|
||||
<p>Return <em>a string array containing the words corresponding to the indices <strong>(in order)</strong> in the selected subsequence</em>. If there are multiple answers, return<em> any of them</em>.</p>
|
||||
|
||||
<p>A <strong>subsequence</strong> of an array is a new array that is formed from the original array by deleting some (possibly none) of the elements without disturbing the relative positions of the remaining elements.</p>
|
||||
|
||||
<p><strong>Note:</strong> strings in <code>words</code> may be <strong>unequal</strong> in length.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, words = ["e","a","b"], groups = [0,0,1]
|
||||
<strong>Output:</strong> ["e","b"]
|
||||
<strong>Explanation: </strong>A subsequence that can be selected is [0,2] because groups[0] != groups[2].
|
||||
So, a valid answer is [words[0],words[2]] = ["e","b"].
|
||||
Another subsequence that can be selected is [1,2] because groups[1] != groups[2].
|
||||
This results in [words[1],words[2]] = ["a","b"].
|
||||
It is also a valid answer.
|
||||
It can be shown that the length of the longest subsequence of indices that satisfies the condition is 2.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, words = ["a","b","c","d"], groups = [1,0,1,1]
|
||||
<strong>Output:</strong> ["a","b","c"]
|
||||
<strong>Explanation:</strong> A subsequence that can be selected is [0,1,2] because groups[0] != groups[1] and groups[1] != groups[2].
|
||||
So, a valid answer is [words[0],words[1],words[2]] = ["a","b","c"].
|
||||
Another subsequence that can be selected is [0,1,3] because groups[0] != groups[1] and groups[1] != groups[3].
|
||||
This results in [words[0],words[1],words[3]] = ["a","b","d"].
|
||||
It is also a valid answer.
|
||||
It can be shown that the length of the longest subsequence of indices that satisfies the condition is 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == words.length == groups.length <= 100</code></li>
|
||||
<li><code>1 <= words[i].length <= 10</code></li>
|
||||
<li><code>0 <= groups[i] < 2</code></li>
|
||||
<li><code>words</code> consists of <strong>distinct</strong> strings.</li>
|
||||
<li><code>words[i]</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,55 @@
|
||||
<p>You are given an integer <code>n</code>, a <strong>0-indexed</strong> string array <code>words</code>, and a <strong>0-indexed</strong> array <code>groups</code>, both arrays having length <code>n</code>.</p>
|
||||
|
||||
<p>The <strong>hamming distance</strong> between two strings of equal length is the number of positions at which the corresponding characters are <strong>different</strong>.</p>
|
||||
|
||||
<p>You need to select the <strong>longest</strong> <strong>subsequence</strong> from an array of indices <code>[0, 1, ..., n - 1]</code>, such that for the subsequence denoted as <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> having length <code>k</code>, the following holds:</p>
|
||||
|
||||
<ul>
|
||||
<li>For <strong>adjacent</strong> indices in the subsequence, their corresponding groups are <strong>unequal</strong>, i.e., <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code>, for each <code>j</code> where <code>0 < j + 1 < k</code>.</li>
|
||||
<li><code>words[i<sub>j</sub>]</code> and <code>words[i<sub>j + 1</sub>]</code> are <strong>equal</strong> in length, and the <strong>hamming distance</strong> between them is <code>1</code>, where <code>0 < j + 1 < k</code>, for all indices in the subsequence.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>a string array containing the words corresponding to the indices <strong>(in order)</strong> in the selected subsequence</em>. If there are multiple answers, return <em>any of them</em>.</p>
|
||||
|
||||
<p>A <strong>subsequence</strong> of an array is a new array that is formed from the original array by deleting some (possibly none) of the elements without disturbing the relative positions of the remaining elements.</p>
|
||||
|
||||
<p><strong>Note:</strong> strings in <code>words</code> may be <strong>unequal</strong> in length.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, words = ["bab","dab","cab"], groups = [1,2,2]
|
||||
<strong>Output:</strong> ["bab","cab"]
|
||||
<strong>Explanation:</strong> A subsequence that can be selected is [0,2].
|
||||
- groups[0] != groups[2]
|
||||
- words[0].length == words[2].length, and the hamming distance between them is 1.
|
||||
So, a valid answer is [words[0],words[2]] = ["bab","cab"].
|
||||
Another subsequence that can be selected is [0,1].
|
||||
- groups[0] != groups[1]
|
||||
- words[0].length == words[1].length, and the hamming distance between them is 1.
|
||||
So, another valid answer is [words[0],words[1]] = ["bab","dab"].
|
||||
It can be shown that the length of the longest subsequence of indices that satisfies the conditions is 2. </pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, words = ["a","b","c","d"], groups = [1,2,3,4]
|
||||
<strong>Output:</strong> ["a","b","c","d"]
|
||||
<strong>Explanation:</strong> We can select the subsequence [0,1,2,3].
|
||||
It satisfies both conditions.
|
||||
Hence, the answer is [words[0],words[1],words[2],words[3]] = ["a","b","c","d"].
|
||||
It has the longest length among all subsequences of indices that satisfy the conditions.
|
||||
Hence, it is the only answer.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == words.length == groups.length <= 1000</code></li>
|
||||
<li><code>1 <= words[i].length <= 10</code></li>
|
||||
<li><code>1 <= groups[i] <= n</code></li>
|
||||
<li><code>words</code> consists of <strong>distinct</strong> strings.</li>
|
||||
<li><code>words[i]</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given a <strong>0-indexed</strong> 2D integer matrix <code><font face="monospace">grid</font></code><font face="monospace"> </font>of size <code>n * m</code>, we define a <strong>0-indexed</strong> 2D matrix <code>p</code> of size <code>n * m</code> as the <strong>product</strong> matrix of <code>grid</code> if the following condition is met:</p>
|
||||
|
||||
<ul>
|
||||
<li>Each element <code>p[i][j]</code> is calculated as the product of all elements in <code>grid</code> except for the element <code>grid[i][j]</code>. This product is then taken modulo <code><font face="monospace">12345</font></code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the product matrix of</em> <code><font face="monospace">grid</font></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,2],[3,4]]
|
||||
<strong>Output:</strong> [[24,12],[8,6]]
|
||||
<strong>Explanation:</strong> p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
|
||||
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
|
||||
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
|
||||
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
|
||||
So the answer is [[24,12],[8,6]].</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[12345],[2],[1]]
|
||||
<strong>Output:</strong> [[2],[0],[0]]
|
||||
<strong>Explanation:</strong> p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
|
||||
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. So p[0][1] = 0.
|
||||
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. So p[0][2] = 0.
|
||||
So the answer is [[2],[0],[0]].</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == grid.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= m == grid[i].length <= 10<sup>5</sup></code></li>
|
||||
<li><code>2 <= n * m <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= grid[i][j] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user