Java 最大化24小时格式的数字。

在玻璃门评论中遇到这个问题，觉得很有趣

给定一个由4位数字组成的整数，我们需要将其最大化为24位 小时制。例如，4372应该返回一个表单字符串 23:47，这是可以从中获得的最大24小时值 给定的整数。假设给定的整数总是正好包含4位数字

这里有一个不完整的方法，我试图解决它：

private static String maximize24Hour(int digits) {
    if (digits == 0)
        return "00:00";
    if (digits < 0)
        return null;

    ArrayList<Integer> list = new ArrayList<>();
    do {
        list.add(digits % 10);
        digits /= 10;
    } while (digits != 0);

    // Extra processing needs to be done here. Haven't figured it out. 

    StringBuilder buf = new StringBuilder();
    for (Integer d : list) {
        buf.append(d);
    }

    String result = buf.toString();
    String hours = result.substring(0, 2);
    String minutes = result.substring(2, result.length()); 

    if (Integer.parseInt(result) > 2359 
            || Integer.parseInt(hours) > 23 
            || Integer.parseInt(minutes) > 59
            || result.length() != 4)
        return null;

    return hours.concat(":").concat(minutes);
}

私有静态字符串最大化24小时（整数位数）{
如果（位数==0）
返回“00:00”；
如果（数字<0）
返回null；
ArrayList=新建ArrayList（）；
做{
列表。添加（数字%10）；
位数/=10；
}while（位数！=0）；
//这里需要做额外的处理，我还没弄明白。
StringBuilder buf=新的StringBuilder（）；
for（整数d:list）{
buf.附加（d）；
}
字符串结果=buf.toString（）；
字符串小时数=结果。子字符串（0，2）；
字符串分钟数=result.substring（2，result.length（））；
if（Integer.parseInt（结果）>2359
||整数.parseInt（小时）>23
||整数.parseInt（分钟）>59
||结果。长度（）！=4）
返回null；
返回时长（“：”）。返回时长（分钟）；
}

我的做法正确吗？如果这只是一个数字，那就微不足道了。但它要求它是24小时格式，这是我发现棘手的

---

我很想知道是否有人对这一挑战有解决方案/想法

这是我的方法。也许不是最有效的，但它确实起到了作用

将输入拆分为单个数字

获取所有数字的所有排列

检查每个输出是否有效，并跟踪最大输出

高层看起来是这样的：

import java.util.List;
import java.util.ArrayList;

public class MaxDigit {
    // ... helper functions here

    // maximize function
    private static String maximize24Hour(int digits) {
        if (digits < 1000 || digits >= 10000) {
            return "invalid input";
        }

        // get all possibles and find the biggest
        int max = -1;
        List<String> singleDigits = getDigits(digits);
        List<String> allPossibles = getPermutations(singleDigits);
        for (String timeStr : allPossibles) {
            int timeInt = Integer.parseInt(timeStr);
            if (isValidTime(timeInt) && timeInt > max) {
                max = timeInt;
            }
        }

        // If none is valid
        if (max < 0) {
            return "cannot find any valid time";
        }
        // Convert int to time
        return max/100 + ":" + max%100;
    }

    public static void main(String[] args) {
        System.out.println(maximize24Hour(4372));
    }
}

import java.util.List；
导入java.util.ArrayList；
公共类MaxDigit{
//…这里的辅助函数
//最大化功能
私有静态字符串最大化24小时（整数位数）{
如果（位数<1000 | |位数>=10000）{
返回“无效输入”；
}
//找到所有可能的，找到最大的
int max=-1；
列表单位数=getDigits（位数）；
列出所有可能性=getPermutations（单位数）；
for（字符串timeStr:allPossibles）{
int-timeInt=Integer.parseInt（timeStr）；
如果（isValidTime（timeInt）&&timeInt>max）{
max=timeInt；
}
}
//如果没有一个是有效的
如果（最大值<0）{
返回“找不到任何有效时间”；
}
//将整数转换为时间
返回最大值/100+“：”+最大值%100；
}
公共静态void main（字符串[]args）{
System.out.println（最大化24小时（4372））；
}
}

以下是帮助者：

/**
 * Check specified time is valid
 * @param time Time in hhmm format
 * @return true if input time is valid
 */
private static boolean isValidTime(int time) {
    int hour = time / 100;
    int min = time % 100;
    return hour <= 23 && min <= 59;
}

/**
 * Generate all possible numbers from input
 *
 * For example: inputs {1, 2} gives {12, 21}
 * For example: inputs {1, 2, 3} gives {123, 132, 213, 231, 312, 321}
 *
 * @param inputs Input digits
 * @return all possibles
 */
private static List<String> getPermutations(List<String> inputs) {
    if (inputs.size() <= 1) {
        return inputs;
    }

    List<String> ret = new ArrayList<>();
    for (int i = 0; i < inputs.size(); ++i) {
        List<String> copy = new ArrayList<>(inputs);
        copy.remove(i);
        List<String> recusive = getPermutations(copy);
        for (String values : recusive) {
            ret.add(inputs.get(i) + values);
        }
    }
    return ret;
}

private static List<String> getDigits(int digits) {
    List<String> singleDigits = new ArrayList<>();
    while (digits > 0) {
        singleDigits.add(Integer.toString(digits%10));
        digits /= 10;
    }
    return singleDigits;
}

/**
*检查指定的时间是否有效
*@param time以hhmm格式显示
*@如果输入时间有效，则返回true
*/
私有静态布尔值isValidTime（整数时间）{
整小时=时间/100；
int min=时间%100；
返程时间
将整数分隔为4位数字
如果没有0、1或2，则没有答案
输入最大的数字，这是否意味着-最小可能的输入整数是1000？？？@SrikanthA，我假设是这样，在这种情况下，它应该返回10:00。这种方法将在{2,0,6,6}中失败