力扣第七十一场双周赛20210205

5984. 拆分数位后四位数字的最小和

给你一个四位 正 整数 num 。请你使用 num 中的 数位 ，将 num 拆成两个新的整数 new1 和 new2 。new1 和 new2 中可以有 前导 0 ，且 num 中 所有 数位都必须使用。

比方说，给你 num = 2932 ，你拥有的数位包括：两个 2 ，一个 9 和一个 3 。一些可能的 [new1, new2] 数对为 [22, 93]，[23, 92]，[223, 9] 和 [2, 329] 。
请你返回可以得到的 new1 和 new2 的 最小 和。

示例 1：

输入：num = 2932
输出：52
解释：可行的 [new1, new2] 数对为 [29, 23] ，[223, 9] 等等。
最小和为数对 [29, 23] 的和：29 + 23 = 52 。

示例 2：

输入：num = 4009
输出：13
解释：可行的 [new1, new2] 数对为 [0, 49] ，[490, 0] 等等。
最小和为数对 [4, 9] 的和：4 + 9 = 13 。

思路

贪心即可

class Solution {
    public int minimumSum(int num) {
        List<Integer> ans = new ArrayList<>();
        while (num != 0) {
            ans.add(num % 10);
            num /= 10;
        }
        Collections.sort(ans);
        int a = ans.get(0) * 10 + ans.get(2);
        int b = ans.get(1) * 10 + ans.get(3);
        return a + b;
    }
}



class Solution {
    public static int minimumSum(int num) {
        int[] arr = new int[4];
        int index = 0;
        while (num != 0){
            arr[index++] = num % 10;
            num = num / 10;
        }

        Arrays.sort(arr);

        int a = arr[0] * 10 + arr[2];
        int b = arr[1] * 10 + arr[3];

        return a+b;
    }
}

5985. 根据给定数字划分数组

给你一个下标从 0 开始的整数数组 nums 和一个整数 pivot 。请你将 nums 重新排列，使得以下条件均成立：

所有小于 pivot 的元素都出现在所有大于 pivot 的元素 之前 。
所有等于 pivot 的元素都出现在小于和大于 pivot 的元素 中间 。
小于 pivot 的元素之间和大于 pivot 的元素之间的 相对顺序 不发生改变。
更正式的，考虑每一对 pi，pj ，pi 是初始时位置 i 元素的新位置，pj 是初始时位置 j 元素的新位置。对于小于 pivot 的元素，如果 i < j 且 nums[i] < pivot 和 nums[j] < pivot 都成立，那么 pi < pj 也成立。类似的，对于大于 pivot 的元素，如果 i < j 且 nums[i] > pivot 和 nums[j] > pivot 都成立，那么 pi < pj 。

请你返回重新排列 nums 数组后的结果数组。

示例 1：

输入：nums = [9,12,5,10,14,3,10], pivot = 10
输出：[9,5,3,10,10,12,14]

解释：
元素 9 ，5 和 3 小于 pivot ，所以它们在数组的最左边。
元素 12 和 14 大于 pivot ，所以它们在数组的最右边。
小于 pivot 的元素的相对位置和大于 pivot 的元素的相对位置分别为 [9, 5, 3] 和 [12, 14] ，它们在结果数组中的相对顺序需要保留。
示例 2：

输入：nums = [-3,4,3,2], pivot = 2
输出：[-3,2,4,3]

解释：
元素 -3 小于 pivot ，所以在数组的最左边。
元素 4 和 3 大于 pivot ，所以它们在数组的最右边。
小于 pivot 的元素的相对位置和大于 pivot 的元素的相对位置分别为 [-3] 和 [4, 3] ，它们在结果数组中的相对顺序需要保留

思路

模拟

class Solution {
    public int[] pivotArray(int[] nums, int pivot) {
        List<Integer> a = new ArrayList<>();
        List<Integer> b = new ArrayList<>();
        List<Integer> c = new ArrayList<>();
        for (int x : nums) {
            if (x < pivot) {
                a.add(x);
            } else if (x == pivot){
                b.add(x);
            } else {
                c.add(x);
            }
        }
        int n = a.size() + b.size() + c.size();
        int[] res = new int[n];
        int i = 0;
        for (int x : a) {
            res[i++] = x;
        }
        for (int x : b) {
            res[i++] = x;
        }
        for (int x : c) {
            res[i++] = x;
        }
        return res;
    }
}