shelterofly

目标

给你一个下标从 0 开始的整数数组 nums 以及一个目标元素 target 。

目标下标 是一个满足 nums[i] == target 的下标 i 。

将 nums 按 非递减 顺序排序后，返回由 nums 中目标下标组成的列表。如果不存在目标下标，返回一个 空 列表。返回的列表必须按 递增 顺序排列。

示例 1：

输入：nums = [1,2,5,2,3], target = 2
输出：[1,2]
解释：排序后，nums 变为 [1,2,2,3,5] 。
满足 nums[i] == 2 的下标是 1 和 2 。

示例 2：

输入：nums = [1,2,5,2,3], target = 3
输出：[3]
解释：排序后，nums 变为 [1,2,2,3,5] 。
满足 nums[i] == 3 的下标是 3 。

示例 3：

输入：nums = [1,2,5,2,3], target = 5
输出：[4]
解释：排序后，nums 变为 [1,2,2,3,5] 。
满足 nums[i] == 5 的下标是 4 。

示例 4：

输入：nums = [1,2,5,2,3], target = 4
输出：[]
解释：nums 中不含值为 4 的元素。

说明：

• 1 <= nums.length <= 100
• 1 <= nums[i], target <= 100

思路

有一个下标从 0 开始的数组 nums，从中查找值为 target 的元素，返回其在排序后的数组中的下标，如果没有找到返回空。

直接的想法是先排序数组，然后遍历查找目标，将下标加入结果集，时间复杂度为 O(nlogn)。

本题只关心特定元素在数组中的位次，只需统计左右两端的元素数目即可算出下标。

代码

/**
 * @date 2026-10-19 8:48
 */
public class TargetIndices2089 {

    public List<Integer> targetIndices(int[] nums, int target) {
        int n = nums.length;
        int l = 0, r = 0;
        List<Integer> res = new ArrayList<>();
        for (int num : nums) {
            if (num < target) {
                l++;
            } else if (num > target) {
                r++;
            }
        }
        int length = n - l - r;
        for (int i = 0; i < length; i++) {
            res.add(l++);
        }
        return res;
    }
}

性能

目标

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

对 nums 中的元素 nums[i] 而言，如果 n 能够被 i 整除，即 n % i == 0 ，则认为 nums[i] 是一个 特殊元素 。

返回 nums 中所有 特殊元素 的 平方和 。

示例 1：

输入：nums = [1,2,3,4]
输出：21
解释：nums 中共有 3 个特殊元素：nums[1]，因为 4 被 1 整除；nums[2]，因为 4 被 2 整除；以及 nums[4]，因为 4 被 4 整除。 
因此，nums 中所有特殊元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21 。

示例 2：

输入：nums = [2,7,1,19,18,3]
输出：63
解释：nums 中共有 4 个特殊元素：nums[1]，因为 6 被 1 整除；nums[2] ，因为 6 被 2 整除；nums[3]，因为 6 被 3 整除；以及 nums[6]，因为 6 被 6 整除。 
因此，nums 中所有特殊元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63 。 

说明：

• 1 <= nums.length == n <= 50
• 1 <= nums[i] <= 50

思路

有一个下标从 1 开始的数组 nums，如果 n % i == 0 则称 nums[i] 为特殊元素，返回特殊元素的平方和。

根据题意模拟即可。

代码

/**
 * @date 2026-10-12 9:38
 */
public class SumOfSquares2778 {

    public int sumOfSquares(int[] nums) {
        int n = nums.length;
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (n % (i + 1) == 0) {
                res += nums[i] * nums[i];
            }
        }
        return res;
    }
}

性能

目标

有效括号字符串为空 ""、"(" + A + ")" 或 A + B ，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。

• 例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。

如果有效字符串 s 非空，且不存在将其拆分为 s = A + B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 s，考虑将其进行原语化分解，使得：s = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。

对 s 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 s 。

示例 1：

输入：s = "(()())(())"
输出："()()()"
解释：
输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，
删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。

示例 2：

输入：s = "(()())(())(()(()))"
输出："()()()()(())"
解释：
输入字符串为 "(()())(())(()(()))"，原语化分解得到 "(()())" + "(())" + "(()(()))"，
删除每个部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。

示例 3：

输入：s = "()()"
输出：""
解释：
输入字符串为 "()()"，原语化分解得到 "()" + "()"，
删除每个部分中的最外层括号后得到 "" + "" = ""。

说明：

• 1 <= s.length <= 10^5
• s[i] 为 '(' 或 ')'
• s 是一个有效括号字符串

思路

有一个仅由 ( 或 ) 组成非空有效括号字符串。删掉最外层的括号并返回删除后的字符串。最外层指没有被嵌套在其它括号内部的括号。

如果左括号的数量等于右括号的数量说明匹配到了最外层括号，去掉首尾保留中间即可。

代码

/**
 * @date 2026-10-08 9:12
 */
public class RemoveOuterParentheses1021 {

    public String removeOuterParentheses(String s) {
        StringBuilder sb = new StringBuilder();
        int n = s.length();
        int lc = 0, rc = 0, l = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '(') {
                lc++;
                if (lc == 1) {
                    l = i;
                }
            } else {
                rc++;
                if (lc == rc) {
                    sb.append(s.substring(l + 1, i));
                    lc = 0;
                    rc = 0;
                }
            }
        }
        return sb.toString();
    }
}

性能

目标

给定 有效括号字符串 s，返回 s 的 嵌套深度。嵌套深度是嵌套括号的 最大 数量。

示例 1：

输入：s = "(1+(2*3)+((8)/4))+1"
输出：3
解释：数字 8 在嵌套的 3 层括号中。

示例 2：

输入：s = "(1)+((2))+(((3)))"
输出：3
解释：数字 3 在嵌套的 3 层括号中。

示例 3：

输入：s = "()(())((()()))"
输出：3

说明：

• 1 <= s.length <= 100
• s 由数字 0-9 和字符 '+'、'-'、'*'、'/'、'('、')' 组成
• 题目数据保证括号字符串 s 是 有效的括号字符串

思路

s 是一个有效的括号字符串，其中的括号是能够合法匹配的。返回 s 中括号嵌套的最大深度。

遇到 ( 深度加一，遇到 ) 深度减一，记录深度的最大值即可。

代码

/**
 * @date 2026-09-28 10:04
 */
public class MaxDepth1614 {

    public int maxDepth(String s) {
        int res = 0;
        int n = s.length();
        int depth = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '(') {
                depth++;
                res = Math.max(res, depth);
            } else if (s.charAt(i) == ')') {
                depth--;
            }
        }
        return res;
    }
}

性能

目标

给你一个整数数组 nums 。

返回满足 nums[i] 的数位和（每一位数字相加求和）等于 i 的 最小 下标 i 。

如果不存在满足要求的下标，返回 -1 。

示例 1：

输入：nums = [1,3,2]
输出：2
解释：
nums[2] = 2，其数位和等于 2 ，与其下标 i = 2 相等。因此，输出为 2 。

示例 2：

输入：nums = [1,10,11]
输出：1
解释：
nums[1] = 10，其数位和等于 1 + 0 = 1，与其下标 i = 1 相等。
nums[2] = 11，其数位和等于是 1 + 1 = 2，与其下标 i = 2 相等。
由于下标 1 是满足要求的最小下标，输出为 1 。

示例 3：

输入：nums = [1,2,3]
输出：-1
解释：
由于不存在满足要求的下标，输出为 -1 。

说明：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 1000

思路

已知数组 nums，返回数位和等于数组下标的最小下标，如果不存在返回 -1。

依题意模拟即可。

代码

/**
 * @date 2026-09-24 8:43
 */
public class SmallestIndex3550 {

    public int smallestIndex(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int num = nums[i], sum = 0;
            while (num > 0) {
                sum += num % 10;
                num /= 10;
            }
            if (sum == i) {
                return i;
            }
        }
        return -1;
    }
}

性能