华为OD机试 - 数字排列

题目

屏幕给出1~9任意4个不重复的数字，大家以最快的时间给出这几个数字可拼成的数字从小到大排列位于第N位置的数字，其中N为给出数字中最大的数（如果不到这么多数字，则给出最后一个即可）。
注意：

1. 2可以当做5来使用 ，反之亦然，但是屏幕不能同时给出2和5；
2. 6可以当做9来使用 ，反之亦然，但是屏幕不能同时给出6和9

输入

1,4，8，7

输出

41

输入输出说明

给出的最大的数字是8，则能拼接的最大的从小到大的数字为：
1,4,7,8,14,17,18,41,47,48…，第8位为41，所以输出41

输入以逗号分隔的4个1~9的数字组成的字符串。

输出这几个数字可拼成的数字从小到大排列位于第N位置的数字，其中N为给出数字中最大的数。

如果输入的数字不在规定的范围内或有重复，则输出-1

那么第N个数字，即第8个数字为41，输出41。

思路

1. 1~9
2. 输入4位数
3. 不能同时包含2和5,6和9
4. 2需要当做5来使用，6需要当做9来使用，5需要当做2来使用，9需要当做6来使用
5. 最快
   如果本题不考虑最快，则可以直接双指针left和right代表下标，依次拼接数字后再排序，然后再输出对应的，但是有最快要求，应该考虑好构建过程就要从小到大

代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

/**
 * @Desc: 数字排列
 * @Auther:chenShunGuo
 * @Date: 2024/6/7 17:43
 */
public class Test029 {
    /**
     * 2和5可以互换，且不能同时出现
     * 6和9可以互换，且不能同时出现
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Integer> inputList = new ArrayList<>(Arrays.stream(sc.nextLine().split(","))
                .map(Integer::parseInt).sorted().toList());
        // 取输入的最大的数
        int max = inputList.get(3);
        // 校验输入合法性，并按要求重新排序list
        if (!checkInput(inputList)) {
            System.out.println(-1);
            return;
        }
        if (max == 4) {
            System.out.println(max);
            return;
        }
        int size = inputList.size();
        // 排序后从左往右构建，必然是从小到大
        for (int left = 0; left < size; left++) {
            if (inputList.size() >= max) {
                break;
            }
            // 从小到大，先拼接left左边的
            for (int i = 0; i < left; i++) {
                if (inputList.size() >= max) {
                    break;
                }
                buildNum(inputList, inputList.get(left), inputList.get(i));
            }
            // 因为list从小到大，所以left是比right小，拼完左边拼left的右边的数字
            for (int right = left + 1; right < size; right++) {
                if (inputList.size() >= max) {
                    break;
                }
                buildNum(inputList, inputList.get(left), inputList.get(right));
            }
        }
        // 获取组成的数字从小到大排序后第N个数字
        if (inputList.size() < max) {
            System.out.println(inputList.getLast());
        } else {
            System.out.println(inputList.get(max - 1));
        }
        sc.close();
    }

    private static void buildNum(List<Integer> inputList, int left, int right) {
        inputList.add(Integer.valueOf(left + String.valueOf(right)));
    }

    private static boolean checkInput(List<Integer> list) {
        // 如果不足4个数字，则输出-1
        // 输入必须是1~9的数字，排序后如果最小数字小于1，或者最大数字大于9则输出-1
        // 不能同时包含2和5
        // 不能同时包含6和9
        if (list.size() != 4
            || list.get(0) < 1 || list.get(3) > 9
            || (list.contains(2) && list.contains(5))
            || (list.contains(6) && list.contains(9))
        ) {
            return false;
        }

        Map<Integer,Integer> map = new HashMap<>();
        map.put(2,5);
        map.put(5,2);
        map.put(6,9);
        map.put(9,6);
        for (int i = 0; i < 4; i++) {
            int n = list.get(i);
            if (n == 2 || n == 5 || n == 6 || n == 9) {
                list.add(map.get(n));
            }
        }
        // 超过4位，重新排序
        if (list.size() > 4) {
            Collections.sort(list);

        }
        return true;
    }
}