mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-01-10 18:48:13 +08:00
update
This commit is contained in:
parent
29fc260318
commit
538ae7bb8b
@ -1,6 +1,6 @@
|
|||||||
# 力扣题库（完整版）
|
# 力扣题库（完整版）
|
||||||
|
|
||||||
> 最后更新日期： **2023.10.05**
|
> 最后更新日期： **2023.10.15**
|
||||||
>
|
>
|
||||||
> 使用脚本前请务必仔细完整阅读本 `README.md` 文件
|
> 使用脚本前请务必仔细完整阅读本 `README.md` 文件
|
||||||
|
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
164
leetcode-cn/originData/construct-product-matrix.json
Normal file
164
leetcode-cn/originData/construct-product-matrix.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
163
leetcode-cn/originData/last-visited-integers.json
Normal file
163
leetcode-cn/originData/last-visited-integers.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
183
leetcode-cn/originData/minimum-processing-time.json
Normal file
183
leetcode-cn/originData/minimum-processing-time.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -0,0 +1,43 @@
|
|||||||
|
<p>给你一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，其中 <code>words[i]</code> 要么是一个字符串形式的正整数，要么是字符串 <code>"prev"</code> 。</p>
|
||||||
|
|
||||||
|
<p>我们从数组的开头开始遍历，对于 <code>words</code> 中的每个 <code>"prev"</code> 字符串，找到 <code>words</code> 中的 <strong>上一个遍历的整数</strong> ，定义如下：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>k</code> 表示到当前位置为止的连续 <code>"prev"</code> 字符串数目（包含当前字符串），令下标从 <strong>0</strong> 开始的 <strong>整数</strong> 数组 <code>nums</code> 表示目前为止遍历过的所有整数，同时用 <code>nums_reverse</code> 表示 <code>nums</code> 反转得到的数组，那么当前 <code>"prev"</code> 对应的 <strong>上一个遍历的整数</strong> 是 <code>nums_reverse</code> 数组中下标为 <code>(k - 1)</code> 的整数。</li>
|
||||||
|
<li>如果 <code>k</code> 比目前为止遍历过的整数数目 <strong>更多</strong> ，那么上一个遍历的整数为 <code>-1</code> 。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>请你返回一个整数数组，包含所有上一个遍历的整数。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b><code>words</code> = ["1","2","prev","prev","prev"]
|
||||||
|
<b>输出：</b>[2,1,-1]
|
||||||
|
<b>解释：</b>
|
||||||
|
对于下标为 2 处的 "prev" ，上一个遍历的整数是 2 ，因为连续 "prev" 数目为 1 ，同时在数组 reverse_nums 中，第一个元素是 2 。
|
||||||
|
对于下标为 3 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev" 数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
|
||||||
|
对于下标为 4 处的 "prev" ，上一个遍历的整数是 -1 ，因为连续 "prev" 数目为 3 ，但总共只遍历过 2 个整数。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b><code>words</code> = ["1","prev","2","prev","prev"]
|
||||||
|
<b>输出：</b>[1,2,1]
|
||||||
|
<strong>解释：</strong>
|
||||||
|
对于下标为 1 处的 "prev" ，上一个遍历的整数是 1 。
|
||||||
|
对于下标为 3 处的 "prev" ，上一个遍历的整数是 2 。
|
||||||
|
对于下标为 4 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev"<strong> </strong>数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</strong></p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>1 <= words.length <= 100</code></li>
|
||||||
|
<li><code>words[i] == "prev"</code> 或 <code>1 <= int(words[i]) <= 100</code></li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,53 @@
|
|||||||
|
<p>给你两个正整数 <code>n</code> 和 <code>m</code> 。</p>
|
||||||
|
|
||||||
|
<p>现定义两个整数 <code>num1</code> 和 <code>num2</code> ，如下所示：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>num1</code>：范围 <code>[1, n]</code> 内所有 <strong>无法被 </strong><code>m</code><strong> 整除</strong> 的整数之和。</li>
|
||||||
|
<li><code>num2</code>：范围 <code>[1, n]</code> 内所有 <strong>能够被 </strong><code>m</code><strong> 整除</strong> 的整数之和。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>返回整数 <code>num1 - num2</code> 。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>n = 10, m = 3
|
||||||
|
<strong>输出：</strong>19
|
||||||
|
<strong>解释：</strong>在这个示例中：
|
||||||
|
- 范围 [1, 10] 内无法被 3 整除的整数为 [1,2,4,5,7,8,10] ，num1 = 这些整数之和 = 37 。
|
||||||
|
- 范围 [1, 10] 内能够被 3 整除的整数为 [3,6,9] ，num2 = 这些整数之和 = 18 。
|
||||||
|
返回 37 - 18 = 19 作为答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>n = 5, m = 6
|
||||||
|
<strong>输出：</strong>15
|
||||||
|
<strong>解释：</strong>在这个示例中：
|
||||||
|
- 范围 [1, 5] 内无法被 6 整除的整数为 [1,2,3,4,5] ，num1 = 这些整数之和 = 15 。
|
||||||
|
- 范围 [1, 5] 内能够被 6 整除的整数为 [] ，num2 = 这些整数之和 = 0 。
|
||||||
|
返回 15 - 0 = 15 作为答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 3：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>n = 5, m = 1
|
||||||
|
<strong>输出：</strong>-15
|
||||||
|
<strong>解释：</strong>在这个示例中：
|
||||||
|
- 范围 [1, 5] 内无法被 1 整除的整数为 [] ，num1 = 这些整数之和 = 0 。
|
||||||
|
- 范围 [1, 5] 内能够被 1 整除的整数为 [1,2,3,4,5] ，num2 = 这些整数之和 = 15 。
|
||||||
|
返回 0 - 15 = -15 作为答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</strong></p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>1 <= n, m <= 1000</code></li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,50 @@
|
|||||||
|
<p>给你一个下标从 <strong>0</strong> 开始的非负整数数组 <code>nums</code> 和两个整数 <code>l</code> 和 <code>r</code> 。</p>
|
||||||
|
|
||||||
|
<p>请你返回 <code>nums</code> 中子多重集合的和在闭区间 <code>[l, r]</code> 之间的 <strong>子多重集合的数目</strong> 。</p>
|
||||||
|
|
||||||
|
<p>由于答案可能很大，请你将答案对 <code>10<sup>9 </sup>+ 7</code> 取余后返回。</p>
|
||||||
|
|
||||||
|
<p><strong>子多重集合</strong> 指的是从数组中选出一些元素构成的 <strong>无序</strong> 集合，每个元素 <code>x</code> 出现的次数可以是 <code>0, 1, ..., occ[x]</code> 次，其中 <code>occ[x]</code> 是元素 <code>x</code> 在数组中的出现次数。</p>
|
||||||
|
|
||||||
|
<p><b>注意：</b></p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li>如果两个子多重集合中的元素排序后一模一样，那么它们两个是相同的 <strong>子多重集合</strong> 。</li>
|
||||||
|
<li><strong>空</strong> 集合的和是 <code>0</code> 。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>nums = [1,2,2,3], l = 6, r = 6
|
||||||
|
<b>输出：</b>1
|
||||||
|
<b>解释：</b>唯一和为 6 的子集合是 {1, 2, 3} 。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>nums = [2,1,4,2,7], l = 1, r = 5
|
||||||
|
<b>输出：</b>7
|
||||||
|
<b>解释：</b>和在闭区间 [1, 5] 之间的子多重集合为 {1} ，{2} ，{4} ，{2, 2} ，{1, 2} ，{1, 4} 和 {1, 2, 2} 。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 3：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>nums = [1,2,1,3,5,2], l = 3, r = 5
|
||||||
|
<b>输出：</b>9
|
||||||
|
<b>解释：</b>和在闭区间 [3, 5] 之间的子多重集合为 {3} ，{5} ，{1, 2} ，{1, 3} ，{2, 2} ，{2, 3} ，{1, 1, 2} ，{1, 1, 3} 和 {1, 2, 2} 。</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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><code>nums</code> 的和不超过 <code>2 * 10<sup>4</sup></code> 。</li>
|
||||||
|
<li><code>0 <= l <= r <= 2 * 10<sup>4</sup></code></li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,46 @@
|
|||||||
|
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> 和一个 <strong>正</strong> 整数 <code>k</code> 。</p>
|
||||||
|
|
||||||
|
<p>你可以对数组执行以下操作 <strong>任意次</strong> ：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li>选择两个互不相同的下标 <code>i</code> 和 <code>j</code> ，<strong>同时</strong> 将 <code>nums[i]</code> 更新为 <code>(nums[i] AND nums[j])</code> 且将 <code>nums[j]</code> 更新为 <code>(nums[i] OR nums[j])</code> ，<code>OR</code> 表示按位 <strong>或</strong> 运算，<code>AND</code> 表示按位 <strong>与</strong> 运算。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>你需要从最终的数组里选择 <code>k</code> 个元素，并计算它们的 <strong>平方</strong> 之和。</p>
|
||||||
|
|
||||||
|
<p>请你返回你可以得到的 <strong>最大</strong> 平方和。</p>
|
||||||
|
|
||||||
|
<p>由于答案可能会很大，将答案对 <code>10<sup>9</sup> + 7</code> <strong>取余</strong> 后返回。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>nums = [2,6,5,8], k = 2
|
||||||
|
<b>输出：</b>261
|
||||||
|
<b>解释：</b>我们可以对数组执行以下操作：
|
||||||
|
- 选择 i = 0 和 j = 3 ，同时将 nums[0] 变为 (2 AND 8) = 0 且 nums[3] 变为 (2 OR 8) = 10 ，结果数组为 nums = [0,6,5,10] 。
|
||||||
|
- 选择 i = 2 和 j = 3 ，同时将 nums[2] 变为 (5 AND 10) = 0 且 nums[3] 变为 (5 OR 10) = 15 ，结果数组为 nums = [0,6,0,15] 。
|
||||||
|
从最终数组里选择元素 15 和 6 ，平方和为 15<sup>2</sup> + 6<sup>2</sup> = 261 。
|
||||||
|
261 是可以得到的最大结果。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>nums = [4,5,4,7], k = 3
|
||||||
|
<b>输出：</b>90
|
||||||
|
<b>解释：</b>不需要执行任何操作。
|
||||||
|
选择元素 7 ，5 和 4 ，平方和为 7<sup>2</sup> + 5<sup>2</sup> + 4<sup>2</sup> = 90 。
|
||||||
|
90 是可以得到的最大结果。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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,44 @@
|
|||||||
|
<p>给你两个下标从 <strong>0</strong> 开始的二进制字符串 <code>s1</code> 和 <code>s2</code> ，两个字符串的长度都是 <code>n</code> ，再给你一个正整数 <code>x</code> 。</p>
|
||||||
|
|
||||||
|
<p>你可以对字符串 <code>s1</code> 执行以下操作 <strong>任意次</strong> ：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li>选择两个下标 <code>i</code> 和 <code>j</code> ，将 <code>s1[i]</code> 和 <code>s1[j]</code> 都反转，操作的代价为 <code>x</code> 。</li>
|
||||||
|
<li>选择满足 <code>i < n - 1</code> 的下标 <code>i</code> ，反转 <code>s1[i]</code> 和 <code>s1[i + 1]</code> ，操作的代价为 <code>1</code> 。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>请你返回使字符串 <code>s1</code> 和 <code>s2</code> 相等的 <strong>最小</strong> 操作代价之和，如果无法让二者相等，返回 <code>-1</code> 。</p>
|
||||||
|
|
||||||
|
<p><strong>注意</strong> ，反转字符的意思是将 <code>0</code> 变成 <code>1</code> ，或者 <code>1</code> 变成 <code>0</code> 。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>s1 = "1100011000", s2 = "0101001010", x = 2
|
||||||
|
<b>输出：</b>4
|
||||||
|
<b>解释：</b>我们可以执行以下操作：
|
||||||
|
- 选择 i = 3 执行第二个操作。结果字符串是 s1 = "110<em><strong>11</strong></em>11000" 。
|
||||||
|
- 选择 i = 4 执行第二个操作。结果字符串是 s1 = "1101<em><strong>00</strong></em>1000" 。
|
||||||
|
- 选择 i = 0 和 j = 8 ，执行第一个操作。结果字符串是 s1 = "<em><strong>0</strong></em>1010010<em><strong>1</strong></em>0" = s2 。
|
||||||
|
总代价是 1 + 1 + 2 = 4 。这是最小代价和。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>s1 = "10110", s2 = "00011", x = 4
|
||||||
|
<b>输出：</b>-1
|
||||||
|
<b>解释：</b>无法使两个字符串相等。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</strong></p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>n == s1.length == s2.length</code></li>
|
||||||
|
<li><code>1 <= n, x <= 500</code></li>
|
||||||
|
<li><code>s1</code> 和 <code>s2</code> 只包含字符 <code>'0'</code> 和 <code>'1'</code> 。</li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,56 @@
|
|||||||
|
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的整数数组 <code>nums</code> ，以及整数 <code>indexDifference</code> 和整数 <code>valueDifference</code> 。</p>
|
||||||
|
|
||||||
|
<p>你的任务是从范围 <code>[0, n - 1]</code> 内找出 <strong>2</strong> 个满足下述所有条件的下标 <code>i</code> 和 <code>j</code> ：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>abs(i - j) >= indexDifference</code> 且</li>
|
||||||
|
<li><code>abs(nums[i] - nums[j]) >= valueDifference</code></li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>返回整数数组 <code>answer</code>。如果存在满足题目要求的两个下标，则 <code>answer = [i, j]</code> ；否则，<code>answer = [-1, -1]</code> 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。</p>
|
||||||
|
|
||||||
|
<p><strong>注意：</strong><code>i</code> 和 <code>j</code> 可能 <strong>相等</strong> 。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
|
||||||
|
<strong>输出：</strong>[0,3]
|
||||||
|
<strong>解释：</strong>在示例中，可以选择 i = 0 和 j = 3 。
|
||||||
|
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
|
||||||
|
因此，[0,3] 是一个符合题目要求的答案。
|
||||||
|
[3,0] 也是符合题目要求的答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>nums = [2,1], indexDifference = 0, valueDifference = 0
|
||||||
|
<strong>输出：</strong>[0,0]
|
||||||
|
<strong>解释：</strong>
|
||||||
|
在示例中，可以选择 i = 0 和 j = 0 。
|
||||||
|
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。
|
||||||
|
因此，[0,0] 是一个符合题目要求的答案。
|
||||||
|
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 3：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>nums = [1,2,3], indexDifference = 2, valueDifference = 4
|
||||||
|
<strong>输出：</strong>[-1,-1]
|
||||||
|
<strong>解释：</strong>在示例中，可以证明无法找出 2 个满足所有条件的下标。
|
||||||
|
因此，返回 [-1,-1] 。</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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,56 @@
|
|||||||
|
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的整数数组 <code>nums</code> ，以及整数 <code>indexDifference</code> 和整数 <code>valueDifference</code> 。</p>
|
||||||
|
|
||||||
|
<p>你的任务是从范围 <code>[0, n - 1]</code> 内找出 <strong>2</strong> 个满足下述所有条件的下标 <code>i</code> 和 <code>j</code> ：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>abs(i - j) >= indexDifference</code> 且</li>
|
||||||
|
<li><code>abs(nums[i] - nums[j]) >= valueDifference</code></li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>返回整数数组 <code>answer</code>。如果存在满足题目要求的两个下标，则 <code>answer = [i, j]</code> ；否则，<code>answer = [-1, -1]</code> 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。</p>
|
||||||
|
|
||||||
|
<p><strong>注意：</strong><code>i</code> 和 <code>j</code> 可能 <strong>相等</strong> 。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
|
||||||
|
<strong>输出：</strong>[0,3]
|
||||||
|
<strong>解释：</strong>在示例中，可以选择 i = 0 和 j = 3 。
|
||||||
|
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
|
||||||
|
因此，[0,3] 是一个符合题目要求的答案。
|
||||||
|
[3,0] 也是符合题目要求的答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>nums = [2,1], indexDifference = 0, valueDifference = 0
|
||||||
|
<strong>输出：</strong>[0,0]
|
||||||
|
<strong>解释：</strong>
|
||||||
|
在示例中，可以选择 i = 0 和 j = 0 。
|
||||||
|
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。
|
||||||
|
因此，[0,0] 是一个符合题目要求的答案。
|
||||||
|
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 3：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>nums = [1,2,3], indexDifference = 2, valueDifference = 4
|
||||||
|
<strong>输出：</strong>[-1,-1]
|
||||||
|
<strong>解释：</strong>在示例中，可以证明无法找出 2 个满足所有条件的下标。
|
||||||
|
因此，返回 [-1,-1] 。</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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,42 @@
|
|||||||
|
<p>你有 <code>n</code> 颗处理器，每颗处理器都有 <code>4</code> 个核心。现有 <code>n * 4</code> 个待执行任务，每个核心只执行 <strong>一个</strong> 任务。</p>
|
||||||
|
|
||||||
|
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>processorTime</code> ，表示每颗处理器最早空闲时间。另给你一个下标从 <strong>0</strong> 开始的整数数组 <code>tasks</code> ，表示执行每个任务所需的时间。返回所有任务都执行完毕需要的 <strong>最小时间</strong> 。</p>
|
||||||
|
|
||||||
|
<p>注意：每个核心独立执行任务。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
|
||||||
|
<strong>输出：</strong>16
|
||||||
|
<strong>解释：</strong>
|
||||||
|
最优的方案是将下标为 4, 5, 6, 7 的任务分配给第一颗处理器（最早空闲时间 time = 8），下标为 0, 1, 2, 3 的任务分配给第二颗处理器（最早空闲时间 time = 10）。
|
||||||
|
第一颗处理器执行完所有任务需要花费的时间 = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16 。
|
||||||
|
第二颗处理器执行完所有任务需要花费的时间 = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13 。
|
||||||
|
因此，可以证明执行完所有任务需要花费的最小时间是 16 。</pre>
|
||||||
|
|
||||||
|
<p><strong>示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
|
||||||
|
<strong>输出：</strong>23
|
||||||
|
<strong>解释：</strong>
|
||||||
|
最优的方案是将下标为 1, 4, 5, 6 的任务分配给第一颗处理器（最早空闲时间 time = 10），下标为 0, 2, 3, 7 的任务分配给第二颗处理器（最早空闲时间 time = 20）。
|
||||||
|
第一颗处理器执行完所有任务需要花费的时间 = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18 。
|
||||||
|
第二颗处理器执行完所有任务需要花费的时间 = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23 。
|
||||||
|
因此，可以证明执行完所有任务需要花费的最小时间是 23 。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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,62 @@
|
|||||||
|
<p>给你一个二进制字符串 <code>s</code> 和一个正整数 <code>k</code> 。</p>
|
||||||
|
|
||||||
|
<p>如果 <code>s</code> 的某个子字符串中 <code>1</code> 的个数恰好等于 <code>k</code> ，则称这个子字符串是一个 <strong>美丽子字符串</strong> 。</p>
|
||||||
|
|
||||||
|
<p>令 <code>len</code> 等于 <strong>最短</strong> 美丽子字符串的长度。</p>
|
||||||
|
|
||||||
|
<p>返回长度等于 <code>len</code> 且字典序 <strong>最小</strong> 的美丽子字符串。如果 <code>s</code> 中不含美丽子字符串，则返回一个 <strong>空</strong> 字符串。</p>
|
||||||
|
|
||||||
|
<p>对于相同长度的两个字符串 <code>a</code> 和 <code>b</code> ，如果在 <code>a</code> 和 <code>b</code> 出现不同的第一个位置上，<code>a</code> 中该位置上的字符严格大于 <code>b</code> 中的对应字符，则认为字符串 <code>a</code> 字典序 <strong>大于</strong> 字符串 <code>b</code> 。</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li>例如，<code>"abcd"</code> 的字典序大于 <code>"abcc"</code> ，因为两个字符串出现不同的第一个位置对应第四个字符，而 <code>d</code> 大于 <code>c</code> 。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>s = "100011001", k = 3
|
||||||
|
<strong>输出：</strong>"11001"
|
||||||
|
<strong>解释：</strong>示例中共有 7 个美丽子字符串：
|
||||||
|
1. 子字符串 "<em><strong>100011</strong></em>001" 。
|
||||||
|
2. 子字符串 "<strong><em>1000110</em></strong>01" 。
|
||||||
|
3. 子字符串 "<strong><em>100011001</em></strong>" 。
|
||||||
|
4. 子字符串 "1<strong><em>00011001</em></strong>" 。
|
||||||
|
5. 子字符串 "10<strong><em>0011001</em></strong>" 。
|
||||||
|
6. 子字符串 "100<em><strong>011001</strong></em>" 。
|
||||||
|
7. 子字符串 "1000<strong><em>11001</em></strong>" 。
|
||||||
|
最短美丽子字符串的长度是 5 。
|
||||||
|
长度为 5 且字典序最小的美丽子字符串是子字符串 "11001" 。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>s = "1011", k = 2
|
||||||
|
<strong>输出：</strong>"11"
|
||||||
|
<strong>解释：</strong>示例中共有 3 个美丽子字符串：
|
||||||
|
1. 子字符串 "<em><strong>101</strong></em>1" 。
|
||||||
|
2. 子字符串 "1<em><strong>011</strong></em>" 。
|
||||||
|
3. 子字符串 "10<em><strong>11</strong></em>" 。
|
||||||
|
最短美丽子字符串的长度是 2 。
|
||||||
|
长度为 2 且字典序最小的美丽子字符串是子字符串 "11" 。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 3：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>s = "000", k = 1
|
||||||
|
<strong>输出：</strong>""
|
||||||
|
<strong>解释：</strong>示例中不存在美丽子字符串。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</strong></p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><code>1 <= s.length <= 100</code></li>
|
||||||
|
<li><code>1 <= k <= s.length</code></li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,47 @@
|
|||||||
|
<p>给你一个整数 <code>n</code> 和一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，和一个下标从 <strong>0</strong> 开始的 <strong>二进制</strong> 数组 <code>groups</code> ，两个数组长度都是 <code>n</code> 。</p>
|
||||||
|
|
||||||
|
<p>你需要从下标 <code>[0, 1, ..., n - 1]</code> 中选出一个 <strong>最长子序列</strong> ，将这个子序列记作长度为 <code>k</code> 的 <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> ，对于所有满足 <code>0 < j + 1 < k</code> 的 <code>j</code> 都有 <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code> 。</p>
|
||||||
|
|
||||||
|
<p>请你返回一个字符串数组，它是下标子序列 <strong>依次</strong> 对应 <code>words</code> 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。</p>
|
||||||
|
|
||||||
|
<p><strong>子序列</strong> 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。</p>
|
||||||
|
|
||||||
|
<p><b>注意：</b><code>words</code> 中的字符串长度可能 <strong>不相等</strong> 。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>n = 3, words = ["e","a","b"], groups = [0,0,1]
|
||||||
|
<b>输出：</b>["e","b"]
|
||||||
|
<strong>解释：</strong>一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
|
||||||
|
所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
|
||||||
|
另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
|
||||||
|
得到答案为 [words[1],words[2]] = ["a","b"] 。
|
||||||
|
这也是一个可行的答案。
|
||||||
|
符合题意的最长子序列的长度为 2 。</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>n = 4, words = ["a","b","c","d"], groups = [1,0,1,1]
|
||||||
|
<b>输出：</b>["a","b","c"]
|
||||||
|
<b>解释：</b>一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
|
||||||
|
所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
|
||||||
|
另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
|
||||||
|
得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
|
||||||
|
这也是一个可行的答案。
|
||||||
|
符合题意的最长子序列的长度为 3 。</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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> 中的字符串 <strong>互不相同</strong> 。</li>
|
||||||
|
<li><code>words[i]</code> 只包含小写英文字母。</li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,57 @@
|
|||||||
|
<p>给你一个整数 <code>n</code> 和一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，和一个下标从 <strong>0</strong> 开始的 <strong>二进制</strong> 数组 <code>groups</code> ，两个数组长度都是 <code>n</code> 。</p>
|
||||||
|
|
||||||
|
<p>两个长度相等字符串的 <strong>汉明距离</strong> 定义为对应位置字符 <strong>不同</strong> 的数目。</p>
|
||||||
|
|
||||||
|
<p>你需要从下标 <code>[0, 1, ..., n - 1]</code> 中选出一个 <strong>最长子序列</strong> ，将这个子序列记作长度为 <code>k</code> 的 <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> ，它需要满足以下条件：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li><strong>相邻</strong> 下标对应的 <code>groups</code> 值 <strong>不同</strong>。即，对于所有满足 <code>0 < j + 1 < k</code> 的 <code>j</code> 都有 <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code> 。</li>
|
||||||
|
<li>对于所有 <code>0 < j + 1 < k</code> 的下标 <code>j</code> ，都满足 <code>words[i<sub>j</sub>]</code> 和 <code>words[i<sub>j + 1</sub>]</code> 的长度 <strong>相等</strong> ，且两个字符串之间的 <strong>汉明距离</strong> 为 <code>1</code> 。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>请你返回一个字符串数组，它是下标子序列 <strong>依次</strong> 对应 <code>words</code> 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。</p>
|
||||||
|
|
||||||
|
<p><strong>子序列</strong> 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。</p>
|
||||||
|
|
||||||
|
<p><b>注意：</b><code>words</code> 中的字符串长度可能 <strong>不相等</strong> 。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>n = 3, words = ["bab","dab","cab"], groups = [1,2,2]
|
||||||
|
<b>输出：</b>["bab","cab"]
|
||||||
|
<b>解释：</b>一个可行的子序列是 [0,2] 。
|
||||||
|
- groups[0] != groups[2]
|
||||||
|
- words[0].length == words[2].length 且它们之间的汉明距离为 1 。
|
||||||
|
所以一个可行的答案是 [words[0],words[2]] = ["bab","cab"] 。
|
||||||
|
另一个可行的子序列是 [0,1] 。
|
||||||
|
- groups[0] != groups[1]
|
||||||
|
- words[0].length = words[1].length 且它们之间的汉明距离为 1 。
|
||||||
|
所以另一个可行的答案是 [words[0],words[1]] = ["bab","dab"] 。
|
||||||
|
符合题意的最长子序列的长度为 2 。</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<b>输入：</b>n = 4, words = ["a","b","c","d"], groups = [1,2,3,4]
|
||||||
|
<b>输出：</b>["a","b","c","d"]
|
||||||
|
<b>解释：</b>我们选择子序列 [0,1,2,3] 。
|
||||||
|
它同时满足两个条件。
|
||||||
|
所以答案为 [words[0],words[1],words[2],words[3]] = ["a","b","c","d"] 。
|
||||||
|
它是所有下标子序列里最长且满足所有条件的。
|
||||||
|
所以它是唯一的答案。
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><b>提示：</b></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> 中的字符串 <strong>互不相同</strong> 。</li>
|
||||||
|
<li><code>words[i]</code> 只包含小写英文字母。</li>
|
||||||
|
</ul>
|
||||||
@ -0,0 +1,41 @@
|
|||||||
|
<p>给你一个下标从 <strong>0</strong> 开始、大小为 <code>n * m</code> 的二维整数矩阵 <code><font face="monospace">grid</font></code><font face="monospace"> ，定义一个下标从 <strong>0</strong> 开始、大小为 <code>n * m</code> 的的二维矩阵</font> <code>p</code>。如果满足以下条件，则称 <code>p</code> 为 <code>grid</code> 的 <strong>乘积矩阵</strong> ：</p>
|
||||||
|
|
||||||
|
<ul>
|
||||||
|
<li>对于每个元素 <code>p[i][j]</code> ，它的值等于除了 <code>grid[i][j]</code> 外所有元素的乘积。乘积对 <code>12345</code> 取余数。</li>
|
||||||
|
</ul>
|
||||||
|
|
||||||
|
<p>返回 <code>grid</code> 的乘积矩阵。</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 1：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>grid = [[1,2],[3,4]]
|
||||||
|
<strong>输出：</strong>[[24,12],[8,6]]
|
||||||
|
<strong>解释：</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
|
||||||
|
所以答案是 [[24,12],[8,6]] 。</pre>
|
||||||
|
|
||||||
|
<p><strong class="example">示例 2：</strong></p>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
<strong>输入：</strong>grid = [[12345],[2],[1]]
|
||||||
|
<strong>输出：</strong>[[2],[0],[0]]
|
||||||
|
<strong>解释：</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 ，所以 p[0][1] = 0
|
||||||
|
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0 ，所以 p[0][2] = 0
|
||||||
|
所以答案是 [[2],[0],[0]] 。</pre>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p><strong>提示：</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>
|
||||||
@ -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>
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
161
leetcode/originData/construct-product-matrix.json
Normal file
161
leetcode/originData/construct-product-matrix.json
Normal file
File diff suppressed because one or more lines are too long
163
leetcode/originData/count-of-sub-multisets-with-bounded-sum.json
Normal file
163
leetcode/originData/count-of-sub-multisets-with-bounded-sum.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
160
leetcode/originData/last-visited-integers.json
Normal file
160
leetcode/originData/last-visited-integers.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
180
leetcode/originData/minimum-processing-time.json
Normal file
180
leetcode/originData/minimum-processing-time.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -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>
|
||||||
39
leetcode/problem/construct-product-matrix.html
Normal file
39
leetcode/problem/construct-product-matrix.html
Normal file
@ -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>
|
||||||
@ -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,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,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>
|
||||||
41
leetcode/problem/last-visited-integers.html
Normal file
41
leetcode/problem/last-visited-integers.html
Normal file
@ -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,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>
|
||||||
40
leetcode/problem/minimum-processing-time.html
Normal file
40
leetcode/problem/minimum-processing-time.html
Normal file
@ -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>
|
||||||
Loading…
Reference in New Issue
Block a user