标签： easy

目标

给你一个 循环 数组 nums ，请你找出相邻元素之间的 最大 绝对差值。

注意：一个循环数组中，第一个元素和最后一个元素是相邻的。

示例 1：

输入：nums = [1,2,4]
输出：3
解释：
由于 nums 是循环的，nums[0] 和 nums[2] 是相邻的，它们之间的绝对差值是最大值 |4 - 1| = 3 。

示例 2：

输入：nums = [-5,-10,-5]
输出：5
解释：
相邻元素 nums[0] 和 nums[1] 之间的绝对差值为最大值 |-5 - (-10)| = 5 。

说明：

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

思路

依题意模拟即可。

代码

/**
 * @date 2025-06-12 0:02
 */
public class MaxAdjacentDistance3423 {

    public int maxAdjacentDistance(int[] nums) {
        int res = 0;
        int n = nums.length;
        for (int i = 1; i <= n; i++) {
            res = Math.max(res, Math.abs(nums[i % n] - nums[i - 1]));
        }
        return res;
    }
}

性能

目标

给你两个正整数 n 和 m 。

现定义两个整数 num1 和 num2 ，如下所示：

• num1：范围 [1, n] 内所有 无法被 m 整除 的整数之和。
• num2：范围 [1, n] 内所有 能够被 m 整除 的整数之和。

返回整数 num1 - num2 。

示例 1：

输入：n = 10, m = 3
输出：19
解释：在这个示例中：
- 范围 [1, 10] 内无法被 3 整除的整数为 [1,2,4,5,7,8,10] ，num1 = 这些整数之和 = 37 。
- 范围 [1, 10] 内能够被 3 整除的整数为 [3,6,9] ，num2 = 这些整数之和 = 18 。
返回 37 - 18 = 19 作为答案。

示例 2：

输入：n = 5, m = 6
输出：15
解释：在这个示例中：
- 范围 [1, 5] 内无法被 6 整除的整数为 [1,2,3,4,5] ，num1 = 这些整数之和 =  15 。
- 范围 [1, 5] 内能够被 6 整除的整数为 [] ，num2 = 这些整数之和 = 0 。
返回 15 - 0 = 15 作为答案。

示例 3：

输入：n = 5, m = 1
输出：-15
解释：在这个示例中：
- 范围 [1, 5] 内无法被 1 整除的整数为 [] ，num1 = 这些整数之和 = 0 。 
- 范围 [1, 5] 内能够被 1 整除的整数为 [1,2,3,4,5] ，num2 = 这些整数之和 = 15 。
返回 0 - 15 = -15 作为答案。

说明：

• 1 <= n, m <= 1000

思路

求 1 ~ n 中无法整除 m 的所有整数和 num1 与 能够整除 m 的所有整数和 num2 之差。

依题意模拟即可。

或者使用等差数列求和公式计算。

根据等差数列求和公式得到所有元素和为 total = (n + 1) * n / 2，能够被 m 整除的所有整数和为 首项为 m，公差为 m，个数为 cnt = n / m 的等差数列和，num2 = m * (cnt + 1) * cnt / 2。结果为 total - 2 * num2。

代码

/**
 * @date 2025-05-27 1:00
 */
public class DifferenceOfSums2894 {

    public int differenceOfSums(int n, int m) {
        int total = (n + 1) * n / 2;
        int cnt = n / m;
        return total - m * (1 + cnt) * cnt;
    }

}

性能

目标

给你一个下标从 0 开始的字符串数组 words 和一个字符 x 。

请你返回一个 下标数组，表示下标在数组中对应的单词包含字符 x 。

注意，返回的数组可以是 任意 顺序。

示例 1：

输入：words = ["leet","code"], x = "e"
输出：[0,1]
解释："e" 在两个单词中都出现了："leet" 和 "code" 。所以我们返回下标 0 和 1 。

示例 2：

输入：words = ["abc","bcd","aaaa","cbc"], x = "a"
输出：[0,2]
解释："a" 在 "abc" 和 "aaaa" 中出现了，所以我们返回下标 0 和 2 。

示例 3：

输入：words = ["abc","bcd","aaaa","cbc"], x = "z"
输出：[]
解释："z" 没有在任何单词中出现。所以我们返回空数组。

提示：

• 1 <= words.length <= 50
• 1 <= words[i].length <= 50
• x 是一个小写英文字母。
• words[i] 只包含小写英文字母。

思路

返回字符串数组中包含给定字符的下标。

代码

/**
 * @date 2025-05-24 10:09
 */
public class FindWordsContaining2942 {

    public List<Integer> findWordsContaining(String[] words, char x) {
        List<Integer> res = new ArrayList<>(words.length);
        for (int i = 0; i < words.length; i++) {
            String word = words[i];
            for (int j = 0; j < word.length(); j++) {
                if (word.charAt(j) == x) {
                    res.add(i);
                    break;
                }
            }
        }
        return res;
    }

}

性能

目标

给你一个下标从 0 开始长度为 3 的整数数组 nums ，需要用它们来构造三角形。

• 如果一个三角形的所有边长度相等，那么这个三角形称为 equilateral 。
• 如果一个三角形恰好有两条边长度相等，那么这个三角形称为 isosceles 。
• 如果一个三角形三条边的长度互不相同，那么这个三角形称为 scalene 。

如果这个数组无法构成一个三角形，请你返回字符串 "none" ，否则返回一个字符串表示这个三角形的类型。

示例 1：

输入：nums = [3,3,3]
输出："equilateral"
解释：由于三条边长度相等，所以可以构成一个等边三角形，返回 "equilateral" 。

示例 2：

输入：nums = [3,4,5]
输出："scalene"
解释：
nums[0] + nums[1] = 3 + 4 = 7 ，大于 nums[2] = 5 。
nums[0] + nums[2] = 3 + 5 = 8 ，大于 nums[1] = 4 。
nums[1] + nums[2] = 4 + 5 = 9 ，大于 nums[0] = 3 。
由于任意两边之和都大于第三边，所以可以构成一个三角形，因为三条边的长度互不相等，所以返回 "scalene"。

说明：

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

思路

已知三角形的三条边的长度，判断三角形的类型。

将数组 nums 排序，判断 nums[2] < nums[0] + nums[1] 如果不满足返回 none，如果 nums[0] == nums[2] 返回 equilateral，如果 nums[0] == nums[1] || nums[1] == nums[2] 返回 isosceles，否则返回 scalene。

代码

/**
 * @date 2025-05-19 8:47
 */
public class TriangleType3024 {

    public String triangleType(int[] nums) {
        Arrays.sort(nums);
        if (nums[0] + nums[1] <= nums[2]) {
            return "none";
        }
        if (nums[0] == nums[2]) {
            return "equilateral";
        } else if (nums[0] == nums[1] || nums[1] == nums[2]) {
            return "isosceles";
        } else {
            return "scalene";
        }
    }

}

性能

目标

给你一个整数数组 digits ，其中每个元素是一个数字（0 - 9）。数组中可能存在重复元素。

你需要找出 所有 满足下述条件且 互不相同 的整数：

• 该整数由 digits 中的三个元素按 任意 顺序 依次连接 组成。
• 该整数不含 前导零
• 该整数是一个 偶数

例如，给定的 digits 是 [1, 2, 3] ，整数 132 和 312 满足上面列出的全部条件。

将找出的所有互不相同的整数按 递增顺序 排列，并以数组形式返回。

示例 1：

输入：digits = [2,1,3,0]
输出：[102,120,130,132,210,230,302,310,312,320]
解释：
所有满足题目条件的整数都在输出数组中列出。 
注意，答案数组中不含有 奇数 或带 前导零 的整数。

示例 2：

输入：digits = [2,2,8,8,2]
输出：[222,228,282,288,822,828,882]
解释：
同样的数字（0 - 9）在构造整数时可以重复多次，重复次数最多与其在 digits 中出现的次数一样。 
在这个例子中，数字 8 在构造 288、828 和 882 时都重复了两次。

示例 3：

输入：digits = [3,7,5]
输出：[]
解释：
使用给定的 digits 无法构造偶数。

说明：

• 3 <= digits.length <= 100
• 0 <= digits[i] <= 9

思路

有一个元素值为 0 ~ 9 的数组，返回由数组中的数字组成的不含前导 0 且长度为 3 的偶数。

暴力枚举每个数位上可能的选择，判断是否为偶数。

代码

/**
 * @date 2025-05-12 8:50
 */
public class FindEvenNumbers2094 {

    public int[] findEvenNumbers(int[] digits) {
        int n = digits.length;
        Set<Integer> set = new HashSet<>();
        boolean[] visited = new boolean[n];
        for (int i = 0; i < n; i++) {
            if (digits[i] == 0) {
                continue;
            }
            visited[i] = true;
            for (int j = 0; j < n; j++) {
                if (visited[j]) {
                    continue;
                }
                visited[j] = true;
                for (int k = 0; k < n; k++) {
                    if (visited[k]) {
                        continue;
                    }
                    int num = digits[i] * 100 + digits[j] * 10 + digits[k];
                    if (num % 2 == 0) {
                        set.add(num);
                    }
                }
                visited[j] = false;
            }
            visited[i] = false;
        }
        int[] res = new int[set.size()];
        ArrayList<Integer> list = new ArrayList<>(set);
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        Arrays.sort(res);
        return res;
    }

}

性能

目标

给你一个 从 0 开始的排列 nums（下标也从 0 开始）。请你构建一个 同样长度 的数组 ans ，其中，对于每个 i（0 <= i < nums.length），都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。

从 0 开始的排列 nums 是一个由 0 到 nums.length - 1（0 和 nums.length - 1 也包含在内）的不同整数组成的数组。

示例 1：

输入：nums = [0,2,1,5,3,4]
输出：[0,1,2,4,5,3]
解释：数组 ans 构建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
    = [0,1,2,4,5,3]

示例 2：

输入：nums = [5,0,1,2,3,4]
输出：[4,5,0,1,2,3]
解释：数组 ans 构建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
    = [4,5,0,1,2,3]

说明：

• 1 <= nums.length <= 1000
• 0 <= nums[i] < nums.length
• nums 中的元素 互不相同

进阶：你能在不使用额外空间的情况下解决此问题吗（即 O(1) 内存）？

思路

数组 nums 是一个 0 ~ n - 1 的排列，构建一个新数组 res 满足 res[i] = nums[nums[i]]。

一般的解法是创建一个新数组，依题意设置对应的值。

进阶解法需要满足空间复杂度为 O(1)，即原地修改。可以将结果左移 10 位保存到原数组，最后将元素值右移 10 位还原结果。

代码

/**
 * @date 2025-05-06 8:43
 */
public class BuildArray1920 {

    public int[] buildArray(int[] nums) {
        int mask = 1023;
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] | ((nums[nums[i]] & mask) << 10);
        }
        for (int i = 0; i < nums.length; i++) {
            nums[i] >>= 10;
        }
        return nums;
    }

}

性能