Question

在Glassdoor评论中遇到过这个问题并认为它很有趣。

给定一个由4位数组成的整数，我们需要在24中最大化它小时格式。例如，4372应返回表单的String 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小时格式，这是我觉得棘手。

我有兴趣看看是否有人有这个挑战的解决方案/想法。

Answer 1

将整数分成4位数。
如果您没有0,1或2，那么就没有答案。
在时间的第一个位置放置＆lt; = 2的最大数字。
如果第一个数字是2，则将剩余的最大数字＆lt; = 3放在第二位。（如果没有，则没有答案。）如果第一个数字是1或0，则将剩余的最大数字放在第二位。
将剩下的最大数字＆lt; = 5放在第三位。
将剩下的唯一号码放在第四位。

我认为您不需要在任何时候回溯，因为步骤3,4和5中的界限严格增加。你当然不需要考虑所有可能的数字排列，因为我们知道某些地方是有限的。

Answer 2

这是我的方法。可能不是最有效的，但它确实起作用。

将输入分成个别数字
获取所有数字的所有排列
检查每个输出是否有效，并跟踪最大输出。

高级别看起来像这样：

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));
    }
}

以下是帮手：

/**
 * 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;
}

以24小时格式最大化数字。

2 个答案: