标签： 模拟

目标

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 "balloon"（气球）。

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 "balloon"。

示例 1：

输入：text = "nlaebolko"
输出：1

示例 2：

输入：text = "loonbalxballpoon"
输出：2

示例 3：

输入：text = "leetcode"
输出：0

提示：

• 1 <= text.length <= 10^4
• text 全部由小写英文字母组成

注意：本题与 2287.重排字符形成目标字符串 相同。

思路

使用字符串 text 中的字母拼凑单词 balloon，求最多能拼出多少个。

单词由 1 个 a、1 个 b、1 个 n、2 个 l 和 2 个 o 组成。对 text 中的字母计数，统计相关字母频次的最小值即可（l 与 o 需要除以 2）。

代码

/**
 * @date 2026-06-22 9:05
 */
public class MaxNumberOfBalloons1189 {

    public int maxNumberOfBalloons_v1(String text) {
        char[] cnt = new char[26];
        for (char c : text.toCharArray()) {
            cnt[c - 'a']++;
        }
        int res = Integer.MAX_VALUE;
        res = Math.min(res, cnt[0]);
        res = Math.min(res, cnt[1]);
        res = Math.min(res, cnt[11] / 2);
        res = Math.min(res, cnt[13]);
        res = Math.min(res, cnt[14] / 2);
        return res;
    }

}

性能

目标

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

示例 1：

输入：gain = [-5,1,5,0,-7]
输出：1
解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。

示例 2：

输入：gain = [-4,-3,-2,-1,4,3,2]
输出：0
解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。

说明：

• n == gain.length
• 1 <= n <= 100
• -100 <= gain[i] <= 100

思路

有 n + 1 个海拔点 altitude，altitude[0] = 0，gain[i] 表示从海拔点 i 到 i + 1 的增量，即 altitude[i + 1] = altitude[i] + gain[i]，返回最大的海拔。

依题意模拟即可。

代码

/**
 * @date 2026-06-19 8:08
 */
public class LargestAltitude1732 {

    public int largestAltitude(int[] gain) {
        int altitude = 0;
        int res = 0;
        for (int g : gain) {
            altitude += g;
            res = Math.max(res, altitude);
        }
        return res;
    }
}

性能

目标

给你一个字符串数组 words，其中每个字符串表示一个由小写英文字母组成的单词。

同时给你一个长度为 26 的整数数组 weights，其中 weights[i] 表示第 i 个小写英文字母的权重。

单词的 权重 定义为其所有字符权重的 总和。

对于每个单词，将其权重对 26 取模，并将结果按字母倒序映射到一个小写英文字母（0 -> 'z', 1 -> 'y', ..., 25 -> 'a'）。

返回一个由所有单词映射后的字符按顺序连接而成的字符串。

示例 1：

输入： words = ["abcd","def","xyz"], weights = [5,3,12,14,1,2,3,2,10,6,6,9,7,8,7,10,8,9,6,9,9,8,3,7,7,2]
输出： "rij"
解释：
"abcd" 的权重是 5 + 3 + 12 + 14 = 34。对 26 取模的结果是 34 % 26 = 8，映射为 'r'。
"def" 的权重是 14 + 1 + 2 = 17。对 26 取模的结果是 17 % 26 = 17，映射为 'i'。
"xyz" 的权重是 7 + 7 + 2 = 16。对 26 取模的结果是 16 % 26 = 16，映射为 'j'。
因此，连接映射字符后形成的字符串是 "rij"。

示例 2：

输入： words = ["a","b","c"], weights = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
输出： "yyy"
解释：
每个单词的权重均为 1。对 26 取模的结果是 1 % 26 = 1，映射为 'y'。
因此，连接映射字符后形成的字符串是 "yyy"。

示例 3：

输入： words = ["abcd"], weights = [7,5,3,4,3,5,4,9,4,2,2,7,10,2,5,10,6,1,2,2,4,1,3,4,4,5]
输出： "g"
解释：
"abcd" 的权重是 7 + 5 + 3 + 4 = 19。对 26 取模的结果是 19 % 26 = 19，映射为 'g'。
因此，连接映射字符后形成的字符串是 "g"。

说明：

• 1 <= words.length <= 100
• 1 <= words[i].length <= 10
• weights.length == 26
• 1 <= weights[i] <= 100
• words[i] 仅由小写英文字母组成。

思路

已知小写字母的权重数组中 weights，计算每个单词的权重之和对 26 取模，将结果倒序映射回小写字母，即 0 -> z、1 -> y ……

根据题意模拟即可。

代码

/**
 * @date 2026-06-15 14:51
 */
public class MapWordWeights3838 {

    public String mapWordWeights(String[] words, int[] weights) {
        StringBuilder sb = new StringBuilder();
        for (String word : words) {
            int sum = 0;
            for (int i = 0; i < word.length(); i++) {
                sum += weights[word.charAt(i) - 'a'];
            }
            char c = (char) ('z' - sum % 26);
            sb.append(c);
        }
        return sb.toString();
    }

}

性能

目标

给你一个下标从 0 开始的长度为 n 的整数数组 nums。

定义两个数组 leftSum 和 rightSum，其中：

• leftSum[i] 是数组 nums 中下标 i 左侧元素之和。如果不存在对应的元素，leftSum[i] = 0 。
• rightSum[i] 是数组 nums 中下标 i 右侧元素之和。如果不存在对应的元素，rightSum[i] = 0 。

返回长度为 n 数组 answer，其中 answer[i] = |leftSum[i] - rightSum[i]|。

示例 1：

输入：nums = [10,4,8,3]
输出：[15,1,11,22]
解释：数组 leftSum 为 [0,10,14,22] 且数组 rightSum 为 [15,11,3,0] 。
数组 answer 为 [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22] 。

示例 2：

输入：nums = [1]
输出：[0]
解释：数组 leftSum 为 [0] 且数组 rightSum 为 [0] 。
数组 answer 为 [|0 - 0|] = [0] 。

说明：

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= 10^5

思路

有一个正整数数组 nums，leftSum[i] 表示下标 i 左侧的元素之和，rightSum[i] 表示下标 i 右侧的元素之和，返回结果数组 answer，answer[i] = abs(leftSum[i] - rightSum[i])。

依题意模拟

• totalSum = leftSum[i] + nums[i] + rightSum[i]，
• answer[i] = abs(leftSum[i] - (totalSum - leftSum[i] - nums[i])) = abs(leftSum[i] + leftSum[i + 1] - totalSum) = abs(leftSum[i] + leftSum[i + 1] - leftSum[n])

计算出前缀和，然后根据返填答案即可。

代码

/**
 * @date 2026-06-08 11:59
 */
public class LeftRightDifference2574 {

    public int[] leftRightDifference(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
        int[] prefix = new int[n + 1];
        for (int i = 0; i < n; i++) {
            prefix[i + 1] = prefix[i] + nums[i];
        }
        for (int i = 0; i < n; i++) {
            res[i] = Math.abs(prefix[i] - (prefix[n] - prefix[i + 1]));
        }
        return res;
    }
}

性能

目标

给你一个整数数组 nums 。

请你将 nums 中每一个元素都替换为它的各个数位之 和 。

请你返回替换所有元素以后 nums 中的 最小 元素。

示例 1：

输入：nums = [10,12,13,14]
输出：1
解释：
nums 替换后变为 [1, 3, 4, 5] ，最小元素为 1 。

示例 2：

输入：nums = [1,2,3,4]
输出：1
解释：
nums 替换后变为 [1, 2, 3, 4] ，最小元素为 1 。

示例 3：

输入：nums = [999,19,199]
输出：10
解释：
nums 替换后变为 [27, 10, 19] ，最小元素为 10 。

说明：

1 <= nums.length <= 100
1 <= nums[i] <= 10^4

思路

将数组中的元素换成其各位数字之和，返回替换后数组的最小值。

代码

/**
 * @date 2026-05-29 0:03
 */
public class MinElement3300 {

    public int minElement(int[] nums) {
        int res = Integer.MAX_VALUE;
        for (int num : nums) {
            int sum = 0;
            while (num > 0){
                sum += num % 10;
                num /= 10;
            }
            res = Math.min(res, sum);
        }
        return res;
    }
}

性能