1、3079. 求出加密整数的和

简单

给你一个整数数组 nums ，数组中的元素都是正整数。定义一个加密函数 encrypt ，encrypt(x) 将一个整数 x 中 每一个 数位都用 x 中的最大数位替换。比方说 encrypt(523) = 555 且 encrypt(213) = 333 。

请你返回数组中所有元素加密后的和。

示例 1：

**输入：**nums = [1,2,3]

**输出：**6

**解释：**加密后的元素位 [1,2,3] 。加密元素的和为 1 + 2 + 3 == 6 。

示例 2：

**输入：**nums = [10,21,31]

**输出：**66

**解释：**加密后的元素为 [11,22,33] 。加密元素的和为 11 + 22 + 33 == 66 。

提示：

1 <= nums.length <= 50
1 <= nums[i] <= 1000

简单模拟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Solution {
    public int sumOfEncryptedInt(int[] nums) {
        int ans = 0;
        for (int x : nums) {
            int mx = 0;
            int base = 0;
            for (; x > 0; x /= 10) {
                mx = Math.max(mx, x % 10);
                base = base * 10 + 1;
            }
            ans += mx * base;
        }
        return ans;
    }
}

2、3080. 执行操作标记数组中的元素

中等

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

同时给你一个长度为 m 的二维操作数组 queries ，其中 queries[i] = [indexi, ki] 。

一开始，数组中的所有元素都 未标记 。

你需要依次对数组执行 m 次操作，第 i 次操作中，你需要执行：

如果下标 indexi 对应的元素还没标记，那么标记这个元素。
然后标记 ki 个数组中还没有标记的最小元素。如果有元素的值相等，那么优先标记它们中下标较小的。如果少于 ki 个未标记元素存在，那么将它们全部标记。

请你返回一个长度为 m 的数组 answer ，其中 answer[i]是第 i 次操作后数组中还没标记元素的和。

示例 1：

**输入：**nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]

输出：[8,3,0]

解释：

我们依次对数组做以下操作：

标记下标为 1 的元素，同时标记 2 个未标记的最小元素。标记完后数组为 nums = [***1***,***2***,2,***1***,2,3,1] 。未标记元素的和为 2 + 2 + 3 + 1 = 8 。
标记下标为 3 的元素，由于它已经被标记过了，所以我们忽略这次标记，同时标记最靠前的 3 个未标记的最小元素。标记完后数组为 nums = [***1***,***2***,***2***,***1***,***2***,3,***1***] 。未标记元素的和为 3 。
标记下标为 4 的元素，由于它已经被标记过了，所以我们忽略这次标记，同时标记最靠前的 2 个未标记的最小元素。标记完后数组为 nums = [***1***,***2***,***2***,***1***,***2***,***3***,***1***] 。未标记元素的和为 0 。

示例 2：

**输入：**nums = [1,4,2,3], queries = [[0,1]]

输出：[7]

**解释：**我们执行一次操作，将下标为 0 处的元素标记，并且标记最靠前的 1 个未标记的最小元素。标记完后数组为 nums = [***1***,4,***2***,3] 。未标记元素的和为 4 + 3 = 7 。

提示：

n == nums.length
m == queries.length
1 <= m <= n <= 105
1 <= nums[i] <= 105
queries[i].length == 2
0 <= indexi, ki <= n - 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Solution {
    public long[] unmarkedSumArray(int[] nums, int[][] queries) {
        // 茶神简单写法
        int n=nums.length;
        long s=0;
        Integer[] ids=new Integer[n];
        for(int i=0;i<n;i++){
            s+=nums[i];
            ids[i]=i;
        }

        Arrays.sort(ids,(i,j)->nums[i]-nums[j]);
        long[] res=new long[queries.length];
        int j=0;
        for(int qi=0;qi<queries.length;qi++){
            int[] q=queries[qi];
            int i=q[0];
            int k=q[1];
            s-=nums[i];
            nums[i]=0;
            for(;j<n&&k>0;j++){
                i=ids[j];
                if(nums[i]>0){
                    s-=nums[i];
                    nums[i]=0;
                    k--;
                }
            }
            res[qi]=s;
        }
        return res;
    }
}