标签： easy

目标

给你一个整数数组 nums 。

你可以从数组 nums 中删除任意数量的元素，但不能将其变为 空 数组。执行删除操作后，选出 nums 中满足下述条件的一个子数组：

• 子数组中的所有元素 互不相同 。
• 最大化 子数组的元素和。

返回子数组的 最大元素和 。

子数组 是数组的一个连续、非空 的元素序列。

示例 1：

输入：nums = [1,2,3,4,5]
输出：15
解释：
不删除任何元素，选中整个数组得到最大元素和。

示例 2：

输入：nums = [1,1,0,1,1]
输出：1
解释：
删除元素 nums[0] == 1、nums[1] == 1、nums[2] == 0 和 nums[3] == 1 。选中整个数组 [1] 得到最大元素和。

示例 3：

输入：nums = [1,2,-1,-2,1,0,-1]
输出：3
解释：
删除元素 nums[2] == -1 和 nums[3] == -2 ，从 [1, 2, 1, 0, -1] 中选中子数组 [2, 1] 以获得最大元素和。

说明：

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

思路

有一个数组 nums，允许删除其中任意元素得到一个 非空 数组，使得最终数组中 不包含重复元素 并且所有 元素和最大。

为了使和最大，我们应该删掉所有的负数，同时对剩余元素去重累加求和。需要注意如果数组中全是负数，需要保留最大元素。

代码

/**
 * @date 2025-07-25 8:55
 */
public class MaxSum3487 {

    public int maxSum(int[] nums) {
        int sum = Arrays.stream(nums).distinct().filter(x -> x > 0).sum();
        if (sum == 0){
            OptionalInt max = Arrays.stream(nums).max();
            return max.isPresent() ? max.getAsInt() : sum;
        }
        return sum;
    }

}

性能

目标

一个字符串如果没有 三个连续 相同字符，那么它就是一个 好字符串 。

给你一个字符串 s ，请你从 s 删除 最少 的字符，使它变成一个 好字符串 。

请你返回删除后的字符串。题目数据保证答案总是 唯一的 。

示例 1：

输入：s = "leeetcode"
输出："leetcode"
解释：
从第一组 'e' 里面删除一个 'e' ，得到 "leetcode" 。
没有连续三个相同字符，所以返回 "leetcode" 。

示例 2：

输入：s = "aaabaaaa"
输出："aabaa"
解释：
从第一组 'a' 里面删除一个 'a' ，得到 "aabaaaa" 。
从第二组 'a' 里面删除两个 'a' ，得到 "aabaa" 。
没有连续三个相同字符，所以返回 "aabaa" 。

示例 3：

输入：s = "aab"
输出："aab"
解释：没有连续三个相同字符，所以返回 "aab" 。

说明：

• 1 <= s.length <= 10^5
• s 只包含小写英文字母。

思路

定义 好字符串 是不包含连续三个相同字符的字符串，给定一个字符串，删掉最少的字符使之变为好字符串。

记录连续重复字符个数，不同则重置，如果达到三个则跳过。

代码

/**
 * @date 2025-07-21 8:40
 */
public class MakeFancyString1957 {

    public String makeFancyString_v1(String s) {
        int n = s.length();
        char prev = ' ';
        int cnt = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (prev == c) {
                if (cnt < 2) {
                    cnt++;
                    sb.append(c);
                }
            } else {
                sb.append(c);
                prev = c;
                cnt = 1;
            }
        }
        return sb.toString();
    }

}

性能

目标

有效单词 需要满足以下几个条件：

• 至少 包含 3 个字符。
• 由数字 0-9 和英文大小写字母组成。（不必包含所有这类字符。）
• 至少 包含一个 元音字母 。
• 至少 包含一个 辅音字母 。

给你一个字符串 word 。如果 word 是一个有效单词，则返回 true ，否则返回 false 。

注意：

• 'a'、'e'、'i'、'o'、'u' 及其大写形式都属于 元音字母 。
• 英文中的 辅音字母 是指那些除元音字母之外的字母。

示例 1：

输入：word = "234Adas"
输出：true
解释：
这个单词满足所有条件。

示例 2：

输入：word = "b3"
输出：false
解释：
这个单词的长度少于 3 且没有包含元音字母。

示例 3：

输入：word = "a3$e"
输出：false
解释：
这个单词包含了 '$' 字符且没有包含辅音字母。

说明：

• 1 <= word.length <= 20
• word 由英文大写和小写字母、数字、'@'、'#' 和 '$' 组成。

思路

判断字符串是否至少包含 3 个字符，且仅由英文字母与数字组成，且至少包含一个元音字母和一个辅音字母。

正则表达式，前瞻断言。

代码

/**
 * @date 2025-07-15 8:52
 */
public class IsValid3136 {

    public static Pattern p = Pattern.compile("^(?=.*[aeiouAEIOU])(?=.*[b-df-hj-np-tv-zB-DF-HJ-NP-TV-Z])[0-9a-zA-z]{3,}$");

    public boolean isValid(String word) {
        return p.matcher(word).find();
    }

}

性能

目标

在整数数组中，如果一个整数的出现频次和它的数值大小相等，我们就称这个整数为「幸运数」。

给你一个整数数组 arr，请你从中找出并返回一个幸运数。

• 如果数组中存在多个幸运数，只需返回 最大 的那个。
• 如果数组中不含幸运数，则返回 -1 。

示例 1：

输入：arr = [2,2,3,4]
输出：2
解释：数组中唯一的幸运数是 2 ，因为数值 2 的出现频次也是 2 。

示例 2：

输入：arr = [1,2,2,3,3,3]
输出：3
解释：1、2 以及 3 都是幸运数，只需要返回其中最大的 3 。

示例 3：

输入：arr = [2,2,2,3,3]
输出：-1
解释：数组中不存在幸运数。

示例 4：

输入：arr = [5]
输出：-1

示例 5：

输入：arr = [7,7,7,7,7,7,7]
输出：7

说明：

• 1 <= arr.length <= 500
• 1 <= arr[i] <= 500

思路

统计元素频次，从大到小找到频次与元素值相等的元素即可。

代码

/**
 * @date 2025-07-05 20:37
 */
public class FindLucky1394 {

    public int findLucky(int[] arr) {
        int[] cnt = new int[501];
        for (int num : arr) {
            cnt[num]++;
        }
        for (int i = 500; i > 0; i--) {
            if (cnt[i] == i) {
                return i;
            }
        }
        return -1;
    }
}

性能

目标

Alice 和 Bob 正在玩一个游戏。最初，Alice 有一个字符串 word = "a"。

给定一个正整数 k。

现在 Bob 会要求 Alice 执行以下操作 无限次 :

• 将 word 中的每个字符 更改 为英文字母表中的 下一个 字符来生成一个新字符串，并将其 追加 到原始的 word。

例如，对 "c" 进行操作生成 "cd"，对 "zb" 进行操作生成 "zbac"。

在执行足够多的操作后， word 中 至少 存在 k 个字符，此时返回 word 中第 k 个字符的值。

注意，在操作中字符 'z' 可以变成 'a'。

示例 1:

输入：k = 5
输出："b"
解释：
最初，word = "a"。需要进行三次操作:
生成的字符串是 "b"，word 变为 "ab"。
生成的字符串是 "bc"，word 变为 "abbc"。
生成的字符串是 "bccd"，word 变为 "abbcbccd"。

示例 2:

输入：k = 10
输出："c"

说明：

• 1 <= k <= 500

思路

开始的时候有一个字符 a，可以反复执行以下操作：将现有的所有字母替换为它在字母表中的下一个字母（z 的下一个字母为 a），拼接到当前字符后面。返回第 k 个字母。

暴力模拟操作过程。

代码

/**
 * @date 2025-07-03 8:48
 */
public class KthCharacter3304 {

    public char kthCharacter(int k) {
        StringBuilder sb = new StringBuilder();
        sb.append('a');
        while (sb.length() < k) {
            String s = sb.toString();
            int length = s.length();
            for (int i = 0; i < length; i++) {
                char c = (char) ('a' + (s.charAt(i) - 'a' + 1) % 26);
                sb.append(c);
            }
        }
        return sb.toString().charAt(k - 1);
    }

}

性能

目标

和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。

给你一个整数数组 nums ，请你在所有可能的 子序列 中找到最长的和谐子序列的长度。

数组的 子序列 是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。

示例 1：

输入：nums = [1,3,2,2,5,2,3,7]
输出：5
解释：
最长和谐子序列是 [3,2,2,2,3]。

示例 2：

输入：nums = [1,2,3,4]
输出：2
解释：
最长和谐子序列是 [1,2]，[2,3] 和 [3,4]，长度都为 2。

示例 3：

输入：nums = [1,1,1,1]
输出：0
解释：
不存在和谐子序列。

说明：

• 1 <= nums.length <= 2 * 10^4
• -10^9 <= nums[i] <= 10^9

思路

统计数字出现次数，求相邻频次之和的最大值。

代码

/**
 * @date 2025-06-30 8:46
 */
public class FindLHS {

    public int findLHS(int[] nums) {
        int n = nums.length;
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int i = 0; i < n; i++) {
            cnt.merge(nums[i], 1, Integer::sum);
        }
        int res = 0;
        for (Map.Entry<Integer, Integer> entry : cnt.entrySet()) {
            int key = entry.getKey();
            Integer nextVal = cnt.get(key + 1);
            if (nextVal != null) {
                res = Math.max(res, entry.getValue() + nextVal);
            }
        }
        return res;
    }
}

性能