米哈游笔试记录菜鸡第一次AK

😂都是直接模拟这个过程做，所以代码写得贼多。。

第一题压缩字符串

一开始考虑很多种情况，然后发现题目已经定好了死规则，一就是有范围的，不然就是字符串或者单个字符，那直接对字符串先小化，然后做一个切分，出现的次数和字符串做好对应。

public static void first() {
        Scanner scanner = new Scanner(System.in);
        String next = scanner.next();
        String[] split = next.toLowerCase().split("\\d+");
        char[] arr = next.toCharArray();
        int[] splitTime = new int[split.length];
        int index = 0;
        for (int i = 0; i < split.length; i++) {
            index += split[i].length();
            int start = index;
            int count = 0;
            while (index < arr.length && arr[index] >= '0' && arr[index] <= '9') {
                index++;
                count++;
            }
            String s = new String(arr, start, count);
            splitTime[i] = Integer.parseInt(s);
        }
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < split.length; i++) {
            firstHelper(splitTime[i], split[i], map);
        }
        Set<Map.Entry<Character, Integer>> set = map.entrySet();
        char result = ' ';
        int time = 0;
        for (Map.Entry<Character, Integer> entry : set) {
            if (entry.getValue() > time) {
                result = entry.getKey();
                time = entry.getValue();
            } else if (entry.getValue() == time) {
                if (entry.getKey() < result) {
                    result = entry.getKey();
                }
            }
        }
        System.out.println("" + result + time);
    }

    public static void firstHelper(int time, String s, HashMap<Character, Integer> map) {
        String[] split = s.split("-");
        char[] chars;
        if (split.length == 1) {
            chars = split[0].toCharArray();
        } else {
            char start = split[0].charAt(0);
            char end = split[1].charAt(0);
            if (start <= end) {
                chars = new char[end - start + 1];
                for (int i = 0; i < chars.length; i++) {
                    chars[i] = (char) (start + i);
                }
            } else {
                chars = new char[26 - start + 'a' + end - 'a' + 1];
                int index = 0;
                while (index < 26 - start + 'a') {
                    chars[index++] = (char) (start + index);
                }
                for (int i = 0; i < end - 'a' + 1; i++) {
                    chars[index++] = (char) ('a' + i);
                }
            }
        }
        for (int i = 0; i < chars.length; i++) {
            Integer integer = map.get(chars[i]);
            if (integer == null) {
                map.put(chars[i], time);
            } else {
                map.put(chars[i], integer + time);
            }
        }

    }

第二题消消乐

暴力模拟

主要有实现两个方法，一个check是遍历全局检查是否可消，并用一个数组记录某点被消，还避免了重复消的问题，最后被消的设0，被消数增加，另一个方法clean就是被消的点上面的还有的点掉落下来，模拟这个过程，重复调用check，clean直到稳定状态

public static void second() {
        Scanner scanner = new Scanner(System.in);
        int r = scanner.nextInt();
        int c = scanner.nextInt();
        char[][] arr = new char[r][];
        for (int i = 0; i < r; i++) {
            arr[i] = scanner.next().toCharArray();
        }
        int[] first = new int[2];
        int[] second = new int[2];
        first[0] = scanner.nextInt();
        first[1] = scanner.nextInt();
        second[0] = scanner.nextInt();
        second[1] = scanner.nextInt();
        char temp = arr[first[0]][first[1]];
        arr[first[0]][first[1]] = arr[second[0]][second[1]];
        arr[second[0]][second[1]] = temp;
        while (check(arr)) {
            clean(arr);
        }
        System.out.println(count);
    }

    static int count = 0;

    public static boolean check(char[][] arr) {
        int[][] ints = new int[arr.length][arr.length];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                char c = arr[i][j];
                if (c == '0') {
                    continue;
                }
                int ***Count = 0;
                boolean flag = false;
                for (int k = j + 1; k < arr[0].length && arr[i][k] == c; k++) {
                    ***Count++;
                }
                if (***Count >= 2) {
                    flag = true;
                    for (int k = j + 1; k < arr[0].length && arr[i][k] == c; k++) {
                        ints[i][k] = 1;
                    }
                }
                ***Count = 0;
                for (int k = i + 1; k < arr.length && arr[k][j] == c; k++) {
                    ***Count++;
                }
                if (***Count >= 2) {
                    flag = true;
                    for (int k = i + 1; k < arr.length && arr[k][j] == c; k++) {
                        ints[k][j] = 1;
                    }
                }
                if (flag) {
                    ints[i][j] = 1;
                }
            }
        }
        boolean flag0 = false;
        for (int i = 0; i < ints.length; i++) {
            for (int j = 0; j < ints[0].length; j++) {
                if (ints[i][j] == 1) {
                    arr[i][j] = '0';
                    count++;
                    flag0 = true;
                }
            }
        }
        return flag0;
    }

    public static void clean(char[][] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = arr[0].length - 1; j >= 0; j--) {
                if (arr[i][j] == '0') {
                    int index = i - 1;
                    int nowindex = i;
                    while (index > 0 && arr[index][j] == '0') {
                        index--;
                    }
                    while (index >= 0 && nowindex > 0) {
                        arr[nowindex][j] = arr[index][j];
                        arr[index][j] = '0';
                        index--;
                        nowindex--;
                    }
                }
            }
        }
    }

#笔试题目##米哈游##题解##校招#