Minimum Deletions to Make Array Divisible

Key: gcd of array int[] nums:

    public int gcd2(int a, int b) {
        if (a == 0) return b;
        return gcd2(b % a, a);
    }
    
    public int gcdN(int[] nums) {
        int res = nums[0];
        for (int n : nums) {
            res = gcd2(res, n);
            if (res == 1) return 1;
        }
        return res;
    }

=>

class Solution {
    public int minOperations(int[] nums, int[] numsDivide) {
        int div = gcdN(numsDivide);
        System.out.println(div);
        Arrays.sort(nums);
        int res = 0;
        for (int n : nums) {
            if (div % n == 0) {
                return res;
            }
            res++;
        }
        return -1;
    }
    
    public int gcd2(int a, int b) {
        if (a == 0) return b;
        return gcd2(b % a, a);
    }
    
    public int gcdN(int[] nums) {
        int res = nums[0];
        for (int n : nums) {
            res = gcd2(res, n);
            if (res == 1) return 1;
        }
        return res;
    }
}

Query Kth Smallest Trimmed Number

This one requires some thinking

class Solution {
        class Datum
        {
            String num;
            int ind;

            public Datum(String num, int ind)
            {
                this.num = num;
                this.ind = ind;
            }
        }

        public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
            int u = nums[0].length();
            int[] ret = new int[queries.length];
            int o = 0;
            for(int[] q : queries){
                int t = q[1];
                Datum[] tnums = new Datum[nums.length];
                for(int i = 0;i < nums.length;i++){
                    tnums[i] = new Datum(nums[i].substring(u-t), i);
                }
                Arrays.sort(tnums, (x, y) -> {
                    if(!x.num.equals(y.num))return x.num.compareTo(y.num);
                    return x.ind - y.ind;
                });
                ret[o++] = tnums[q[0]-1].ind;
            }
            return ret;
        }
    }

Max Sum of a Pair With Equal Sum of Digits

Original thought: sum 2 nums map, then iterate: no good cuz in fact only need to keep track of max 2 numbers:

class Solution {
public:
    int maximumSum(vector<int>& nums) {
        int res = -1;
        map<int, int> m;
        for (int i : nums) {
            int x = i, y = 0;
            while (x) {
                y += x%10;
                x /= 10;
            }
            if (m.count(y)) res = max(res, m[y] + i);
            m[y] = max(m[y], i);
        }
        
        return res;
    }
};

Concise. Or use 2 arrays(from uwi):

class Solution {
    public int maximumSum(int[] nums) {
        long[] max = new long[1000];
        long[] max2 = new long[1000];
        for(int v : nums){
            int s = 0;
            for(int w = v;w > 0;w /= 10){
                s += w%10;
            }
            if(v > max[s]){
                max2[s] = max[s];
                max[s] = v;
            }else if(v > max2[s]){
                max2[s] = v;
            }
        }
        long mx = -1;
        for(int i = 0;i < 1000;i++){
            if(max2[i] > 0){
                long w = max[i] + max2[i];
                mx = Math.max(mx, w);
            }
        }
        return (int)mx;
    }
}

Maximum Number of Pairs in Array

class Solution {
    public int[] numberOfPairs(int[] nums) {
        int[] f = new int[101];
        for (int n : nums) {
            f[n]++;
        }
        int count = 0;
        for (int i : f) count += i / 2;
        return new int[]{count, nums.length - 2 * count};
    }
}