Java 从字符串中查找特定排列

我最近在一次面试准备中接到了类似的任务，只花了40分钟。我知道我可以用条件语句来强制它，但由于第一个小时和第一分钟的位置限制，它开始变得有点复杂，这让我慢了下来。我是否遗漏了一些东西，有没有更简单、更快的方法？我过去对自己处理字符串和排列的能力很有信心，但现在我在这项任务上的时间不够了，这让我怀疑自己是否真的达到了一个刚毕业的初级工作的标准

任务：

使用给定给该方法的字符串中提供的这些数字的某些排列可以显示的下一个最早时间是什么

类解决方案{公共字符串解决方案（字符串S）；}

编写一个函数，给定一个“HH:MM”格式的非空字符串S，该函数返回相同格式的字符串，指定给定时间后的第一次，该时间可由S中的数字排列表示。 例如，给定“11:10”，函数应返回“01:11”；对于“23:58”，结果应该是“23:58”（因为在该实例中只有1种可能的排列）

交换分钟数ex（35->53），如果交换时的分钟数大于且小于60，则完成交换

如果分钟数不大于24，则查看下一个最大小时（ex 11->12）模24

检查您是否可以使用给定的数字进行下一个小时（12）

如果是，请使用剩余数字创建最小分钟时间，确保分钟数有效，即<60，否则请增加小时数，然后重试

如果你到达开始的时间，你已经翻滚了，返回相同的排列，因为没有答案

这是我的pusedocode，如果你看到任何错误，请随时指出。顺便提一下，这个问题很有趣

这是我的解决方案，我做这个问题很有趣

public class Main {

    public static String nextTime(String s) {
        int hours;
        if (s.charAt(3) < s.charAt(4) && s.charAt(4) < '6')
            return s.substring(0, 3) + s.charAt(4) + s.charAt(3);
        hours = Integer.parseInt(s.substring(0, 2));
        int tempHours = hours + 1;
        while (tempHours % 24 != hours) {
            tempHours %= 24;
            String h = String.format("%02d", tempHours);
            String minutes = s;
            for (int i = 0; i < s.length(); i++) {
                if (h.charAt(0) == s.charAt(i)) {
                    minutes = s.substring(0, i) + s.substring(i + 1);
                    break;
                }
            }

            for (int i = 0; i < minutes.length(); i++) {
                if (h.charAt(1) == minutes.charAt(i)) {
                    minutes = minutes.substring(0, i) + minutes.substring(i + 1);
                    break;
                }
            }

            if (minutes.length() > 3) {
                tempHours++;
                continue;
            }

            for (int i = 0; i < minutes.length(); i++) {
                if (':' == minutes.charAt(i)) {
                    minutes = minutes.substring(0, i) + minutes.substring(i + 1);
                    break;
                }
            }

            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) != h.charAt(0) && h.charAt(1) != s.charAt(i) && s.charAt(i) != ':') {
                    minutes += s.charAt(i);
                }
            }

            if (minutes.charAt(0) < minutes.charAt(1) && Integer.parseInt(minutes) < 60) {
                return h + ":" + minutes;
            } else if (minutes.charAt(1) < '6') {
                return h + ":" + minutes.charAt(1) + minutes.charAt(0);
            }

            tempHours++;
        }
        return s;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println(nextTime(in.next()));
        in.close();
    }

公共类主{
公共静态字符串nextTime（字符串s）{
整小时；
如果（s.charAt（3）3）{
tempHours++；
继续；
}
对于（int i=0；i

我可能在这里遗漏了一些显而易见的东西，但为什么不干脆呢

• 从提供的时间开始
• 数到+1分钟，直到你再次达到相同的时间
• 返回与提供的时间具有相同数字的第一次时间

---

？

不应该将这4个数字按升序排序并将其格式化为HH:MM应该会产生预期的输出？

最有效的方法是确定性方法，即根据数字创建时间组合。由于时间只有4个数字，最大组合为4！=24。此算法最多创建2个4个组合（递归），但会短路，并且只有持续有效时间的建筑组合。因此，实际组合数量通常少于24个

给定（最多24个）组合，然后按时间对它们进行排序。下一个时间就是给定时间之后排序中的下一个元素

算法： 输入：有效的时间字符串T
输出：输入时间后的下一次N

创建一个空集（用于存储有效时间）S
创建T的有效组合并添加到S
将S转换为列表L
排序L
确定T
如果大小（L）==1，则N=T
elseN=索引I+1处L中的元素（模数列表大小）

以及守则：

public class NextTime {

public static void main(String[] args) {

    String time = "12:12";
    System.out.println("Starting time="+time);
    System.out.println("Next time="+getNextTime(time));
}

static Set<Integer> times = new HashSet<>();

private static String getNextTime(String time) {
    // Create a list with the 4 digits (strip out the ':')
    List<String> digits = Arrays.asList(time.split("")).stream().filter(d -> !d.equals(":"))
            .collect(Collectors.toList());
    // Build up the set of maximum 24 times
    timeCombinations(digits, 0, "");
    // Sort the list of times (which are integers representing minutes)
    List<Integer> sortedTimeList = times.stream().sorted().collect(Collectors.toList());
    // Find the next index immediately after the current time
    int newIndex = 0;
    if (sortedTimeList.size() > 1) {
        int currentTime = Integer.valueOf(time.substring(0, 2)) * 60 + Integer.valueOf(time.substring(3, 5));
        int listPosition = sortedTimeList.indexOf(currentTime);
        newIndex = (listPosition + 1) % times.size();
    }
    // Turn the time back into a string
    String newTimeString = String.format("%02d:%02d", sortedTimeList.get(newIndex)/60, sortedTimeList.get(newIndex)%60);
    return newTimeString;
}

private static void timeCombinations(List<String> digits, int depth, String result) {
    if (depth == 4) {
        // You have a valid time; Convert time string like 1234 to minutes
        int minutes = Integer.valueOf(result.substring(0, 2)) * 60 + Integer.valueOf(result.substring(2, 4));
        times.add(minutes);
    } else {
        for (int d = 0; d < digits.size(); d++) {
            int c = Integer.valueOf(digits.get(d)).intValue();
            // Validation rule for the first digit of the hour
            if (depth == 0 && c > 2)
                continue;
            // Validation rule for the first digit of the minutes
            if (depth == 2 && c > 5)
                continue;
            List<String> digitsClone = new ArrayList<>(digits);
            String resultClone = new String(result) + digitsClone.get(d);
            // Validation rule for the complete hour
            if (depth == 1 && Integer.valueOf(resultClone).intValue() > 23)
                continue;
            digitsClone.remove(d);
            timeCombinations(digitsClone, depth + 1, resultClone);
        }
    }
}

公共类下一时刻{
公共静态void main（字符串[]args）{
字符串时间=“12:12”；
System.out.println（“开始时间=+时间”）；
System.out.println（“Next time=“+getNextTime（time））；
}
静态设置时间=新HashSet（）；
私有静态字符串getNextTime（字符串时间）