获得徽章 0
- 2024-12-27：到达第 K 级台阶的方案数。用go语言，给定一个非负整数 k，我们有一个无限长度的台阶，从第 0 层开始编号。
Alice 从第 1 层出发，并拥有一个初始值为 0 的变量 jump。
她可以通过以下两种操作在台阶之间移动：
1. 向下移动到第 i - 1 层，但这个操作不能连续使用，且在第 0 层时无法再向下移动。
2. 向上移动到第 i + 2^jump 层，同时将 jump 的值增加 1。
Alice 的目标是到达第 k 层。请你计算她到达第 k 层的所有可能方案的数量。
需要注意的是，如果 Alice 在到达第 k 层后通过某些操作再次返回到 k 层，这也被视为一种不同的方案。
0 <= k <= 1000000000。
输入：k = 0。
输出：2。
解释：
2 种到达台阶 0 的方案为：
1.Alice 从台阶 1 开始。
1.1.执行第一种操作，从台阶 1 向下走到台阶 0 。
2.Alice 从台阶 1 开始。
2.1.执行第一种操作，从台阶 1 向下走到台阶 0 。
2.2.执行第二种操作，向上走 20 级台阶到台阶 1 。
2.3.执行第一种操作，从台阶 1 向下走到台阶 0 。展开评论1 - 2024-12-28：求出出现两次数字的 XOR 值。用go语言，给定一个数组 nums，其中的数字出现的频率要么是一次，要么是两次。
请找出所有出现两次的数字，并计算它们的按位 XOR 值。
如果没有数字出现两次，则返回 0。
1 <= nums.length <= 50。
1 <= nums[i] <= 50。
nums 中每个数字要么出现过一次，要么出现过两次。
输入：nums = [1,2,2,1]。
输出：3。
解释：
数字 1 和 2 出现过两次。1 XOR 2 == 3 。展开评论1 - 2024-12-29：查询数组中元素的出现位置。用go语言，给定一个整数数组 nums、一个整数数组 queries 和一个整数 x。
对于每个查询 queries[i]，你需要在 nums 中找到第 queries[i] 次出现的 x 的位置。
如果 x 在 nums 中的出现次数少于 queries[i]，则该查询的结果应为 -1。
请返回一个包含所有查询结果的整数数组 answer。
1 <= nums.length, queries.length <= 100000。
1 <= queries[i] <= 100000。
1 <= nums[i], x <= 10000。
输入：nums = [1,3,1,7], queries = [1,3,2,4], x = 1。
输出：[0,-1,2,-1]。
解释：
第 1 个查询，第一个 1 出现在下标 0 处。
第 2 个查询，nums 中只有两个 1 ，所以答案为 -1 。
第 3 个查询，第二个 1 出现在下标 2 处。
第 4 个查询，nums 中只有两个 1 ，所以答案为 -1 。展开21 - 2024-12-30：所有球里面不同颜色的数目。用go语言，给定一个整数 limit 和一个大小为 n x 2 的二维数组 queries，其中包含若干操作。
我们有 limit + 1 个球，它们的编号为 [0, limit]，每个球的编号都是独特的。
一开始，所有的球都是无色的。
每个操作的形式为 [x, y]，表示将球 x 染成颜色 y。
在每次操作后，我们需要计算并返回所有球中不同颜色的数量。
请返回一个长度为 n 的数组 result，该数组的第 i 个元素表示第 i 次操作后不同颜色的总数。
需要注意的是，没有染色的球不计入不同颜色的统计。
1 <= limit <= 1000000000。
1 <= n == queries.length <= 100000。
queries[i].length == 2。
0 <= queries[i][0] <= limit。
1 <= queries[i][1] <= 1000000000。
输入：limit = 4, queries = [[1,4],[2,5],[1,3],[3,4]]。
输出：[1,2,2,3]。
操作 0 后，球 1 颜色为 4 。
操作 1 后，球 1 颜色为 4 ，球 2 颜色为 5 。
操作 2 后，球 1 颜色为 3 ，球 2 颜色为 5 。
操作 3 后，球 1 颜色为 3 ，球 2 颜色为 5 ，球 3 颜色为 4 。展开11 - 2024-12-19：分割字符频率相等的最少子字符串。用go语言，给定一个字符串 s，你需要将其分割成一个或多个“平衡”子字符串。所谓“平衡”字符串是指其中所有字符出现的次数相同。例如，对于 s = "ababcc"，你可以得到多个合法的分割方式，如 ("abab", "c", "c")、("ab", "abc", "c") 和 ("ababcc")。然而，像 ("a", "bab", "cc")、("aba", "bc", "c") 和 ("ab", "abcc") 这样的分割则是不合法的。请你返回将 s 最少分割成多少个平衡子字符串。
请注意，平衡字符串的定义是：字符串中每个字符的出现次数必须一致。
1 <= s.length <= 1000。
s 只包含小写英文字母。展开评论1 - 2024-12-20：两个字符串的排列差。用go语言，给定两个字符串 s 和 t，每个字符串中的字符都是唯一的，并且 t 是 s 的一种排列。
我们定义 排列差 为 s 和 t 中每个字符在两个字符串中位置的绝对差值的总和。
请计算并返回 s 和 t 之间的排列差。
1 <= s.length <= 26。
每个字符在 s 中最多出现一次。
t 是 s 的一个排列。
s 仅由小写英文字母组成。
输入：s = "abc", t = "bac"。
输出：2。
解释：
对于 s = "abc" 和 t = "bac"，排列差是：
1."a" 在 s 中的位置与在 t 中的位置之差的绝对值。
2."b" 在 s 中的位置与在 t 中的位置之差的绝对值。
3."c" 在 s 中的位置与在 t 中的位置之差的绝对值。
即，s 和 t 的排列差等于 |0 - 1| + |1 - 0| + |2 - 2| = 2。展开评论1 - 2024-12-21：从魔法师身上吸取的最大能量。用go语言，在一个神秘的地牢里，有 n 名魔法师排成一列。每位魔法师都有一个能量属性，有的提供正能量，而有的则会消耗你的能量。
你被施加了一种诅咒，吸收来自第 i 位魔法师的能量后，你会立即被传送到第 (i + k) 位魔法师。在这个过程中，你会不断进行这种跳跃，直到到达一个不存在的魔法师为止。
换句话说，你可以选择一个起始魔法师，并且以 k 为步长进行跳跃，直到超出魔法师的范围。在这个过程中，你需要计算出可以获得的最大能量。
给定一个能量数组和一个整数 k，返回你能够获得的最高能量值。
1 <= energy.length <= 100000。
-1000 <= energy[i] <= 1000。
1 <= k <= energy.length - 1。
输入： energy = [5,2,-10,-5,1], k = 3。
输出： 3。
解释：可以从魔法师 1 开始，吸收能量 2 + 1 = 3。展开评论1 - 2024-12-22：矩阵中的最大得分。用go语言，给定一个由正整数构成的 m x n 矩阵 grid，你可以从任意单元格开始，移动到正下方或正右侧的任一单元格（不要求相邻）。
在从值为 c1 的单元格移动到值为 c2 的单元格时，得分计算为 c2 - c1。
你的目标是至少移动一次，并找到能够获得的最大总得分。
请返回这个最大得分。
m == grid.length。
n == grid[i].length。
2 <= m, n <= 1000。
4 <= m * n <= 100000。
1 <= grid[i][j] <= 100000。
输入：grid = [[9,5,7,3],[8,9,6,1],[6,7,14,3],[2,5,3,1]]。
输出：9。
解释：从单元格 (0, 1) 开始，并执行以下移动：
1.从单元格 (0, 1) 移动到 (2, 1)，得分为 7 - 5 = 2 。
2.从单元格 (2, 1) 移动到 (2, 2)，得分为 14 - 7 = 7 。
总得分为 2 + 7 = 9 。展开评论1 - 2024-12-23：找出分数最低的排列。用go语言，给定一个数组 nums，它包含从 0 到 n-1 的一个排列。
我们定义一个排列 perm 的分数为：
score(perm) = |perm[0] - nums[perm[1]]| + |perm[1] - nums[perm[2]]| + ... + |perm[n - 1] - nums[perm[0]]|
任务是找出一个排列 perm，使得其分数最低。
如果有多个排列的分数相同，则需要返回字典序最小的那个排列。
2 <= n == nums.length <= 14。
nums 是 [0, 1, 2, ..., n - 1] 的一个排列。
输入：nums = [1,0,2]。
输出：[0,1,2]。
字典序最小且分数最低的排列是 [0,1,2]。这个排列的分数是 |0 - 0| + |1 - 2| + |2 - 1| = 2 。展开评论1 - 2024-12-24：特殊数组Ⅰ。用go语言，一个数组被称为“特殊数组”，当且仅当其所有相邻的两个元素具有不同的奇偶性（即一个为奇数，另一个为偶数）。
给定一个整数数组 nums，请判断这个数组是否满足这一条件，如果满足则返回 true，否则返回 false。
1 <= nums.length <= 100。
1 <= nums[i] <= 100。
输入：nums = [2,1,4]。
输出：true。
解释：
只有两对相邻元素： (2,1) 和 (1,4)，它们都包含了奇偶性不同的数字，因此答案为 true。展开评论1
