moonfdd

优质互联网领域创作者

2025-01-08：找到按位或最接近 K 的子数组。用go语言，给定一个数组 nums 和一个整数 k，你的目标是找到一个子数组，使得该子数组中所有元素进行按位或运算后的结果与 k 之间的绝对差值尽量小。
具体地，你需要确定一个子数组 nums[l..r]，使得以下表达式的值最小化： |k - (nums[l] OR nums[l + 1] ... OR nums[r])| 最后，返回这个最小绝对差值。这里所说的子数组指的是数组中连续的非空元素序列。 1 <= nums.length <= 100000。 1 <= nums[i] <= 1000000000。 1 <= k <= 1000000000。输入：nums = [1,2,4,5], k = 3。输出：0。解释：子数组 nums[0..1] 的按位 OR 运算值为 3 ，得到最小差值 |3 - 3| = 0 。

moonfdd

优质互联网领域创作者

2025-01-07：删除星号以后字典序最小的字符串。用go语言，给定一个字符串 s，其中可能包含任意数量的 '*' 字符。
我们的目标是移除所有的 '*' 字符。在字符串中只要还有至少一个 '*' 字符，我们可以执行以下操作： 1.删除最左侧的 '*' 字符。 2.同时，删除一个字典序最小的字符。如果存在多个字典序最小的字符，任选其一删除。最终，我们需要返回在删除所有 '*' 字符后，剩余字符连接成的字典序最小的字符串。 1 <= s.length <= 100000。 s 只含有小写英文字母和 '*' 字符。输入保证操作可以删除所有的 '*' 字符。输入：s = "aaba*"。输出："aab"。解释：删除 '*' 号和它左边的其中一个 'a' 字符。如果我们选择删除 s[3] ，s 字典序最小。

moonfdd

优质互联网领域创作者

2025-01-06：无需开会的工作日。用go语言，给定一个正整数 days，表示员工可以工作的总天数（从第 1 天开始）。
同时还有一个二维数组 meetings，其长度为 n，其中每个元素 meetings[i] = [start_i, end_i] 表示第 i 次会议的开始和结束天数（包含这两天）。请计算员工可以工作的天数，这些天数在所有安排的会议时间之外，且要考虑会议时间可能的重叠情况。 1 <= days <= 1000000000。 1 <= meetings.length <= 100000。 meetings[i].length == 2。 1 <= meetings[i][0] <= meetings[i][1] <= days。输入：days = 10, meetings = [[5,7],[1,3],[9,10]]。输出：2。解释：第 4 天和第 8 天没有安排会议。

moonfdd

优质互联网领域创作者

2025-01-05：候诊室中的最少椅子数。用go语言，给定一个字符串 s，模拟每秒发生的事件 i：
1.当 s[i] 为 'E'，表示一位顾客进入候诊室并占用一把椅子。 2.当 s[i] 为 'L'，表示一位顾客离开候诊室，释放一把椅子。请计算并返回为确保每位进入候诊室的顾客都有座位所需的最少椅子数量，假设候诊室一开始是空的。 1 <= s.length <= 50。 s 仅由字母 'E' 和 'L' 组成。 s 表示一个有效的进出序列。输入：s = "EEEEEEE"。输出：7。解释：每秒后都有一个顾客进入候诊室，没有人离开。因此，至少需要 7 把椅子。

moonfdd

优质互联网领域创作者

2025-01-04：不包含相邻元素的子序列的最大和。用go语言，给定一个整数数组 nums 和一个由二维数组 queries 组成的查询列表，其中每个查询的格式为 queries[i] = [posi, xi]。
对于每个查询 i，首先将 nums[posi] 的值更新为 xi，然后计算在这一更新后，数组 nums 中所有不包含相邻元素的子序列的最大和。最后，返回所有查询的结果之和。需要注意的是，由于最终答案可能非常大，因此要对其进行 1000000007 的取余处理。请根据以上描述进行相关的处理。 1 <= nums.length <= 5 * 10000。 -100000 <= nums[i] <= 100000。 1 <= queries.length <= 5 * 10000。 queries[i] == [posi, xi]。 0 <= posi <= nums.length - 1。 -100000 <= xi <= 100000。

moonfdd

优质互联网领域创作者

2025-01-03：优质数对的总数Ⅱ。用go语言，给定两个整数数组 nums1 和 nums2，分别具有长度 n 和 m，同时还有一个正整数 k。
如果 nums1 中的元素 nums1[i] 能被 nums2[j] 乘以 k 所整除，我们称这种组合 (i, j) 为优质数对（其中 0 <= i <= n - 1，0 <= j <= m - 1）。请计算并返回优质数对的总数量。 1 <= n, m <= 100000。 1 <= nums1[i], nums2[j] <= 1000000。 1 <= k <= 1000。输入：nums1 = [1,3,4], nums2 = [1,3,4], k = 1。输出：5。解释： 5个优质数对分别是 (0, 0), (1, 0), (1, 1), (2, 0), 和 (2, 2)。

moonfdd

优质互联网领域创作者

2025-01-02：压缩字符串Ⅲ。用go语言，给定一个字符串 word，请按照以下算法进行压缩：
1.从一个空字符串 comp 开始。 2.当 word 仍有内容时，执行以下步骤： 2.1.找到 word 开头最长的由同一个字符 c 重复组成的前缀，且这个前缀的长度不能超过 9。 2.2.将前缀的长度和字符 c 追加到 comp 中。 3.最后返回压缩后的字符串 comp。 1 <= word.length <= 2 * 100000。 word 仅由小写英文字母组成。输入：word = "abcde"。输出："1a1b1c1d1e"。解释：初始时，comp = "" 。进行 5 次操作，每次操作分别选择 "a"、"b"、"c"、"d" 和 "e" 作为前缀。对每个前缀，将 "1" 和对应的字符追加到 comp。

moonfdd

优质互联网领域创作者

2025-01-01：优质数对的总数Ⅰ。用go语言，给定两个整数数组 nums1 和 nums2，分别长度为 n 和 m，以及一个正整数 k。
如果 nums1 数组中的元素 nums1[i] 能被 nums2 数组中的元素 nums2[j] 乘以 k 除尽，则称 (i, j) 为一个优质数对（其中 0 <= i <= n - 1，0 <= j <= m - 1）。请计算并返回所有优质数对的数量。 1 <= n, m <= 50。 1 <= nums1[i], nums2[j] <= 50。 1 <= k <= 50。输入：nums1 = [1,3,4], nums2 = [1,3,4], k = 1。输出：5。解释： 5个优质数对分别是 (0, 0), (1, 0), (1, 1), (2, 0), 和 (2, 2)。

moonfdd

优质互联网领域创作者

2024-12-31：物块放置查询。用go语言，在一个无限延伸的数轴上，原点位于 0 处，沿着 x 轴向正方向无限延伸。
现在我们有一个二维数组 queries，其中包含两种操作： 1. 操作类型 1：queries[i] = [1, x]。在距离原点 x 的位置上建立一个障碍物。保证在执行该操作时，位置 x 上不会有任何障碍物。 2. 操作类型 2：queries[i] = [2, x, sz]。检查在数轴范围 [0, x] 内，是否可以放置一个长度为 sz 的物体。该物体必须完全位于 [0, x] 的范围内，且不能与任何障碍物重叠，但可以与障碍物刚好接触。注意，这只是一个查询，不会实际放置物体。每个查询都是独立的。最终，我们需要返回一个布尔数组 results，在第 i 个操作类型 2 的查询中，如果可以放置物体，则 results[i] 为 true，否则为 false。 1 <= queries.length <= 15 * 10000。 2 <= queries[i].length <= 3。 1 <= queries[i][0] <= 2。 1 <= x, sz <= min(5 * 10000, 3 * queries.length)。输入保证操作 1 中，x 处不会有障碍物。输入保证至少有一个操作类型 2 。输入：queries = [[1,2],[2,3,3],[2,3,1],[2,2,2]]。输出：[false,true,true]。解释：查询 0 ，在 x = 2 处放置一个障碍物。在 x = 3 之前任何大小不超过 2 的物块都可以被放置。

moonfdd

优质互联网领域创作者

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 。

moonfdd

优质互联网领域创作者

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 。

moonfdd

优质互联网领域创作者

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 。

moonfdd

优质互联网领域创作者

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 。

moonfdd

优质互联网领域创作者

2024-12-25：特殊数组Ⅱ。用go语言，一个数组被称为“特殊数组”，如果它的每一对相邻元素的奇偶性不同。给定一个整数数组 nums 和一个二维整数矩阵 queries，我们需要判断对于每一个查询 queries[i] = [fromi, toi]，对应的子数组 nums[fromi..toi] 是否为特殊数组。
最终，我们将返回一个布尔数组 answer，如果 nums[fromi..toi] 是特殊数组，则 answer[i] 为 true；否则为 false。 1 <= nums.length <= 100000。 1 <= nums[i] <= 100000。 1 <= queries.length <= 100000。 queries[i].length == 2。 0 <= queries[i][0] <= queries[i][1] <= nums.length - 1。输入：nums = [4,3,1,6], queries = [[0,2],[2,3]]。输出：[false,true]。解释：子数组是 [4,3,1]。3 和 1 都是奇数。因此这个查询的答案是 false。子数组是 [1,6]。只有一对：(1,6)，且包含了奇偶性不同的数字。因此这个查询的答案是 true。

moonfdd

优质互联网领域创作者

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。

moonfdd

优质互联网领域创作者

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 。

moonfdd

优质互联网领域创作者

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 。

moonfdd

优质互联网领域创作者

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。

moonfdd

优质互联网领域创作者

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。

moonfdd

优质互联网领域创作者

2024-12-18：正方形中的最多点数。用go语言，给定一个二维数组 points 和一个字符串 s，其中 points[i] 表示第 i 个点的坐标，s[i] 表示第 i 个点的标签。
如果一个正方形的中心在（0, 0），边与坐标轴平行，并且内部没有标签相同的两个点，则称这个正方形为“合法”的。你的任务是返回可以被“合法”正方形所包含的最多点数。注意： 1.如果一个点位于正方形的边上或其内部，则视为在正方形内。 2.正方形的边长可以为零。 1 <= s.length, points.length <= 100000。 points[i].length == 2。 -1000000000 <= points[i][0], points[i][1] <= 1000000000。 s.length == points.length。 points 中的点坐标互不相同。 s 只包含小写英文字母。