mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-05 07:21:40 +08:00
update
This commit is contained in:
@@ -0,0 +1,57 @@
|
||||
<p>设计一个类 <code>Calculator</code> 。该类应提供加法、减法、乘法、除法和乘方等数学运算功能。同时，它还应支持连续操作的方法链式调用。<code>Calculator</code> 类的构造函数应接受一个数字作为 <code>result</code> 的初始值。</p>
|
||||
|
||||
<p>你的 <code>Calculator</code> 类应包含以下方法：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>add</code> - 将给定的数字 <code>value</code> 与 <code>result</code> 相加，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>subtract</code> - 从 <code>result</code> 中减去给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>multiply</code> - 将 <code>result</code> 乘以给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>divide</code> - 将 <code>result</code> 除以给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。如果传入的值为 <code>0</code> ，则抛出错误 <code>"Division by zero is not allowed"</code> 。</li>
|
||||
<li><code>power</code> - 将 <code>result</code> 的值乘以给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>getResult</code> - 返回 <code>result</code> 的值。</li>
|
||||
</ul>
|
||||
|
||||
<p>结果与实际结果相差在 <code>10<sup>-5</sup></code><sup> </sup>范围内的解被认为是正确的。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><b>示例 1：</b></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["Calculator", "add", "subtract", "getResult"], values = [10, 5, 7]
|
||||
<b>输出：</b>8
|
||||
<b>解释：</b>
|
||||
new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["Calculator", "multiply", "power", "getResult"], values = [2, 5, 2]
|
||||
<b>输出：</b>100
|
||||
<b>解释：</b>
|
||||
new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["Calculator", "divide", "getResult"], values = [20, 0]
|
||||
<b>输出：</b>"Division by zero is not allowed"
|
||||
<b>解释：</b>
|
||||
new Calculator(20).divide(0).getResult() // 20 / 0
|
||||
|
||||
由于不能除以零，因此应抛出错误。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= actions.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= values.length <= 2 * 10<sup>4</sup></code><code> - 1</code></li>
|
||||
<li><code>actions[i] 是 "Calculator", "add", "subtract", "multiply", "divide", "power", 和 "getResult" 其中的元素</code></li>
|
||||
<li><code><font face="monospace">最后一个操作总是 "getResult"</font></code></li>
|
||||
<li><code><font face="monospace">values </font>是一个数字的 JSON 数组</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>给你一个三位数整数 <code>n</code> 。</p>
|
||||
|
||||
<p>如果经过以下修改得到的数字 <strong>恰好</strong> 包含数字 <code>1</code> 到 <code>9</code> 各一次且不包含任何 <code>0</code> ，那么我们称数字 <code>n</code> 是 <strong>迷人的</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>将 <code>n</code> 与数字 <code>2 * n</code> 和 <code>3 * n</code> <strong>连接</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>如果 <code>n</code> 是迷人的，返回 <code>true</code>，否则返回 <code>false</code> 。</p>
|
||||
|
||||
<p><strong>连接</strong> 两个数字表示把它们首尾相接连在一起。比方说 <code>121</code> 和 <code>371</code> 连接得到 <code>121371</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 192
|
||||
<b>输出：</b>true
|
||||
<b>解释：</b>我们将数字 n = 192 ，2 * n = 384 和 3 * n = 576 连接，得到 192384576 。这个数字包含 1 到 9 恰好各一次。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 100
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>我们将数字 n = 100 ，2 * n = 200 和 3 * n = 300 连接，得到 100200300 。这个数字不符合上述条件。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>100 <= n <= 999</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>给定一个对象或数组，判断它是否为空。</p>
|
||||
|
||||
<ul>
|
||||
<li>一个空对象不包含任何键值对。</li>
|
||||
<li>一个空数组不包含任何元素。</li>
|
||||
</ul>
|
||||
|
||||
<p>你可以假设对象或数组是通过 <code>JSON.parse</code> 解析得到的。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>obj = {"x": 5, "y": 42}
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>The object has 2 key-value pairs so it is not empty.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>obj = {}
|
||||
<b>输出：</b>true
|
||||
<b>解释：</b>The object doesn't have any key-value pairs so it is empty.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>obj = [null, false, 0]
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>The array has 3 elements so it is not empty.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li> <code>2 <= JSON.stringify(obj).length <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>你可以在 O(1) 时间复杂度内解决这个问题吗？</strong>
|
||||
@@ -0,0 +1,54 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的整数排列 <code>nums</code> 。</p>
|
||||
|
||||
<p>如果排列的第一个数字等于 <code>1</code> 且最后一个数字等于 <code>n</code> ，则称其为 <strong>半有序排列</strong> 。你可以执行多次下述操作，直到将 <code>nums</code> 变成一个 <strong>半有序排列</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择 <code>nums</code> 中相邻的两个元素，然后交换它们。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回使 <code>nums</code> 变成 <strong>半有序排列</strong> 所需的最小操作次数。</p>
|
||||
|
||||
<p><strong>排列</strong> 是一个长度为 <code>n</code> 的整数序列，其中包含从 <code>1</code> 到 <code>n</code> 的每个数字恰好一次。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,1,4,3]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>可以依次执行下述操作得到半有序排列：
|
||||
1 - 交换下标 0 和下标 1 对应元素。排列变为 [1,2,4,3] 。
|
||||
2 - 交换下标 2 和下标 3 对应元素。排列变为 [1,2,3,4] 。
|
||||
可以证明，要让 nums 成为半有序排列，不存在执行操作少于 2 次的方案。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,4,1,3]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：
|
||||
</strong>可以依次执行下述操作得到半有序排列：
|
||||
1 - 交换下标 1 和下标 2 对应元素。排列变为 [2,1,4,3] 。
|
||||
2 - 交换下标 0 和下标 1 对应元素。排列变为 [1,2,4,3] 。
|
||||
3 - 交换下标 2 和下标 3 对应元素。排列变为 [1,2,3,4] 。
|
||||
可以证明，要让 nums 成为半有序排列，不存在执行操作少于 3 次的方案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,3,4,2,5]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>这个排列已经是一个半有序排列，无需执行任何操作。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length == n <= 50</code></li>
|
||||
<li><code>1 <= nums[i] <= 50</code></li>
|
||||
<li><code>nums</code> 是一个 <strong>排列</strong></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,62 @@
|
||||
<p>给定一个异步函数数组 <code>functions</code>，返回一个新的 promise 对象 <code>promise</code>。数组中的每个函数都不接受参数并返回一个 promise。</p>
|
||||
|
||||
<p><code>promise</code> resolve 条件：</p>
|
||||
|
||||
<ul>
|
||||
<li>当所有从 <code>functions</code> 返回的 promise 都成功解析时。<code>promise</code> 的解析值应该是一个按照它们在 <code>functions</code> 中的顺序排列的 promise 的解析值数组。</li>
|
||||
</ul>
|
||||
|
||||
<p><code>promise</code> reject 条件：</p>
|
||||
|
||||
<ul>
|
||||
<li>当任何从 <code>functions</code> 返回的 promise 被拒绝时。<code>promise</code> 也会被拒绝，并返回第一个拒绝的原因。</li>
|
||||
</ul>
|
||||
|
||||
<p>请在不使用内置的 <code>Promise.all</code> 函数的情况下解决。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>functions = [
|
||||
() => new Promise(resolve => setTimeout(() => resolve(5), 200))
|
||||
]
|
||||
<b>输出：</b>{"t": 200, "resolved": [5]}
|
||||
<b>解释：</b>
|
||||
promiseAll(functions).then(console.log); // [5]
|
||||
|
||||
单个函数在 200 毫秒后以值 5 成功解析。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>functions = [
|
||||
() => new Promise(resolve => setTimeout(() => resolve(1), 200)),
|
||||
() => new Promise((resolve, reject) => setTimeout(() => reject("Error"), 100))
|
||||
]
|
||||
<b>输出：</b>{"t": 100, "rejected": "Error"}
|
||||
<b>解释：</b>由于其中一个 promise 被拒绝，返回的 promise 也在同一时间被拒绝并返回相同的错误。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>functions = [
|
||||
() => new Promise(resolve => setTimeout(() => resolve(4), 50)),
|
||||
() => new Promise(resolve => setTimeout(() => resolve(10), 150)),
|
||||
() => new Promise(resolve => setTimeout(() => resolve(16), 100))
|
||||
]
|
||||
<b>输出：</b>{"t": 150, "resolved": [4, 10, 16]}
|
||||
<b>解释：</b>所有的 promise 都成功执行。当最后一个 promise 被解析时，返回的 promise 也被解析了。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>functions is an array of functions that returns promises</code></li>
|
||||
<li><code>1 <= functions.length <= 10</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>现给定一个函数 <code>fn</code> ，一个参数数组 <code>args</code> 和一个以毫秒为单位的超时时间 <code>t</code> ，返回一个取消函数 <code>cancelFn</code> 。</p>
|
||||
|
||||
<p>在经过 <code>t</code> 毫秒的延迟后，<strong>除非</strong> 先调用 <code>cancelFn</code> ，否则 <code>fn</code> 应该以 <code>args</code> 作为参数被调用。并且在这种情况下，<code>fn</code> 不应该被调用。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x) => x * 5, args = [2], t = 20, cancelTime = 50
|
||||
<b>输出：</b>[{"time": 20, "returned": 10}]
|
||||
<b>解释：</b>
|
||||
const cancel = cancellable(fn, [2], 20); // // 在 t=20ms 时调用 fn(2)
|
||||
setTimeout(cancel, 50);
|
||||
|
||||
cancelTime（50ms）在延迟时间（20ms）之后，所以 fn(2) 应该在 t=20ms 时调用。fn 的返回值是 10。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x) => x**2, args = [2], t = 100, cancelTime = 50
|
||||
<b>输出：</b>[]
|
||||
<b>解释：</b>fn(2) 从未被调用，因为 cancelTime（50ms）在延迟时间（100ms）之前。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x1, x2) => x1 * x2, args = [2,4], t = 30, cancelTime = 100
|
||||
<b>输出：</b>[{"time": 30, "returned": 8}]
|
||||
<b>解释：</b>fn(2) 从未被调用，因为 cancelTime（50ms）在延迟时间（100ms）之前。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>fn 是一个函数</code></li>
|
||||
<li><code>args 是一个有效的 JSON 数组</code></li>
|
||||
<li><code>1 <= args.length <= 10</code></li>
|
||||
<li><code><font face="monospace">20 <= t <= 1000</font></code></li>
|
||||
<li><code><font face="monospace">10 <= cancelT <= 1000</font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>给你一个仅由小写英文字母组成的字符串 <code>s</code> 。在一步操作中，你可以完成以下行为：</p>
|
||||
|
||||
<ul>
|
||||
<li>选则 <code>s</code> 的任一非空子字符串，可能是整个字符串，接着将字符串中的每一个字符替换为英文字母表中的前一个字符。例如，'b' 用 'a' 替换，'a' 用 'z' 替换。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回执行上述操作 <strong>恰好一次</strong> 后可以获得的 <strong>字典序最小</strong> 的字符串。</p>
|
||||
|
||||
<p><strong>子字符串</strong> 是字符串中的一个连续字符序列。</p>
|
||||
现有长度相同的两个字符串 <code>x</code> 和 字符串 <code>y</code> ，在满足 <code>x[i] != y[i]</code> 的第一个位置 <code>i</code> 上，如果 <code>x[i]</code> 在字母表中先于 <code>y[i]</code> 出现，则认为字符串 <code>x</code> 比字符串 <code>y</code> <strong>字典序更小</strong> 。
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "cbabc"
|
||||
<strong>输出：</strong>"baabc"
|
||||
<strong>解释：</strong>我们选择从下标 0 开始、到下标 1 结束的子字符串执行操作。
|
||||
可以证明最终得到的字符串是字典序最小的。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "acbbc"
|
||||
<strong>输出：</strong>"abaab"
|
||||
<strong>解释：</strong>我们选择从下标 1 开始、到下标 4 结束的子字符串执行操作。
|
||||
可以证明最终得到的字符串是字典序最小的。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "leetcode"
|
||||
<strong>输出：</strong>"kddsbncd"
|
||||
<strong>解释：</strong>我们选择整个字符串执行操作。
|
||||
可以证明最终得到的字符串是字典序最小的。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 3 * 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串 <code>s</code> ，这个字符串只包含 <code>0</code> 到 <code>9</code> 的数字字符。</p>
|
||||
|
||||
<p>如果一个字符串 <code>t</code> 中至多有一对相邻字符是相等的，那么称这个字符串是 <strong>半重复的</strong> 。</p>
|
||||
|
||||
<p>请你返回 <code>s</code> 中最长 <strong>半重复</strong> 子字符串的长度。</p>
|
||||
|
||||
<p>一个 <strong>子字符串</strong> 是一个字符串中一段连续 <strong>非空</strong> 的字符。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "52233"
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b>最长半重复子字符串是 "5223" ，子字符串从 i = 0 开始，在 j = 3 处结束。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "5494"
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b>s 就是一个半重复字符串，所以答案为 4 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "1111111"
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>最长半重复子字符串是 "11" ，子字符串从 i = 0 开始，在 j = 1 处结束。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 50</code></li>
|
||||
<li><code>'0' <= s[i] <= '9'</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始大小为 <code>m x n</code> 的二进制矩阵 <code>grid</code> 。</p>
|
||||
|
||||
<p>从原矩阵中选出若干行构成一个行的 <strong>非空 </strong>子集，如果子集中任何一列的和至多为子集大小的一半，那么我们称这个子集是 <strong>好子集</strong>。</p>
|
||||
|
||||
<p>更正式的，如果选出来的行子集大小（即行的数量）为 k，那么每一列的和至多为 <code>floor(k / 2)</code> 。</p>
|
||||
|
||||
<p>请你返回一个整数数组，它包含好子集的行下标，请你将子集中的元素 <b>升序</b> 返回。</p>
|
||||
|
||||
<p>如果有多个好子集，你可以返回任意一个。如果没有好子集，请你返回一个空数组。</p>
|
||||
|
||||
<p>一个矩阵 <code>grid</code> 的行 <strong>子集</strong> ，是删除 <code>grid</code> 中某些（也可能不删除）行后，剩余行构成的元素集合。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[0,1,1,0],[0,0,0,1],[1,1,1,1]]
|
||||
<b>输出：</b>[0,1]
|
||||
<b>解释：</b>我们可以选择第 0 和第 1 行构成一个好子集。
|
||||
选出来的子集大小为 2 。
|
||||
- 第 0 列的和为 0 + 0 = 0 ，小于等于子集大小的一半。
|
||||
- 第 1 列的和为 1 + 0 = 1 ，小于等于子集大小的一半。
|
||||
- 第 2 列的和为 1 + 0 = 1 ，小于等于子集大小的一半。
|
||||
- 第 3 列的和为 0 + 1 = 1 ，小于等于子集大小的一半。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[0]]
|
||||
<b>输出：</b>[0]
|
||||
<strong>解释：</strong>我们可以选择第 0 行构成一个好子集。
|
||||
选出来的子集大小为 1 。
|
||||
- 第 0 列的和为 0 ，小于等于子集大小的一半。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[1,1,1],[1,1,1]]
|
||||
<b>输出：</b>[]
|
||||
<b>解释：</b>没有办法得到一个好子集。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= n <= 5</code></li>
|
||||
<li><code>grid[i][j]</code> 要么是 <code>0</code> ，要么是 <code>1</code> 。</li>
|
||||
</ul>
|
||||
39
leetcode-cn/problem (Chinese)/排序方式 [sort-by].html
Normal file
39
leetcode-cn/problem (Chinese)/排序方式 [sort-by].html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>给定一个数组 <code>arr</code> 和一个函数 <code>fn</code>，返回一个排序后的数组 <code>sortedArr</code>。你可以假设 <code>fn</code> 只返回数字，并且这些数字决定了 <code>sortedArr</code> 的排序顺序。<code>sortedArr</code> 必须按照 <code>fn</code> 的输出值 <strong>升序</strong> 排序。</p>
|
||||
|
||||
<p>你可以假设对于给定的数组，<code>fn</code> 不会返回重复的数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>arr = [5, 4, 1, 2, 3], fn = (x) => x
|
||||
<b>输出：</b>[1, 2, 3, 4, 5]
|
||||
<b>解释：</b>fn 只是返回传入的数字，因此数组按升序排序。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>arr = [{"x": 1}, {"x": 0}, {"x": -1}], fn = (d) => d.x
|
||||
<b>输出：</b>[{"x": -1}, {"x": 0}, {"x": 1}]
|
||||
<b>解释：</b>fn 返回 "x" 键的值，因此数组根据该值排序。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>arr = [[3, 4], [5, 2], [10, 1]], fn = (x) => x[1]
|
||||
<b>输出：</b>[[10, 1], [5, 2], [3, 4]]
|
||||
<b>解释：</b>数组按照索引为 1 处的数字升序排序。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>arr 是一个有效的 JSON 数组</code></li>
|
||||
<li><code>fn 是一个函数，返回一个数字</code></li>
|
||||
<li><code>1 <= arr.length <= 5 * 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>给你一个长度为 <code>n</code> 、下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，表示收集不同巧克力的成本。每个巧克力都对应一个不同的类型，最初，位于下标 <code>i</code> 的巧克力就对应第 <code>i</code> 个类型。</p>
|
||||
|
||||
<p>在一步操作中，你可以用成本 <code>x</code> 执行下述行为：</p>
|
||||
|
||||
<ul>
|
||||
<li>同时修改所有巧克力的类型，将巧克力的类型 <code>i<sup>th</sup></code> 修改为类型 <code>((i + 1) mod n)<sup>th</sup></code>。</li>
|
||||
</ul>
|
||||
|
||||
<p>假设你可以执行任意次操作，请返回收集所有类型巧克力所需的最小成本。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [20,1,15], x = 5
|
||||
<strong>输出：</strong>13
|
||||
<strong>解释：</strong>最开始，巧克力的类型分别是 [0,1,2] 。我们可以用成本 1 购买第 1 个类型的巧克力。
|
||||
接着，我们用成本 5 执行一次操作，巧克力的类型变更为 [1,2,0] 。我们可以用成本 1 购买第 2 个类型的巧克力。
|
||||
然后，我们用成本 5 执行一次操作，巧克力的类型变更为 [2,0,1] 。我们可以用成本 1 购买第 0 个类型的巧克力。
|
||||
因此，收集所有类型的巧克力需要的总成本是 (1 + 5 + 1 + 5 + 1) = 13 。可以证明这是一种最优方案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3], x = 4
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>我们将会按最初的成本收集全部三个类型的巧克力，而不需执行任何操作。因此，收集所有类型的巧克力需要的总成本是 1 + 2 + 3 = 6 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= x <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>给你一个整数数组 <code>nums</code> ，数组由 <strong>不同正整数</strong> 组成，请你找出并返回数组中 <strong>任一</strong> 既不是 <strong>最小值</strong> 也不是 <strong>最大值</strong> 的数字，如果不存在这样的数字，返回 <strong><code>-1</code></strong> 。</p>
|
||||
|
||||
<p>返回所选整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [3,2,1,4]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>在这个示例中，最小值是 1 ，最大值是 4 。因此，2 或 3 都是有效答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [1,2]
|
||||
<strong>输出：</strong>-1
|
||||
<strong>解释：</strong>由于不存在既不是最大值也不是最小值的数字，我们无法选出满足题目给定条件的数字。因此，不存在答案，返回 -1 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [2,1,3]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>2 既不是最小值，也不是最大值，这个示例只有这一个有效答案。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 100</code></li>
|
||||
<li><code>nums</code> 中的所有数字互不相同</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>给你两个长度为 <code>n</code> 、下标从 <strong>0</strong> 开始的整数数组 <code>nums1</code> 和 <code>nums2</code> ，另给你一个下标从 <strong>1</strong> 开始的二维数组 <code>queries</code> ，其中 <code>queries[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> 。</p>
|
||||
|
||||
<p>对于第 <code>i</code> 个查询，在所有满足 <code>nums1[j] >= x<sub>i</sub></code> 且 <code>nums2[j] >= y<sub>i</sub></code> 的下标 <code>j</code> <code>(0 <= j < n)</code> 中，找出 <code>nums1[j] + nums2[j]</code> 的 <strong>最大值</strong> ，如果不存在满足条件的 <code>j</code> 则返回 <strong>-1</strong> 。</p>
|
||||
|
||||
<p>返回数组<em> </em><code>answer</code><em> ，</em>其中<em> </em><code>answer[i]</code><em> </em>是第 <code>i</code> 个查询的答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
|
||||
<strong>输出：</strong>[6,10,7]
|
||||
<strong>解释：</strong>
|
||||
对于第 1 个查询：<code>x<sub>i</sub> = 4</code> 且 <code>y<sub>i</sub> = 1</code> ，可以选择下标 <code>j = 0</code> ，此时 <code>nums1[j] >= 4</code> 且 <code>nums2[j] >= 1</code> 。<code>nums1[j] + nums2[j]</code> 等于 6 ，可以证明 6 是可以获得的最大值。
|
||||
对于第 2 个查询：<code>x<sub>i</sub> = 1</code> 且 <code>y<sub>i</sub> = 3</code> ，可以选择下标 <code>j = 2</code> ，此时 <code>nums1[j] >= 1</code> 且 <code>nums2[j] >= 3</code> 。<code>nums1[j] + nums2[j]</code> 等于 10 ，可以证明 10 是可以获得的最大值。
|
||||
对于第 3 个查询：<code>x<sub>i</sub> = 2</code> 且 <code>y<sub>i</sub> = 5</code> ，可以选择下标 <code>j = 3</code> ，此时 <code>nums1[j] >= 2</code> 且 <code>nums2[j] >= 5</code> 。<code>nums1[j] + nums2[j]</code> 等于 7 ，可以证明 7 是可以获得的最大值。
|
||||
因此，我们返回 <code>[6,10,7]</code> 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
|
||||
<strong>输出：</strong>[9,9,9]
|
||||
<strong>解释：</strong>对于这个示例，我们可以选择下标 <code>j = 2</code> ，该下标可以满足每个查询的限制。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
|
||||
<strong>输出：</strong>[-1]
|
||||
<strong>解释：</strong>示例中的查询 <code>x<sub>i</sub></code> = 3 且 <code>y<sub>i</sub></code> = 3 。对于每个下标 j ，都只满足 nums1[j] < <code>x<sub>i</sub></code> 或者 nums2[j] < <code>y<sub>i</sub></code> 。因此，不存在答案。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>nums1.length == nums2.length</code> </li>
|
||||
<li><code>n == nums1.length </code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= 10<sup>9</sup> </code></li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>queries[i].length == 2</code></li>
|
||||
<li><code>x<sub>i</sub> == queries[i][1]</code></li>
|
||||
<li><code>y<sub>i</sub> == queries[i][2]</code></li>
|
||||
<li><code>1 <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串 <code>s</code> ，重复执行下述操作 <strong>任意</strong> 次：</p>
|
||||
|
||||
<ul>
|
||||
<li>在字符串中选出一个下标 <code>i</code> ，并使 <code>c</code> 为字符串下标 <code>i</code> 处的字符。并在 <code>i</code> <strong>左侧</strong>（如果有）和 <strong>右侧</strong>（如果有）各 <strong>删除 </strong>一个距离 <code>i</code> <strong>最近</strong> 的字符 <code>c</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你通过执行上述操作任意次，使 <code>s</code> 的长度 <strong>最小化</strong> 。</p>
|
||||
|
||||
<p>返回一个表示 <strong>最小化</strong> 字符串的长度的整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "aaabc"
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>在这个示例中，s 等于 "aaabc" 。我们可以选择位于下标 1 处的字符 'a' 开始。接着删除下标 1 左侧最近的那个 'a'（位于下标 0）以及下标 1 右侧最近的那个 'a'（位于下标 2）。执行操作后，字符串变为 "abc" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 3 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "cbbd"
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>我们可以选择位于下标 1 处的字符 'b' 开始。下标 1 左侧不存在字符 'b' ，但右侧存在一个字符 'b'（位于下标 2），所以会删除位于下标 2 的字符 'b' 。执行操作后，字符串变为 "cbd" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 3 。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "dddaaa"
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>我们可以选择位于下标 1 处的字符 'd' 开始。接着删除下标 1 左侧最近的那个 'd'（位于下标 0）以及下标 1 右侧最近的那个 'd'（位于下标 2）。执行操作后，字符串变为 "daaa" 。继续对新字符串执行操作，可以选择位于下标 2 的字符 'a' 。接着删除下标 2 左侧最近的那个 'a'（位于下标 1）以及下标 2 右侧最近的那个 'a'（位于下标 3）。执行操作后，字符串变为 "da" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 2 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>给你一个整数 <code>n</code> 和一个下标从 <strong>0</strong> 开始的 <strong>二维数组</strong> <code>queries</code> ，其中 <code>queries[i] = [type<sub>i</sub>, index<sub>i</sub>, val<sub>i</sub>]</code> 。</p>
|
||||
|
||||
<p>一开始，给你一个下标从 <strong>0</strong> 开始的 <code>n x n</code> 矩阵，所有元素均为 <code>0</code> 。每一个查询，你需要执行以下操作之一：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果 <code>type<sub>i</sub> == 0</code> ，将第 <code>index<sub>i</sub></code> 行的元素全部修改为 <code>val<sub>i</sub></code> ，覆盖任何之前的值。</li>
|
||||
<li>如果 <code>type<sub>i</sub> == 1</code> ，将第 <code>index<sub>i</sub></code> 列的元素全部修改为 <code>val<sub>i</sub></code> ，覆盖任何之前的值。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你执行完所有查询以后，返回矩阵中所有整数的和。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/05/11/exm1.png" style="width: 681px; height: 161px;"></p>
|
||||
|
||||
<pre><b>输入：</b>n = 3, queries = [[0,0,1],[1,2,2],[0,2,3],[1,0,4]]
|
||||
<b>输出：</b>23
|
||||
<b>解释：</b>上图展示了每个查询以后矩阵的值。所有操作执行完以后，矩阵元素之和为 23 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/05/11/exm2.png" style="width: 681px; height: 331px;"></p>
|
||||
|
||||
<pre><b>输入：</b>n = 3, queries = [[0,0,4],[0,1,2],[1,0,1],[0,2,3],[1,2,1]]
|
||||
<b>输出：</b>17
|
||||
<b>解释：</b>上图展示了每一个查询操作之后的矩阵。所有操作执行完以后，矩阵元素之和为 17 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= queries.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>queries[i].length == 3</code></li>
|
||||
<li><code>0 <= type<sub>i</sub> <= 1</code></li>
|
||||
<li><code>0 <= index<sub>i</sub> < n</code></li>
|
||||
<li><code>0 <= val<sub>i</sub> <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,79 @@
|
||||
<p>现给定两个数组 <code>arr1</code> 和 <code>arr2</code> ，返回一个新的数组 <code>joinedArray</code> 。两个输入数组中的每个对象都包含一个 <code>id</code> 字段。<code>joinedArray</code> 是一个通过 <code>id</code> 将 <code>arr1</code> 和 <code>arr2</code> 连接而成的数组。<code>joinedArray</code> 的长度应为唯一值 <code>id</code> 的长度。返回的数组应按 <code>id</code> <strong>升序</strong> 排序。</p>
|
||||
|
||||
<p>如果一个 <code>id</code> 存在于一个数组中但不存在于另一个数组中，则该对象应包含在结果数组中且不进行修改。</p>
|
||||
|
||||
<p>如果两个对象共享一个 <code>id</code> ，则它们的属性应进行合并：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果一个键只存在于一个对象中，则该键值对应该包含在对象中。</li>
|
||||
<li>如果一个键在两个对象中都包含，则 <code>arr2</code> 中的值应覆盖 <code>arr1</code> 中的值。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
arr1 = [
|
||||
{"id": 1, "x": 1},
|
||||
{"id": 2, "x": 9}
|
||||
],
|
||||
arr2 = [
|
||||
{"id": 3, "x": 5}
|
||||
]
|
||||
<b>输出：</b>
|
||||
[
|
||||
{"id": 1, "x": 1},
|
||||
{"id": 2, "x": 9},
|
||||
{"id": 3, "x": 5}
|
||||
]
|
||||
<b>解释：</b>没有共同的 id，因此将 arr1 与 arr2 简单地连接起来。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
arr1 = [
|
||||
{"id": 1, "x": 2, "y": 3},
|
||||
{"id": 2, "x": 3, "y": 6}
|
||||
],
|
||||
arr2 = [
|
||||
{"id": 2, "x": 10, "y": 20},
|
||||
{"id": 3, "x": 0, "y": 0}
|
||||
]
|
||||
<b>输出：</b>
|
||||
[
|
||||
{"id": 1, "x": 2, "y": 3},
|
||||
{"id": 2, "x": 10, "y": 20},
|
||||
{"id": 3, "x": 0, "y": 0}
|
||||
]
|
||||
<b>解释：</b>id 为 1 和 id 为 3 的对象在结果数组中保持不变。id 为 2 的两个对象合并在一起。arr2 中的键覆盖 arr1 中的值。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
arr1 = [
|
||||
{"id": 1, "b": {"b": 94},"v": [4, 3], "y": 48}
|
||||
]
|
||||
arr2 = [
|
||||
{"id": 1, "b": {"c": 84}, "v": [1, 3]}
|
||||
]
|
||||
<strong>输出：</strong> [
|
||||
{"id": 1, "b": {"c": 84}, "v": [1, 3], "y": 48}
|
||||
]
|
||||
<b>解释：</b>具有 id 为 1 的对象合并在一起。对于键 "b" 和 "v" ，使用 arr2 中的值。由于键 "y" 只存在于 arr1 中，因此取 arr1 的值。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>arr1 和 arr2 都是有效的 JSON 数组</code></li>
|
||||
<li><code>在 arr1 和 arr2 中都有唯一的键值 id</code></li>
|
||||
<li><code>2 <= JSON.stringify(arr1).length <= 10<sup>6</sup></code></li>
|
||||
<li><code>2 <= JSON.stringify(arr2).length <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
给定两个 promise 对象 <code>promise1</code> 和 <code>promise2</code>，返回一个新的 promise。<code>promise1</code> 和 <code>promise2</code> 都会被解析为一个数字。返回的 Promise 应该解析为这两个数字的和。
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20)),
|
||||
promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60))
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>两个输入的 Promise 分别解析为值 2 和 5。返回的 Promise 应该解析为 2 + 5 = 7。返回的 Promise 解析的时间不作为判断条件。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50)),
|
||||
promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30))
|
||||
<b>输出：</b>-2
|
||||
<b>解释：</b>两个输入的 Promise 分别解析为值 10 和 -12。返回的 Promise 应该解析为 10 + -12 = -2。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>promise1 和 promise2 都是被解析为一个数字的 promise 对象</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,67 @@
|
||||
<p>有一些机器人分布在一条无限长的数轴上，他们初始坐标用一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> 表示。当你给机器人下达命令时，它们以每秒钟一单位的速度开始移动。</p>
|
||||
|
||||
<p>给你一个字符串 <code>s</code> ，每个字符按顺序分别表示每个机器人移动的方向。<code>'L'</code> 表示机器人往左或者数轴的负方向移动，<code>'R'</code> 表示机器人往右或者数轴的正方向移动。</p>
|
||||
|
||||
<p>当两个机器人相撞时，它们开始沿着原本相反的方向移动。</p>
|
||||
|
||||
<p>请你返回指令重复执行 <code>d</code> 秒后，所有机器人之间两两距离之和。由于答案可能很大，请你将答案对 <code>10<sup>9</sup> + 7</code> 取余后返回。</p>
|
||||
|
||||
<p><b>注意：</b></p>
|
||||
|
||||
<ul>
|
||||
<li>对于坐标在 <code>i</code> 和 <code>j</code> 的两个机器人，<code>(i,j)</code> 和 <code>(j,i)</code> 视为相同的坐标对。也就是说，机器人视为无差别的。</li>
|
||||
<li>当机器人相撞时，它们 <strong>立即改变</strong> 它们的前进时间，这个过程不消耗任何时间。</li>
|
||||
<li>
|
||||
<p>当两个机器人在同一时刻占据相同的位置时，就会相撞。</p>
|
||||
|
||||
<ul>
|
||||
<li>
|
||||
<p>例如，如果一个机器人位于位置 0 并往右移动，另一个机器人位于位置 2 并往左移动，下一秒，它们都将占据位置 1，并改变方向。再下一秒钟后，第一个机器人位于位置 0 并往左移动，而另一个机器人位于位置 2 并往右移动。</p>
|
||||
</li>
|
||||
<li>
|
||||
<p>例如，如果一个机器人位于位置 0 并往右移动，另一个机器人位于位置 1 并往左移动，下一秒，第一个机器人位于位置 0 并往左行驶，而另一个机器人位于位置 1 并往右移动。</p>
|
||||
</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [-2,0,2], s = "RLL", d = 3
|
||||
<b>输出：</b>8
|
||||
<b>解释：</b>
|
||||
1 秒后，机器人的位置为 [-1,-1,1] 。现在下标为 0 的机器人开始往左移动，下标为 1 的机器人开始往右移动。
|
||||
2 秒后，机器人的位置为 [-2,0,0] 。现在下标为 1 的机器人开始往左移动，下标为 2 的机器人开始往右移动。
|
||||
3 秒后，机器人的位置为 [-3,-1,1] 。
|
||||
下标为 0 和 1 的机器人之间距离为 abs(-3 - (-1)) = 2 。
|
||||
下标为 0 和 2 的机器人之间的距离为 abs(-3 - 1) = 4 。
|
||||
下标为 1 和 2 的机器人之间的距离为 abs(-1 - 1) = 2 。
|
||||
所有机器人对之间的总距离为 2 + 4 + 2 = 8 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,0], s = "RL", d = 2
|
||||
<b>输出：</b>5
|
||||
<b>解释：</b>
|
||||
1 秒后，机器人的位置为 [2,-1] 。
|
||||
2 秒后，机器人的位置为 [3,-2] 。
|
||||
两个机器人的距离为 abs(-2 - 3) = 5 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-2 * 10<sup>9</sup> <= nums[i] <= 2 * 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= d <= 10<sup>9</sup></code></li>
|
||||
<li><code>nums.length == s.length </code></li>
|
||||
<li><code>s</code> 只包含 <code>'L'</code> 和 <code>'R'</code> 。</li>
|
||||
<li><code>nums[i]</code> 互不相同。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>给你两个数字字符串 <code>num1</code> 和 <code>num2</code> ，以及两个整数 <code>max_sum</code> 和 <code>min_sum</code> 。如果一个整数 <code>x</code> 满足以下条件，我们称它是一个好整数：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>num1 <= x <= num2</code></li>
|
||||
<li><code>min_sum <= digit_sum(x) <= max_sum</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回好整数的数目。答案可能很大，请返回答案对 <code>10<sup>9</sup> + 7</code> 取余后的结果。</p>
|
||||
|
||||
<p>注意，<code>digit_sum(x)</code> 表示 <code>x</code> 各位数字之和。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>num1 = "1", num2 = "12", min_num = 1, max_num = 8
|
||||
<b>输出：</b>11
|
||||
<b>解释：</b>总共有 11 个整数的数位和在 1 到 8 之间，分别是 1,2,3,4,5,6,7,8,10,11 和 12 。所以我们返回 11 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>num1 = "1", num2 = "5", min_num = 1, max_num = 5
|
||||
<b>输出：</b>5
|
||||
<b>解释：</b>数位和在 1 到 5 之间的 5 个整数分别为 1,2,3,4 和 5 。所以我们返回 5 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num1 <= num2 <= 10<sup>22</sup></code></li>
|
||||
<li><code>1 <= min_sum <= max_sum <= 400</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,79 @@
|
||||
现给定一个函数 <code>fn</code>，一个参数数组 <code>args</code> 和一个时间间隔 <code>t</code>，返回一个取消函数 <code>cancelFn</code>。函数 <code>fn</code> 应该立即使用 <code>args</code> 调用，并且在每个 <code>t</code> 毫秒内再次调用，直到调用 <code>cancelFn</code>。
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x) => x * 2, args = [4], t = 20, cancelT = 110
|
||||
<b>输出：</b>
|
||||
[
|
||||
{"time": 0, "returned": 8},
|
||||
{"time": 20, "returned": 8},
|
||||
{"time": 40, "returned": 8},
|
||||
{"time": 60, "returned": 8},
|
||||
{"time": 80, "returned": 8},
|
||||
{"time": 100, "returned": 8}
|
||||
]
|
||||
<strong>解释：</strong> 每隔 20ms，调用 fn(4)。直到 t=110ms，然后取消。
|
||||
const cancel = cancellable(x => x * 2, [4], 20);
|
||||
setTimeout(cancel, 110);
|
||||
第一次调用 fn 是在 0ms。fn(4) 返回 8。
|
||||
第二次调用 fn 是在 20ms。fn(4) 返回 8。
|
||||
第三次调用 fn 是在 40ms。fn(4) 返回 8。
|
||||
第四次调用 fn 是在 60ms。fn(4) 返回 8。
|
||||
第五次调用 fn 是在 80ms。fn(4) 返回 8。
|
||||
第六次调用 fn 是在 100ms。fn(4) 返回 8。</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x1, x2) => (x1 * x2), args = [2, 5], t = 25, cancelT = 140
|
||||
<strong>输出：</strong>
|
||||
[
|
||||
{"time": 0, "returned": 10},
|
||||
{"time": 25, "returned": 10},
|
||||
{"time": 50, "returned": 10},
|
||||
{"time": 75, "returned": 10},
|
||||
{"time": 100, "returned": 10},
|
||||
{"time": 125, "returned": 10}
|
||||
]
|
||||
<strong>解释：</strong>每隔 25ms，调用 fn(2, 5)。直到 t=140ms，然后取消。
|
||||
第一次调用 fn 是在 0ms
|
||||
第二次调用 fn 是在 25ms
|
||||
第三次调用 fn 是在 50ms
|
||||
第四次调用 fn 是在 75ms
|
||||
第五次调用 fn 是在 100ms
|
||||
第六次调用 fn 是在 125ms
|
||||
在 140ms 取消
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x1, x2, x3) => (x1 + x2 + x3), args = [5, 1, 3], t = 50, cancelT = 180
|
||||
<b>输出：</b>
|
||||
[
|
||||
{"time": 0, "returned": 9},
|
||||
{"time": 50, "returned": 9},
|
||||
{"time": 100, "returned": 9},
|
||||
{"time": 150, "returned": 9}
|
||||
]
|
||||
<b>解释：</b>每隔 50ms，调用 fn(5, 1, 3)。直到 t=180ms，然后取消。
|
||||
第一次调用 fn 是在 0ms
|
||||
第二次调用 fn 是在 50ms
|
||||
第三次调用 fn 是在 100ms
|
||||
第四次调用 fn 是在 150ms
|
||||
在 180ms 取消
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>fn 是一个函数</code></li>
|
||||
<li><code>args 是一个有效的 JSON 数组</code></li>
|
||||
<li><code>1 <= args.length <= 10</code></li>
|
||||
<li><code><font face="monospace">20 <= t <= 1000</font></code></li>
|
||||
<li><code><font face="monospace">10 <= cancelT <= 1000</font></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user