OD机试题-2022.4

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class ODTest {
    public static void main(String[] args) {
        /**
         * 1. 标题：构成的正方形数量 | 时间限制：1秒 | 内存限制：262144K | 语言限制：不限
         * 输入N个互不相同的二维整数坐标, 求这N个坐标可以构成的正方形数量。(内积为零的两个向量垂直)
         * 输入描述:
         * 第一行输入为 N，N 代表坐标数量，N为正整数。N <= 100
         * 之后的 K 行输入为坐标 x y以空格分隔，x, y 为整数, -10<=x, y <= 10
         * 输出描述:
         * 输出可以构成的正方形数量
         * 示例1
         * 输入
         * 3
         * 1 3
         * 2 4
         * 3 1
         * 输出
         * 0
         * 说明 3个点不足以构成正方形
         * 示例2
         * 输入
         * 4
         * 0 0
         * 1 2
         * 3 1
         * 2 -1
         * 输出
         * 1
         * 说明 此4点可构成正方形
         */
        Scanner scanner = new Scanner(System.in);
        int N = Integer.parseInt(scanner.nextLine());

        if (N < 4) {
            System.out.println(0);
            return;
        }

        //定义N行两列的二维数组
        int[][] zuobiaos = new int[N][2];
        for (int i = 0; i < zuobiaos.length; i++) {
            String[] strings = scanner.nextLine().split(" ");
            zuobiaos[i][0] = Integer.parseInt(strings[0]);
            zuobiaos[i][1] = Integer.parseInt(strings[1]);
        }

        int count = 0;
        for (int i = 0; i < zuobiaos.length - 3; i++) {
            for (int j = i + 1; j < zuobiaos.length - 2; j++) {
                for (int k = j + 1; k < zuobiaos.length - 1; k++) {
                    for (int l = k + 1; l < zuobiaos.length; l++) {
                        if (canBeSquare(zuobiaos[i], zuobiaos[j], zuobiaos[k], zuobiaos[l])) {
                            count++;
                        }
                    }
                }
            }
        }

        System.out.println(count);

        /**
         * 2. 如果三个正整数A、B、C ,A²+B²=C²则为勾股数
         * 如果ABC之间两两互质，即A与B，A与C，B与C均互质没有公约数，
         * 则称其为勾股数元组。
         * 请求出给定n~m范围内所有的勾股数元组
         */
        List<int[]> out2 = fun2(1, 20);
        out2.forEach(res1 -> {
            System.out.println(res1[0] + " " + res1[1] + " " + res1[2]);
        });

        /**
         * 3. 警察在侦破一个案件时，得到了线人给出的可能犯罪时间，形如 “HH:MM” 表示的时刻。
         * 根据警察和线人的约定，为了隐蔽，该时间是修改过的，解密规则为：利用当前出现过的数字，
         * 构造下一个距离当前时间最近的时刻，则该时间为可能的犯罪时间。每个出现数字都可以被无限次使用。"
         */

        String out3 = fun3("22:59");
        System.out.println(out3);
    }

    public static boolean canBeSquare(int[] i, int[] j, int[] k, int[] l) {
        //0 0, 1 2, 3 1, 2 -1
        return calculate(new int[]{i[0] - j[0], i[1] - j[1]}, new int[]{k[0] - l[0], k[1] - l[1]}) ||
                calculate(new int[]{i[0] - k[0], i[1] - k[1]}, new int[]{j[0] - l[0], j[1] - l[1]}) ||
                calculate(new int[]{i[0] - l[0], i[1] - l[1]}, new int[]{j[0] - k[0], j[1] - k[1]});
    }

    // 关键点： 判断正方形,需要其对角线垂直且长度相等
    public static boolean calculate(int[] vec1, int[] vec2) {
        return vec1[0] * vec2[0] + vec1[1] * vec2[1] == 0 && (vec1[0] * vec1[0] + vec1[1] * vec1[1]) == (vec2[0] * vec2[0] + vec2[1] * vec2[1]);
    }

    public static List fun2(int n, int m) {
        List res = new ArrayList();
        for (int a = n; a <= m; a++) {
            for (int b = a + 1; b <= m; b++) {
                double y = Math.pow(a, 2) + Math.pow(b, 2);
                for (int c = b + 1; c <= m; c++) {
                    double x = Math.pow(c, 2);
                    if (x == y) {
                        if (isP(a, b) && isP(a, c)) {
                            res.add(new int[]{a, b, c});
                        }
                    }
                }
            }
        }
        return res;
    }

    public static boolean isP(int a, int b) {
        if (a < b) {
            int tmp = a;
            a = b;
            b = tmp;
        }
        int c;
        while ((c = a % b) !=0) {
            a = b;
            b = c;
        }
        return b == 1;
    }

    public static String fun3(String time) {
        char[] chars = time.toCharArray();
        //单个数字list
        ArrayList<Integer> nums = new ArrayList<>();
        for (char c : chars) {
            if (c != ':') {
                nums.add(c - '0');
            }
        }
        String[] split = time.split(":");
        //小时
        Integer H = Integer.parseInt(split[0]);
        //分钟
        Integer M = Integer.parseInt(split[1]);
        ArrayList<Integer> list = new ArrayList<>();
        for (int i : nums) {
            for (int j : nums) {
                if (i <= 5) {
                    list.add(i * 10 + j);
                }
            }
        }
        //备选项排序，既可当H，也可以当M
        list.sort(Comparator.comparing(o -> o));
        //仅仅改变分钟就能得到最近的值
        for (int i : list) {
            if (i <= M) {
                continue;
            }
            //12:13 -> 12:31
            return format(H + ":" + i);
        }
        //小时数在23以下，可以使用最近的小时数
        if (H != 23) {
            for (int i : list) {
                if (i <= H) {
                    continue;
                }
                //确保i的合法性
                if (i <= 23) {
                    //12:59 ->15:11
                    return format(i + ":" + list.get(0));
                }
            }
        }
        //无法改别最近的小时与分钟。如23:59,00:00,15:15
        return format(list.get(0) + ":" + list.get(0));
    }

    public static String format(String time) {
        String[] split = time.split(":");
        String H = split[0];
        String M = split[1];
        H = H.length() == 2 ? H : "0" + H;
        M = M.length() == 2 ? M : "0" + M;
        return H + ":" + M;
    }
}