Algorithm 显示给定四个整数的最长军事时间

我在一次面试中遇到了这个问题

问题是给定四个整数，以24小时格式HH:MM显示可能的最大时间。例如，如果给定A=1、B=9、C=9、D=2，则输出应为19:29。最大时间可以是23:59，最小时间可以是00:00。如果无法构建24小时时间，则返回错误。例如，给定A=1、B=9、C=7、D=9，应返回错误，因为这些整数表示的最短时间为17:99，这是无效的

我最初的方法是找到给定数字的所有24个整数置换，然后消除所有大于2400的整数置换。在此之后，消除最后两位中大于59的所有整数。也就是说，10的位置是5，单位的位置是9。过滤之后，返回结果集中剩余的最大整数

这种方法在这里是可行的，因为我们只需要计算24个排列，甚至更少的组合，因为重复项将被删除。但我觉得这是一种暴力手段。有没有其他不需要我们生成所有排列的想法

另外，作为这个问题的扩展，如果我们被要求将时间分别延长到6位或8位，那么我的方法将是昂贵的。让我们假设允许的最大运行时复杂性可以是O（nlogn），从而允许我们进行排序。另外，如何检查我上面提到的边缘情况

谢谢

编辑：下面是评论中建议答案的代码

//Input arraylist contains the four integers
public static String maxTime(ArrayList<Integer> list){
    int first = -1;
    int second = -1;
    int third = -1;
    int fourth = -1;

    for (int a : list) {
        if (a <= 2 && a > first) {
            first = a;
        }
    }
    list.remove(Integer.valueOf(first));

    for (int a : list) {
        if (first == 2 && a <= 3 && a > second) {
            second = a;
        }
    }
    if (second == -1) {
        for (int a : list) {
            if (a > second) {
                second = a;
            }
        }
    }
    list.remove(Integer.valueOf(second));

    for (int a : list) {
        if (a <= 5 && a > third) {
            third = a;
        }
    }
    list.remove(Integer.valueOf(third));

    fourth = list.get(0);

    StringBuilder sb = new StringBuilder(5);
    sb.append(first);
    sb.append(second);
    sb.append(':');
    sb.append(third);
    sb.append(fourth);

    return sb.toString();
}

//输入数组列表包含四个整数
公共静态字符串maxTime（ArrayList列表）{
int first=-1；
int秒=-1；
int-third=-1；
int-fourth=-1；
用于（INTA：列表）{
如果（第一次）{
第一个=a；
}
}
list.remove（Integer.valueOf（first））；
用于（INTA：列表）{
如果（第一个==2&&1秒）{
秒=a；
}
}
如果（秒==-1）{
用于（INTA：列表）{
如果（a>秒）{
秒=a；
}
}
}
list.remove（Integer.valueOf（秒））；
用于（INTA：列表）{
如果（第三个）{
第三=a；
}
}
list.remove（Integer.valueOf（第三个））；
第四个=list.get（0）；
StringBuilder sb=新StringBuilder（5）；
某人（先）；
某人（第二）；
某人附加（“：”）；
某人（第三）；
某人（第四）；
使某人返回字符串（）；
}

我的解决方案：）

函数getMaxTime（a、b、c、d）{ 让nums=Array.from（arguments）.sort（）； 函数getMaxNum（num，arr）{ let指数； arr.map（函数（el，i）{ 如果（el我的解决方案：）

函数getMaxTime（a、b、c、d）{ 让nums=Array.from（arguments）.sort（）； 函数getMaxNum（num，arr）{ let指数； arr.map（函数（el，i）{

---

如果（el和我的朋友一起，我们已经思考了这个问题几个小时，我认为最好的解决方案是从i=2359开始迭代，将i数除以独立的数字，排序，最后检查是否等于输入数的排序数组。此外，如果i%100==0，则从i中减去41，以避免分钟数大于60。完整的、经过测试的实现详情如下:

public String solution(int A, int B, int C, int D) {

    int[] inputNumbers = { A, B, C, D };
    Arrays.sort(inputNumbers);

    for (int i = 2359; i >= 0; i--) {

        if (i % 100 == 0 && i != 0) {
            i -= 41;
        }
        StringBuilder potentialTimeNumbers = new StringBuilder(i + "");

        for (int k = potentialTimeNumbers.length(); k < 4; k++) {
            potentialTimeNumbers.insert(0, "0");
        }

        int[] iNumbers = Stream.of(potentialTimeNumbers.toString().split("")).
                mapToInt(Integer::parseInt).toArray();
        Arrays.sort(iNumbers);

        if (Arrays.equals(inputNumbers, iNumbers)) {
            return potentialTimeNumbers.insert(2, ":").toString();
        }

    }
    return "NOT VALID";
}

公共字符串解决方案（inta、intb、intc、intd）{
int[]inputNumbers={A，B，C，D}；
数组。排序（输入编号）；
对于（int i=2359；i>=0；i--）{
如果（i%100==0&&i！=0）{
i-=41；
}
StringBuilder PotentialTimeNumber=新的StringBuilder（i+“”）；
对于（int k=potentialTimeNumbers.length（）；k<4；k++）{
潜在时间编号。插入（0，“0”）；
}
int[]iNumbers=Stream.of（可能是timenumbers.toString（）.split（“”））。
mapToInt（Integer:：parseInt）.toArray（）；
数组。排序（iNumbers）；
if（Arrays.equals（inputNumber，iNumbers））{
返回PotentialTimeNumber.insert（2，“：”）.toString（）；
}
}
返回“无效”；
}

与我的朋友一起，我们已经思考了这个问题几个小时，我认为最好的解决方案是从i=2359开始迭代，将i数除以独立的数字，排序，最后检查是否等于输入数的排序数组。此外，如果i%100==0，则从i中减去41，以避免分钟数大于60。完整、经过测试的implem详情如下：

public String solution(int A, int B, int C, int D) {

    int[] inputNumbers = { A, B, C, D };
    Arrays.sort(inputNumbers);

    for (int i = 2359; i >= 0; i--) {

        if (i % 100 == 0 && i != 0) {
            i -= 41;
        }
        StringBuilder potentialTimeNumbers = new StringBuilder(i + "");

        for (int k = potentialTimeNumbers.length(); k < 4; k++) {
            potentialTimeNumbers.insert(0, "0");
        }

        int[] iNumbers = Stream.of(potentialTimeNumbers.toString().split("")).
                mapToInt(Integer::parseInt).toArray();
        Arrays.sort(iNumbers);

        if (Arrays.equals(inputNumbers, iNumbers)) {
            return potentialTimeNumbers.insert(2, ":").toString();
        }

    }
    return "NOT VALID";
}

公共字符串解决方案（inta、intb、intc、intd）{
int[]inputNumbers={A，B，C，D}；
数组。排序（输入编号）；
对于（int i=2359；i>=0；i--）{
如果（i%100==0&&i！=0）{
i-=41；
}
StringBuilder PotentialTimeNumber=新的StringBuilder（i+“”）；
对于（int k=potentialTimeNumbers.length（）；k<4；k++）{
潜在时间编号。插入（0，“0”）；
}
int[]iNumbers=Stream.of（可能是timenumbers.toString（）.split（“”））。
mapToInt（Integer:：parseInt）.toArray（）；
数组。排序（iNumbers）；
if（Arrays.equals（inputNumber，iNumbers））{
返回PotentialTimeNumber.insert（2，“：”）.toString（）；
}
}
返回“无效”；
}

我已经浏览了该问题链接，但没有任何令人满意的答案。请看一看。链接的问题有一个很好的答案。我看了一下。只需执行它。如果您有问题，请发布代码并问一个关于问题是什么的特定问题。执行了它。仍然没有给出所需的输出。显然，我在问题中提到的用于检查输入有效性的边缘大小写是不正确的。因此，即使是答案中指向的边缘大小写也丢失了。我已使用代码更新了我的问题。我已经浏览了该问题链接，但没有任何令人满意的答案。请查看它。链接的问题有一个