Next Closest Time - Practice Coding Problems

Next Closest Time - Problem

Imagine you're working on a digital clock application that has a unique constraint: the display can only show digits that are already present in the current time.

Given a time in the format "HH:MM" (24-hour format), your task is to find the next closest time by rearranging and reusing only the existing digits. You can reuse any digit multiple times, but you cannot introduce new digits.

Important rules:

Time format is always "HH:MM" (e.g., "01:34", "23:59")
Hours range from 00 to 23
Minutes range from 00 to 59
If no valid next time exists on the same day, wrap around to the next day

Example: Given "19:34", the available digits are [1, 9, 3, 4]. The next closest time using these digits would be "19:39".

Input & Output

example_1.py — Basic increment

$ Input: "19:34"

› Output: "19:39"

💡 Note: Available digits are [1,9,3,4]. The next closest time can be formed by changing the last digit from 4 to 9, giving us 19:39.

example_2.py — Wraparound to next day

$ Input: "23:59"

› Output: "22:22"

💡 Note: Available digits are [2,3,5,9]. No valid time exists after 23:59 on the same day, so we find the smallest valid time for the next day: 22:22.

example_3.py — All same digits

$ Input: "11:11"

› Output: "11:11"

💡 Note: Only digit 1 is available. The next valid time using only 1s is 11:11 (wraps around to the next day).

Constraints

The input time is in the format "HH:MM"
Hours are in range [00, 23]
Minutes are in range [00, 59]
All digits in the result must be present in the original time
Return the lexicographically next closest time

Visualization

Tap to expand

Understanding the Visualization

Identify Working Segments

Extract all unique digits from current time - these are the only segments that work

Smart Increment Strategy

Try to increment the rightmost position first (minutes units), then move left

Validate Time Constraints

Ensure each position respects time limits (hours: 00-23, minutes: 00-59)

Handle Overflow

If no valid time exists today, wrap to next day with smallest valid time

Key Takeaway

🎯 Key Insight: Instead of brute-force checking every minute, we strategically increment time positions from right to left, respecting digit availability and time constraints for optimal O(1) performance.

Asked in

G Google 42 a Amazon 38 f Facebook 31 ⊞ Microsoft 25

The optimal approach uses smart enumeration by trying to increment each time position from right to left (minutes units → minutes tens → hours units → hours tens). This avoids checking every possible minute and leverages the structure of time representation to find the lexicographically next closest valid time in O(1) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Smart Enumeration (Optimal)	O(1)	O(1)	Generate next valid time by strategically incrementing from rightmost position

Smart Enumeration (Optimal) — Algorithm Steps

Extract available digits and sort them
Try to increment minute units digit to next valid digit
If not possible, increment minute tens and reset units to smallest
If minutes can't be incremented, try incrementing hour units
If hours can't be incremented, wrap to next day with smallest valid time
Build and return the result time

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract & Sort Digits

Get sorted unique digits from input

Try Increment Minutes

Try to find next valid minute using available digits

Try Increment Hours

If minutes fail, try incrementing hours

Wrap to Next Day

If all fail, find smallest valid time for next day

Code -

solution.c — C

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

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

void nextClosestTime(char* time, char* result) {
    // Extract and sort available digits
    char digits[5] = {time[0], time[1], time[3], time[4], '\0'};
    
    // Remove duplicates and sort
    char uniqueDigits[5];
    int uniqueCount = 0;
    for (int i = 0; i < 4; i++) {
        bool found = false;
        for (int j = 0; j < uniqueCount; j++) {
            if (uniqueDigits[j] == digits[i]) {
                found = true;
                break;
            }
        }
        if (!found) {
            uniqueDigits[uniqueCount++] = digits[i];
        }
    }
    qsort(uniqueDigits, uniqueCount, sizeof(char), compare);
    
    // Convert to array for easier manipulation
    char timeChars[4] = {time[0], time[1], time[3], time[4]};
    
    // Try to increment from rightmost position
    for (int i = 3; i >= 0; i--) {
        char currentDigit = timeChars[i];
        char nextDigit = '\0';
        
        for (int j = 0; j < uniqueCount; j++) {
            char digit = uniqueDigits[j];
            if (digit > currentDigit) {
                // Check if this digit is valid for the position
                if (i == 0 && digit <= '2') { // First hour digit: 0-2
                    nextDigit = digit;
                    break;
                } else if (i == 1) { // Second hour digit
                    if (timeChars[0] == '2' && digit <= '3') { // 20-23
                        nextDigit = digit;
                        break;
                    } else if (timeChars[0] < '2') { // 00-19
                        nextDigit = digit;
                        break;
                    }
                } else if (i == 2 && digit <= '5') { // First minute digit: 0-5
                    nextDigit = digit;
                    break;
                } else if (i == 3) { // Second minute digit: 0-9
                    nextDigit = digit;
                    break;
                }
            }
        }
        
        if (nextDigit != '\0') {
            // Found valid next digit, set it and reset positions to the right
            timeChars[i] = nextDigit;
            for (int k = i + 1; k < 4; k++) {
                // Set to smallest valid digit for this position
                for (int j = 0; j < uniqueCount; j++) {
                    char digit = uniqueDigits[j];
                    if (k == 1) { // Second hour digit
                        if (timeChars[0] == '2' && digit <= '3') {
                            timeChars[k] = digit;
                            break;
                        } else if (timeChars[0] < '2') {
                            timeChars[k] = digit;
                            break;
                        }
                    } else if (k == 2 && digit <= '5') { // First minute digit
                        timeChars[k] = digit;
                        break;
                    } else if (k == 3) { // Second minute digit
                        timeChars[k] = digit;
                        break;
                    }
                }
            }
            
            sprintf(result, "%c%c:%c%c", timeChars[0], timeChars[1], timeChars[2], timeChars[3]);
            return;
        }
    }
    
    // If no increment possible, wrap to next day with smallest valid time
    char resultChars[4];
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < uniqueCount; j++) {
            char digit = uniqueDigits[j];
            if (i == 0 && digit <= '2') {
                resultChars[i] = digit;
                break;
            } else if (i == 1 && ((resultChars[0] == '2' && digit <= '3') || (resultChars[0] < '2'))) {
                resultChars[i] = digit;
                break;
            } else if (i == 2 && digit <= '5') {
                resultChars[i] = digit;
                break;
            } else if (i == 3) {
                resultChars[i] = digit;
                break;
            }
        }
    }
    
    sprintf(result, "%c%c:%c%c", resultChars[0], resultChars[1], resultChars[2], resultChars[3]);
}

int main() {
    char time[10];
    char result[10];
    fgets(time, sizeof(time), stdin);
    
    // Remove newline and quotes
    char cleanTime[6];
    sscanf(time, "\"%5s", cleanTime);
    cleanTime[5] = '\0';
    
    nextClosestTime(cleanTime, result);
    printf("\"%s\"", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

At most tries a few digit combinations for each position, bounded by constant

✓ Linear Growth

Space Complexity

O(1)

Only stores available digits (at most 4 unique digits) and temporary variables

✓ Linear Space

78.6K Views

Medium Frequency

~18 min Avg. Time

1.8K 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

Smart Enumeration (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler