标签： easy

目标

给定一个正整数，检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。

示例 1：

输入：n = 5
输出：true
解释：5 的二进制表示是：101

示例 2：

输入：n = 7
输出：false
解释：7 的二进制表示是：111.

示例 3：

输入：n = 11
输出：false
解释：11 的二进制表示是：1011.

说明：

• 1 <= n <= 2^31 - 1

思路

判断给定 num 的二进制表示是否是 0、1 交替出现的。

将 num 右移 1 位得到 mask，如果是 0、1 交替出现，那么 (mask & num) == 0 && (mask | num) == (1L << l) - 1，其中 l 是 num 的二进制长度。判断 x 是否全是 1，也可以使用 ((x + 1) & x) == 0。

代码

/**
 * @date 2026-02-24 16:40
 */
public class HasAlternatingBits693 {

    public boolean hasAlternatingBits_v1(int n) {
        int mask = n >> 1;
        int or = mask | n;
        return (mask & n) == 0 && ((or + 1) & or) == 0;
    }

}

性能

目标

颠倒给定的 32 位有符号整数的二进制位。

示例 1：

输入：n = 43261596
输出：964176192
解释：
整数       二进制
43261596  00000010100101000001111010011100
964176192 00111001011110000010100101000000

示例 2：

输入：n = 2147483644
输出：1073741822
解释：
整数        二进制
2147483644 01111111111111111111111111111100
1073741822 00111111111111111111111111111110

说明：

• 0 <= n <= 2^31 - 2
• n 为偶数

进阶: 如果多次调用这个函数，你将如何优化你的算法？

思路

颠倒 32 位有符号整数的二进制表示，返回其表示的数字。

题目限定 n 是正偶数，颠倒之后的最高位为 0，仍是非负数。模拟颠倒的过程，提前记录前导零的个数 lz，最后将结果左移 lz。

代码

/**
 * @date 2024-06-08 22:28
 */
public class ReverseBits190 {

    public int reverseBits_new(int n) {
        int res = 0;
        int lz = Integer.numberOfLeadingZeros(n);
        while (n > 0) {
            int b = n & 1;
            res = (res << 1) | b;
            n >>= 1;
        }
        return res << lz;
    }

}

性能

目标

给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

示例 1：

输入:a = "11", b = "1"
输出："100"

示例 2：

输入：a = "1010", b = "1011"
输出："10101"

说明：

• 1 <= a.length, b.length <= 10^4
• a 和 b 仅由字符 '0' 或 '1' 组成
• 字符串如果不是 "0" ，就不含前导零

思路

对二进制字符串求和，将结果以二进制字符串的形式返回。

代码

/**
 * @date 2024-05-25 21:50
 */
public class AddBinary67 {

    public String addBinary_new(String a, String b) {
        int al = a.length();
        int bl = b.length();
        int n = Math.max(a.length(), b.length());
        int i = 1;
        StringBuilder sb = new StringBuilder();
        // 进位
        int j = 0;
        while (i <= n) {
            int av = 0;
            // 计算从右侧起第 i 个位置的下标
            int ai = al - i;
            if (ai >= 0) {
                av = a.charAt(ai) - '0';
            }
            int bv = 0;
            int bi = bl - i;
            if (bi >= 0) {
                bv = b.charAt(bi) - '0';
            }
            int sum = av + bv + j;
            if (sum > 1) {
                sb.append(sum - 2);
                j = 1;
            } else {
                sb.append(sum);
                j = 0;
            }
            i++;
        }
        if (j == 1) {
            sb.append(j);
        }
        return sb.reverse().toString();
    }

}

性能

目标

给你一个整数数组 nums，它表示一个循环数组。请你遵循以下规则创建一个大小 相同 的新数组 result ：

对于每个下标 i（其中 0 <= i < nums.length），独立执行以下操作：

• 如果 nums[i] > 0：从下标 i 开始，向 右 移动 nums[i] 步，在循环数组中落脚的下标对应的值赋给 result[i]。
• 如果 nums[i] < 0：从下标 i 开始，向 左 移动 abs(nums[i]) 步，在循环数组中落脚的下标对应的值赋给 result[i]。
• 如果 nums[i] == 0：将 nums[i] 的值赋给 result[i]。

返回新数组 result。

注意：由于 nums 是循环数组，向右移动超过最后一个元素时将回到开头，向左移动超过第一个元素时将回到末尾。

示例 1：

输入： nums = [3,-2,1,1]
输出： [1,1,1,3]
解释：
对于 nums[0] 等于 3，向右移动 3 步到 nums[3]，因此 result[0] 为 1。
对于 nums[1] 等于 -2，向左移动 2 步到 nums[3]，因此 result[1] 为 1。
对于 nums[2] 等于 1，向右移动 1 步到 nums[3]，因此 result[2] 为 1。
对于 nums[3] 等于 1，向右移动 1 步到 nums[0]，因此 result[3] 为 3。

示例 2：

输入： nums = [-1,4,-1]
输出： [-1,-1,4]
解释：
对于 nums[0] 等于 -1，向左移动 1 步到 nums[2]，因此 result[0] 为 -1。
对于 nums[1] 等于 4，向右移动 4 步到 nums[2]，因此 result[1] 为 -1。
对于 nums[2] 等于 -1，向左移动 1 步到 nums[1]，因此 result[2] 为 4。

说明：

• 1 <= nums.length <= 100
• -100 <= nums[i] <= 100

思路

将循环数组 nums 根据规则转换成一个新数组，新数组下标 i 的值是 nums[offset]，当 nums[i] > 0 时，offset 取 i 右边 nums[i] 个位置上的值，当 nums[i] < 0 时，取 i 左边 nums[i] 个位置上的值，如果为 0，取 nums[i]。

代码

/**
 * @date 2026-02-05 8:43
 */
public class ConstructTransformedArray3379 {

    public int[] constructTransformedArray_v1(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = nums[((i + nums[i]) % n + n) % n];
        }
        return res;
    }

}

性能

目标

给你一个长度为 n 的整数数组 nums。

如果存在索引 0 < p < q < n − 1，使得数组满足以下条件，则称其为 三段式数组（trionic）：

• nums[0...p] 严格 递增，
• nums[p...q] 严格 递减，
• nums[q...n − 1] 严格 递增。

如果 nums 是三段式数组，返回 true；否则，返回 false。

示例 1:

输入: nums = [1,3,5,4,2,6]
输出: true
解释:
选择 p = 2, q = 4：
nums[0...2] = [1, 3, 5] 严格递增 (1 < 3 < 5)。
nums[2...4] = [5, 4, 2] 严格递减 (5 > 4 > 2)。
nums[4...5] = [2, 6] 严格递增 (2 < 6)。

示例 2:

输入: nums = [2,1,3]
输出: false
解释:
无法选出能使数组满足三段式要求的 p 和 q 。

说明:

• 3 <= n <= 100
• -1000 <= nums[i] <= 1000

思路

判断数组是否是三段式数组，所谓三段式数组指第一段严格递增，第二段严格递减，第三段严格递增。

根据题意模拟，判断数组拐弯的次数是否等于 2，注意第一段应该是严格递增的。

代码

/**
 * @date 2026-02-03 9:11
 */
public class IsTrionic3637 {

    public boolean isTrionic(int[] nums) {
        if (nums[0] >= nums[1]) {
            return false;
        }
        int n = nums.length;
        int cnt = 0;
        for (int i = 1; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return false;
            } else if (nums[i - 1] > nums[i] != nums[i] > nums[i + 1]) {
                cnt++;
            }
        }
        return cnt == 2;
    }

}

性能

目标

给你一个长度为 n 的整数数组 nums 。

一个数组的 代价 是它的 第一个 元素。比方说，[1,2,3] 的代价是 1 ，[3,4,1] 的代价是 3 。

你需要将 nums 分成 3 个 连续且没有交集 的子数组。

请你返回这些子数组的 最小 代价 总和 。

示例 1：

输入：nums = [1,2,3,12]
输出：6
解释：最佳分割成 3 个子数组的方案是：[1] ，[2] 和 [3,12] ，总代价为 1 + 2 + 3 = 6 。
其他得到 3 个子数组的方案是：
- [1] ，[2,3] 和 [12] ，总代价是 1 + 2 + 12 = 15 。
- [1,2] ，[3] 和 [12] ，总代价是 1 + 3 + 12 = 16 。

示例 2：

输入：nums = [5,4,3]
输出：12
解释：最佳分割成 3 个子数组的方案是：[5] ，[4] 和 [3] ，总代价为 5 + 4 + 3 = 12 。
12 是所有分割方案里的最小总代价。

示例 3：

输入：nums = [10,3,1,1]
输出：12
解释：最佳分割成 3 个子数组的方案是：[10,3] ，[1] 和 [1] ，总代价为 10 + 1 + 1 = 12 。
12 是所有分割方案里的最小总代价。

说明：

• 3 <= n <= 50
• 1 <= nums[i] <= 50

思路

定义数组的代价是其第一个元素值，有一个数组 nums，将其分割成 3 个连续且不相交子数组，求子数组的最小总代价。

第一个数组的代价是固定的，问题变成从 1 ~ n -1 选两个最小的元素值。可以排序后取前三个元素的和，或者使用双指针记录最小与次小元素。

代码

/**
 * @date 2026-02-02 9:49
 */
public class MinimumCost3010 {

    public int minimumCost(int[] nums) {
        int n = nums.length;
        int min1 = Integer.MAX_VALUE;
        int min2 = Integer.MAX_VALUE;
        for (int i = 1; i < n; i++) {
            if (nums[i] < min1) {
                min2 = min1;
                min1 = nums[i];
            } else if (nums[i] < min2) {
                min2 = nums[i];
            }
        }
        return nums[0] + min1 + min2;
    }
}

性能

目标

给你一个字符数组 letters，该数组按非递减顺序排序，以及一个字符 target。letters 里至少有两个不同的字符。

返回 letters 中大于 target 的最小的字符。如果不存在这样的字符，则返回 letters 的第一个字符。

示例 1：

输入: letters = ['c', 'f', 'j']，target = 'a'
输出: 'c'
解释：letters 中字典上比 'a' 大的最小字符是 'c'。

示例 2:

输入: letters = ['c','f','j'], target = 'c'
输出: 'f'
解释：letters 中字典顺序上大于 'c' 的最小字符是 'f'。

示例 3:

输入: letters = ['x','x','y','y'], target = 'z'
输出: 'x'
解释：letters 中没有一个字符在字典上大于 'z'，所以我们返回 letters[0]。

说明：

• 2 <= letters.length <= 10^4
• letters[i] 是一个小写字母
• letters 按非递减顺序排序
• letters 最少包含两个不同的字母
• target 是一个小写字母

思路

有一个升序排列的字符数组 letters，返回大于 target 的最小字符，如不存在返回第一个字符。

使用二分，查找第一个大于 target 的字符。

代码

/**
 * @date 2026-02-02 9:42
 */
public class NextGreatestLetter744 {

    public char nextGreatestLetter(char[] letters, char target) {
        int n = letters.length;
        int r = n - 1;
        int l = 0;
        int m = l + (r - l) / 2;
        while (l <= r) {
            if (letters[m] <= target) {
                l = m + 1;
            } else {
                r = m - 1;
            }
            m = l + (r - l) / 2;
        }
        return l < n ? letters[l] : letters[0];
    }

}

性能

目标

给你个整数数组 arr，其中每个元素都 不相同。

请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。

每对元素对 [a,b] 如下：

• a , b 均为数组 arr 中的元素
• a < b
• b - a 等于 arr 中任意两个元素的最小绝对差

示例 1：

输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]

示例 2：

输入：arr = [1,3,6,10,15]
输出：[[1,3]]

示例 3：

输入：arr = [3,8,-10,23,19,-4,-14,27]
输出：[[-14,-10],[19,23],[23,27]]

说明：

• 2 <= arr.length <= 10^5
• -10^6 <= arr[i] <= 10^6

思路

找到数组 arr 中元素值距离最小的元素对，按照升序返回。升序指 元素对 内部升序，结果集中元素对第一个元素升序。

将数组排序，最小距离在相邻元素中产生。

代码

/**
 * @date 2026-01-26 8:44
 */
public class MinimumAbsDifference1200 {

    public List<List<Integer>> minimumAbsDifference(int[] arr) {
        Arrays.sort(arr);
        List<List<Integer>> res = new ArrayList<>();
        int n = arr.length;
        int diff = Integer.MAX_VALUE;
        for (int i = 0; i < n - 1; i++) {
            diff = Math.min(diff, arr[i + 1] - arr[i]);
        }
        for (int i = 0; i < n - 1; i++) {
            if (arr[i + 1] - arr[i] == diff) {
                List<Integer> tmp = new ArrayList<>();
                tmp.add(arr[i]);
                tmp.add(arr[i + 1]);
                res.add(tmp);
            }
        }
        return res;
    }
}

性能