task_id stringlengths 33 83 | url stringlengths 44 94 | title stringlengths 14 64 | meta dict | prompt stringlengths 399 2.26k | prompt_sft stringlengths 424 2.29k | test stringlengths 8.25k 44.9k | start_time int64 1.69B 1.71B |
|---|---|---|---|---|---|---|---|
biweekly-contest-114-minimum-operations-to-collect-elements | https://leetcode.com/problems/minimum-operations-to-collect-elements | minimum-operations-to-collect-elements | {
"questionId": "3044",
"questionFrontendId": "2869",
"title": "Minimum Operations to Collect Elements",
"titleSlug": "minimum-operations-to-collect-elements",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 130,
"dislikes": 10,
"categoryTitle": "Algorithms"
} | """
给你一个正整数数组 nums 和一个整数 k 。
一次操作中，你可以将数组的最后一个元素删除，将该元素添加到一个集合中。
请你返回收集元素 1, 2, ..., k 需要的 最少操作次数 。
示例 1：
输入：nums = [3,1,5,4,2], k = 2
输出：4
解释：4 次操作后，集合中的元素依次添加了 2 ，4 ，5 和 1 。此时集合中包含元素 1 和 2 ，所以答案为 4 。
示例 2：
输入：nums = [3,1,5,4,2], k = 5
输出：5
解释：5 次操作后，集合中的元素依次添加了 2 ，4 ，5 ，1 和 3 。此时集合中包含元素 1 到 5 ，所以答案为 5 。
示例 3：
... | 给你一个正整数数组 nums 和一个整数 k 。
一次操作中，你可以将数组的最后一个元素删除，将该元素添加到一个集合中。
请你返回收集元素 1, 2, ..., k 需要的 最少操作次数 。
示例 1：
输入：nums = [3,1,5,4,2], k = 2
输出：4
解释：4 次操作后，集合中的元素依次添加了 2 ，4 ，5 和 1 。此时集合中包含元素 1 和 2 ，所以答案为 4 。
示例 2：
输入：nums = [3,1,5,4,2], k = 5
输出：5
解释：5 次操作后，集合中的元素依次添加了 2 ，4 ，5 ，1 和 3 。此时集合中包含元素 1 到 5 ，所以答案为 5 。
示例 3：
输入：... |
my_solution = Solution()
test_input = { "nums": [3,1,5,4,2], "k": 2 }
assert my_solution.minOperations(**test_input) == 4
test_input = { "nums": [3,1,5,4,2], "k": 5 }
assert my_solution.minOperations(**test_input) == 5
test_input = { "nums": [3,2,5,3,1], "k": 3 }
assert my_solution.minOperations(**test_input) == 4
... | 1,696,084,200 |
biweekly-contest-114-minimum-number-of-operations-to-make-array-empty | https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty | minimum-number-of-operations-to-make-array-empty | {
"questionId": "3094",
"questionFrontendId": "2870",
"title": "Minimum Number of Operations to Make Array Empty",
"titleSlug": "minimum-number-of-operations-to-make-array-empty",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 147,
"dislikes": 5,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的正整数数组 nums 。
你可以对数组执行以下两种操作 任意次 ：
* 从数组中选择 两个 值 相等 的元素，并将它们从数组中 删除 。
* 从数组中选择 三个 值 相等 的元素，并将它们从数组中 删除 。
请你返回使数组为空的 最少 操作次数，如果无法达成，请返回 -1 。
示例 1：
输入：nums = [2,3,3,2,2,4,2,3,4]
输出：4
解释：我们可以执行以下操作使数组为空：
- 对下标为 0 和 3 的元素执行第一种操作，得到 nums = [3,3,2,4,2,3,4] 。
- 对下标为 2 和 4 的元素执行第一种操作，得到 nums = [3,3,4,3,4... | 给你一个下标从 0 开始的正整数数组 nums 。
你可以对数组执行以下两种操作 任意次 ：
* 从数组中选择 两个 值 相等 的元素，并将它们从数组中 删除 。
* 从数组中选择 三个 值 相等 的元素，并将它们从数组中 删除 。
请你返回使数组为空的 最少 操作次数，如果无法达成，请返回 -1 。
示例 1：
输入：nums = [2,3,3,2,2,4,2,3,4]
输出：4
解释：我们可以执行以下操作使数组为空：
- 对下标为 0 和 3 的元素执行第一种操作，得到 nums = [3,3,2,4,2,3,4] 。
- 对下标为 2 和 4 的元素执行第一种操作，得到 nums = [3,3,4,3,4] 。
... |
my_solution = Solution()
test_input = { "nums": [2,3,3,2,2,4,2,3,4] }
assert my_solution.minOperations(**test_input) == 4
test_input = { "nums": [2,1,2,2,3,3] }
assert my_solution.minOperations(**test_input) == -1
test_input = { "nums": [3,3] }
assert my_solution.minOperations(**test_input) == 1
test_input = { "nu... | 1,696,084,200 |
biweekly-contest-114-split-array-into-maximum-number-of-subarrays | https://leetcode.com/problems/split-array-into-maximum-number-of-subarrays | split-array-into-maximum-number-of-subarrays | {
"questionId": "3080",
"questionFrontendId": "2871",
"title": "Split Array Into Maximum Number of Subarrays",
"titleSlug": "split-array-into-maximum-number-of-subarrays",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 188,
"dislikes": 24,
"categoryTitle": "Algorithms"
} | """
给你一个只包含 非负 整数的数组 nums 。
我们定义满足 l <= r 的子数组 nums[l..r] 的分数为 nums[l] AND nums[l + 1] AND ... AND nums[r] ，其中 AND 是按位与运算。
请你将数组分割成一个或者更多子数组，满足：
* 每个 元素都 只 属于一个子数组。
* 子数组分数之和尽可能 小 。
请你在满足以上要求的条件下，返回 最多 可以得到多少个子数组。
一个 子数组 是一个数组中一段连续的元素。
示例 1：
输入：nums = [1,0,2,0,1,2]
输出：3
解释：我们可以将数组分割成以下子数组：
- [1,0] 。子数组分数为 1 AN... | 给你一个只包含 非负 整数的数组 nums 。
我们定义满足 l <= r 的子数组 nums[l..r] 的分数为 nums[l] AND nums[l + 1] AND ... AND nums[r] ，其中 AND 是按位与运算。
请你将数组分割成一个或者更多子数组，满足：
* 每个 元素都 只 属于一个子数组。
* 子数组分数之和尽可能 小 。
请你在满足以上要求的条件下，返回 最多 可以得到多少个子数组。
一个 子数组 是一个数组中一段连续的元素。
示例 1：
输入：nums = [1,0,2,0,1,2]
输出：3
解释：我们可以将数组分割成以下子数组：
- [1,0] 。子数组分数为 1 AND 0 ... |
my_solution = Solution()
test_input = { "nums": [1,0,2,0,1,2] }
assert my_solution.maxSubarrays(**test_input) == 3
test_input = { "nums": [5,7,1,3] }
assert my_solution.maxSubarrays(**test_input) == 1
test_input = { "nums": [1,0,2,1] }
assert my_solution.maxSubarrays(**test_input) == 2
test_input = { "nums": [0] }... | 1,696,084,200 |
biweekly-contest-114-maximum-number-of-k-divisible-components | https://leetcode.com/problems/maximum-number-of-k-divisible-components | maximum-number-of-k-divisible-components | {
"questionId": "3058",
"questionFrontendId": "2872",
"title": "Maximum Number of K-Divisible Components",
"titleSlug": "maximum-number-of-k-divisible-components",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 170,
"dislikes": 3,
"categoryTitle": "Algorithms"
} | """
给你一棵 n 个节点的无向树，节点编号为 0 到 n - 1 。给你整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 有一条边。
同时给你一个下标从 0 开始长度为 n 的整数数组 values ，其中 values[i] 是第 i 个节点的 值 。再给你一个整数 k 。
你可以从树中删除一些边，也可以一条边也不删，得到若干连通块。一个 连通块的值 定义为连通块中所有节点值之和。如果所有连通块的值都可以被 k 整除，那么我们说这是一个 合法分割 。
请你返回所有合法分割中，连通块数目的最大值 。
示例 1：
[https:/... | 给你一棵 n 个节点的无向树，节点编号为 0 到 n - 1 。给你整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 有一条边。
同时给你一个下标从 0 开始长度为 n 的整数数组 values ，其中 values[i] 是第 i 个节点的 值 。再给你一个整数 k 。
你可以从树中删除一些边，也可以一条边也不删，得到若干连通块。一个 连通块的值 定义为连通块中所有节点值之和。如果所有连通块的值都可以被 k 整除，那么我们说这是一个 合法分割 。
请你返回所有合法分割中，连通块数目的最大值 。
示例 1：
[https://ass... |
my_solution = Solution()
test_input = { "n": 5, "edges": [[0,2],[1,2],[1,3],[2,4]], "values": [1,8,1,4,4], "k": 6 }
assert my_solution.maxKDivisibleComponents(**test_input) == 2
test_input = { "n": 7, "edges": [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]], "values": [3,0,6,1,5,2,1], "k": 3 }
assert my_solution.maxKDivisible... | 1,696,084,200 |
weekly-contest-364-maximum-odd-binary-number | https://leetcode.com/problems/maximum-odd-binary-number | maximum-odd-binary-number | {
"questionId": "3055",
"questionFrontendId": "2864",
"title": "Maximum Odd Binary Number",
"titleSlug": "maximum-odd-binary-number",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 149,
"dislikes": 1,
"categoryTitle": "Algorithms"
} | """
给你一个 二进制 字符串 s ，其中至少包含一个 '1' 。
你必须按某种方式 重新排列 字符串中的位，使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。
以字符串形式，表示并返回可以由给定组合生成的最大二进制奇数。
注意 返回的结果字符串 可以 含前导零。
示例 1：
输入：s = "010"
输出："001"
解释：因为字符串 s 中仅有一个 '1' ，其必须出现在最后一位上。所以答案是 "001" 。
示例 2：
输入：s = "0101"
输出："1001"
解释：其中一个 '1' 必须出现在最后一位上。而由剩下的数字可以生产的最大数字是 "100" 。所以答案是 "1001" 。
提示：
... | 给你一个 二进制 字符串 s ，其中至少包含一个 '1' 。
你必须按某种方式 重新排列 字符串中的位，使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。
以字符串形式，表示并返回可以由给定组合生成的最大二进制奇数。
注意 返回的结果字符串 可以 含前导零。
示例 1：
输入：s = "010"
输出："001"
解释：因为字符串 s 中仅有一个 '1' ，其必须出现在最后一位上。所以答案是 "001" 。
示例 2：
输入：s = "0101"
输出："1001"
解释：其中一个 '1' 必须出现在最后一位上。而由剩下的数字可以生产的最大数字是 "100" 。所以答案是 "1001" 。
提示：
* ... |
my_solution = Solution()
test_input = { "s": "010" }
assert my_solution.maximumOddBinaryNumber(**test_input) == "001"
test_input = { "s": "0101" }
assert my_solution.maximumOddBinaryNumber(**test_input) == "1001"
test_input = { "s": "1" }
assert my_solution.maximumOddBinaryNumber(**test_input) == "1"
test_input = ... | 1,695,522,600 |
weekly-contest-364-beautiful-towers-i | https://leetcode.com/problems/beautiful-towers-i | beautiful-towers-i | {
"questionId": "3114",
"questionFrontendId": "2865",
"title": "Beautiful Towers I",
"titleSlug": "beautiful-towers-i",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 160,
"dislikes": 26,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。
你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。
如果以下条件满足，我们称这些塔是 美丽 的：
1. 1 <= heights[i] <= maxHeights[i]
2. heights 是一个 山状 数组。
如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：
* 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
* 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= hei... | 给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。
你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。
如果以下条件满足，我们称这些塔是 美丽 的：
1. 1 <= heights[i] <= maxHeights[i]
2. heights 是一个 山状 数组。
如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：
* 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
* 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= heights... |
my_solution = Solution()
test_input = { "maxHeights": [5,3,4,1,1] }
assert my_solution.maximumSumOfHeights(**test_input) == 13
test_input = { "maxHeights": [6,5,3,9,2,7] }
assert my_solution.maximumSumOfHeights(**test_input) == 22
test_input = { "maxHeights": [3,2,5,5,2,3] }
assert my_solution.maximumSumOfHeights(*... | 1,695,522,600 |
weekly-contest-364-beautiful-towers-ii | https://leetcode.com/problems/beautiful-towers-ii | beautiful-towers-ii | {
"questionId": "3113",
"questionFrontendId": "2866",
"title": "Beautiful Towers II",
"titleSlug": "beautiful-towers-ii",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 348,
"dislikes": 22,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。
你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。
如果以下条件满足，我们称这些塔是 美丽 的：
1. 1 <= heights[i] <= maxHeights[i]
2. heights 是一个 山状 数组。
如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：
* 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
* 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= hei... | 给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。
你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。
如果以下条件满足，我们称这些塔是 美丽 的：
1. 1 <= heights[i] <= maxHeights[i]
2. heights 是一个 山状 数组。
如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：
* 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
* 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= heights... |
my_solution = Solution()
test_input = { "maxHeights": [5,3,4,1,1] }
assert my_solution.maximumSumOfHeights(**test_input) == 13
test_input = { "maxHeights": [6,5,3,9,2,7] }
assert my_solution.maximumSumOfHeights(**test_input) == 22
test_input = { "maxHeights": [3,2,5,5,2,3] }
assert my_solution.maximumSumOfHeights(*... | 1,695,522,600 |
weekly-contest-364-count-valid-paths-in-a-tree | https://leetcode.com/problems/count-valid-paths-in-a-tree | count-valid-paths-in-a-tree | {
"questionId": "3112",
"questionFrontendId": "2867",
"title": "Count Valid Paths in a Tree",
"titleSlug": "count-valid-paths-in-a-tree",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 212,
"dislikes": 5,
"categoryTitle": "Algorithms"
} | """
给你一棵 n 个节点的无向树，节点编号为 1 到 n 。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示节点 ui 和 vi 在树中有一条边。
请你返回树中的 合法路径数目 。
如果在节点 a 到节点 b 之间 恰好有一个 节点的编号是质数，那么我们称路径 (a, b) 是 合法的 。
注意：
* 路径 (a, b) 指的是一条从节点 a 开始到节点 b 结束的一个节点序列，序列中的节点 互不相同 ，且相邻节点之间在树上有一条边。
* 路径 (a, b) 和路径 (b, a) 视为 同一条 路径，且只计入答案 一次 。
示例 1：
[... | 给你一棵 n 个节点的无向树，节点编号为 1 到 n 。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示节点 ui 和 vi 在树中有一条边。
请你返回树中的 合法路径数目 。
如果在节点 a 到节点 b 之间 恰好有一个 节点的编号是质数，那么我们称路径 (a, b) 是 合法的 。
注意：
* 路径 (a, b) 指的是一条从节点 a 开始到节点 b 结束的一个节点序列，序列中的节点 互不相同 ，且相邻节点之间在树上有一条边。
* 路径 (a, b) 和路径 (b, a) 视为 同一条 路径，且只计入答案 一次 。
示例 1：
[http... |
my_solution = Solution()
test_input = { "n": 5, "edges": [[1,2],[1,3],[2,4],[2,5]] }
assert my_solution.countPaths(**test_input) == 4
test_input = { "n": 6, "edges": [[1,2],[1,3],[2,4],[3,5],[3,6]] }
assert my_solution.countPaths(**test_input) == 6
test_input = { "n": 1, "edges": [] }
assert my_solution.countPaths(... | 1,695,522,600 |
weekly-contest-363-sum-of-values-at-indices-with-k-set-bits | https://leetcode.com/problems/sum-of-values-at-indices-with-k-set-bits | sum-of-values-at-indices-with-k-set-bits | {
"questionId": "3093",
"questionFrontendId": "2859",
"title": "Sum of Values at Indices With K Set Bits",
"titleSlug": "sum-of-values-at-indices-with-k-set-bits",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 154,
"dislikes": 16,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。
请你用整数形式返回 nums 中的特定元素之 和 ，这些特定元素满足：其对应下标的二进制表示中恰存在 k 个置位。
整数的二进制表示中的 1 就是这个整数的 置位 。
例如，21 的二进制表示为 10101 ，其中有 3 个置位。
示例 1：
输入：nums = [5,10,1,5,2], k = 1
输出：13
解释：下标的二进制表示是：
0 = 0002
1 = 0012
2 = 0102
3 = 0112
4 = 1002
下标 1、2 和 4 在其二进制表示中都存在 k = 1 个置位。
因此，答案为 nums[1] + nums[2] + ... | 给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。
请你用整数形式返回 nums 中的特定元素之 和 ，这些特定元素满足：其对应下标的二进制表示中恰存在 k 个置位。
整数的二进制表示中的 1 就是这个整数的 置位 。
例如，21 的二进制表示为 10101 ，其中有 3 个置位。
示例 1：
输入：nums = [5,10,1,5,2], k = 1
输出：13
解释：下标的二进制表示是：
0 = 0002
1 = 0012
2 = 0102
3 = 0112
4 = 1002
下标 1、2 和 4 在其二进制表示中都存在 k = 1 个置位。
因此，答案为 nums[1] + nums[2] + nums... |
my_solution = Solution()
test_input = { "nums": [5,10,1,5,2], "k": 1 }
assert my_solution.sumIndicesWithKSetBits(**test_input) == 13
test_input = { "nums": [4,3,2,1], "k": 2 }
assert my_solution.sumIndicesWithKSetBits(**test_input) == 1
test_input = { "nums": [1], "k": 0 }
assert my_solution.sumIndicesWithKSetBits(... | 1,694,917,800 |
weekly-contest-363-happy-students | https://leetcode.com/problems/happy-students | happy-students | {
"questionId": "3104",
"questionFrontendId": "2860",
"title": "Happy Students",
"titleSlug": "happy-students",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 144,
"dislikes": 272,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始、长度为 n 的整数数组 nums ，其中 n 是班级中学生的总数。班主任希望能够在让所有学生保持开心的情况下选出一组学生：
如果能够满足下述两个条件之一，则认为第 i 位学生将会保持开心：
* 这位学生被选中，并且被选中的学生人数 严格大于 nums[i] 。
* 这位学生没有被选中，并且被选中的学生人数 严格小于 nums[i] 。
返回能够满足让所有学生保持开心的分组方法的数目。
示例 1：
输入：nums = [1,1]
输出：2
解释：
有两种可行的方法：
班主任没有选中学生。
班主任选中所有学生形成一组。
如果班主任仅选中一个学生来完成分组，那么两个学生都无法保持开心。因此，... | 给你一个下标从 0 开始、长度为 n 的整数数组 nums ，其中 n 是班级中学生的总数。班主任希望能够在让所有学生保持开心的情况下选出一组学生：
如果能够满足下述两个条件之一，则认为第 i 位学生将会保持开心：
* 这位学生被选中，并且被选中的学生人数 严格大于 nums[i] 。
* 这位学生没有被选中，并且被选中的学生人数 严格小于 nums[i] 。
返回能够满足让所有学生保持开心的分组方法的数目。
示例 1：
输入：nums = [1,1]
输出：2
解释：
有两种可行的方法：
班主任没有选中学生。
班主任选中所有学生形成一组。
如果班主任仅选中一个学生来完成分组，那么两个学生都无法保持开心。因此，仅存在两... |
my_solution = Solution()
test_input = { "nums": [1,1] }
assert my_solution.countWays(**test_input) == 2
test_input = { "nums": [6,0,3,3,6,7,2,7] }
assert my_solution.countWays(**test_input) == 3
test_input = { "nums": [1,1,0,1] }
assert my_solution.countWays(**test_input) == 1
test_input = { "nums": [5,0,3,4,2,1,2... | 1,694,917,800 |
weekly-contest-363-maximum-number-of-alloys | https://leetcode.com/problems/maximum-number-of-alloys | maximum-number-of-alloys | {
"questionId": "3095",
"questionFrontendId": "2861",
"title": "Maximum Number of Alloys",
"titleSlug": "maximum-number-of-alloys",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 227,
"dislikes": 36,
"categoryTitle": "Algorithms"
} | """
假设你是一家合金制造公司的老板，你的公司使用多种金属来制造合金。现在共有 n 种不同类型的金属可以使用，并且你可以使用 k 台机器来制造合金。每台机器都需要特定数量的每种金属来创建合金。
对于第 i 台机器而言，创建合金需要 composition[i][j] 份 j 类型金属。最初，你拥有 stock[i] 份 i 类型金属，而每购入一份 i 类型金属需要花费 cost[i] 的金钱。
给你整数 n、k、budget，下标从 1 开始的二维数组 composition，两个下标从 1 开始的数组 stock 和 cost，请你在预算不超过 budget 金钱的前提下，最大化 公司制造合金的数量。
所有合金都需要由同一... | 假设你是一家合金制造公司的老板，你的公司使用多种金属来制造合金。现在共有 n 种不同类型的金属可以使用，并且你可以使用 k 台机器来制造合金。每台机器都需要特定数量的每种金属来创建合金。
对于第 i 台机器而言，创建合金需要 composition[i][j] 份 j 类型金属。最初，你拥有 stock[i] 份 i 类型金属，而每购入一份 i 类型金属需要花费 cost[i] 的金钱。
给你整数 n、k、budget，下标从 1 开始的二维数组 composition，两个下标从 1 开始的数组 stock 和 cost，请你在预算不超过 budget 金钱的前提下，最大化 公司制造合金的数量。
所有合金都需要由同一台机器制... |
my_solution = Solution()
test_input = { "n": 3, "k": 2, "budget": 15, "composition": [[1,1,1],[1,1,10]], "stock": [0,0,0], "cost": [1,2,3] }
assert my_solution.maxNumberOfAlloys(**test_input) == 2
test_input = { "n": 3, "k": 2, "budget": 15, "composition": [[1,1,1],[1,1,10]], "stock": [0,0,100], "cost": [1,2,3] }
as... | 1,694,917,800 |
weekly-contest-363-maximum-element-sum-of-a-complete-subset-of-indices | https://leetcode.com/problems/maximum-element-sum-of-a-complete-subset-of-indices | maximum-element-sum-of-a-complete-subset-of-indices | {
"questionId": "3047",
"questionFrontendId": "2862",
"title": "Maximum Element-Sum of a Complete Subset of Indices",
"titleSlug": "maximum-element-sum-of-a-complete-subset-of-indices",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 157,
"dislikes": 27,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 1 开始、由 n 个整数组成的数组。
如果一组数字中每对元素的乘积都是一个完全平方数，则称这组数字是一个 完全集 。
下标集 {1, 2, ..., n} 的子集可以表示为 {i1, i2, ..., ik}，我们定义对应该子集的 元素和 为 nums[i1] + nums[i2] + ... + nums[ik] 。
返回下标集 {1, 2, ..., n} 的 完全子集 所能取到的 最大元素和 。
完全平方数是指可以表示为一个整数和其自身相乘的数。
示例 1：
输入：nums = [8,7,3,5,7,2,4,9]
输出：16
解释：除了由单个下标组成的子集之外，还有两个下标集的完全子集：{1... | 给你一个下标从 1 开始、由 n 个整数组成的数组。
如果一组数字中每对元素的乘积都是一个完全平方数，则称这组数字是一个 完全集 。
下标集 {1, 2, ..., n} 的子集可以表示为 {i1, i2, ..., ik}，我们定义对应该子集的 元素和 为 nums[i1] + nums[i2] + ... + nums[ik] 。
返回下标集 {1, 2, ..., n} 的 完全子集 所能取到的 最大元素和 。
完全平方数是指可以表示为一个整数和其自身相乘的数。
示例 1：
输入：nums = [8,7,3,5,7,2,4,9]
输出：16
解释：除了由单个下标组成的子集之外，还有两个下标集的完全子集：{1,4} ... |
my_solution = Solution()
test_input = { "nums": [8,7,3,5,7,2,4,9] }
assert my_solution.maximumSum(**test_input) == 16
test_input = { "nums": [5,10,3,10,1,13,7,9,4] }
assert my_solution.maximumSum(**test_input) == 19
test_input = { "nums": [1,1,1,1] }
assert my_solution.maximumSum(**test_input) == 2
test_input = { ... | 1,694,917,800 |
biweekly-contest-113-minimum-right-shifts-to-sort-the-array | https://leetcode.com/problems/minimum-right-shifts-to-sort-the-array | minimum-right-shifts-to-sort-the-array | {
"questionId": "3045",
"questionFrontendId": "2855",
"title": "Minimum Right Shifts to Sort the Array",
"titleSlug": "minimum-right-shifts-to-sort-the-array",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 169,
"dislikes": 6,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 下标从 0 开始的数组 nums ，数组中的元素为 互不相同 的正整数。请你返回让 nums 成为递增数组的 最少右移 次数，如果无法得到递增数组，返回 -1 。
一次 右移 指的是同时对所有下标进行操作，将下标为 i 的元素移动到下标 (i + 1) % n 处。
示例 1：
输入：nums = [3,4,5,1,2]
输出：2
解释：
第一次右移后，nums = [2,3,4,5,1] 。
第二次右移后，nums = [1,2,3,4,5] 。
现在 nums 是递增数组了，所以答案为 2 。
示例 2：
输入：nums = [1,3,5]
输出：0
解释：nums 已经是递增数组了，所以答... | 给你一个长度为 n 下标从 0 开始的数组 nums ，数组中的元素为 互不相同 的正整数。请你返回让 nums 成为递增数组的 最少右移 次数，如果无法得到递增数组，返回 -1 。
一次 右移 指的是同时对所有下标进行操作，将下标为 i 的元素移动到下标 (i + 1) % n 处。
示例 1：
输入：nums = [3,4,5,1,2]
输出：2
解释：
第一次右移后，nums = [2,3,4,5,1] 。
第二次右移后，nums = [1,2,3,4,5] 。
现在 nums 是递增数组了，所以答案为 2 。
示例 2：
输入：nums = [1,3,5]
输出：0
解释：nums 已经是递增数组了，所以答案为 0... |
my_solution = Solution()
test_input = { "nums": [3,4,5,1,2] }
assert my_solution.minimumRightShifts(**test_input) == 2
test_input = { "nums": [1,3,5] }
assert my_solution.minimumRightShifts(**test_input) == 0
test_input = { "nums": [2,1,4] }
assert my_solution.minimumRightShifts(**test_input) == -1
test_input = { ... | 1,694,874,600 |
biweekly-contest-113-minimum-array-length-after-pair-removals | https://leetcode.com/problems/minimum-array-length-after-pair-removals | minimum-array-length-after-pair-removals | {
"questionId": "3081",
"questionFrontendId": "2856",
"title": "Minimum Array Length After Pair Removals",
"titleSlug": "minimum-array-length-after-pair-removals",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 259,
"dislikes": 88,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的 非递减 整数数组 nums 。
你可以执行以下操作任意次：
* 选择 两个 下标 i 和 j ，满足 i < j 且 nums[i] < nums[j] 。
* 将 nums 中下标在 i 和 j 处的元素删除。剩余元素按照原来的顺序组成新的数组，下标也重新从 0 开始编号。
请你返回一个整数，表示执行以上操作任意次后（可以执行 0 次），nums 数组的 最小 数组长度。
请注意，nums 数组是按 非降序 排序的。
示例 1：
输入：nums = [1,3,4,9]
输出：0
解释：一开始，nums = [1, 3, 4, 9] 。
第一次操作，我们选择下标 0 和 1 ，满足... | 给你一个下标从 0 开始的 非递减 整数数组 nums 。
你可以执行以下操作任意次：
* 选择 两个 下标 i 和 j ，满足 i < j 且 nums[i] < nums[j] 。
* 将 nums 中下标在 i 和 j 处的元素删除。剩余元素按照原来的顺序组成新的数组，下标也重新从 0 开始编号。
请你返回一个整数，表示执行以上操作任意次后（可以执行 0 次），nums 数组的 最小 数组长度。
请注意，nums 数组是按 非降序 排序的。
示例 1：
输入：nums = [1,3,4,9]
输出：0
解释：一开始，nums = [1, 3, 4, 9] 。
第一次操作，我们选择下标 0 和 1 ，满足 num... |
my_solution = Solution()
test_input = { "nums": [1,3,4,9] }
assert my_solution.minLengthAfterRemovals(**test_input) == 0
test_input = { "nums": [2,3,6,9] }
assert my_solution.minLengthAfterRemovals(**test_input) == 0
test_input = { "nums": [1,1,2] }
assert my_solution.minLengthAfterRemovals(**test_input) == 1
test... | 1,694,874,600 |
biweekly-contest-113-count-pairs-of-points-with-distance-k | https://leetcode.com/problems/count-pairs-of-points-with-distance-k | count-pairs-of-points-with-distance-k | {
"questionId": "2953",
"questionFrontendId": "2857",
"title": "Count Pairs of Points With Distance k",
"titleSlug": "count-pairs-of-points-with-distance-k",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 238,
"dislikes": 34,
"categoryTitle": "Algorithms"
} | """
给你一个 二维 整数数组 coordinates 和一个整数 k ，其中 coordinates[i] = [xi, yi] 是第 i 个点在二维平面里的坐标。
我们定义两个点 (x1, y1) 和 (x2, y2) 的 距离 为 (x1 XOR x2) + (y1 XOR y2) ，XOR 指的是按位异或运算。
请你返回满足 i < j 且点 i 和点 j之间距离为 k 的点对数目。
示例 1：
输入：coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
输出：2
解释：以下点对距离为 k ：
- (0, 1)：(1 XOR 4) + (2 XOR 2) = 5 。
- (2... | 给你一个 二维 整数数组 coordinates 和一个整数 k ，其中 coordinates[i] = [xi, yi] 是第 i 个点在二维平面里的坐标。
我们定义两个点 (x1, y1) 和 (x2, y2) 的 距离 为 (x1 XOR x2) + (y1 XOR y2) ，XOR 指的是按位异或运算。
请你返回满足 i < j 且点 i 和点 j之间距离为 k 的点对数目。
示例 1：
输入：coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
输出：2
解释：以下点对距离为 k ：
- (0, 1)：(1 XOR 4) + (2 XOR 2) = 5 。
- (2, 3)... |
my_solution = Solution()
test_input = { "coordinates": [[1,2],[4,2],[1,3],[5,2]], "k": 5 }
assert my_solution.countPairs(**test_input) == 2
test_input = { "coordinates": [[1,3],[1,3],[1,3],[1,3],[1,3]], "k": 0 }
assert my_solution.countPairs(**test_input) == 10
test_input = { "coordinates": [[27,94],[61,68],[47,0],... | 1,694,874,600 |
biweekly-contest-113-minimum-edge-reversals-so-every-node-is-reachable | https://leetcode.com/problems/minimum-edge-reversals-so-every-node-is-reachable | minimum-edge-reversals-so-every-node-is-reachable | {
"questionId": "3105",
"questionFrontendId": "2858",
"title": "Minimum Edge Reversals So Every Node Is Reachable",
"titleSlug": "minimum-edge-reversals-so-every-node-is-reachable",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 227,
"dislikes": 3,
"categoryTitle": "Algorithms"
} | """
给你一个 n 个点的 简单有向图 （没有重复边的有向图），节点编号为 0 到 n - 1 。如果这些边是双向边，那么这个图形成一棵 树 。
给你一个整数 n 和一个 二维 整数数组 edges ，其中 edges[i] = [ui, vi] 表示从节点 ui 到节点 vi 有一条 有向边 。
边反转 指的是将一条边的方向反转，也就是说一条从节点 ui 到节点 vi 的边会变为一条从节点 vi 到节点 ui 的边。
对于范围 [0, n - 1] 中的每一个节点 i ，你的任务是分别 独立 计算 最少 需要多少次 边反转 ，从节点 i 出发经过 一系列有向边 ，可以到达所有的节点。
请你返回一个长度为 n 的整数数组 ... | 给你一个 n 个点的 简单有向图 （没有重复边的有向图），节点编号为 0 到 n - 1 。如果这些边是双向边，那么这个图形成一棵 树 。
给你一个整数 n 和一个 二维 整数数组 edges ，其中 edges[i] = [ui, vi] 表示从节点 ui 到节点 vi 有一条 有向边 。
边反转 指的是将一条边的方向反转，也就是说一条从节点 ui 到节点 vi 的边会变为一条从节点 vi 到节点 ui 的边。
对于范围 [0, n - 1] 中的每一个节点 i ，你的任务是分别 独立 计算 最少 需要多少次 边反转 ，从节点 i 出发经过 一系列有向边 ，可以到达所有的节点。
请你返回一个长度为 n 的整数数组 answ... |
my_solution = Solution()
test_input = { "n": 4, "edges": [[2,0],[2,1],[1,3]] }
assert my_solution.minEdgeReversals(**test_input) == [1,1,0,2]
test_input = { "n": 3, "edges": [[1,2],[2,0]] }
assert my_solution.minEdgeReversals(**test_input) == [2,0,1]
test_input = { "n": 2, "edges": [[0,1]] }
assert my_solution.minE... | 1,694,874,600 |
weekly-contest-362-points-that-intersect-with-cars | https://leetcode.com/problems/points-that-intersect-with-cars | points-that-intersect-with-cars | {
"questionId": "3034",
"questionFrontendId": "2848",
"title": "Points That Intersect With Cars",
"titleSlug": "points-that-intersect-with-cars",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 211,
"dislikes": 13,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的二维整数数组 nums 表示汽车停放在数轴上的坐标。对于任意下标 i，nums[i] = [starti, endi] ，其中 starti 是第 i 辆车的起点，endi 是第 i 辆车的终点。
返回数轴上被车 任意部分 覆盖的整数点的数目。
示例 1：
输入：nums = [[3,6],[1,5],[4,7]]
输出：7
解释：从 1 到 7 的所有点都至少与一辆车相交，因此答案为 7 。
示例 2：
输入：nums = [[1,3],[5,8]]
输出：7
解释：1、2、3、5、6、7、8 共计 7 个点满足至少与一辆车相交，因此答案为 7 。
提示：
* 1 <= nums... | 给你一个下标从 0 开始的二维整数数组 nums 表示汽车停放在数轴上的坐标。对于任意下标 i，nums[i] = [starti, endi] ，其中 starti 是第 i 辆车的起点，endi 是第 i 辆车的终点。
返回数轴上被车 任意部分 覆盖的整数点的数目。
示例 1：
输入：nums = [[3,6],[1,5],[4,7]]
输出：7
解释：从 1 到 7 的所有点都至少与一辆车相交，因此答案为 7 。
示例 2：
输入：nums = [[1,3],[5,8]]
输出：7
解释：1、2、3、5、6、7、8 共计 7 个点满足至少与一辆车相交，因此答案为 7 。
提示：
* 1 <= nums.len... |
my_solution = Solution()
test_input = { "nums": [[3,6],[1,5],[4,7]] }
assert my_solution.numberOfPoints(**test_input) == 7
test_input = { "nums": [[1,3],[5,8]] }
assert my_solution.numberOfPoints(**test_input) == 7
test_input = { "nums": [[4,4],[9,10],[9,10],[3,8]] }
assert my_solution.numberOfPoints(**test_input) ... | 1,694,313,000 |
weekly-contest-362-determine-if-a-cell-is-reachable-at-a-given-time | https://leetcode.com/problems/determine-if-a-cell-is-reachable-at-a-given-time | determine-if-a-cell-is-reachable-at-a-given-time | {
"questionId": "3056",
"questionFrontendId": "2849",
"title": "Determine if a Cell Is Reachable at a Given Time",
"titleSlug": "determine-if-a-cell-is-reachable-at-a-given-time",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 782,
"dislikes": 730,
"categoryTitle": "Algorithms"
} | """
给你四个整数 sx、sy、fx、fy 以及一个 非负整数 t 。
在一个无限的二维网格中，你从单元格 (sx, sy) 开始出发。每一秒，你 必须 移动到任一与之前所处单元格相邻的单元格中。
如果你能在 恰好 t 秒 后到达单元格 (fx, fy) ，返回 true ；否则，返回 false 。
单元格的 相邻单元格 是指该单元格周围与其至少共享一个角的 8 个单元格。你可以多次访问同一个单元格。
示例 1：
[https://assets.leetcode.com/uploads/2023/08/05/example2.svg]
输入：sx = 2, sy = 4, fx = 7, fy = 7, t = ... | 给你四个整数 sx、sy、fx、fy 以及一个 非负整数 t 。
在一个无限的二维网格中，你从单元格 (sx, sy) 开始出发。每一秒，你 必须 移动到任一与之前所处单元格相邻的单元格中。
如果你能在 恰好 t 秒 后到达单元格 (fx, fy) ，返回 true ；否则，返回 false 。
单元格的 相邻单元格 是指该单元格周围与其至少共享一个角的 8 个单元格。你可以多次访问同一个单元格。
示例 1：
[https://assets.leetcode.com/uploads/2023/08/05/example2.svg]
输入：sx = 2, sy = 4, fx = 7, fy = 7, t = 6
输出... |
my_solution = Solution()
test_input = { "sx": 3, "sy": 1, "fx": 7, "fy": 3, "t": 3 }
assert my_solution.isReachableAtTime(**test_input) == False
test_input = { "sx": 2, "sy": 4, "fx": 7, "fy": 7, "t": 6 }
assert my_solution.isReachableAtTime(**test_input) == True
test_input = { "sx": 1, "sy": 1, "fx": 1, "fy": 2, "... | 1,694,313,000 |
weekly-contest-362-minimum-moves-to-spread-stones-over-grid | https://leetcode.com/problems/minimum-moves-to-spread-stones-over-grid | minimum-moves-to-spread-stones-over-grid | {
"questionId": "3092",
"questionFrontendId": "2850",
"title": "Minimum Moves to Spread Stones Over Grid",
"titleSlug": "minimum-moves-to-spread-stones-over-grid",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 419,
"dislikes": 43,
"categoryTitle": "Algorithms"
} | """
给你一个大小为 3 * 3 ，下标从 0 开始的二维整数矩阵 grid ，分别表示每一个格子里石头的数目。网格图中总共恰好有 9 个石头，一个格子里可能会有 多个 石头。
每一次操作中，你可以将一个石头从它当前所在格子移动到一个至少有一条公共边的相邻格子。
请你返回每个格子恰好有一个石头的 最少移动次数 。
示例 1：
[https://assets.leetcode.com/uploads/2023/08/23/example1-3.svg]
输入：grid = [[1,1,0],[1,1,1],[1,2,1]]
输出：3
解释：让每个格子都有一个石头的一个操作序列为：
1 - 将一个石头从格子 (2,1) 移动... | 给你一个大小为 3 * 3 ，下标从 0 开始的二维整数矩阵 grid ，分别表示每一个格子里石头的数目。网格图中总共恰好有 9 个石头，一个格子里可能会有 多个 石头。
每一次操作中，你可以将一个石头从它当前所在格子移动到一个至少有一条公共边的相邻格子。
请你返回每个格子恰好有一个石头的 最少移动次数 。
示例 1：
[https://assets.leetcode.com/uploads/2023/08/23/example1-3.svg]
输入：grid = [[1,1,0],[1,1,1],[1,2,1]]
输出：3
解释：让每个格子都有一个石头的一个操作序列为：
1 - 将一个石头从格子 (2,1) 移动到 (2... |
my_solution = Solution()
test_input = { "grid": [[1,1,0],[1,1,1],[1,2,1]] }
assert my_solution.minimumMoves(**test_input) == 3
test_input = { "grid": [[1,3,0],[1,0,0],[1,0,3]] }
assert my_solution.minimumMoves(**test_input) == 4
test_input = { "grid": [[1,2,2],[1,1,0],[0,1,1]] }
assert my_solution.minimumMoves(**te... | 1,694,313,000 |
weekly-contest-362-string-transformation | https://leetcode.com/problems/string-transformation | string-transformation | {
"questionId": "3024",
"questionFrontendId": "2851",
"title": "String Transformation",
"titleSlug": "string-transformation",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 140,
"dislikes": 19,
"categoryTitle": "Algorithms"
} | """
给你两个长度都为 n 的字符串 s 和 t 。你可以对字符串 s 执行以下操作：
* 将 s 长度为 l （0 < l < n）的 后缀字符串 删除，并将它添加在 s 的开头。
比方说，s = 'abcd' ，那么一次操作中，你可以删除后缀 'cd' ，并将它添加到 s 的开头，得到 s = 'cdab' 。
给你一个整数 k ，请你返回 恰好 k 次操作将 s 变为 t 的方案数。
由于答案可能很大，返回答案对 109 + 7 取余 后的结果。
示例 1：
输入：s = "abcd", t = "cdab", k = 2
输出：2
解释：
第一种方案：
第一次操作，选择 index = 3 开始的后缀，得... | 给你两个长度都为 n 的字符串 s 和 t 。你可以对字符串 s 执行以下操作：
* 将 s 长度为 l （0 < l < n）的 后缀字符串 删除，并将它添加在 s 的开头。
比方说，s = 'abcd' ，那么一次操作中，你可以删除后缀 'cd' ，并将它添加到 s 的开头，得到 s = 'cdab' 。
给你一个整数 k ，请你返回 恰好 k 次操作将 s 变为 t 的方案数。
由于答案可能很大，返回答案对 109 + 7 取余 后的结果。
示例 1：
输入：s = "abcd", t = "cdab", k = 2
输出：2
解释：
第一种方案：
第一次操作，选择 index = 3 开始的后缀，得到 s ... |
my_solution = Solution()
test_input = { "s": "abcd", "t": "cdab", "k": 2 }
assert my_solution.numberOfWays(**test_input) == 2
test_input = { "s": "ababab", "t": "ababab", "k": 1 }
assert my_solution.numberOfWays(**test_input) == 2
test_input = { "s": "goxoq", "t": "dfqgl", "k": 244326024901249 }
assert my_solution.... | 1,694,313,000 |
weekly-contest-361-count-symmetric-integers | https://leetcode.com/problems/count-symmetric-integers | count-symmetric-integers | {
"questionId": "2998",
"questionFrontendId": "2843",
"title": " Count Symmetric Integers",
"titleSlug": "count-symmetric-integers",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 210,
"dislikes": 9,
"categoryTitle": "Algorithms"
} | """
给你两个正整数 low 和 high 。
对于一个由 2 * n 位数字组成的整数 x ，如果其前 n 位数字之和与后 n 位数字之和相等，则认为这个数字是一个对称整数。
返回在 [low, high] 范围内的 对称整数的数目 。
示例 1：
输入：low = 1, high = 100
输出：9
解释：在 1 到 100 范围内共有 9 个对称整数：11、22、33、44、55、66、77、88 和 99 。
示例 2：
输入：low = 1200, high = 1230
输出：4
解释：在 1200 到 1230 范围内共有 4 个对称整数：1203、1212、1221 和 1230 。
提示：
... | 给你两个正整数 low 和 high 。
对于一个由 2 * n 位数字组成的整数 x ，如果其前 n 位数字之和与后 n 位数字之和相等，则认为这个数字是一个对称整数。
返回在 [low, high] 范围内的 对称整数的数目 。
示例 1：
输入：low = 1, high = 100
输出：9
解释：在 1 到 100 范围内共有 9 个对称整数：11、22、33、44、55、66、77、88 和 99 。
示例 2：
输入：low = 1200, high = 1230
输出：4
解释：在 1200 到 1230 范围内共有 4 个对称整数：1203、1212、1221 和 1230 。
提示：
* 1 ... |
my_solution = Solution()
test_input = { "low": 1, "high": 100 }
assert my_solution.countSymmetricIntegers(**test_input) == 9
test_input = { "low": 1200, "high": 1230 }
assert my_solution.countSymmetricIntegers(**test_input) == 4
test_input = { "low": 1, "high": 1 }
assert my_solution.countSymmetricIntegers(**test_i... | 1,693,708,200 |
weekly-contest-361-minimum-operations-to-make-a-special-number | https://leetcode.com/problems/minimum-operations-to-make-a-special-number | minimum-operations-to-make-a-special-number | {
"questionId": "3046",
"questionFrontendId": "2844",
"title": "Minimum Operations to Make a Special Number",
"titleSlug": "minimum-operations-to-make-a-special-number",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 317,
"dislikes": 48,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的字符串 num ，表示一个非负整数。
在一次操作中，您可以选择 num 的任意一位数字并将其删除。请注意，如果你删除 num 中的所有数字，则 num 变为 0。
返回最少需要多少次操作可以使 num 变成特殊数字。
如果整数 x 能被 25 整除，则该整数 x 被认为是特殊数字。
示例 1：
输入：num = "2245047"
输出：2
解释：删除数字 num[5] 和 num[6] ，得到数字 "22450" ，可以被 25 整除。
可以证明要使数字变成特殊数字，最少需要删除 2 位数字。
示例 2：
输入：num = "2908305"
输出：3
解释：删除 num[3]、n... | 给你一个下标从 0 开始的字符串 num ，表示一个非负整数。
在一次操作中，您可以选择 num 的任意一位数字并将其删除。请注意，如果你删除 num 中的所有数字，则 num 变为 0。
返回最少需要多少次操作可以使 num 变成特殊数字。
如果整数 x 能被 25 整除，则该整数 x 被认为是特殊数字。
示例 1：
输入：num = "2245047"
输出：2
解释：删除数字 num[5] 和 num[6] ，得到数字 "22450" ，可以被 25 整除。
可以证明要使数字变成特殊数字，最少需要删除 2 位数字。
示例 2：
输入：num = "2908305"
输出：3
解释：删除 num[3]、num[4... |
my_solution = Solution()
test_input = { "num": "2245047" }
assert my_solution.minimumOperations(**test_input) == 2
test_input = { "num": "2908305" }
assert my_solution.minimumOperations(**test_input) == 3
test_input = { "num": "10" }
assert my_solution.minimumOperations(**test_input) == 1
test_input = { "num": "1"... | 1,693,708,200 |
weekly-contest-361-count-of-interesting-subarrays | https://leetcode.com/problems/count-of-interesting-subarrays | count-of-interesting-subarrays | {
"questionId": "2915",
"questionFrontendId": "2845",
"title": "Count of Interesting Subarrays",
"titleSlug": "count-of-interesting-subarrays",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 449,
"dislikes": 62,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums ，以及整数 modulo 和整数 k 。
请你找出并统计数组中 趣味子数组 的数目。
如果 子数组 nums[l..r] 满足下述条件，则称其为 趣味子数组 ：
* 在范围 [l, r] 内，设 cnt 为满足 nums[i] % modulo == k 的索引 i 的数量。并且 cnt % modulo == k 。
以整数形式表示并返回趣味子数组的数目。
注意：子数组是数组中的一个连续非空的元素序列。
示例 1：
输入：nums = [3,2,4], modulo = 2, k = 1
输出：3
解释：在这个示例中，趣味子数组分别是：
子数组 nums[0..... | 给你一个下标从 0 开始的整数数组 nums ，以及整数 modulo 和整数 k 。
请你找出并统计数组中 趣味子数组 的数目。
如果 子数组 nums[l..r] 满足下述条件，则称其为 趣味子数组 ：
* 在范围 [l, r] 内，设 cnt 为满足 nums[i] % modulo == k 的索引 i 的数量。并且 cnt % modulo == k 。
以整数形式表示并返回趣味子数组的数目。
注意：子数组是数组中的一个连续非空的元素序列。
示例 1：
输入：nums = [3,2,4], modulo = 2, k = 1
输出：3
解释：在这个示例中，趣味子数组分别是：
子数组 nums[0..0] ，... |
my_solution = Solution()
test_input = { "nums": [3,2,4], "modulo": 2, "k": 1 }
assert my_solution.countInterestingSubarrays(**test_input) == 3
test_input = { "nums": [3,1,9,6], "modulo": 3, "k": 0 }
assert my_solution.countInterestingSubarrays(**test_input) == 2
test_input = { "nums": [11,12,21,31], "modulo": 10, "... | 1,693,708,200 |
weekly-contest-361-minimum-edge-weight-equilibrium-queries-in-a-tree | https://leetcode.com/problems/minimum-edge-weight-equilibrium-queries-in-a-tree | minimum-edge-weight-equilibrium-queries-in-a-tree | {
"questionId": "3079",
"questionFrontendId": "2846",
"title": "Minimum Edge Weight Equilibrium Queries in a Tree",
"titleSlug": "minimum-edge-weight-equilibrium-queries-in-a-tree",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 260,
"dislikes": 4,
"categoryTitle": "Algorithms"
} | """
现有一棵由 n 个节点组成的无向树，节点按从 0 到 n - 1 编号。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi, wi] 表示树中存在一条位于节点 ui 和节点 vi 之间、权重为 wi 的边。
另给你一个长度为 m 的二维整数数组 queries ，其中 queries[i] = [ai, bi] 。对于每条查询，请你找出使从 ai 到 bi 路径上每条边的权重相等所需的 最小操作次数 。在一次操作中，你可以选择树上的任意一条边，并将其权重更改为任意值。
注意：
* 查询之间 相互独立 的，这意味着每条新的查询时，树都会回到 初始状态 。... | 现有一棵由 n 个节点组成的无向树，节点按从 0 到 n - 1 编号。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi, wi] 表示树中存在一条位于节点 ui 和节点 vi 之间、权重为 wi 的边。
另给你一个长度为 m 的二维整数数组 queries ，其中 queries[i] = [ai, bi] 。对于每条查询，请你找出使从 ai 到 bi 路径上每条边的权重相等所需的 最小操作次数 。在一次操作中，你可以选择树上的任意一条边，并将其权重更改为任意值。
注意：
* 查询之间 相互独立 的，这意味着每条新的查询时，树都会回到 初始状态 。
* ... |
my_solution = Solution()
test_input = { "n": 7, "edges": [[0,1,1],[1,2,1],[2,3,1],[3,4,2],[4,5,2],[5,6,2]], "queries": [[0,3],[3,6],[2,6],[0,6]] }
assert my_solution.minOperationsQueries(**test_input) == [0,0,1,3]
test_input = { "n": 8, "edges": [[1,2,6],[1,3,4],[2,4,6],[2,5,3],[3,6,6],[3,0,8],[7,0,2]], "queries": [... | 1,693,708,200 |
biweekly-contest-112-check-if-strings-can-be-made-equal-with-operations-i | https://leetcode.com/problems/check-if-strings-can-be-made-equal-with-operations-i | check-if-strings-can-be-made-equal-with-operations-i | {
"questionId": "2999",
"questionFrontendId": "2839",
"title": "Check if Strings Can be Made Equal With Operations I",
"titleSlug": "check-if-strings-can-be-made-equal-with-operations-i",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 164,
"dislikes": 20,
"categoryTitle": "Algorithms"
} | """
给你两个字符串 s1 和 s2 ，两个字符串的长度都为 4 ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
* 选择两个下标 i 和 j 且满足 j - i = 2 ，然后 交换 这个字符串中两个下标对应的字符。
如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
示例 1：
输入：s1 = "abcd", s2 = "cdab"
输出：true
解释： 我们可以对 s1 执行以下操作：
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbad" 。
- 选择下标 i = 1 ，j = 3 ，得到字符串 s1 = "... | 给你两个字符串 s1 和 s2 ，两个字符串的长度都为 4 ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
* 选择两个下标 i 和 j 且满足 j - i = 2 ，然后 交换 这个字符串中两个下标对应的字符。
如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
示例 1：
输入：s1 = "abcd", s2 = "cdab"
输出：true
解释： 我们可以对 s1 执行以下操作：
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbad" 。
- 选择下标 i = 1 ，j = 3 ，得到字符串 s1 = "cdab... |
my_solution = Solution()
test_input = { "s1": "abcd", "s2": "cdab" }
assert my_solution.canBeEqual(**test_input) == True
test_input = { "s1": "abcd", "s2": "dacb" }
assert my_solution.canBeEqual(**test_input) == False
test_input = { "s1": "gudo", "s2": "ogdu" }
assert my_solution.canBeEqual(**test_input) == False
... | 1,693,665,000 |
biweekly-contest-112-check-if-strings-can-be-made-equal-with-operations-ii | https://leetcode.com/problems/check-if-strings-can-be-made-equal-with-operations-ii | check-if-strings-can-be-made-equal-with-operations-ii | {
"questionId": "2978",
"questionFrontendId": "2840",
"title": "Check if Strings Can be Made Equal With Operations II",
"titleSlug": "check-if-strings-can-be-made-equal-with-operations-ii",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 231,
"dislikes": 2,
"categoryTitle": "Algorithms"
} | """
给你两个字符串 s1 和 s2 ，两个字符串长度都为 n ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
* 选择两个下标 i 和 j ，满足 i < j 且 j - i 是 偶数，然后 交换 这个字符串中两个下标对应的字符。
如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
示例 1：
输入：s1 = "abcdba", s2 = "cabdab"
输出：true
解释：我们可以对 s1 执行以下操作：
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbadba" 。
- 选择下标 i = 2 ，j = 4 ... | 给你两个字符串 s1 和 s2 ，两个字符串长度都为 n ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
* 选择两个下标 i 和 j ，满足 i < j 且 j - i 是 偶数，然后 交换 这个字符串中两个下标对应的字符。
如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
示例 1：
输入：s1 = "abcdba", s2 = "cabdab"
输出：true
解释：我们可以对 s1 执行以下操作：
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbadba" 。
- 选择下标 i = 2 ，j = 4 ，得到字... |
my_solution = Solution()
test_input = { "s1": "abe", "s2": "bea" }
assert my_solution.checkStrings(**test_input) == False
test_input = { "s1": "abcdba", "s2": "cabdab" }
assert my_solution.checkStrings(**test_input) == True
test_input = { "s1": "ublnlasppynwgx", "s2": "ganplbuylnswpx" }
assert my_solution.checkStri... | 1,693,665,000 |
biweekly-contest-112-maximum-sum-of-almost-unique-subarray | https://leetcode.com/problems/maximum-sum-of-almost-unique-subarray | maximum-sum-of-almost-unique-subarray | {
"questionId": "2954",
"questionFrontendId": "2841",
"title": "Maximum Sum of Almost Unique Subarray",
"titleSlug": "maximum-sum-of-almost-unique-subarray",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 230,
"dislikes": 133,
"categoryTitle": "Algorithms"
} | """
给你一个整数数组 nums 和两个正整数 m 和 k 。
请你返回 nums 中长度为 k 的 几乎唯一 子数组的 最大和 ，如果不存在几乎唯一子数组，请你返回 0 。
如果 nums 的一个子数组有至少 m 个互不相同的元素，我们称它是 几乎唯一 子数组。
子数组指的是一个数组中一段连续 非空 的元素序列。
示例 1：
输入：nums = [2,6,7,3,1,7], m = 3, k = 4
输出：18
解释：总共有 3 个长度为 k = 4 的几乎唯一子数组。分别为 [2, 6, 7, 3] ，[6, 7, 3, 1] 和 [7, 3, 1, 7] 。这些子数组中，和最大的是 [2, 6, 7, 3] ，和为... | 给你一个整数数组 nums 和两个正整数 m 和 k 。
请你返回 nums 中长度为 k 的 几乎唯一 子数组的 最大和 ，如果不存在几乎唯一子数组，请你返回 0 。
如果 nums 的一个子数组有至少 m 个互不相同的元素，我们称它是 几乎唯一 子数组。
子数组指的是一个数组中一段连续 非空 的元素序列。
示例 1：
输入：nums = [2,6,7,3,1,7], m = 3, k = 4
输出：18
解释：总共有 3 个长度为 k = 4 的几乎唯一子数组。分别为 [2, 6, 7, 3] ，[6, 7, 3, 1] 和 [7, 3, 1, 7] 。这些子数组中，和最大的是 [2, 6, 7, 3] ，和为 18 ... |
my_solution = Solution()
test_input = { "nums": [2,6,7,3,1,7], "m": 3, "k": 4 }
assert my_solution.maxSum(**test_input) == 18
test_input = { "nums": [5,9,9,2,4,5,4], "m": 1, "k": 3 }
assert my_solution.maxSum(**test_input) == 23
test_input = { "nums": [1,2,1,2,1,2,1], "m": 3, "k": 3 }
assert my_solution.maxSum(**te... | 1,693,665,000 |
biweekly-contest-112-count-k-subsequences-of-a-string-with-maximum-beauty | https://leetcode.com/problems/count-k-subsequences-of-a-string-with-maximum-beauty | count-k-subsequences-of-a-string-with-maximum-beauty | {
"questionId": "3057",
"questionFrontendId": "2842",
"title": "Count K-Subsequences of a String With Maximum Beauty",
"titleSlug": "count-k-subsequences-of-a-string-with-maximum-beauty",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 286,
"dislikes": 21,
"categoryTitle": "Algorithms"
} | """
给你一个字符串 s 和一个整数 k 。
k 子序列指的是 s 的一个长度为 k 的 子序列 ，且所有字符都是 唯一 的，也就是说每个字符在子序列里只出现过一次。
定义 f(c) 为字符 c 在 s 中出现的次数。
k 子序列的 美丽值 定义为这个子序列中每一个字符 c 的 f(c) 之 和 。
比方说，s = "abbbdd" 和 k = 2 ，我们有：
* f('a') = 1, f('b') = 3, f('d') = 2
* s 的部分 k 子序列为：
* "abbbdd" -> "ab" ，美丽值为 f('a') + f('b') = 4
* "abbbdd" -> "ad" ，美丽值为 f... | 给你一个字符串 s 和一个整数 k 。
k 子序列指的是 s 的一个长度为 k 的 子序列 ，且所有字符都是 唯一 的，也就是说每个字符在子序列里只出现过一次。
定义 f(c) 为字符 c 在 s 中出现的次数。
k 子序列的 美丽值 定义为这个子序列中每一个字符 c 的 f(c) 之 和 。
比方说，s = "abbbdd" 和 k = 2 ，我们有：
* f('a') = 1, f('b') = 3, f('d') = 2
* s 的部分 k 子序列为：
* "abbbdd" -> "ab" ，美丽值为 f('a') + f('b') = 4
* "abbbdd" -> "ad" ，美丽值为 f('a'... |
my_solution = Solution()
test_input = { "s": "bcca", "k": 2 }
assert my_solution.countKSubsequencesWithMaxBeauty(**test_input) == 4
test_input = { "s": "abbcd", "k": 4 }
assert my_solution.countKSubsequencesWithMaxBeauty(**test_input) == 2
test_input = { "s": "am", "k": 2 }
assert my_solution.countKSubsequencesWith... | 1,693,665,000 |
weekly-contest-360-furthest-point-from-origin | https://leetcode.com/problems/furthest-point-from-origin | furthest-point-from-origin | {
"questionId": "3019",
"questionFrontendId": "2833",
"title": "Furthest Point From Origin",
"titleSlug": "furthest-point-from-origin",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 203,
"dislikes": 29,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 的字符串 moves ，该字符串仅由字符 'L'、'R' 和 '_' 组成。字符串表示你在一条原点为 0 的数轴上的若干次移动。
你的初始位置就在原点（0），第 i 次移动过程中，你可以根据对应字符选择移动方向：
* 如果 moves[i] = 'L' 或 moves[i] = '_' ，可以选择向左移动一个单位距离
* 如果 moves[i] = 'R' 或 moves[i] = '_' ，可以选择向右移动一个单位距离
移动 n 次之后，请你找出可以到达的距离原点 最远 的点，并返回 从原点到这一点的距离 。
示例 1：
输入：moves = "L_RL__R"
输出：3
解释：可以到达的... | 给你一个长度为 n 的字符串 moves ，该字符串仅由字符 'L'、'R' 和 '_' 组成。字符串表示你在一条原点为 0 的数轴上的若干次移动。
你的初始位置就在原点（0），第 i 次移动过程中，你可以根据对应字符选择移动方向：
* 如果 moves[i] = 'L' 或 moves[i] = '_' ，可以选择向左移动一个单位距离
* 如果 moves[i] = 'R' 或 moves[i] = '_' ，可以选择向右移动一个单位距离
移动 n 次之后，请你找出可以到达的距离原点 最远 的点，并返回 从原点到这一点的距离 。
示例 1：
输入：moves = "L_RL__R"
输出：3
解释：可以到达的距离原点... |
my_solution = Solution()
test_input = { "moves": "L_RL__R" }
assert my_solution.furthestDistanceFromOrigin(**test_input) == 3
test_input = { "moves": "_R__LL_" }
assert my_solution.furthestDistanceFromOrigin(**test_input) == 5
test_input = { "moves": "_______" }
assert my_solution.furthestDistanceFromOrigin(**test_... | 1,693,103,400 |
weekly-contest-360-find-the-minimum-possible-sum-of-a-beautiful-array | https://leetcode.com/problems/find-the-minimum-possible-sum-of-a-beautiful-array | find-the-minimum-possible-sum-of-a-beautiful-array | {
"questionId": "3026",
"questionFrontendId": "2834",
"title": "Find the Minimum Possible Sum of a Beautiful Array",
"titleSlug": "find-the-minimum-possible-sum-of-a-beautiful-array",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 276,
"dislikes": 37,
"categoryTitle": "Algorithms"
} | """
给你两个正整数：n 和 target 。
如果数组 nums 满足下述条件，则称其为 美丽数组 。
* nums.length == n.
* nums 由两两互不相同的正整数组成。
* 在范围 [0, n-1] 内，不存在 两个 不同 下标 i 和 j ，使得 nums[i] + nums[j] == target 。
返回符合条件的美丽数组所可能具备的 最小 和，并对结果进行取模 109 + 7。
示例 1：
输入：n = 2, target = 3
输出：4
解释：nums = [1,3] 是美丽数组。
- nums 的长度为 n = 2 。
- nums 由两两互不相同的正整数组成。
- 不存在两个不... | 给你两个正整数：n 和 target 。
如果数组 nums 满足下述条件，则称其为 美丽数组 。
* nums.length == n.
* nums 由两两互不相同的正整数组成。
* 在范围 [0, n-1] 内，不存在 两个 不同 下标 i 和 j ，使得 nums[i] + nums[j] == target 。
返回符合条件的美丽数组所可能具备的 最小 和，并对结果进行取模 109 + 7。
示例 1：
输入：n = 2, target = 3
输出：4
解释：nums = [1,3] 是美丽数组。
- nums 的长度为 n = 2 。
- nums 由两两互不相同的正整数组成。
- 不存在两个不同下标 ... |
my_solution = Solution()
test_input = { "n": 2, "target": 3 }
assert my_solution.minimumPossibleSum(**test_input) == 4
test_input = { "n": 3, "target": 3 }
assert my_solution.minimumPossibleSum(**test_input) == 8
test_input = { "n": 1, "target": 1 }
assert my_solution.minimumPossibleSum(**test_input) == 1
test_inp... | 1,693,103,400 |
weekly-contest-360-minimum-operations-to-form-subsequence-with-target-sum | https://leetcode.com/problems/minimum-operations-to-form-subsequence-with-target-sum | minimum-operations-to-form-subsequence-with-target-sum | {
"questionId": "3025",
"questionFrontendId": "2835",
"title": "Minimum Operations to Form Subsequence With Target Sum",
"titleSlug": "minimum-operations-to-form-subsequence-with-target-sum",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 503,
"dislikes": 125,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的数组 nums ，它包含 非负 整数，且全部为 2 的幂，同时给你一个整数 target 。
一次操作中，你必须对数组做以下修改：
* 选择数组中一个元素 nums[i] ，满足 nums[i] > 1 。
* 将 nums[i] 从数组中删除。
* 在 nums 的 末尾 添加 两个 数，值都为 nums[i] / 2 。
你的目标是让 nums 的一个 子序列 的元素和等于 target ，请你返回达成这一目标的 最少操作次数 。如果无法得到这样的子序列，请你返回 -1 。
数组中一个 子序列 是通过删除原数组中一些元素，并且不改变剩余元素顺序得到的剩余数组。
示例 1：
输入... | 给你一个下标从 0 开始的数组 nums ，它包含 非负 整数，且全部为 2 的幂，同时给你一个整数 target 。
一次操作中，你必须对数组做以下修改：
* 选择数组中一个元素 nums[i] ，满足 nums[i] > 1 。
* 将 nums[i] 从数组中删除。
* 在 nums 的 末尾 添加 两个 数，值都为 nums[i] / 2 。
你的目标是让 nums 的一个 子序列 的元素和等于 target ，请你返回达成这一目标的 最少操作次数 。如果无法得到这样的子序列，请你返回 -1 。
数组中一个 子序列 是通过删除原数组中一些元素，并且不改变剩余元素顺序得到的剩余数组。
示例 1：
输入：num... |
my_solution = Solution()
test_input = { "nums": [1,2,8], "target": 7 }
assert my_solution.minOperations(**test_input) == 1
test_input = { "nums": [1,32,1,2], "target": 12 }
assert my_solution.minOperations(**test_input) == 2
test_input = { "nums": [1,32,1], "target": 35 }
assert my_solution.minOperations(**test_inp... | 1,693,103,400 |
weekly-contest-360-maximize-value-of-function-in-a-ball-passing-game | https://leetcode.com/problems/maximize-value-of-function-in-a-ball-passing-game | maximize-value-of-function-in-a-ball-passing-game | {
"questionId": "3032",
"questionFrontendId": "2836",
"title": "Maximize Value of Function in a Ball Passing Game",
"titleSlug": "maximize-value-of-function-in-a-ball-passing-game",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 202,
"dislikes": 85,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 下标从 0 开始的整数数组 receiver 和一个整数 k 。
总共有 n 名玩家，玩家 编号 互不相同，且为 [0, n - 1] 中的整数。这些玩家玩一个传球游戏，receiver[i] 表示编号为 i 的玩家会传球给编号为 receiver[i] 的玩家。玩家可以传球给自己，也就是说 receiver[i] 可能等于 i 。
你需要从 n 名玩家中选择一名玩家作为游戏开始时唯一手中有球的玩家，球会被传 恰好 k 次。
如果选择编号为 x 的玩家作为开始玩家，定义函数 f(x) 表示从编号为 x 的玩家开始，k 次传球内所有接触过球玩家的编号之 和 ，如果有玩家多次触球，则 累加多次 。换句话... | 给你一个长度为 n 下标从 0 开始的整数数组 receiver 和一个整数 k 。
总共有 n 名玩家，玩家 编号 互不相同，且为 [0, n - 1] 中的整数。这些玩家玩一个传球游戏，receiver[i] 表示编号为 i 的玩家会传球给编号为 receiver[i] 的玩家。玩家可以传球给自己，也就是说 receiver[i] 可能等于 i 。
你需要从 n 名玩家中选择一名玩家作为游戏开始时唯一手中有球的玩家，球会被传 恰好 k 次。
如果选择编号为 x 的玩家作为开始玩家，定义函数 f(x) 表示从编号为 x 的玩家开始，k 次传球内所有接触过球玩家的编号之 和 ，如果有玩家多次触球，则 累加多次 。换句话说， f... |
my_solution = Solution()
test_input = { "receiver": [2,0,1], "k": 4 }
assert my_solution.getMaxFunctionValue(**test_input) == 6
test_input = { "receiver": [1,1,1,2,3], "k": 3 }
assert my_solution.getMaxFunctionValue(**test_input) == 10
test_input = { "receiver": [0], "k": 1 }
assert my_solution.getMaxFunctionValue(... | 1,693,103,400 |
weekly-contest-359-check-if-a-string-is-an-acronym-of-words | https://leetcode.com/problems/check-if-a-string-is-an-acronym-of-words | check-if-a-string-is-an-acronym-of-words | {
"questionId": "2977",
"questionFrontendId": "2828",
"title": "Check if a String Is an Acronym of Words",
"titleSlug": "check-if-a-string-is-an-acronym-of-words",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 257,
"dislikes": 7,
"categoryTitle": "Algorithms"
} | """
给你一个字符串数组 words 和一个字符串 s ，请你判断 s 是不是 words 的 首字母缩略词 。
如果可以按顺序串联 words 中每个字符串的第一个字符形成字符串 s ，则认为 s 是 words 的首字母缩略词。例如，"ab" 可以由 ["apple", "banana"] 形成，但是无法从 ["bear", "aardvark"] 形成。
如果 s 是 words 的首字母缩略词，返回 true ；否则，返回 false 。
示例 1：
输入：words = ["alice","bob","charlie"], s = "abc"
输出：true
解释：words 中 "alice"、"bob" 和 ... | 给你一个字符串数组 words 和一个字符串 s ，请你判断 s 是不是 words 的 首字母缩略词 。
如果可以按顺序串联 words 中每个字符串的第一个字符形成字符串 s ，则认为 s 是 words 的首字母缩略词。例如，"ab" 可以由 ["apple", "banana"] 形成，但是无法从 ["bear", "aardvark"] 形成。
如果 s 是 words 的首字母缩略词，返回 true ；否则，返回 false 。
示例 1：
输入：words = ["alice","bob","charlie"], s = "abc"
输出：true
解释：words 中 "alice"、"bob" 和 "cha... |
my_solution = Solution()
test_input = { "words": ["an","apple"], "s": "a" }
assert my_solution.isAcronym(**test_input) == False
test_input = { "words": ["alice","bob","charlie"], "s": "abc" }
assert my_solution.isAcronym(**test_input) == True
test_input = { "words": ["never","gonna","give","up","on","you"], "s": "n... | 1,692,498,600 |
weekly-contest-359-determine-the-minimum-sum-of-a-k-avoiding-array | https://leetcode.com/problems/determine-the-minimum-sum-of-a-k-avoiding-array | determine-the-minimum-sum-of-a-k-avoiding-array | {
"questionId": "2811",
"questionFrontendId": "2829",
"title": "Determine the Minimum Sum of a k-avoiding Array",
"titleSlug": "determine-the-minimum-sum-of-a-k-avoiding-array",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 305,
"dislikes": 8,
"categoryTitle": "Algorithms"
} | """
给你两个整数 n 和 k 。
对于一个由 不同 正整数组成的数组，如果其中不存在任何求和等于 k 的不同元素对，则称其为 k-avoiding 数组。
返回长度为 n 的 k-avoiding 数组的可能的最小总和。
示例 1：
输入：n = 5, k = 4
输出：18
解释：设若 k-avoiding 数组为 [1,2,4,5,6] ，其元素总和为 18 。
可以证明不存在总和小于 18 的 k-avoiding 数组。
示例 2：
输入：n = 2, k = 6
输出：3
解释：可以构造数组 [1,2] ，其元素总和为 3 。
可以证明不存在总和小于 3 的 k-avoiding 数组。
提示：
*... | 给你两个整数 n 和 k 。
对于一个由 不同 正整数组成的数组，如果其中不存在任何求和等于 k 的不同元素对，则称其为 k-avoiding 数组。
返回长度为 n 的 k-avoiding 数组的可能的最小总和。
示例 1：
输入：n = 5, k = 4
输出：18
解释：设若 k-avoiding 数组为 [1,2,4,5,6] ，其元素总和为 18 。
可以证明不存在总和小于 18 的 k-avoiding 数组。
示例 2：
输入：n = 2, k = 6
输出：3
解释：可以构造数组 [1,2] ，其元素总和为 3 。
可以证明不存在总和小于 3 的 k-avoiding 数组。
提示：
* 1 <... |
my_solution = Solution()
test_input = { "n": 5, "k": 4 }
assert my_solution.minimumSum(**test_input) == 18
test_input = { "n": 2, "k": 6 }
assert my_solution.minimumSum(**test_input) == 3
test_input = { "n": 1, "k": 1 }
assert my_solution.minimumSum(**test_input) == 1
test_input = { "n": 1, "k": 2 }
assert my_solu... | 1,692,498,600 |
weekly-contest-359-maximize-the-profit-as-the-salesman | https://leetcode.com/problems/maximize-the-profit-as-the-salesman | maximize-the-profit-as-the-salesman | {
"questionId": "2979",
"questionFrontendId": "2830",
"title": "Maximize the Profit as the Salesman",
"titleSlug": "maximize-the-profit-as-the-salesman",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 603,
"dislikes": 19,
"categoryTitle": "Algorithms"
} | """
给你一个整数 n 表示数轴上的房屋数量，编号从 0 到 n - 1 。
另给你一个二维整数数组 offers ，其中 offers[i] = [starti, endi, goldi] 表示第 i 个买家想要以 goldi 枚金币的价格购买从 starti 到 endi 的所有房屋。
作为一名销售，你需要有策略地选择并销售房屋使自己的收入最大化。
返回你可以赚取的金币的最大数目。
注意 同一所房屋不能卖给不同的买家，并且允许保留一些房屋不进行出售。
示例 1：
输入：n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
输出：3
解释：
有 5 所房屋，编号从 0 到 4 ，共有 3... | 给你一个整数 n 表示数轴上的房屋数量，编号从 0 到 n - 1 。
另给你一个二维整数数组 offers ，其中 offers[i] = [starti, endi, goldi] 表示第 i 个买家想要以 goldi 枚金币的价格购买从 starti 到 endi 的所有房屋。
作为一名销售，你需要有策略地选择并销售房屋使自己的收入最大化。
返回你可以赚取的金币的最大数目。
注意 同一所房屋不能卖给不同的买家，并且允许保留一些房屋不进行出售。
示例 1：
输入：n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
输出：3
解释：
有 5 所房屋，编号从 0 到 4 ，共有 3 个购买... |
my_solution = Solution()
test_input = { "n": 5, "offers": [[0,0,1],[0,2,2],[1,3,2]] }
assert my_solution.maximizeTheProfit(**test_input) == 3
test_input = { "n": 5, "offers": [[0,0,1],[0,2,10],[1,3,2]] }
assert my_solution.maximizeTheProfit(**test_input) == 10
test_input = { "n": 4, "offers": [[1,3,10],[1,3,3],[0,0... | 1,692,498,600 |
weekly-contest-359-find-the-longest-equal-subarray | https://leetcode.com/problems/find-the-longest-equal-subarray | find-the-longest-equal-subarray | {
"questionId": "2832",
"questionFrontendId": "2831",
"title": "Find the Longest Equal Subarray",
"titleSlug": "find-the-longest-equal-subarray",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 579,
"dislikes": 14,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。
如果子数组中所有元素都相等，则认为子数组是一个 等值子数组 。注意，空数组是 等值子数组 。
从 nums 中删除最多 k 个元素后，返回可能的最长等值子数组的长度。
子数组 是数组中一个连续且可能为空的元素序列。
示例 1：
输入：nums = [1,3,2,3,1,3], k = 3
输出：3
解释：最优的方案是删除下标 2 和下标 4 的元素。
删除后，nums 等于 [1, 3, 3, 3] 。
最长等值子数组从 i = 1 开始到 j = 3 结束，长度等于 3 。
可以证明无法创建更长的等值子数组。
示例 2：
输入：nums = [... | 给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。
如果子数组中所有元素都相等，则认为子数组是一个 等值子数组 。注意，空数组是 等值子数组 。
从 nums 中删除最多 k 个元素后，返回可能的最长等值子数组的长度。
子数组 是数组中一个连续且可能为空的元素序列。
示例 1：
输入：nums = [1,3,2,3,1,3], k = 3
输出：3
解释：最优的方案是删除下标 2 和下标 4 的元素。
删除后，nums 等于 [1, 3, 3, 3] 。
最长等值子数组从 i = 1 开始到 j = 3 结束，长度等于 3 。
可以证明无法创建更长的等值子数组。
示例 2：
输入：nums = [1,1,... |
my_solution = Solution()
test_input = { "nums": [1,3,2,3,1,3], "k": 3 }
assert my_solution.longestEqualSubarray(**test_input) == 3
test_input = { "nums": [1,1,2,2,1,1], "k": 2 }
assert my_solution.longestEqualSubarray(**test_input) == 4
test_input = { "nums": [1], "k": 0 }
assert my_solution.longestEqualSubarray(**... | 1,692,498,600 |
biweekly-contest-111-count-pairs-whose-sum-is-less-than-target | https://leetcode.com/problems/count-pairs-whose-sum-is-less-than-target | count-pairs-whose-sum-is-less-than-target | {
"questionId": "2917",
"questionFrontendId": "2824",
"title": "Count Pairs Whose Sum is Less than Target",
"titleSlug": "count-pairs-whose-sum-is-less-than-target",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 358,
"dislikes": 23,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始长度为 n 的整数数组 nums 和一个整数 target ，请你返回满足 0 <= i < j < n 且 nums[i] + nums[j] < target 的下标对 (i, j) 的数目。
示例 1：
输入：nums = [-1,1,2,3,1], target = 2
输出：3
解释：总共有 3 个下标对满足题目描述：
- (0, 1) ，0 < 1 且 nums[0] + nums[1] = 0 < target
- (0, 2) ，0 < 2 且 nums[0] + nums[2] = 1 < target
- (0, 4) ，0 < 4 且 nums[0] + nums[4] = ... | 给你一个下标从 0 开始长度为 n 的整数数组 nums 和一个整数 target ，请你返回满足 0 <= i < j < n 且 nums[i] + nums[j] < target 的下标对 (i, j) 的数目。
示例 1：
输入：nums = [-1,1,2,3,1], target = 2
输出：3
解释：总共有 3 个下标对满足题目描述：
- (0, 1) ，0 < 1 且 nums[0] + nums[1] = 0 < target
- (0, 2) ，0 < 2 且 nums[0] + nums[2] = 1 < target
- (0, 4) ，0 < 4 且 nums[0] + nums[4] = 0 < ... |
my_solution = Solution()
test_input = { "nums": [-1,1,2,3,1], "target": 2 }
assert my_solution.countPairs(**test_input) == 3
test_input = { "nums": [-6,2,5,-2,-7,-1,3], "target": -2 }
assert my_solution.countPairs(**test_input) == 10
test_input = { "nums": [9,-5,-5,5,-5,-4,-6,6,-6], "target": 3 }
assert my_solution... | 1,692,455,400 |
biweekly-contest-111-make-string-a-subsequence-using-cyclic-increments | https://leetcode.com/problems/make-string-a-subsequence-using-cyclic-increments | make-string-a-subsequence-using-cyclic-increments | {
"questionId": "3018",
"questionFrontendId": "2825",
"title": "Make String a Subsequence Using Cyclic Increments",
"titleSlug": "make-string-a-subsequence-using-cyclic-increments",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 273,
"dislikes": 9,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的字符串 str1 和 str2 。
一次操作中，你选择 str1 中的若干下标。对于选中的每一个下标 i ，你将 str1[i] 循环 递增，变成下一个字符。也就是说 'a' 变成 'b' ，'b' 变成 'c' ，以此类推，'z' 变成 'a' 。
如果执行以上操作 至多一次 ，可以让 str2 成为 str1 的子序列，请你返回 true ，否则返回 false 。
注意：一个字符串的子序列指的是从原字符串中删除一些（可以一个字符也不删）字符后，剩下字符按照原本先后顺序组成的新字符串。
示例 1：
输入：str1 = "abc", str2 = "ad"
输出：true
解释：选择 s... | 给你一个下标从 0 开始的字符串 str1 和 str2 。
一次操作中，你选择 str1 中的若干下标。对于选中的每一个下标 i ，你将 str1[i] 循环 递增，变成下一个字符。也就是说 'a' 变成 'b' ，'b' 变成 'c' ，以此类推，'z' 变成 'a' 。
如果执行以上操作 至多一次 ，可以让 str2 成为 str1 的子序列，请你返回 true ，否则返回 false 。
注意：一个字符串的子序列指的是从原字符串中删除一些（可以一个字符也不删）字符后，剩下字符按照原本先后顺序组成的新字符串。
示例 1：
输入：str1 = "abc", str2 = "ad"
输出：true
解释：选择 str1 ... |
my_solution = Solution()
test_input = { "str1": "ab", "str2": "d" }
assert my_solution.canMakeSubsequence(**test_input) == False
test_input = { "str1": "a", "str2": "d" }
assert my_solution.canMakeSubsequence(**test_input) == False
test_input = { "str1": "abc", "str2": "ad" }
assert my_solution.canMakeSubsequence(*... | 1,692,455,400 |
biweekly-contest-111-sorting-three-groups | https://leetcode.com/problems/sorting-three-groups | sorting-three-groups | {
"questionId": "2904",
"questionFrontendId": "2826",
"title": "Sorting Three Groups",
"titleSlug": "sorting-three-groups",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 347,
"dislikes": 72,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始长度为 n 的整数数组 nums 。
从 0 到 n - 1 的数字被分为编号从 1 到 3 的三个组，数字 i 属于组 nums[i] 。注意，有的组可能是 空的 。
你可以执行以下操作任意次：
* 选择数字 x 并改变它的组。更正式的，你可以将 nums[x] 改为数字 1 到 3 中的任意一个。
你将按照以下过程构建一个新的数组 res ：
1. 将每个组中的数字分别排序。
2. 将组 1 ，2 和 3 中的元素 依次 连接以得到 res 。
如果得到的 res 是 非递减顺序的，那么我们称数组 nums 是 美丽数组 。
请你返回将 nums 变为 美丽数组 需要的最少步数... | 给你一个下标从 0 开始长度为 n 的整数数组 nums 。
从 0 到 n - 1 的数字被分为编号从 1 到 3 的三个组，数字 i 属于组 nums[i] 。注意，有的组可能是 空的 。
你可以执行以下操作任意次：
* 选择数字 x 并改变它的组。更正式的，你可以将 nums[x] 改为数字 1 到 3 中的任意一个。
你将按照以下过程构建一个新的数组 res ：
1. 将每个组中的数字分别排序。
2. 将组 1 ，2 和 3 中的元素 依次 连接以得到 res 。
如果得到的 res 是 非递减顺序的，那么我们称数组 nums 是 美丽数组 。
请你返回将 nums 变为 美丽数组 需要的最少步数。
示... |
my_solution = Solution()
test_input = { "nums": [2,1,3,2,1] }
assert my_solution.minimumOperations(**test_input) == 3
test_input = { "nums": [1,3,2,1,3,3] }
assert my_solution.minimumOperations(**test_input) == 2
test_input = { "nums": [2,2,2,2,3,3] }
assert my_solution.minimumOperations(**test_input) == 0
test_in... | 1,692,455,400 |
biweekly-contest-111-number-of-beautiful-integers-in-the-range | https://leetcode.com/problems/number-of-beautiful-integers-in-the-range | number-of-beautiful-integers-in-the-range | {
"questionId": "3017",
"questionFrontendId": "2827",
"title": "Number of Beautiful Integers in the Range",
"titleSlug": "number-of-beautiful-integers-in-the-range",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 313,
"dislikes": 24,
"categoryTitle": "Algorithms"
} | """
给你正整数 low ，high 和 k 。
如果一个数满足以下两个条件，那么它是 美丽的 ：
* 偶数数位的数目与奇数数位的数目相同。
* 这个整数可以被 k 整除。
请你返回范围 [low, high] 中美丽整数的数目。
示例 1：
输入：low = 10, high = 20, k = 3
输出：2
解释：给定范围中有 2 个美丽数字：[12,18]
- 12 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 3 整除。
- 18 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 3 整除。
以下是一些不是美丽整数的例子：
- 16 不是美丽整数，因为它... | 给你正整数 low ，high 和 k 。
如果一个数满足以下两个条件，那么它是 美丽的 ：
* 偶数数位的数目与奇数数位的数目相同。
* 这个整数可以被 k 整除。
请你返回范围 [low, high] 中美丽整数的数目。
示例 1：
输入：low = 10, high = 20, k = 3
输出：2
解释：给定范围中有 2 个美丽数字：[12,18]
- 12 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 3 整除。
- 18 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 3 整除。
以下是一些不是美丽整数的例子：
- 16 不是美丽整数，因为它不能被 ... |
my_solution = Solution()
test_input = { "low": 10, "high": 20, "k": 3 }
assert my_solution.numberOfBeautifulIntegers(**test_input) == 2
test_input = { "low": 1, "high": 10, "k": 1 }
assert my_solution.numberOfBeautifulIntegers(**test_input) == 1
test_input = { "low": 5, "high": 5, "k": 2 }
assert my_solution.number... | 1,692,455,400 |
weekly-contest-358-max-pair-sum-in-an-array | https://leetcode.com/problems/max-pair-sum-in-an-array | max-pair-sum-in-an-array | {
"questionId": "2902",
"questionFrontendId": "2815",
"title": "Max Pair Sum in an Array",
"titleSlug": "max-pair-sum-in-an-array",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 274,
"dislikes": 91,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 。请你从 nums 中找出和 最大 的一对数，且这两个数数位上最大的数字相等。
返回最大和，如果不存在满足题意的数字对，返回 -1 。
示例 1：
输入：nums = [51,71,17,24,42]
输出：88
解释：
i = 1 和 j = 2 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 71 + 17 = 88 。
i = 3 和 j = 4 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 24 + 42 = 66 。
可以证明不存在其他数对满足数位上最大的数字相等，所以答案是 88 。
示例 2：
输入... | 给你一个下标从 0 开始的整数数组 nums 。请你从 nums 中找出和 最大 的一对数，且这两个数数位上最大的数字相等。
返回最大和，如果不存在满足题意的数字对，返回 -1 。
示例 1：
输入：nums = [51,71,17,24,42]
输出：88
解释：
i = 1 和 j = 2 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 71 + 17 = 88 。
i = 3 和 j = 4 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 24 + 42 = 66 。
可以证明不存在其他数对满足数位上最大的数字相等，所以答案是 88 。
示例 2：
输入：num... |
my_solution = Solution()
test_input = { "nums": [51,71,17,24,42] }
assert my_solution.maxSum(**test_input) == 88
test_input = { "nums": [1,2,3,4] }
assert my_solution.maxSum(**test_input) == -1
test_input = { "nums": [31,25,72,79,74] }
assert my_solution.maxSum(**test_input) == 146
test_input = { "nums": [84,91,18... | 1,691,893,800 |
weekly-contest-358-double-a-number-represented-as-a-linked-list | https://leetcode.com/problems/double-a-number-represented-as-a-linked-list | double-a-number-represented-as-a-linked-list | {
"questionId": "2871",
"questionFrontendId": "2816",
"title": "Double a Number Represented as a Linked List",
"titleSlug": "double-a-number-represented-as-a-linked-list",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 397,
"dislikes": 5,
"categoryTitle": "Algorithms"
} | """
给你一个 非空 链表的头节点 head ，表示一个不含前导零的非负数整数。
将链表 翻倍 后，返回头节点 head 。
示例 1：
[https://assets.leetcode.com/uploads/2023/05/28/example.png]
输入：head = [1,8,9]
输出：[3,7,8]
解释：上图中给出的链表，表示数字 189 。返回的链表表示数字 189 * 2 = 378 。
示例 2：
[https://assets.leetcode.com/uploads/2023/05/28/example2.png]
输入：head = [9,9,9]
输出：[1,9,9,8]
解释：上图中... | 给你一个 非空 链表的头节点 head ，表示一个不含前导零的非负数整数。
将链表 翻倍 后，返回头节点 head 。
示例 1：
[https://assets.leetcode.com/uploads/2023/05/28/example.png]
输入：head = [1,8,9]
输出：[3,7,8]
解释：上图中给出的链表，表示数字 189 。返回的链表表示数字 189 * 2 = 378 。
示例 2：
[https://assets.leetcode.com/uploads/2023/05/28/example2.png]
输入：head = [9,9,9]
输出：[1,9,9,8]
解释：上图中给出的链... |
my_solution = Solution()
_f1 = lambda lst: ListNode(lst[0], _f1(lst[1:])) if lst else None
_f2 = lambda node: [node.val] + _f2(node.next) if node else []
test_input = { "head": _f1([1,8,9]) }
assert _f2(my_solution.doubleIt(**test_input)) == [3,7,8]
test_input = { "head": _f1([9,9,9]) }
assert _f2(my_solution.doub... | 1,691,893,800 |
weekly-contest-358-minimum-absolute-difference-between-elements-with-constraint | https://leetcode.com/problems/minimum-absolute-difference-between-elements-with-constraint | minimum-absolute-difference-between-elements-with-constraint | {
"questionId": "3000",
"questionFrontendId": "2817",
"title": "Minimum Absolute Difference Between Elements With Constraint",
"titleSlug": "minimum-absolute-difference-between-elements-with-constraint",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 618,
"dislikes": 64,
"categoryTitle": "Algor... | """
给你一个下标从 0 开始的整数数组 nums 和一个整数 x 。
请你找到数组中下标距离至少为 x 的两个元素的 差值绝对值 的 最小值 。
换言之，请你找到两个下标 i 和 j ，满足 abs(i - j) >= x 且 abs(nums[i] - nums[j]) 的值最小。
请你返回一个整数，表示下标距离至少为 x 的两个元素之间的差值绝对值的 最小值 。
示例 1：
输入：nums = [4,3,2,4], x = 2
输出：0
解释：我们选择 nums[0] = 4 和 nums[3] = 4 。
它们下标距离满足至少为 2 ，差值绝对值为最小值 0 。
0 是最优解。
示例 2：
输入：nums =... | 给你一个下标从 0 开始的整数数组 nums 和一个整数 x 。
请你找到数组中下标距离至少为 x 的两个元素的 差值绝对值 的 最小值 。
换言之，请你找到两个下标 i 和 j ，满足 abs(i - j) >= x 且 abs(nums[i] - nums[j]) 的值最小。
请你返回一个整数，表示下标距离至少为 x 的两个元素之间的差值绝对值的 最小值 。
示例 1：
输入：nums = [4,3,2,4], x = 2
输出：0
解释：我们选择 nums[0] = 4 和 nums[3] = 4 。
它们下标距离满足至少为 2 ，差值绝对值为最小值 0 。
0 是最优解。
示例 2：
输入：nums = [5,... |
my_solution = Solution()
test_input = { "nums": [4,3,2,4], "x": 2 }
assert my_solution.minAbsoluteDifference(**test_input) == 0
test_input = { "nums": [5,3,2,10,15], "x": 1 }
assert my_solution.minAbsoluteDifference(**test_input) == 1
test_input = { "nums": [1,2,3,4], "x": 3 }
assert my_solution.minAbsoluteDifferen... | 1,691,893,800 |
weekly-contest-358-apply-operations-to-maximize-score | https://leetcode.com/problems/apply-operations-to-maximize-score | apply-operations-to-maximize-score | {
"questionId": "3001",
"questionFrontendId": "2818",
"title": "Apply Operations to Maximize Score",
"titleSlug": "apply-operations-to-maximize-score",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 301,
"dislikes": 9,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 的正整数数组 nums 和一个整数 k 。
一开始，你的分数为 1 。你可以进行以下操作至多 k 次，目标是使你的分数最大：
* 选择一个之前没有选过的 非空 子数组 nums[l, ..., r] 。
* 从 nums[l, ..., r] 里面选择一个 质数分数 最高的元素 x 。如果多个元素质数分数相同且最高，选择下标最小的一个。
* 将你的分数乘以 x 。
nums[l, ..., r] 表示 nums 中起始下标为 l ，结束下标为 r 的子数组，两个端点都包含。
一个整数的 质数分数 等于 x 不同质因子的数目。比方说， 300 的质数分数为 3 ，因为 300 = 2 * 2 ... | 给你一个长度为 n 的正整数数组 nums 和一个整数 k 。
一开始，你的分数为 1 。你可以进行以下操作至多 k 次，目标是使你的分数最大：
* 选择一个之前没有选过的 非空 子数组 nums[l, ..., r] 。
* 从 nums[l, ..., r] 里面选择一个 质数分数 最高的元素 x 。如果多个元素质数分数相同且最高，选择下标最小的一个。
* 将你的分数乘以 x 。
nums[l, ..., r] 表示 nums 中起始下标为 l ，结束下标为 r 的子数组，两个端点都包含。
一个整数的 质数分数 等于 x 不同质因子的数目。比方说， 300 的质数分数为 3 ，因为 300 = 2 * 2 * 3 ... |
my_solution = Solution()
test_input = { "nums": [8,3,9,3,8], "k": 2 }
assert my_solution.maximumScore(**test_input) == 81
test_input = { "nums": [19,12,14,6,10,18], "k": 3 }
assert my_solution.maximumScore(**test_input) == 4788
test_input = { "nums": [3289,2832,14858,22011], "k": 6 }
assert my_solution.maximumScore... | 1,691,893,800 |
weekly-contest-357-faulty-keyboard | https://leetcode.com/problems/faulty-keyboard | faulty-keyboard | {
"questionId": "2886",
"questionFrontendId": "2810",
"title": "Faulty Keyboard",
"titleSlug": "faulty-keyboard",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 343,
"dislikes": 5,
"categoryTitle": "Algorithms"
} | """
你的笔记本键盘存在故障，每当你在上面输入字符 'i' 时，它会反转你所写的字符串。而输入其他字符则可以正常工作。
给你一个下标从 0 开始的字符串 s ，请你用故障键盘依次输入每个字符。
返回最终笔记本屏幕上输出的字符串。
示例 1：
输入：s = "string"
输出："rtsng"
解释：
输入第 1 个字符后，屏幕上的文本是："s" 。
输入第 2 个字符后，屏幕上的文本是："st" 。
输入第 3 个字符后，屏幕上的文本是："str" 。
因为第 4 个字符是 'i' ，屏幕上的文本被反转，变成 "rts" 。
输入第 5 个字符后，屏幕上的文本是："rtsn" 。
输入第 6 个字符后，屏幕上的文本是： ... | 你的笔记本键盘存在故障，每当你在上面输入字符 'i' 时，它会反转你所写的字符串。而输入其他字符则可以正常工作。
给你一个下标从 0 开始的字符串 s ，请你用故障键盘依次输入每个字符。
返回最终笔记本屏幕上输出的字符串。
示例 1：
输入：s = "string"
输出："rtsng"
解释：
输入第 1 个字符后，屏幕上的文本是："s" 。
输入第 2 个字符后，屏幕上的文本是："st" 。
输入第 3 个字符后，屏幕上的文本是："str" 。
因为第 4 个字符是 'i' ，屏幕上的文本被反转，变成 "rts" 。
输入第 5 个字符后，屏幕上的文本是："rtsn" 。
输入第 6 个字符后，屏幕上的文本是： "rts... |
my_solution = Solution()
test_input = { "s": "string" }
assert my_solution.finalString(**test_input) == "rtsng"
test_input = { "s": "poiinter" }
assert my_solution.finalString(**test_input) == "ponter"
test_input = { "s": "goci" }
assert my_solution.finalString(**test_input) == "cog"
test_input = { "s": "ksi" }
as... | 1,691,289,000 |
weekly-contest-357-check-if-it-is-possible-to-split-array | https://leetcode.com/problems/check-if-it-is-possible-to-split-array | check-if-it-is-possible-to-split-array | {
"questionId": "2916",
"questionFrontendId": "2811",
"title": "Check if it is Possible to Split Array",
"titleSlug": "check-if-it-is-possible-to-split-array",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 425,
"dislikes": 84,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 的数组 nums 和一个整数 m 。请你判断能否执行一系列操作，将数组拆分成 n 个 非空 数组。
在每一步操作中，你可以选择一个 长度至少为 2 的现有数组（之前步骤的结果） 并将其拆分成 2 个子数组，而得到的 每个 子数组，至少 需要满足以下条件之一：
* 子数组的长度为 1 ，或者
* 子数组元素之和 大于或等于 m 。
如果你可以将给定数组拆分成 n 个满足要求的数组，返回 true ；否则，返回 false 。
注意：子数组是数组中的一个连续非空元素序列。
示例 1：
输入：nums = [2, 2, 1], m = 4
输出：true
解释：
第 1 步，将数组 nums ... | 给你一个长度为 n 的数组 nums 和一个整数 m 。请你判断能否执行一系列操作，将数组拆分成 n 个 非空 数组。
在每一步操作中，你可以选择一个 长度至少为 2 的现有数组（之前步骤的结果） 并将其拆分成 2 个子数组，而得到的 每个 子数组，至少 需要满足以下条件之一：
* 子数组的长度为 1 ，或者
* 子数组元素之和 大于或等于 m 。
如果你可以将给定数组拆分成 n 个满足要求的数组，返回 true ；否则，返回 false 。
注意：子数组是数组中的一个连续非空元素序列。
示例 1：
输入：nums = [2, 2, 1], m = 4
输出：true
解释：
第 1 步，将数组 nums 拆分成 ... |
my_solution = Solution()
test_input = { "nums": [2, 2, 1], "m": 4 }
assert my_solution.canSplitArray(**test_input) == True
test_input = { "nums": [2, 3, 3, 2, 3], "m": 6 }
assert my_solution.canSplitArray(**test_input) == True
test_input = { "nums": [1], "m": 1 }
assert my_solution.canSplitArray(**test_input) == Tr... | 1,691,289,000 |
weekly-contest-357-find-the-safest-path-in-a-grid | https://leetcode.com/problems/find-the-safest-path-in-a-grid | find-the-safest-path-in-a-grid | {
"questionId": "2914",
"questionFrontendId": "2812",
"title": "Find the Safest Path in a Grid",
"titleSlug": "find-the-safest-path-in-a-grid",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 706,
"dislikes": 68,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始、大小为 n x n 的二维矩阵 grid ，其中 (r, c) 表示：
* 如果 grid[r][c] = 1 ，则表示一个存在小偷的单元格
* 如果 grid[r][c] = 0 ，则表示一个空单元格
你最开始位于单元格 (0, 0) 。在一步移动中，你可以移动到矩阵中的任一相邻单元格，包括存在小偷的单元格。
矩阵中路径的 安全系数 定义为：从路径中任一单元格到矩阵中任一小偷所在单元格的 最小 曼哈顿距离。
返回所有通向单元格 (n - 1, n - 1) 的路径中的 最大安全系数 。
单元格 (r, c) 的某个 相邻 单元格，是指在矩阵中存在的 (r, c + 1)、(r, c ... | 给你一个下标从 0 开始、大小为 n x n 的二维矩阵 grid ，其中 (r, c) 表示：
* 如果 grid[r][c] = 1 ，则表示一个存在小偷的单元格
* 如果 grid[r][c] = 0 ，则表示一个空单元格
你最开始位于单元格 (0, 0) 。在一步移动中，你可以移动到矩阵中的任一相邻单元格，包括存在小偷的单元格。
矩阵中路径的 安全系数 定义为：从路径中任一单元格到矩阵中任一小偷所在单元格的 最小 曼哈顿距离。
返回所有通向单元格 (n - 1, n - 1) 的路径中的 最大安全系数 。
单元格 (r, c) 的某个 相邻 单元格，是指在矩阵中存在的 (r, c + 1)、(r, c - 1)... |
my_solution = Solution()
test_input = { "grid": [[1,0,0],[0,0,0],[0,0,1]] }
assert my_solution.maximumSafenessFactor(**test_input) == 0
test_input = { "grid": [[0,0,1],[0,0,0],[0,0,0]] }
assert my_solution.maximumSafenessFactor(**test_input) == 2
test_input = { "grid": [[0,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,0]] }
as... | 1,691,289,000 |
weekly-contest-357-maximum-elegance-of-a-k-length-subsequence | https://leetcode.com/problems/maximum-elegance-of-a-k-length-subsequence | maximum-elegance-of-a-k-length-subsequence | {
"questionId": "2894",
"questionFrontendId": "2813",
"title": "Maximum Elegance of a K-Length Subsequence",
"titleSlug": "maximum-elegance-of-a-k-length-subsequence",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 270,
"dislikes": 3,
"categoryTitle": "Algorithms"
} | """
给你一个长度为 n 的二维整数数组 items 和一个整数 k 。
items[i] = [profiti, categoryi]，其中 profiti 和 categoryi 分别表示第 i 个项目的利润和类别。
现定义 items 的 子序列 的 优雅度 可以用 total_profit + distinct_categories2 计算，其中 total_profit 是子序列中所有项目的利润总和，distinct_categories 是所选子序列所含的所有类别中不同类别的数量。
你的任务是从 items 所有长度为 k 的子序列中，找出 最大优雅度 。
用整数形式表示并返回 items 中所有长度恰好为 k... | 给你一个长度为 n 的二维整数数组 items 和一个整数 k 。
items[i] = [profiti, categoryi]，其中 profiti 和 categoryi 分别表示第 i 个项目的利润和类别。
现定义 items 的 子序列 的 优雅度 可以用 total_profit + distinct_categories2 计算，其中 total_profit 是子序列中所有项目的利润总和，distinct_categories 是所选子序列所含的所有类别中不同类别的数量。
你的任务是从 items 所有长度为 k 的子序列中，找出 最大优雅度 。
用整数形式表示并返回 items 中所有长度恰好为 k 的子序... |
my_solution = Solution()
test_input = { "items": [[3,2],[5,1],[10,1]], "k": 2 }
assert my_solution.findMaximumElegance(**test_input) == 17
test_input = { "items": [[3,1],[3,1],[2,2],[5,3]], "k": 3 }
assert my_solution.findMaximumElegance(**test_input) == 19
test_input = { "items": [[1,1],[2,1],[3,1]], "k": 3 }
asse... | 1,691,289,000 |
biweekly-contest-110-account-balance-after-rounded-purchase | https://leetcode.com/problems/account-balance-after-rounded-purchase | account-balance-after-rounded-purchase | {
"questionId": "2955",
"questionFrontendId": "2806",
"title": "Account Balance After Rounded Purchase",
"titleSlug": "account-balance-after-rounded-purchase",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 178,
"dislikes": 37,
"categoryTitle": "Algorithms"
} | """
一开始，你的银行账户里有 100 块钱。
给你一个整数purchaseAmount ，它表示你在一次购买中愿意支出的金额。
在一个商店里，你进行一次购买，实际支出的金额会向 最近 的 10 的 倍数 取整。换句话说，你实际会支付一个 非负 金额 roundedAmount ，满足 roundedAmount 是 10 的倍数且 abs(roundedAmount - purchaseAmount) 的值 最小 。
如果存在多于一个最接近的 10 的倍数，较大的倍数 是你的实际支出金额。
请你返回一个整数，表示你在愿意支出金额为 purchaseAmount 块钱的前提下，购买之后剩下的余额。
注意： 0 也是 10... | 一开始，你的银行账户里有 100 块钱。
给你一个整数purchaseAmount ，它表示你在一次购买中愿意支出的金额。
在一个商店里，你进行一次购买，实际支出的金额会向 最近 的 10 的 倍数 取整。换句话说，你实际会支付一个 非负 金额 roundedAmount ，满足 roundedAmount 是 10 的倍数且 abs(roundedAmount - purchaseAmount) 的值 最小 。
如果存在多于一个最接近的 10 的倍数，较大的倍数 是你的实际支出金额。
请你返回一个整数，表示你在愿意支出金额为 purchaseAmount 块钱的前提下，购买之后剩下的余额。
注意： 0 也是 10 的倍数... |
my_solution = Solution()
test_input = { "purchaseAmount": 9 }
assert my_solution.accountBalanceAfterPurchase(**test_input) == 90
test_input = { "purchaseAmount": 15 }
assert my_solution.accountBalanceAfterPurchase(**test_input) == 80
test_input = { "purchaseAmount": 10 }
assert my_solution.accountBalanceAfterPurcha... | 1,691,245,800 |
biweekly-contest-110-insert-greatest-common-divisors-in-linked-list | https://leetcode.com/problems/insert-greatest-common-divisors-in-linked-list | insert-greatest-common-divisors-in-linked-list | {
"questionId": "2903",
"questionFrontendId": "2807",
"title": "Insert Greatest Common Divisors in Linked List",
"titleSlug": "insert-greatest-common-divisors-in-linked-list",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 390,
"dislikes": 12,
"categoryTitle": "Algorithms"
} | """
给你一个链表的头 head ，每个结点包含一个整数值。
在相邻结点之间，请你插入一个新的结点，结点值为这两个相邻结点值的 最大公约数 。
请你返回插入之后的链表。
两个数的 最大公约数 是可以被两个数字整除的最大正整数。
示例 1：
[https://assets.leetcode.com/uploads/2023/07/18/ex1_copy.png]
输入：head = [18,6,10,3]
输出：[18,6,6,2,10,1,3]
解释：第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。
- 18 和 6 的最大公约数为 6 ，插入第一和第二个结点之间。
- 6 和 10 的最大... | 给你一个链表的头 head ，每个结点包含一个整数值。
在相邻结点之间，请你插入一个新的结点，结点值为这两个相邻结点值的 最大公约数 。
请你返回插入之后的链表。
两个数的 最大公约数 是可以被两个数字整除的最大正整数。
示例 1：
[https://assets.leetcode.com/uploads/2023/07/18/ex1_copy.png]
输入：head = [18,6,10,3]
输出：[18,6,6,2,10,1,3]
解释：第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。
- 18 和 6 的最大公约数为 6 ，插入第一和第二个结点之间。
- 6 和 10 的最大公约数为... |
my_solution = Solution()
_f1 = lambda lst: ListNode(lst[0], _f1(lst[1:])) if lst else None
_f2 = lambda node: [node.val] + _f2(node.next) if node else []
test_input = { "head": _f1([18,6,10,3]) }
assert _f2(my_solution.insertGreatestCommonDivisors(**test_input)) == [18,6,6,2,10,1,3]
test_input = { "head": _f1([7])... | 1,691,245,800 |
biweekly-contest-110-minimum-seconds-to-equalize-a-circular-array | https://leetcode.com/problems/minimum-seconds-to-equalize-a-circular-array | minimum-seconds-to-equalize-a-circular-array | {
"questionId": "2920",
"questionFrontendId": "2808",
"title": "Minimum Seconds to Equalize a Circular Array",
"titleSlug": "minimum-seconds-to-equalize-a-circular-array",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 481,
"dislikes": 25,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始长度为 n 的数组 nums 。
每一秒，你可以对数组执行以下操作：
* 对于范围在 [0, n - 1] 内的每一个下标 i ，将 nums[i] 替换成 nums[i] ，nums[(i - 1 + n) % n] 或者 nums[(i + 1) % n] 三者之一。
注意，所有元素会被同时替换。
请你返回将数组 nums 中所有元素变成相等元素所需要的 最少 秒数。
示例 1：
输入：nums = [1,2,1,2]
输出：1
解释：我们可以在 1 秒内将数组变成相等元素：
- 第 1 秒，将每个位置的元素分别变为 [nums[3],nums[1],nums[3],nums[3]]... | 给你一个下标从 0 开始长度为 n 的数组 nums 。
每一秒，你可以对数组执行以下操作：
* 对于范围在 [0, n - 1] 内的每一个下标 i ，将 nums[i] 替换成 nums[i] ，nums[(i - 1 + n) % n] 或者 nums[(i + 1) % n] 三者之一。
注意，所有元素会被同时替换。
请你返回将数组 nums 中所有元素变成相等元素所需要的 最少 秒数。
示例 1：
输入：nums = [1,2,1,2]
输出：1
解释：我们可以在 1 秒内将数组变成相等元素：
- 第 1 秒，将每个位置的元素分别变为 [nums[3],nums[1],nums[3],nums[3]] 。变化... |
my_solution = Solution()
test_input = { "nums": [1,2,1,2] }
assert my_solution.minimumSeconds(**test_input) == 1
test_input = { "nums": [2,1,3,3,2] }
assert my_solution.minimumSeconds(**test_input) == 2
test_input = { "nums": [5,5,5,5] }
assert my_solution.minimumSeconds(**test_input) == 0
test_input = { "nums": [... | 1,691,245,800 |
biweekly-contest-110-minimum-time-to-make-array-sum-at-most-x | https://leetcode.com/problems/minimum-time-to-make-array-sum-at-most-x | minimum-time-to-make-array-sum-at-most-x | {
"questionId": "2952",
"questionFrontendId": "2809",
"title": "Minimum Time to Make Array Sum At Most x",
"titleSlug": "minimum-time-to-make-array-sum-at-most-x",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 207,
"dislikes": 10,
"categoryTitle": "Algorithms"
} | """
给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2 。每一秒，对于所有下标 0 <= i < nums1.length ，nums1[i] 的值都增加 nums2[i] 。操作 完成后 ，你可以进行如下操作：
* 选择任一满足 0 <= i < nums1.length 的下标 i ，并使 nums1[i] = 0 。
同时给你一个整数 x 。
请你返回使 nums1 中所有元素之和 小于等于 x 所需要的 最少 时间，如果无法实现，那么返回 -1 。
示例 1：
输入：nums1 = [1,2,3], nums2 = [1,2,3], x = 4
输出：3
解释：
第 1 秒，我们对 i =... | 给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2 。每一秒，对于所有下标 0 <= i < nums1.length ，nums1[i] 的值都增加 nums2[i] 。操作 完成后 ，你可以进行如下操作：
* 选择任一满足 0 <= i < nums1.length 的下标 i ，并使 nums1[i] = 0 。
同时给你一个整数 x 。
请你返回使 nums1 中所有元素之和 小于等于 x 所需要的 最少 时间，如果无法实现，那么返回 -1 。
示例 1：
输入：nums1 = [1,2,3], nums2 = [1,2,3], x = 4
输出：3
解释：
第 1 秒，我们对 i = 0 进... |
my_solution = Solution()
test_input = { "nums1": [1,2,3], "nums2": [1,2,3], "x": 4 }
assert my_solution.minimumTime(**test_input) == 3
test_input = { "nums1": [1,2,3], "nums2": [3,3,3], "x": 4 }
assert my_solution.minimumTime(**test_input) == -1
test_input = { "nums1": [4,4,9,10], "nums2": [4,4,1,3], "x": 16 }
asse... | 1,691,245,800 |
weekly-contest-356-number-of-employees-who-met-the-target | https://leetcode.com/problems/number-of-employees-who-met-the-target | number-of-employees-who-met-the-target | {
"questionId": "2876",
"questionFrontendId": "2798",
"title": "Number of Employees Who Met the Target",
"titleSlug": "number-of-employees-who-met-the-target",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 362,
"dislikes": 46,
"categoryTitle": "Algorithms"
} | """
公司里共有 n 名员工，按从 0 到 n - 1 编号。每个员工 i 已经在公司工作了 hours[i] 小时。
公司要求每位员工工作 至少 target 小时。
给你一个下标从 0 开始、长度为 n 的非负整数数组 hours 和一个非负整数 target 。
请你用整数表示并返回工作至少 target 小时的员工数。
示例 1：
输入：hours = [0,1,2,3,4], target = 2
输出：3
解释：公司要求每位员工工作至少 2 小时。
- 员工 0 工作 0 小时，不满足要求。
- 员工 1 工作 1 小时，不满足要求。
- 员工 2 工作 2 小时，满足要求。
- 员工 3 工作 3 小时，满... | 公司里共有 n 名员工，按从 0 到 n - 1 编号。每个员工 i 已经在公司工作了 hours[i] 小时。
公司要求每位员工工作 至少 target 小时。
给你一个下标从 0 开始、长度为 n 的非负整数数组 hours 和一个非负整数 target 。
请你用整数表示并返回工作至少 target 小时的员工数。
示例 1：
输入：hours = [0,1,2,3,4], target = 2
输出：3
解释：公司要求每位员工工作至少 2 小时。
- 员工 0 工作 0 小时，不满足要求。
- 员工 1 工作 1 小时，不满足要求。
- 员工 2 工作 2 小时，满足要求。
- 员工 3 工作 3 小时，满足要求。... |
my_solution = Solution()
test_input = { "hours": [0,1,2,3,4], "target": 2 }
assert my_solution.numberOfEmployeesWhoMetTarget(**test_input) == 3
test_input = { "hours": [5,1,4,2,2], "target": 6 }
assert my_solution.numberOfEmployeesWhoMetTarget(**test_input) == 0
test_input = { "hours": [98], "target": 5 }
assert my... | 1,690,684,200 |
weekly-contest-356-count-complete-subarrays-in-an-array | https://leetcode.com/problems/count-complete-subarrays-in-an-array | count-complete-subarrays-in-an-array | {
"questionId": "2856",
"questionFrontendId": "2799",
"title": "Count Complete Subarrays in an Array",
"titleSlug": "count-complete-subarrays-in-an-array",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 464,
"dislikes": 9,
"categoryTitle": "Algorithms"
} | """
给你一个由 正 整数组成的数组 nums 。
如果数组中的某个子数组满足下述条件，则称之为 完全子数组 ：
* 子数组中 不同 元素的数目等于整个数组不同元素的数目。
返回数组中 完全子数组 的数目。
子数组 是数组中的一个连续非空序列。
示例 1：
输入：nums = [1,3,1,2,2]
输出：4
解释：完全子数组有：[1,3,1,2]、[1,3,1,2,2]、[3,1,2] 和 [3,1,2,2] 。
示例 2：
输入：nums = [5,5,5,5]
输出：10
解释：数组仅由整数 5 组成，所以任意子数组都满足完全子数组的条件。子数组的总数为 10 。
提示：
* 1 <= nums.l... | 给你一个由 正 整数组成的数组 nums 。
如果数组中的某个子数组满足下述条件，则称之为 完全子数组 ：
* 子数组中 不同 元素的数目等于整个数组不同元素的数目。
返回数组中 完全子数组 的数目。
子数组 是数组中的一个连续非空序列。
示例 1：
输入：nums = [1,3,1,2,2]
输出：4
解释：完全子数组有：[1,3,1,2]、[1,3,1,2,2]、[3,1,2] 和 [3,1,2,2] 。
示例 2：
输入：nums = [5,5,5,5]
输出：10
解释：数组仅由整数 5 组成，所以任意子数组都满足完全子数组的条件。子数组的总数为 10 。
提示：
* 1 <= nums.lengt... |
my_solution = Solution()
test_input = { "nums": [1,3,1,2,2] }
assert my_solution.countCompleteSubarrays(**test_input) == 4
test_input = { "nums": [5,5,5,5] }
assert my_solution.countCompleteSubarrays(**test_input) == 10
test_input = { "nums": [459,459,962,1579,1435,756,1872,1597] }
assert my_solution.countCompleteS... | 1,690,684,200 |
weekly-contest-356-shortest-string-that-contains-three-strings | https://leetcode.com/problems/shortest-string-that-contains-three-strings | shortest-string-that-contains-three-strings | {
"questionId": "2877",
"questionFrontendId": "2800",
"title": "Shortest String That Contains Three Strings",
"titleSlug": "shortest-string-that-contains-three-strings",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 301,
"dislikes": 244,
"categoryTitle": "Algorithms"
} | """
给你三个字符串 a ，b 和 c ， 你的任务是找到长度 最短 的字符串，且这三个字符串都是它的 子字符串 。
如果有多个这样的字符串，请你返回 字典序最小 的一个。
请你返回满足题目要求的字符串。
注意：
* 两个长度相同的字符串 a 和 b ，如果在第一个不相同的字符处，a 的字母在字母表中比 b 的字母 靠前 ，那么字符串 a 比字符串 b 字典序小 。
* 子字符串 是一个字符串中一段连续的字符序列。
示例 1：
输入：a = "abc", b = "bca", c = "aaa"
输出："aaabca"
解释：字符串 "aaabca" 包含所有三个字符串：a = ans[2...4] ，b = an... | 给你三个字符串 a ，b 和 c ， 你的任务是找到长度 最短 的字符串，且这三个字符串都是它的 子字符串 。
如果有多个这样的字符串，请你返回 字典序最小 的一个。
请你返回满足题目要求的字符串。
注意：
* 两个长度相同的字符串 a 和 b ，如果在第一个不相同的字符处，a 的字母在字母表中比 b 的字母 靠前 ，那么字符串 a 比字符串 b 字典序小 。
* 子字符串 是一个字符串中一段连续的字符序列。
示例 1：
输入：a = "abc", b = "bca", c = "aaa"
输出："aaabca"
解释：字符串 "aaabca" 包含所有三个字符串：a = ans[2...4] ，b = ans[3.... |
my_solution = Solution()
test_input = { "a": "abc", "b": "bca", "c": "aaa" }
assert my_solution.minimumString(**test_input) == "aaabca"
test_input = { "a": "ab", "b": "ba", "c": "aba" }
assert my_solution.minimumString(**test_input) == "aba"
test_input = { "a": "xyyyz", "b": "xzyz", "c": "zzz" }
assert my_solution.... | 1,690,684,200 |
weekly-contest-356-count-stepping-numbers-in-range | https://leetcode.com/problems/count-stepping-numbers-in-range | count-stepping-numbers-in-range | {
"questionId": "2921",
"questionFrontendId": "2801",
"title": "Count Stepping Numbers in Range",
"titleSlug": "count-stepping-numbers-in-range",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 312,
"dislikes": 8,
"categoryTitle": "Algorithms"
} | """
给你两个正整数 low 和 high ，都用字符串表示，请你统计闭区间 [low, high] 内的 步进数字 数目。
如果一个整数相邻数位之间差的绝对值都 恰好 是 1 ，那么这个数字被称为 步进数字 。
请你返回一个整数，表示闭区间 [low, high] 之间步进数字的数目。
由于答案可能很大，请你将它对 109 + 7 取余 后返回。
注意：步进数字不能有前导 0 。
示例 1：
输入：low = "1", high = "11"
输出：10
解释：区间 [1,11] 内的步进数字为 1 ，2 ，3 ，4 ，5 ，6 ，7 ，8 ，9 和 10 。总共有 10 个步进数字。所以输出为 10 。
示例 2... | 给你两个正整数 low 和 high ，都用字符串表示，请你统计闭区间 [low, high] 内的 步进数字 数目。
如果一个整数相邻数位之间差的绝对值都 恰好 是 1 ，那么这个数字被称为 步进数字 。
请你返回一个整数，表示闭区间 [low, high] 之间步进数字的数目。
由于答案可能很大，请你将它对 109 + 7 取余 后返回。
注意：步进数字不能有前导 0 。
示例 1：
输入：low = "1", high = "11"
输出：10
解释：区间 [1,11] 内的步进数字为 1 ，2 ，3 ，4 ，5 ，6 ，7 ，8 ，9 和 10 。总共有 10 个步进数字。所以输出为 10 。
示例 2：
输... |
my_solution = Solution()
test_input = { "low": "1", "high": "11" }
assert my_solution.countSteppingNumbers(**test_input) == 10
test_input = { "low": "90", "high": "101" }
assert my_solution.countSteppingNumbers(**test_input) == 2
test_input = { "low": "2", "high": "40" }
assert my_solution.countSteppingNumbers(**te... | 1,690,684,200 |
weekly-contest-355-split-strings-by-separator | https://leetcode.com/problems/split-strings-by-separator | split-strings-by-separator | {
"questionId": "2881",
"questionFrontendId": "2788",
"title": "Split Strings by Separator",
"titleSlug": "split-strings-by-separator",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 262,
"dislikes": 4,
"categoryTitle": "Algorithms"
} | """
给你一个字符串数组 words 和一个字符 separator ，请你按 separator 拆分 words 中的每个字符串。
返回一个由拆分后的新字符串组成的字符串数组，不包括空字符串 。
注意
* separator 用于决定拆分发生的位置，但它不包含在结果字符串中。
* 拆分可能形成两个以上的字符串。
* 结果字符串必须保持初始相同的先后顺序。
示例 1：
输入：words = ["one.two.three","four.five","six"], separator = "."
输出：["one","two","three","four","five","six"]
解释：在本示例中，我们进行下述... | 给你一个字符串数组 words 和一个字符 separator ，请你按 separator 拆分 words 中的每个字符串。
返回一个由拆分后的新字符串组成的字符串数组，不包括空字符串 。
注意
* separator 用于决定拆分发生的位置，但它不包含在结果字符串中。
* 拆分可能形成两个以上的字符串。
* 结果字符串必须保持初始相同的先后顺序。
示例 1：
输入：words = ["one.two.three","four.five","six"], separator = "."
输出：["one","two","three","four","five","six"]
解释：在本示例中，我们进行下述拆分：
... |
my_solution = Solution()
test_input = { "words": ["one.two.three","four.five","six"], "separator": "." }
assert my_solution.splitWordsBySeparator(**test_input) == ["one","two","three","four","five","six"]
test_input = { "words": ["$easy$","$problem$"], "separator": "$" }
assert my_solution.splitWordsBySeparator(**te... | 1,690,079,400 |
weekly-contest-355-largest-element-in-an-array-after-merge-operations | https://leetcode.com/problems/largest-element-in-an-array-after-merge-operations | largest-element-in-an-array-after-merge-operations | {
"questionId": "2872",
"questionFrontendId": "2789",
"title": "Largest Element in an Array after Merge Operations",
"titleSlug": "largest-element-in-an-array-after-merge-operations",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 413,
"dislikes": 26,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始、由正整数组成的数组 nums 。
你可以在数组上执行下述操作 任意 次：
* 选中一个同时满足 0 <= i < nums.length - 1 和 nums[i] <= nums[i + 1] 的整数 i 。将元素 nums[i + 1] 替换为 nums[i] + nums[i + 1] ，并从数组中删除元素 nums[i] 。
返回你可以从最终数组中获得的 最大 元素的值。
示例 1：
输入：nums = [2,3,7,9,3]
输出：21
解释：我们可以在数组上执行下述操作：
- 选中 i = 0 ，得到数组 nums = [5,7,9,3] 。
- 选中 i = 1 ，得到数组... | 给你一个下标从 0 开始、由正整数组成的数组 nums 。
你可以在数组上执行下述操作 任意 次：
* 选中一个同时满足 0 <= i < nums.length - 1 和 nums[i] <= nums[i + 1] 的整数 i 。将元素 nums[i + 1] 替换为 nums[i] + nums[i + 1] ，并从数组中删除元素 nums[i] 。
返回你可以从最终数组中获得的 最大 元素的值。
示例 1：
输入：nums = [2,3,7,9,3]
输出：21
解释：我们可以在数组上执行下述操作：
- 选中 i = 0 ，得到数组 nums = [5,7,9,3] 。
- 选中 i = 1 ，得到数组 num... |
my_solution = Solution()
test_input = { "nums": [2,3,7,9,3] }
assert my_solution.maxArrayValue(**test_input) == 21
test_input = { "nums": [5,3,3] }
assert my_solution.maxArrayValue(**test_input) == 11
test_input = { "nums": [77] }
assert my_solution.maxArrayValue(**test_input) == 77
test_input = { "nums": [34,95,5... | 1,690,079,400 |
weekly-contest-355-maximum-number-of-groups-with-increasing-length | https://leetcode.com/problems/maximum-number-of-groups-with-increasing-length | maximum-number-of-groups-with-increasing-length | {
"questionId": "2919",
"questionFrontendId": "2790",
"title": "Maximum Number of Groups With Increasing Length",
"titleSlug": "maximum-number-of-groups-with-increasing-length",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 383,
"dislikes": 38,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始、长度为 n 的数组 usageLimits 。
你的任务是使用从 0 到 n - 1 的数字创建若干组，并确保每个数字 i 在 所有组 中使用的次数总共不超过 usageLimits[i] 次。此外，还必须满足以下条件：
* 每个组必须由 不同 的数字组成，也就是说，单个组内不能存在重复的数字。
* 每个组（除了第一个）的长度必须 严格大于 前一个组。
在满足所有条件的情况下，以整数形式返回可以创建的最大组数。
示例 1：
输入：usageLimits = [1,2,5]
输出：3
解释：在这个示例中，我们可以使用 0 至多一次，使用 1 至多 2 次，使用 2 至多 5 次。
一种既... | 给你一个下标从 0 开始、长度为 n 的数组 usageLimits 。
你的任务是使用从 0 到 n - 1 的数字创建若干组，并确保每个数字 i 在 所有组 中使用的次数总共不超过 usageLimits[i] 次。此外，还必须满足以下条件：
* 每个组必须由 不同 的数字组成，也就是说，单个组内不能存在重复的数字。
* 每个组（除了第一个）的长度必须 严格大于 前一个组。
在满足所有条件的情况下，以整数形式返回可以创建的最大组数。
示例 1：
输入：usageLimits = [1,2,5]
输出：3
解释：在这个示例中，我们可以使用 0 至多一次，使用 1 至多 2 次，使用 2 至多 5 次。
一种既能满足所... |
my_solution = Solution()
test_input = { "usageLimits": [1,2,5] }
assert my_solution.maxIncreasingGroups(**test_input) == 3
test_input = { "usageLimits": [2,1,2] }
assert my_solution.maxIncreasingGroups(**test_input) == 2
test_input = { "usageLimits": [1,1] }
assert my_solution.maxIncreasingGroups(**test_input) == 1... | 1,690,079,400 |
weekly-contest-355-count-paths-that-can-form-a-palindrome-in-a-tree | https://leetcode.com/problems/count-paths-that-can-form-a-palindrome-in-a-tree | count-paths-that-can-form-a-palindrome-in-a-tree | {
"questionId": "2905",
"questionFrontendId": "2791",
"title": "Count Paths That Can Form a Palindrome in a Tree",
"titleSlug": "count-paths-that-can-form-a-palindrome-in-a-tree",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 343,
"dislikes": 4,
"categoryTitle": "Algorithms"
} | """
给你一棵 树（即，一个连通、无向且无环的图），根 节点为 0 ，由编号从 0 到 n - 1 的 n 个节点组成。这棵树用一个长度为 n 、下标从 0 开始的数组 parent 表示，其中 parent[i] 为节点 i 的父节点，由于节点 0 为根节点，所以 parent[0] == -1 。
另给你一个长度为 n 的字符串 s ，其中 s[i] 是分配给 i 和 parent[i] 之间的边的字符。s[0] 可以忽略。
找出满足 u < v ，且从 u 到 v 的路径上分配的字符可以 重新排列 形成 回文 的所有节点对 (u, v) ，并返回节点对的数目。
如果一个字符串正着读和反着读都相同，那么这个字符串就是一个... | 给你一棵 树（即，一个连通、无向且无环的图），根 节点为 0 ，由编号从 0 到 n - 1 的 n 个节点组成。这棵树用一个长度为 n 、下标从 0 开始的数组 parent 表示，其中 parent[i] 为节点 i 的父节点，由于节点 0 为根节点，所以 parent[0] == -1 。
另给你一个长度为 n 的字符串 s ，其中 s[i] 是分配给 i 和 parent[i] 之间的边的字符。s[0] 可以忽略。
找出满足 u < v ，且从 u 到 v 的路径上分配的字符可以 重新排列 形成 回文 的所有节点对 (u, v) ，并返回节点对的数目。
如果一个字符串正着读和反着读都相同，那么这个字符串就是一个 回文 ... |
my_solution = Solution()
test_input = { "parent": [-1,0,0,1,1,2], "s": "acaabc" }
assert my_solution.countPalindromePaths(**test_input) == 8
test_input = { "parent": [-1,0,0,0,0], "s": "aaaaa" }
assert my_solution.countPalindromePaths(**test_input) == 10
test_input = { "parent": [-1,0], "s": "pi" }
assert my_soluti... | 1,690,079,400 |
biweekly-contest-109-check-if-array-is-good | https://leetcode.com/problems/check-if-array-is-good | check-if-array-is-good | {
"questionId": "2892",
"questionFrontendId": "2784",
"title": "Check if Array is Good",
"titleSlug": "check-if-array-is-good",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 233,
"dislikes": 43,
"categoryTitle": "Algorithms"
} | """
给你一个整数数组 nums ，如果它是数组 base[n] 的一个排列，我们称它是个 好 数组。
base[n] = [1, 2, ..., n - 1, n, n] （换句话说，它是一个长度为 n + 1 且包含 1 到 n - 1 恰好各一次，包含 n 两次的一个数组）。比方说，base[1] = [1, 1] ，base[3] = [1, 2, 3, 3] 。
如果数组是一个好数组，请你返回 true ，否则返回 false 。
注意：数组的排列是这些数字按任意顺序排布后重新得到的数组。
示例 1：
输入：nums = [2, 1, 3]
输出：false
解释：因为数组的最大元素是 3 ，唯一可以构成这个... | 给你一个整数数组 nums ，如果它是数组 base[n] 的一个排列，我们称它是个 好 数组。
base[n] = [1, 2, ..., n - 1, n, n] （换句话说，它是一个长度为 n + 1 且包含 1 到 n - 1 恰好各一次，包含 n 两次的一个数组）。比方说，base[1] = [1, 1] ，base[3] = [1, 2, 3, 3] 。
如果数组是一个好数组，请你返回 true ，否则返回 false 。
注意：数组的排列是这些数字按任意顺序排布后重新得到的数组。
示例 1：
输入：nums = [2, 1, 3]
输出：false
解释：因为数组的最大元素是 3 ，唯一可以构成这个数组的 ... |
my_solution = Solution()
test_input = { "nums": [1, 3, 3, 2] }
assert my_solution.isGood(**test_input) == True
test_input = { "nums": [2, 1, 3] }
assert my_solution.isGood(**test_input) == False
test_input = { "nums": [1, 1] }
assert my_solution.isGood(**test_input) == True
test_input = { "nums": [1, 2, 2] }
asser... | 1,690,036,200 |
biweekly-contest-109-sort-vowels-in-a-string | https://leetcode.com/problems/sort-vowels-in-a-string | sort-vowels-in-a-string | {
"questionId": "2887",
"questionFrontendId": "2785",
"title": "Sort Vowels in a String",
"titleSlug": "sort-vowels-in-a-string",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 883,
"dislikes": 50,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的字符串 s ，将 s 中的元素重新 排列 得到新的字符串 t ，它满足：
* 所有辅音字母都在原来的位置上。更正式的，如果满足 0 <= i < s.length 的下标 i 处的 s[i] 是个辅音字母，那么 t[i] = s[i] 。
* 元音字母都必须以他们的 ASCII 值按 非递减 顺序排列。更正式的，对于满足 0 <= i < j < s.length 的下标 i 和 j ，如果 s[i] 和 s[j] 都是元音字母，那么 t[i] 的 ASCII 值不能大于 t[j] 的 ASCII 值。
请你返回结果字母串。
元音字母为 'a' ，'e' ，'i' ，'o' 和 'u' ... | 给你一个下标从 0 开始的字符串 s ，将 s 中的元素重新 排列 得到新的字符串 t ，它满足：
* 所有辅音字母都在原来的位置上。更正式的，如果满足 0 <= i < s.length 的下标 i 处的 s[i] 是个辅音字母，那么 t[i] = s[i] 。
* 元音字母都必须以他们的 ASCII 值按 非递减 顺序排列。更正式的，对于满足 0 <= i < j < s.length 的下标 i 和 j ，如果 s[i] 和 s[j] 都是元音字母，那么 t[i] 的 ASCII 值不能大于 t[j] 的 ASCII 值。
请你返回结果字母串。
元音字母为 'a' ，'e' ，'i' ，'o' 和 'u' ，它们可... |
my_solution = Solution()
test_input = { "s": "lEetcOde" }
assert my_solution.sortVowels(**test_input) == "lEOtcede"
test_input = { "s": "lYmpH" }
assert my_solution.sortVowels(**test_input) == "lYmpH"
test_input = { "s": "mDVD" }
assert my_solution.sortVowels(**test_input) == "mDVD"
test_input = { "s": "xdX" }
ass... | 1,690,036,200 |
biweekly-contest-109-visit-array-positions-to-maximize-score | https://leetcode.com/problems/visit-array-positions-to-maximize-score | visit-array-positions-to-maximize-score | {
"questionId": "2893",
"questionFrontendId": "2786",
"title": "Visit Array Positions to Maximize Score",
"titleSlug": "visit-array-positions-to-maximize-score",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 438,
"dislikes": 21,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 和一个正整数 x 。
你 一开始 在数组的位置 0 处，你可以按照下述规则访问数组中的其他位置：
* 如果你当前在位置 i ，那么你可以移动到满足 i < j 的 任意 位置 j 。
* 对于你访问的位置 i ，你可以获得分数 nums[i] 。
* 如果你从位置 i 移动到位置 j 且 nums[i] 和 nums[j] 的 奇偶性 不同，那么你将失去分数 x 。
请你返回你能得到的 最大 得分之和。
注意 ，你一开始的分数为 nums[0] 。
示例 1：
输入：nums = [2,3,6,1,9,2], x = 5
输出：13
解释：我们可以按顺序访问数组... | 给你一个下标从 0 开始的整数数组 nums 和一个正整数 x 。
你 一开始 在数组的位置 0 处，你可以按照下述规则访问数组中的其他位置：
* 如果你当前在位置 i ，那么你可以移动到满足 i < j 的 任意 位置 j 。
* 对于你访问的位置 i ，你可以获得分数 nums[i] 。
* 如果你从位置 i 移动到位置 j 且 nums[i] 和 nums[j] 的 奇偶性 不同，那么你将失去分数 x 。
请你返回你能得到的 最大 得分之和。
注意 ，你一开始的分数为 nums[0] 。
示例 1：
输入：nums = [2,3,6,1,9,2], x = 5
输出：13
解释：我们可以按顺序访问数组中的位置... |
my_solution = Solution()
test_input = { "nums": [2,3,6,1,9,2], "x": 5 }
assert my_solution.maxScore(**test_input) == 13
test_input = { "nums": [2,4,6,8], "x": 3 }
assert my_solution.maxScore(**test_input) == 20
test_input = { "nums": [38,92,23,30,25,96,6,71,78,77,33,23,71,48,87,77,53,28,6,20,90,83,42,21,64,95,84,29... | 1,690,036,200 |
biweekly-contest-109-ways-to-express-an-integer-as-sum-of-powers | https://leetcode.com/problems/ways-to-express-an-integer-as-sum-of-powers | ways-to-express-an-integer-as-sum-of-powers | {
"questionId": "2882",
"questionFrontendId": "2787",
"title": "Ways to Express an Integer as Sum of Powers",
"titleSlug": "ways-to-express-an-integer-as-sum-of-powers",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 346,
"dislikes": 11,
"categoryTitle": "Algorithms"
} | """
给你两个 正 整数 n 和 x 。
请你返回将 n 表示成一些 互不相同 正整数的 x 次幂之和的方案数。换句话说，你需要返回互不相同整数 [n1, n2, ..., nk] 的集合数目，满足 n = n1x + n2x + ... + nkx 。
由于答案可能非常大，请你将它对 109 + 7 取余后返回。
比方说，n = 160 且 x = 3 ，一个表示 n 的方法是 n = 23 + 33 + 53 。
示例 1：
输入：n = 10, x = 2
输出：1
解释：我们可以将 n 表示为：n = 32 + 12 = 10 。
这是唯一将 10 表达成不同整数 2 次方之和的方案。
示例 2：
输入：n ... | 给你两个 正 整数 n 和 x 。
请你返回将 n 表示成一些 互不相同 正整数的 x 次幂之和的方案数。换句话说，你需要返回互不相同整数 [n1, n2, ..., nk] 的集合数目，满足 n = n1x + n2x + ... + nkx 。
由于答案可能非常大，请你将它对 109 + 7 取余后返回。
比方说，n = 160 且 x = 3 ，一个表示 n 的方法是 n = 23 + 33 + 53 。
示例 1：
输入：n = 10, x = 2
输出：1
解释：我们可以将 n 表示为：n = 32 + 12 = 10 。
这是唯一将 10 表达成不同整数 2 次方之和的方案。
示例 2：
输入：n = 4,... |
my_solution = Solution()
test_input = { "n": 10, "x": 2 }
assert my_solution.numberOfWays(**test_input) == 1
test_input = { "n": 4, "x": 1 }
assert my_solution.numberOfWays(**test_input) == 2
test_input = { "n": 1, "x": 1 }
assert my_solution.numberOfWays(**test_input) == 1
test_input = { "n": 1, "x": 2 }
assert m... | 1,690,036,200 |
weekly-contest-354-sum-of-squares-of-special-elements | https://leetcode.com/problems/sum-of-squares-of-special-elements | sum-of-squares-of-special-elements | {
"questionId": "2844",
"questionFrontendId": "2778",
"title": "Sum of Squares of Special Elements ",
"titleSlug": "sum-of-squares-of-special-elements",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 218,
"dislikes": 65,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 1 开始、长度为 n 的整数数组 nums 。
对 nums 中的元素 nums[i] 而言，如果 n 能够被 i 整除，即 n % i == 0 ，则认为 num[i] 是一个 特殊元素 。
返回 nums 中所有 特殊元素 的 平方和 。
示例 1：
输入：nums = [1,2,3,4]
输出：21
解释：nums 中共有 3 个特殊元素：nums[1]，因为 4 被 1 整除；nums[2]，因为 4 被 2 整除；以及 nums[4]，因为 4 被 4 整除。
因此，nums 中所有特殊元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums... | 给你一个下标从 1 开始、长度为 n 的整数数组 nums 。
对 nums 中的元素 nums[i] 而言，如果 n 能够被 i 整除，即 n % i == 0 ，则认为 num[i] 是一个 特殊元素 。
返回 nums 中所有 特殊元素 的 平方和 。
示例 1：
输入：nums = [1,2,3,4]
输出：21
解释：nums 中共有 3 个特殊元素：nums[1]，因为 4 被 1 整除；nums[2]，因为 4 被 2 整除；以及 nums[4]，因为 4 被 4 整除。
因此，nums 中所有特殊元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[4] ... |
my_solution = Solution()
test_input = { "nums": [1,2,3,4] }
assert my_solution.sumOfSquares(**test_input) == 21
test_input = { "nums": [2,7,1,19,18,3] }
assert my_solution.sumOfSquares(**test_input) == 63
test_input = { "nums": [1] }
assert my_solution.sumOfSquares(**test_input) == 1
test_input = { "nums": [2] }
a... | 1,689,474,600 |
weekly-contest-354-maximum-beauty-of-an-array-after-applying-operation | https://leetcode.com/problems/maximum-beauty-of-an-array-after-applying-operation | maximum-beauty-of-an-array-after-applying-operation | {
"questionId": "2891",
"questionFrontendId": "2779",
"title": "Maximum Beauty of an Array After Applying Operation",
"titleSlug": "maximum-beauty-of-an-array-after-applying-operation",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 559,
"dislikes": 12,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 和一个 非负 整数 k 。
在一步操作中，你可以执行下述指令：
* 在范围 [0, nums.length - 1] 中选择一个 此前没有选过 的下标 i 。
* 将 nums[i] 替换为范围 [nums[i] - k, nums[i] + k] 内的任一整数。
数组的 美丽值 定义为数组中由相等元素组成的最长子序列的长度。
对数组 nums 执行上述操作任意次后，返回数组可能取得的 最大 美丽值。
注意：你 只 能对每个下标执行 一次 此操作。
数组的 子序列 定义是：经由原数组删除一些元素（也可能不删除）得到的一个新数组，且在此过程中剩余元素的顺序不发生改变... | 给你一个下标从 0 开始的整数数组 nums 和一个 非负 整数 k 。
在一步操作中，你可以执行下述指令：
* 在范围 [0, nums.length - 1] 中选择一个 此前没有选过 的下标 i 。
* 将 nums[i] 替换为范围 [nums[i] - k, nums[i] + k] 内的任一整数。
数组的 美丽值 定义为数组中由相等元素组成的最长子序列的长度。
对数组 nums 执行上述操作任意次后，返回数组可能取得的 最大 美丽值。
注意：你 只 能对每个下标执行 一次 此操作。
数组的 子序列 定义是：经由原数组删除一些元素（也可能不删除）得到的一个新数组，且在此过程中剩余元素的顺序不发生改变。
示... |
my_solution = Solution()
test_input = { "nums": [4,6,1,2], "k": 2 }
assert my_solution.maximumBeauty(**test_input) == 3
test_input = { "nums": [1,1,1,1], "k": 10 }
assert my_solution.maximumBeauty(**test_input) == 4
test_input = { "nums": [12,71], "k": 10 }
assert my_solution.maximumBeauty(**test_input) == 1
test_... | 1,689,474,600 |
weekly-contest-354-minimum-index-of-a-valid-split | https://leetcode.com/problems/minimum-index-of-a-valid-split | minimum-index-of-a-valid-split | {
"questionId": "2888",
"questionFrontendId": "2780",
"title": "Minimum Index of a Valid Split",
"titleSlug": "minimum-index-of-a-valid-split",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 282,
"dislikes": 11,
"categoryTitle": "Algorithms"
} | """
如果元素 x 在长度为 m 的整数数组 arr 中满足 freq(x) * 2 > m ，那么我们称 x 是 支配元素 。其中 freq(x) 是 x 在数组 arr 中出现的次数。注意，根据这个定义，数组 arr 最多 只会有 一个 支配元素。
给你一个下标从 0 开始长度为 n 的整数数组 nums ，数据保证它含有一个支配元素。
你需要在下标 i 处将 nums 分割成两个数组 nums[0, ..., i] 和 nums[i + 1, ..., n - 1] ，如果一个分割满足以下条件，我们称它是 合法 的：
* 0 <= i < n - 1
* nums[0, ..., i] 和 nums[i + 1, ... | 如果元素 x 在长度为 m 的整数数组 arr 中满足 freq(x) * 2 > m ，那么我们称 x 是 支配元素 。其中 freq(x) 是 x 在数组 arr 中出现的次数。注意，根据这个定义，数组 arr 最多 只会有 一个 支配元素。
给你一个下标从 0 开始长度为 n 的整数数组 nums ，数据保证它含有一个支配元素。
你需要在下标 i 处将 nums 分割成两个数组 nums[0, ..., i] 和 nums[i + 1, ..., n - 1] ，如果一个分割满足以下条件，我们称它是 合法 的：
* 0 <= i < n - 1
* nums[0, ..., i] 和 nums[i + 1, ...,... |
my_solution = Solution()
test_input = { "nums": [1,2,2,2] }
assert my_solution.minimumIndex(**test_input) == 2
test_input = { "nums": [2,1,3,1,1,1,7,1,2,1] }
assert my_solution.minimumIndex(**test_input) == 4
test_input = { "nums": [3,3,3,3,7,2,2] }
assert my_solution.minimumIndex(**test_input) == -1
test_input = ... | 1,689,474,600 |
weekly-contest-354-length-of-the-longest-valid-substring | https://leetcode.com/problems/length-of-the-longest-valid-substring | length-of-the-longest-valid-substring | {
"questionId": "2884",
"questionFrontendId": "2781",
"title": "Length of the Longest Valid Substring",
"titleSlug": "length-of-the-longest-valid-substring",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 447,
"dislikes": 9,
"categoryTitle": "Algorithms"
} | """
给你一个字符串 word 和一个字符串数组 forbidden 。
如果一个字符串不包含 forbidden 中的任何字符串，我们称这个字符串是 合法 的。
请你返回字符串 word 的一个 最长合法子字符串 的长度。
子字符串 指的是一个字符串中一段连续的字符，它可以为空。
示例 1：
输入：word = "cbaaaabc", forbidden = ["aaa","cb"]
输出：4
解释：总共有 11 个合法子字符串："c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" 和 "aabc"。最长合法子字符串的长度为 4 。
其他子字符串都要么包含... | 给你一个字符串 word 和一个字符串数组 forbidden 。
如果一个字符串不包含 forbidden 中的任何字符串，我们称这个字符串是 合法 的。
请你返回字符串 word 的一个 最长合法子字符串 的长度。
子字符串 指的是一个字符串中一段连续的字符，它可以为空。
示例 1：
输入：word = "cbaaaabc", forbidden = ["aaa","cb"]
输出：4
解释：总共有 11 个合法子字符串："c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" 和 "aabc"。最长合法子字符串的长度为 4 。
其他子字符串都要么包含 "aa... |
my_solution = Solution()
test_input = { "word": "cbaaaabc", "forbidden": ["aaa","cb"] }
assert my_solution.longestValidSubstring(**test_input) == 4
test_input = { "word": "leetcode", "forbidden": ["de","le","e"] }
assert my_solution.longestValidSubstring(**test_input) == 4
test_input = { "word": "a", "forbidden": [... | 1,689,474,600 |
weekly-contest-353-find-the-maximum-achievable-number | https://leetcode.com/problems/find-the-maximum-achievable-number | find-the-maximum-achievable-number | {
"questionId": "2812",
"questionFrontendId": "2769",
"title": "Find the Maximum Achievable Number",
"titleSlug": "find-the-maximum-achievable-number",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 230,
"dislikes": 286,
"categoryTitle": "Algorithms"
} | """
给你两个整数 num 和 t 。
如果整数 x 可以在执行下述操作不超过 t 次的情况下变为与 num 相等，则称其为 可达成数字 ：
* 每次操作将 x 的值增加或减少 1 ，同时可以选择将 num 的值增加或减少 1 。
返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。
示例 1：
输入：num = 4, t = 1
输出：6
解释：最大可达成数字是 x = 6 ，执行下述操作可以使其等于 num ：
- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。
可以证明不存在大于 6 的可达成数字。
示例 2：
输入：num = 3, t = 2
输出：7
解释：... | 给你两个整数 num 和 t 。
如果整数 x 可以在执行下述操作不超过 t 次的情况下变为与 num 相等，则称其为 可达成数字 ：
* 每次操作将 x 的值增加或减少 1 ，同时可以选择将 num 的值增加或减少 1 。
返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。
示例 1：
输入：num = 4, t = 1
输出：6
解释：最大可达成数字是 x = 6 ，执行下述操作可以使其等于 num ：
- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。
可以证明不存在大于 6 的可达成数字。
示例 2：
输入：num = 3, t = 2
输出：7
解释：最大的可... |
my_solution = Solution()
test_input = { "num": 4, "t": 1 }
assert my_solution.theMaximumAchievableX(**test_input) == 6
test_input = { "num": 3, "t": 2 }
assert my_solution.theMaximumAchievableX(**test_input) == 7
test_input = { "num": 1, "t": 1 }
assert my_solution.theMaximumAchievableX(**test_input) == 3
test_inp... | 1,688,869,800 |
weekly-contest-353-maximum-number-of-jumps-to-reach-the-last-index | https://leetcode.com/problems/maximum-number-of-jumps-to-reach-the-last-index | maximum-number-of-jumps-to-reach-the-last-index | {
"questionId": "2855",
"questionFrontendId": "2770",
"title": "Maximum Number of Jumps to Reach the Last Index",
"titleSlug": "maximum-number-of-jumps-to-reach-the-last-index",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 356,
"dislikes": 10,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始、由 n 个整数组成的数组 nums 和一个整数 target 。
你的初始位置在下标 0 。在一步操作中，你可以从下标 i 跳跃到任意满足下述条件的下标 j ：
* 0 <= i < j < n
* -target <= nums[j] - nums[i] <= target
返回到达下标 n - 1 处所需的 最大跳跃次数 。
如果无法到达下标 n - 1 ，返回 -1 。
示例 1：
输入：nums = [1,3,6,4,1,2], target = 2
输出：3
解释：要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
- 从下标 0 跳跃到下标 ... | 给你一个下标从 0 开始、由 n 个整数组成的数组 nums 和一个整数 target 。
你的初始位置在下标 0 。在一步操作中，你可以从下标 i 跳跃到任意满足下述条件的下标 j ：
* 0 <= i < j < n
* -target <= nums[j] - nums[i] <= target
返回到达下标 n - 1 处所需的 最大跳跃次数 。
如果无法到达下标 n - 1 ，返回 -1 。
示例 1：
输入：nums = [1,3,6,4,1,2], target = 2
输出：3
解释：要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
- 从下标 0 跳跃到下标 1 。
... |
my_solution = Solution()
test_input = { "nums": [1,3,6,4,1,2], "target": 2 }
assert my_solution.maximumJumps(**test_input) == 3
test_input = { "nums": [1,3,6,4,1,2], "target": 3 }
assert my_solution.maximumJumps(**test_input) == 5
test_input = { "nums": [1,3,6,4,1,2], "target": 0 }
assert my_solution.maximumJumps(*... | 1,688,869,800 |
weekly-contest-353-longest-non-decreasing-subarray-from-two-arrays | https://leetcode.com/problems/longest-non-decreasing-subarray-from-two-arrays | longest-non-decreasing-subarray-from-two-arrays | {
"questionId": "2869",
"questionFrontendId": "2771",
"title": "Longest Non-decreasing Subarray From Two Arrays",
"titleSlug": "longest-non-decreasing-subarray-from-two-arrays",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 505,
"dislikes": 10,
"categoryTitle": "Algorithms"
} | """
给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，长度均为 n 。
让我们定义另一个下标从 0 开始、长度为 n 的整数数组，nums3 。对于范围 [0, n - 1] 的每个下标 i ，你可以将 nums1[i] 或 nums2[i] 的值赋给 nums3[i] 。
你的任务是使用最优策略为 nums3 赋值，以最大化 nums3 中 最长非递减子数组 的长度。
以整数形式表示并返回 nums3 中 最长非递减 子数组的长度。
注意：子数组 是数组中的一个连续非空元素序列。
示例 1：
输入：nums1 = [2,3,1], nums2 = [1,2,1]
输出：2
解释：构造 nums3 的... | 给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，长度均为 n 。
让我们定义另一个下标从 0 开始、长度为 n 的整数数组，nums3 。对于范围 [0, n - 1] 的每个下标 i ，你可以将 nums1[i] 或 nums2[i] 的值赋给 nums3[i] 。
你的任务是使用最优策略为 nums3 赋值，以最大化 nums3 中 最长非递减子数组 的长度。
以整数形式表示并返回 nums3 中 最长非递减 子数组的长度。
注意：子数组 是数组中的一个连续非空元素序列。
示例 1：
输入：nums1 = [2,3,1], nums2 = [1,2,1]
输出：2
解释：构造 nums3 的方法之一... |
my_solution = Solution()
test_input = { "nums1": [2,3,1], "nums2": [1,2,1] }
assert my_solution.maxNonDecreasingLength(**test_input) == 2
test_input = { "nums1": [1,3,2,1], "nums2": [2,2,3,4] }
assert my_solution.maxNonDecreasingLength(**test_input) == 4
test_input = { "nums1": [1,1], "nums2": [2,2] }
assert my_sol... | 1,688,869,800 |
weekly-contest-353-apply-operations-to-make-all-array-elements-equal-to-zero | https://leetcode.com/problems/apply-operations-to-make-all-array-elements-equal-to-zero | apply-operations-to-make-all-array-elements-equal-to-zero | {
"questionId": "2878",
"questionFrontendId": "2772",
"title": "Apply Operations to Make All Array Elements Equal to Zero",
"titleSlug": "apply-operations-to-make-all-array-elements-equal-to-zero",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 339,
"dislikes": 19,
"categoryTitle": "Algorithms"... | """
给你一个下标从 0 开始的整数数组 nums 和一个正整数 k 。
你可以对数组执行下述操作 任意次 ：
* 从数组中选出长度为 k 的 任一 子数组，并将子数组中每个元素都 减去 1 。
如果你可以使数组中的所有元素都等于 0 ，返回 true ；否则，返回 false 。
子数组 是数组中的一个非空连续元素序列。
示例 1：
输入：nums = [2,2,3,1,1,0], k = 3
输出：true
解释：可以执行下述操作：
- 选出子数组 [2,2,3] ，执行操作后，数组变为 nums = [1,1,2,1,1,0] 。
- 选出子数组 [2,1,1] ，执行操作后，数组变为 nums = [1,1... | 给你一个下标从 0 开始的整数数组 nums 和一个正整数 k 。
你可以对数组执行下述操作 任意次 ：
* 从数组中选出长度为 k 的 任一 子数组，并将子数组中每个元素都 减去 1 。
如果你可以使数组中的所有元素都等于 0 ，返回 true ；否则，返回 false 。
子数组 是数组中的一个非空连续元素序列。
示例 1：
输入：nums = [2,2,3,1,1,0], k = 3
输出：true
解释：可以执行下述操作：
- 选出子数组 [2,2,3] ，执行操作后，数组变为 nums = [1,1,2,1,1,0] 。
- 选出子数组 [2,1,1] ，执行操作后，数组变为 nums = [1,1,1,0... |
my_solution = Solution()
test_input = { "nums": [1,3,1,1], "k": 2 }
assert my_solution.checkArray(**test_input) == False
test_input = { "nums": [2,2,3,1,1,0], "k": 3 }
assert my_solution.checkArray(**test_input) == True
test_input = { "nums": [24,24,14,37,31,88,94,38,94,0,100,100,4,46,5,50,0,33,22,25,0], "k": 10 }
... | 1,688,869,800 |
biweekly-contest-108-longest-alternating-subarray | https://leetcode.com/problems/longest-alternating-subarray | longest-alternating-subarray | {
"questionId": "2870",
"questionFrontendId": "2765",
"title": "Longest Alternating Subarray",
"titleSlug": "longest-alternating-subarray",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 181,
"dislikes": 153,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 。如果 nums 中长度为 m 的子数组 s 满足以下条件，我们称它是一个 交替子序列 ：
* m 大于 1 。
* s1 = s0 + 1 。
* 下标从 0 开始的子数组 s 与数组 [s0, s1, s0, s1,...,s(m-1) % 2] 一样。也就是说，s1 - s0 = 1 ，s2 - s1 = -1 ，s3 - s2 = 1 ，s4 - s3 = -1 ，以此类推，直到 s[m - 1] - s[m - 2] = (-1)m 。
请你返回 nums 中所有 交替 子数组中，最长的长度，如果不存在交替子数组，请你返回 -1 。
子数组是一个数组中一段连... | 给你一个下标从 0 开始的整数数组 nums 。如果 nums 中长度为 m 的子数组 s 满足以下条件，我们称它是一个 交替子序列 ：
* m 大于 1 。
* s1 = s0 + 1 。
* 下标从 0 开始的子数组 s 与数组 [s0, s1, s0, s1,...,s(m-1) % 2] 一样。也就是说，s1 - s0 = 1 ，s2 - s1 = -1 ，s3 - s2 = 1 ，s4 - s3 = -1 ，以此类推，直到 s[m - 1] - s[m - 2] = (-1)m 。
请你返回 nums 中所有 交替 子数组中，最长的长度，如果不存在交替子数组，请你返回 -1 。
子数组是一个数组中一段连续 非空... |
my_solution = Solution()
test_input = { "nums": [2,3,4,3,4] }
assert my_solution.alternatingSubarray(**test_input) == 4
test_input = { "nums": [4,5,6] }
assert my_solution.alternatingSubarray(**test_input) == 2
test_input = { "nums": [31,32,31,32,33] }
assert my_solution.alternatingSubarray(**test_input) == 4
test... | 1,688,826,600 |
biweekly-contest-108-relocate-marbles | https://leetcode.com/problems/relocate-marbles | relocate-marbles | {
"questionId": "2834",
"questionFrontendId": "2766",
"title": "Relocate Marbles",
"titleSlug": "relocate-marbles",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 170,
"dislikes": 13,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。
在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。
完成这些操作后，请你按升序返回所有 有 石块的位置。
注意：
* 如果一个位置至少有一个石块，我们称这个位置 有 石块。
* 一个位置可能会有多个石块。
示例 1：
输入：nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
输出... | 给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。
在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。
完成这些操作后，请你按升序返回所有 有 石块的位置。
注意：
* 如果一个位置至少有一个石块，我们称这个位置 有 石块。
* 一个位置可能会有多个石块。
示例 1：
输入：nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
输出：[5,... |
my_solution = Solution()
test_input = { "nums": [1,6,7,8], "moveFrom": [1,7,2], "moveTo": [2,9,5] }
assert my_solution.relocateMarbles(**test_input) == [5,6,8,9]
test_input = { "nums": [1,1,3,3], "moveFrom": [1,3], "moveTo": [2,2] }
assert my_solution.relocateMarbles(**test_input) == [2]
test_input = { "nums": [5,7... | 1,688,826,600 |
biweekly-contest-108-partition-string-into-minimum-beautiful-substrings | https://leetcode.com/problems/partition-string-into-minimum-beautiful-substrings | partition-string-into-minimum-beautiful-substrings | {
"questionId": "2883",
"questionFrontendId": "2767",
"title": "Partition String Into Minimum Beautiful Substrings",
"titleSlug": "partition-string-into-minimum-beautiful-substrings",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 289,
"dislikes": 8,
"categoryTitle": "Algorithms"
} | """
给你一个二进制字符串 s ，你需要将字符串分割成一个或者多个 子字符串 ，使每个子字符串都是 美丽 的。
如果一个字符串满足以下条件，我们称它是 美丽 的：
* 它不包含前导 0 。
* 它是 5 的幂的 二进制 表示。
请你返回分割后的子字符串的 最少 数目。如果无法将字符串 s 分割成美丽子字符串，请你返回 -1 。
子字符串是一个字符串中一段连续的字符序列。
示例 1：
输入：s = "1011"
输出：2
解释：我们可以将输入字符串分成 ["101", "1"] 。
- 字符串 "101" 不包含前导 0 ，且它是整数 51 = 5 的二进制表示。
- 字符串 "1" 不包含前导 0 ，且它是整数 ... | 给你一个二进制字符串 s ，你需要将字符串分割成一个或者多个 子字符串 ，使每个子字符串都是 美丽 的。
如果一个字符串满足以下条件，我们称它是 美丽 的：
* 它不包含前导 0 。
* 它是 5 的幂的 二进制 表示。
请你返回分割后的子字符串的 最少 数目。如果无法将字符串 s 分割成美丽子字符串，请你返回 -1 。
子字符串是一个字符串中一段连续的字符序列。
示例 1：
输入：s = "1011"
输出：2
解释：我们可以将输入字符串分成 ["101", "1"] 。
- 字符串 "101" 不包含前导 0 ，且它是整数 51 = 5 的二进制表示。
- 字符串 "1" 不包含前导 0 ，且它是整数 50 =... |
my_solution = Solution()
test_input = { "s": "1011" }
assert my_solution.minimumBeautifulSubstrings(**test_input) == 2
test_input = { "s": "111" }
assert my_solution.minimumBeautifulSubstrings(**test_input) == 3
test_input = { "s": "0" }
assert my_solution.minimumBeautifulSubstrings(**test_input) == -1
test_input ... | 1,688,826,600 |
biweekly-contest-108-number-of-black-blocks | https://leetcode.com/problems/number-of-black-blocks | number-of-black-blocks | {
"questionId": "2889",
"questionFrontendId": "2768",
"title": "Number of Black Blocks",
"titleSlug": "number-of-black-blocks",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 204,
"dislikes": 21,
"categoryTitle": "Algorithms"
} | """
给你两个整数 m 和 n ，表示一个下标从 0 开始的 m x n 的网格图。
给你一个下标从 0 开始的二维整数矩阵 coordinates ，其中 coordinates[i] = [x, y] 表示坐标为 [x, y] 的格子是 黑色的 ，所有没出现在 coordinates 中的格子都是 白色的。
一个块定义为网格图中 2 x 2 的一个子矩阵。更正式的，对于左上角格子为 [x, y] 的块，其中 0 <= x < m - 1 且 0 <= y < n - 1 ，包含坐标为 [x, y] ，[x + 1, y] ，[x, y + 1] 和 [x + 1, y + 1] 的格子。
请你返回一个下标从 0 开始长度... | 给你两个整数 m 和 n ，表示一个下标从 0 开始的 m x n 的网格图。
给你一个下标从 0 开始的二维整数矩阵 coordinates ，其中 coordinates[i] = [x, y] 表示坐标为 [x, y] 的格子是 黑色的 ，所有没出现在 coordinates 中的格子都是 白色的。
一个块定义为网格图中 2 x 2 的一个子矩阵。更正式的，对于左上角格子为 [x, y] 的块，其中 0 <= x < m - 1 且 0 <= y < n - 1 ，包含坐标为 [x, y] ，[x + 1, y] ，[x, y + 1] 和 [x + 1, y + 1] 的格子。
请你返回一个下标从 0 开始长度为 5 ... |
my_solution = Solution()
test_input = { "m": 3, "n": 3, "coordinates": [[0,0]] }
assert my_solution.countBlackBlocks(**test_input) == [3,1,0,0,0]
test_input = { "m": 3, "n": 3, "coordinates": [[0,0],[1,1],[0,2]] }
assert my_solution.countBlackBlocks(**test_input) == [0,2,2,0,0]
test_input = { "m": 32, "n": 32, "coo... | 1,688,826,600 |
weekly-contest-352-longest-even-odd-subarray-with-threshold | https://leetcode.com/problems/longest-even-odd-subarray-with-threshold | longest-even-odd-subarray-with-threshold | {
"questionId": "2866",
"questionFrontendId": "2760",
"title": "Longest Even Odd Subarray With Threshold",
"titleSlug": "longest-even-odd-subarray-with-threshold",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 248,
"dislikes": 243,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 和一个整数 threshold 。
请你从 nums 的子数组中找出以下标 l 开头、下标 r 结尾 (0 <= l <= r < nums.length) 且满足以下条件的 最长子数组 ：
* nums[l] % 2 == 0
* 对于范围 [l, r - 1] 内的所有下标 i ，nums[i] % 2 != nums[i + 1] % 2
* 对于范围 [l, r] 内的所有下标 i ，nums[i] <= threshold
以整数形式返回满足题目要求的最长子数组的长度。
注意：子数组 是数组中的一个连续非空元素序列。
示例 1：
输入：nums = [... | 给你一个下标从 0 开始的整数数组 nums 和一个整数 threshold 。
请你从 nums 的子数组中找出以下标 l 开头、下标 r 结尾 (0 <= l <= r < nums.length) 且满足以下条件的 最长子数组 ：
* nums[l] % 2 == 0
* 对于范围 [l, r - 1] 内的所有下标 i ，nums[i] % 2 != nums[i + 1] % 2
* 对于范围 [l, r] 内的所有下标 i ，nums[i] <= threshold
以整数形式返回满足题目要求的最长子数组的长度。
注意：子数组 是数组中的一个连续非空元素序列。
示例 1：
输入：nums = [3,2,... |
my_solution = Solution()
test_input = { "nums": [3,2,5,4], "threshold": 5 }
assert my_solution.longestAlternatingSubarray(**test_input) == 3
test_input = { "nums": [1,2], "threshold": 2 }
assert my_solution.longestAlternatingSubarray(**test_input) == 1
test_input = { "nums": [2,3,4,5], "threshold": 4 }
assert my_so... | 1,688,265,000 |
weekly-contest-352-prime-pairs-with-target-sum | https://leetcode.com/problems/prime-pairs-with-target-sum | prime-pairs-with-target-sum | {
"questionId": "2873",
"questionFrontendId": "2761",
"title": "Prime Pairs With Target Sum",
"titleSlug": "prime-pairs-with-target-sum",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 311,
"dislikes": 30,
"categoryTitle": "Algorithms"
} | """
给你一个整数 n 。如果两个整数 x 和 y 满足下述条件，则认为二者形成一个质数对：
* 1 <= x <= y <= n
* x + y == n
* x 和 y 都是质数
请你以二维有序列表的形式返回符合题目要求的所有 [xi, yi] ，列表需要按 xi 的 非递减顺序 排序。如果不存在符合要求的质数对，则返回一个空数组。
注意：质数是大于 1 的自然数，并且只有两个因子，即它本身和 1 。
示例 1：
输入：n = 10
输出：[[3,7],[5,5]]
解释：在这个例子中，存在满足条件的两个质数对。
这两个质数对分别是 [3,7] 和 [5,5]，按照题面描述中的方式排序后返回。
示例 2：
... | 给你一个整数 n 。如果两个整数 x 和 y 满足下述条件，则认为二者形成一个质数对：
* 1 <= x <= y <= n
* x + y == n
* x 和 y 都是质数
请你以二维有序列表的形式返回符合题目要求的所有 [xi, yi] ，列表需要按 xi 的 非递减顺序 排序。如果不存在符合要求的质数对，则返回一个空数组。
注意：质数是大于 1 的自然数，并且只有两个因子，即它本身和 1 。
示例 1：
输入：n = 10
输出：[[3,7],[5,5]]
解释：在这个例子中，存在满足条件的两个质数对。
这两个质数对分别是 [3,7] 和 [5,5]，按照题面描述中的方式排序后返回。
示例 2：
输入：n... |
my_solution = Solution()
test_input = { "n": 10 }
assert my_solution.findPrimePairs(**test_input) == [[3,7],[5,5]]
test_input = { "n": 2 }
assert my_solution.findPrimePairs(**test_input) == []
test_input = { "n": 1 }
assert my_solution.findPrimePairs(**test_input) == []
test_input = { "n": 3 }
assert my_solution.f... | 1,688,265,000 |
weekly-contest-352-continuous-subarrays | https://leetcode.com/problems/continuous-subarrays | continuous-subarrays | {
"questionId": "2868",
"questionFrontendId": "2762",
"title": "Continuous Subarrays",
"titleSlug": "continuous-subarrays",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 604,
"dislikes": 17,
"categoryTitle": "Algorithms"
} | """
给你一个下标从 0 开始的整数数组 nums 。nums 的一个子数组如果满足以下条件，那么它是 不间断 的：
* i，i + 1 ，...，j 表示子数组中的下标。对于所有满足 i <= i1, i2 <= j 的下标对，都有 0 <= |nums[i1] - nums[i2]| <= 2 。
请你返回 不间断 子数组的总数目。
子数组是一个数组中一段连续 非空 的元素序列。
示例 1：
输入：nums = [5,4,2,4]
输出：8
解释：
大小为 1 的不间断子数组：[5], [4], [2], [4] 。
大小为 2 的不间断子数组：[5,4], [4,2], [2,4] 。
大小为 3 的不间断子数... | 给你一个下标从 0 开始的整数数组 nums 。nums 的一个子数组如果满足以下条件，那么它是 不间断 的：
* i，i + 1 ，...，j 表示子数组中的下标。对于所有满足 i <= i1, i2 <= j 的下标对，都有 0 <= |nums[i1] - nums[i2]| <= 2 。
请你返回 不间断 子数组的总数目。
子数组是一个数组中一段连续 非空 的元素序列。
示例 1：
输入：nums = [5,4,2,4]
输出：8
解释：
大小为 1 的不间断子数组：[5], [4], [2], [4] 。
大小为 2 的不间断子数组：[5,4], [4,2], [2,4] 。
大小为 3 的不间断子数组：[4... |
my_solution = Solution()
test_input = { "nums": [5,4,2,4] }
assert my_solution.continuousSubarrays(**test_input) == 8
test_input = { "nums": [1,2,3] }
assert my_solution.continuousSubarrays(**test_input) == 6
test_input = { "nums": [31,30,31,32] }
assert my_solution.continuousSubarrays(**test_input) == 10
test_inp... | 1,688,265,000 |
weekly-contest-352-sum-of-imbalance-numbers-of-all-subarrays | https://leetcode.com/problems/sum-of-imbalance-numbers-of-all-subarrays | sum-of-imbalance-numbers-of-all-subarrays | {
"questionId": "2849",
"questionFrontendId": "2763",
"title": "Sum of Imbalance Numbers of All Subarrays",
"titleSlug": "sum-of-imbalance-numbers-of-all-subarrays",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 278,
"dislikes": 7,
"categoryTitle": "Algorithms"
} | """
一个长度为 n 下标从 0 开始的整数数组 arr 的 不平衡数字 定义为，在 sarr = sorted(arr) 数组中，满足以下条件的下标数目：
* 0 <= i < n - 1 ，和
* sarr[i+1] - sarr[i] > 1
这里，sorted(arr) 表示将数组 arr 排序后得到的数组。
给你一个下标从 0 开始的整数数组 nums ，请你返回它所有 子数组 的 不平衡数字 之和。
子数组指的是一个数组中连续一段 非空 的元素序列。
示例 1：
输入：nums = [2,3,1,4]
输出：3
解释：总共有 3 个子数组有非 0 不平衡数字：
- 子数组 [3, 1] ，不平衡数字为 ... | 一个长度为 n 下标从 0 开始的整数数组 arr 的 不平衡数字 定义为，在 sarr = sorted(arr) 数组中，满足以下条件的下标数目：
* 0 <= i < n - 1 ，和
* sarr[i+1] - sarr[i] > 1
这里，sorted(arr) 表示将数组 arr 排序后得到的数组。
给你一个下标从 0 开始的整数数组 nums ，请你返回它所有 子数组 的 不平衡数字 之和。
子数组指的是一个数组中连续一段 非空 的元素序列。
示例 1：
输入：nums = [2,3,1,4]
输出：3
解释：总共有 3 个子数组有非 0 不平衡数字：
- 子数组 [3, 1] ，不平衡数字为 1 。
... |
my_solution = Solution()
test_input = { "nums": [2,3,1,4] }
assert my_solution.sumImbalanceNumbers(**test_input) == 3
test_input = { "nums": [1,3,3,3,5] }
assert my_solution.sumImbalanceNumbers(**test_input) == 8
test_input = { "nums": [1] }
assert my_solution.sumImbalanceNumbers(**test_input) == 0
test_input = { ... | 1,688,265,000 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.