微软8.20笔试

public int solution(int[] A) {
        // write your code in Java 8 (Java SE 8)
        HashMap<Integer, PriorityQueue<Integer>> map = new HashMap<>();
        for (int num : A) {
            int temp = num;
            int sum = 0;
            while (temp != 0) {
                sum += temp % 10;
                temp /= 10;
            }
            if (map.containsKey(sum)) {
                map.get(sum).offer(num);
            } else {
                PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> {return b - a;});
                pq.offer(num);
                map.put(sum, pq);
            }
        }
        int res = -1;
        for (Map.Entry<Integer, PriorityQueue<Integer>> entry : map.entrySet()) {
            PriorityQueue<Integer> value = entry.getValue();
            if (value.size() < 2) continue;
            res = Math.max(res, value.poll() + value.poll());
        }
        return res;
    }

public int solution(int M, int N) {
        // write your code in Java 8 (Java SE 8)
        int sum = M + N * 4;
        int right = (int) Math.sqrt(sum);
        while (right > 0) {
            if (check(M, N, right)) return right;
            right--;
        }
        return 0;
    }

    public boolean check(int m, int n, int len) {
        int sum = len * len;
        int count = len / 2;
        int num = count * count;
        num = num > n ? n : num;
        return m >= sum - (4 * num);
    }

public int solution(int K, int[][] A) {
        // write your code in Java 8 (Java SE 8)
        int count = 0;
        int m = A.length, n = A[0].length;
        int[][] map = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (A[i][j] == 1) {
                    count++;
                    cal(map, K, i, j, A);
                }
            }
        }
        int res = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (map[i][j] == count) {
                    res++;
                }
            }
        }
        return res;
    }
    void cal(int[][] map, int k, int i, int j, int[][] A) {
        int m = A.length, n = A[0].length;
        int row = i - k >= 0 ? i - k : 0;
        while (row < m) {
            int diff = k - Math.abs(row - i);
            int p = j - diff >= 0 ? j - diff : 0;
            for (; p <= j + diff && p < n; p++) {
                if (A[row][p] != 1) {
                    map[row][p]++;
                }
            }
            row++;
        }
    }