Next Closest Time - Practice Coding Problems

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:41"

💡 Note: The next closest time using digits {1,3,4,9} is 19:41. We increment the minutes from 34 to 41 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

Understanding the Visualization

Input

Time string in HH:MM format with available digits

Process

Find next time using only these digits

Output

Return next closest valid time

Key Takeaway

🎯 Key Insight: Reuse only the available digits from input time to minimize the next valid time increment

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

Approach	Time	Space	Notes
✓ Enumeration - Generate All Valid Times	O(1)	O(1)	Generate all possible valid times using available digits, then find the next one
Brute Force - Minute by Minute	O(1)	O(1)	Check every minute forward until we find a valid time using only available digits
Optimized - Smart Digit Replacement	O(1)	O(1)	Try to replace digits from right to left to find the minimal next time increment

Enumeration - Generate All Valid Times — Algorithm Steps

Extract available digits
Generate all valid HH:MM combinations
Sort the valid times
Find next time after input

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Get unique digits from input

Generate Combinations

Create all HH:MM combinations

Find Next

Return next time in sorted list

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return strcmp(*(char**)a, *(char**)b);
}

char* solution(char* time) {
    static char result[6];
    
    // Extract available digits
    bool digitMap[10] = {false};
    char digits[10];
    int digitCount = 0;
    
    for (int i = 0; time[i]; i++) {
        if (time[i] != ':' && !digitMap[time[i] - '0']) {
            digitMap[time[i] - '0'] = true;
            digits[digitCount++] = time[i];
        }
    }
    
    // Generate all valid times
    char validTimes[1000][6];
    int validCount = 0;
    
    for (int i = 0; i < digitCount; i++) {
        for (int j = 0; j < digitCount; j++) {
            for (int k = 0; k < digitCount; k++) {
                for (int l = 0; l < digitCount; l++) {
                    int hour = (digits[i] - '0') * 10 + (digits[j] - '0');
                    int minute = (digits[k] - '0') * 10 + (digits[l] - '0');
                    if (hour < 24 && minute < 60) {
                        sprintf(validTimes[validCount], "%02d:%02d", hour, minute);
                        
                        // Check for duplicates
                        bool duplicate = false;
                        for (int m = 0; m < validCount; m++) {
                            if (strcmp(validTimes[m], validTimes[validCount]) == 0) {
                                duplicate = true;
                                break;
                            }
                        }
                        if (!duplicate) validCount++;
                    }
                }
            }
        }
    }
    
    // Sort times
    char* timePtrs[1000];
    for (int i = 0; i < validCount; i++) {
        timePtrs[i] = validTimes[i];
    }
    qsort(timePtrs, validCount, sizeof(char*), compare);
    
    // Find next time
    int currentIdx = -1;
    for (int i = 0; i < validCount; i++) {
        if (strcmp(timePtrs[i], time) == 0) {
            currentIdx = i;
            break;
        }
    }
    
    strcpy(result, timePtrs[(currentIdx + 1) % validCount]);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

At most 4⁴ = 256 combinations to generate, which is constant

✓ Linear Growth

Space Complexity

O(1)

At most 1440 valid times stored, which is constant

✓ 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

Enumeration - Generate All Valid Times — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler