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

Question

Came across this question in a Glassdoor review and thought it was interesting.

Given an integer consisting of 4 digits, we need to maximize it in 24 hour format. For example, 4372 should return a String of the form 23:47, which is the maximum 24 hour value that can be obtained from the given integer. Assume the given integer always contains exactly 4 digits.

Here's an incomplete method I wrote trying to solve it:

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

Am I even approaching it correctly? If this was just any number, it would be trivial. But it's asking for it to be in 24 hour format which is what I find tricky.

I'd be interested to see if anyone has solutions/ideas for this challenge.

Answer 1

1. Separate the integer into 4 digits.
2. If you don't have a 0, 1, or 2 then there is no answer.
3. Put the largest number that is <= 2 in the first spot in the time.
4. If the first digit was a 2, then put the largest remaining number that is <=3 in the second place. (If there isn't one, then there is no answer.) If the first digit was 1 or 0, then place the largest remaining number in the second place.
5. Put the largest remaining number that is <= 5 in the third place.
6. Put the only remaining number in the fourth place.

I think you don't need to back-track at any point because the bounds in steps 3, 4, and 5 are strictly increasing. You certainly don't need to consider all possible permutations of the numbers since we know that certain places are bounded.

Answer 2

Here is my method. May not be the most efficient one, but it does the job.

1. Break input into individual digits
2. Get all permutations of all digits
3. Check each output is valid, and keep track of the biggest.

High level looks like this:

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

And here are the helpers:

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