Next Closest Time

Next Closest Time - Problem

Given a time represented in the format "HH:MM", form the next closest time by reusing the current digits. There is no limit on how many times a digit can be reused.

You may assume the given input string is always valid. For example, "01:34", "12:09" are all valid. "1:34", "12:9" are all invalid.

Return the next closest time in the same format "HH:MM".

Input & Output

Example 1 — Basic Case

$ Input: time = "19:34"

› Output: "19:39"

💡 Note: The next closest time using digits {1,3,4,9} is 19:39. We increment the minutes from 34 to 39 using available digits.

Example 2 — Wrap to Next Hour

$ Input: time = "23:59"

› Output: "22:22"

💡 Note: Available digits are {2,3,5,9}. Since no valid time exists after 23:59 on same day using these digits, we wrap to next day with smallest time: 22:22.

Example 3 — Same Digits

$ Input: time = "00:00"

› Output: "00:00"

💡 Note: Only digit 0 is available. The next closest time using only 0s is still 00:00 (wraps around).

Constraints

time.length == 5
time is in the format "HH:MM"
0 ≤ HH ≤ 23
0 ≤ MM ≤ 59

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12

The key insight is to reuse only the available digits from the input time to form the next valid time. The optimal approach tries to replace digits from right to left to minimize the time increment. Time: O(1), Space: O(1).

Common Approaches

✓ Brute Force - Minute by Minute

⏱️ Time: O(1) Space: O(1)

Extract the available digits from input time, then increment minute by minute (wrapping around after 23:59) until we find a time that can be formed using only these digits.

Enumeration - Generate All Valid Times

⏱️ Time: O(1) Space: O(1)

Create all possible times that can be formed using only the available digits, sort them, and find the one that comes immediately after the input time.

Optimized - Smart Digit Replacement

⏱️ Time: O(1) Space: O(1)

Start from the rightmost position and try to find the next larger valid digit. If not possible, move left and repeat. This minimizes the time jump by making the smallest possible change.

Brute Force - Minute by Minute — Algorithm Steps

Extract unique digits from input time
Start from next minute
Check if current time uses only available digits
Return first valid time found

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Get available digits from input time

Try Next Minutes

Check each subsequent time

Validate

Return first time using only available digits

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

char* solution(char* time) {
    static char result[6];
    
    // Extract available digits
    bool digits[10] = {false};
    for (int i = 0; time[i]; i++) {
        if (time[i] != ':') {
            digits[time[i] - '0'] = true;
        }
    }
    
    // Convert to minutes
    int hour = (time[0] - '0') * 10 + (time[1] - '0');
    int minute = (time[3] - '0') * 10 + (time[4] - '0');
    int currentMinutes = hour * 60 + minute;
    
    // Try each minute forward
    for (int i = 1; i <= 24 * 60; i++) {
        int nextMinutes = (currentMinutes + i) % (24 * 60);
        int nextHour = nextMinutes / 60;
        int nextMin = nextMinutes % 60;
        
        // Format as HH:MM
        sprintf(result, "%02d:%02d", nextHour, nextMin);
        
        // Check if all digits are available
        bool valid = true;
        for (int j = 0; result[j]; j++) {
            if (result[j] != ':') {
                if (!digits[result[j] - '0']) {
                    valid = false;
                    break;
                }
            }
        }
        
        if (valid) return result;
    }
    
    strcpy(result, time);
    return result;
}

int main() {
    char time[10];
    fgets(time, sizeof(time), stdin);
    time[strcspn(time, "\n")] = 0; // Remove newline
    
    char* result = solution(time);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

At most 24*60 = 1440 iterations, which is constant

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables and digit set

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Minute by Minute — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler