Largest Time for Given Digits

Largest Time for Given Digits - Problem

Given an array arr of 4 digits, find the latest 24-hour time that can be made using each digit exactly once.

24-hour times are formatted as "HH:MM", where:

HH is between 00 and 23
MM is between 00 and 59

The earliest 24-hour time is 00:00, and the latest is 23:59.

Return the latest 24-hour time in "HH:MM" format. If no valid time can be made, return an empty string.

Input & Output

Example 1 — Basic Case

$ Input: arr = [1,2,3,4]

› Output: 23:41

💡 Note: The largest valid time is 23:41. We use digits 2,3 for hours (23 ≤ 23) and digits 4,1 for minutes (41 ≤ 59).

Example 2 — No Valid Time

$ Input: arr = [5,5,5,5]

› Output: ""

💡 Note: No valid time can be formed. The smallest hour would be 55:55, but 55 > 23 for hours and 55 > 59 for minutes.

Example 3 — Edge Case with Zeros

$ Input: arr = [0,0,0,2]

› Output: 20:00

💡 Note: The largest valid time is 20:00. We use 2,0 for hours (20 ≤ 23) and 0,0 for minutes (00 ≤ 59).

Constraints

arr.length == 4
0 ≤ arr[i] ≤ 9

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28

The key insight is that with only 4 digits, there are exactly 4! = 24 possible arrangements to check. We can generate all permutations and find the maximum valid time, or work backwards from 23:59 to find the first valid time. Best approach is brute force permutation for simplicity. Time: O(1), Space: O(1).

Common Approaches

✓ Backtracking - Build Time Position by Position

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

Instead of generating all permutations first, we build the time string position by position. At each position (H1, H2, M1, M2), we try each available digit and backtrack if the partial time becomes invalid. This allows early pruning when we know a partial combination can't lead to a valid time.

Brute Force - Try All Permutations

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

Since we only have 4 digits, there are exactly 4! = 24 possible arrangements. We can generate all permutations, check if each forms a valid time (HH between 00-23, MM between 00-59), and keep track of the maximum valid time found.

Optimized - Sort and Generate Greedily

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

Instead of checking all permutations, we can be more strategic. Sort the digits in descending order and try to place the largest possible digit at each position while maintaining validity. Start from the latest possible hour (23:XX) and work backwards, then for each valid hour, try to maximize the minutes.

Backtracking - Build Time Position by Position — Algorithm Steps

Start with empty time string and all 4 digits available
Try placing each available digit in current position
Check if partial time is still valid (e.g., first hour digit ≤ 2)
Recursively fill remaining positions
Backtrack if no valid completion possible
Keep track of maximum valid time found

Visualization

Tap to expand

Step-by-Step Walkthrough

Position by Position

Fill H1, H2, M1, M2 in order

Early Pruning

Skip invalid partial combinations

Track Maximum

Keep the best valid time found

Code -

solution.c — C

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

char maxTime[6] = "";

void backtrack(int arr[], int pos, char* currentTime, bool used[]) {
    if (pos == 4) {
        char hourStr[3] = {currentTime[0], currentTime[1], '\0'};
        char minStr[3] = {currentTime[3], currentTime[4], '\0'};
        int hours = atoi(hourStr);
        int minutes = atoi(minStr);
        
        if (hours <= 23 && minutes <= 59) {
            if (strcmp(currentTime, maxTime) > 0) {
                strcpy(maxTime, currentTime);
            }
        }
        return;
    }
    
    for (int i = 0; i < 4; i++) {
        if (used[i]) continue;
        
        char digit = '0' + arr[i];
        char newTime[6];
        strcpy(newTime, currentTime);
        
        if (pos == 0) {
            if (arr[i] > 2) continue;
            newTime[pos] = digit;
        } else if (pos == 1) {
            if (currentTime[0] == '2' && arr[i] > 3) continue;
            newTime[1] = digit;
            newTime[2] = ':';
        } else if (pos == 2) {
            if (arr[i] > 5) continue;
            newTime[3] = digit;
        } else {
            newTime[4] = digit;
            newTime[5] = '\0';
        }
        
        used[i] = true;
        backtrack(arr, pos + 1, newTime, used);
        used[i] = false;
    }
}

char* solution(int arr[]) {
    strcpy(maxTime, "");
    bool used[4] = {false};
    char initial[6] = "";
    backtrack(arr, 0, initial, used);
    return maxTime;
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    int arr[4];
    char* ptr = strchr(line, '[') + 1;
    for (int i = 0; i < 4; i++) {
        arr[i] = strtol(ptr, &ptr, 10);
        if (i < 3) ptr = strchr(ptr, ',') + 1;
    }
    
    char* result = solution(arr);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

At most 24 paths to explore, with early pruning

✓ Linear Growth

Space Complexity

O(1)

Recursion depth is constant (4 levels), plus used array

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Backtracking - Build Time Position by Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler