Largest Time for Given Digits - Practice Coding Problems

Largest Time for Given Digits - Problem

Given an array arr of exactly 4 digits, your task is to find the latest possible 24-hour time that can be formed using each digit exactly once.

A valid 24-hour time follows the format "HH:MM" where:

HH represents hours: from 00 to 23
MM represents minutes: from 00 to 59

Your goal is to arrange the four digits to create the maximum valid time. For example, if you have digits [1, 2, 3, 4], you want to find the arrangement that gives you the time closest to 23:59.

Return: The latest valid time as a string in "HH:MM" format, or an empty string "" if no valid time can be constructed.

Input & Output

example_1.py — Basic Example

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

› Output: "23:41"

💡 Note: The largest valid time we can make is 23:41. We use 2,3 for hours (23 ≤ 23) and 4,1 for minutes (41 ≤ 59). Other arrangements like 43:21 would be invalid since 43 > 23.

example_2.py — No Valid Time

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

› Output: ""

💡 Note: No valid time can be formed. Any arrangement would give 55:55, but the maximum valid hour is 23, so 55 hours is invalid.

example_3.py — Edge Case with Zeros

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

› Output: "00:00"

💡 Note: All zeros form the time 00:00, which is valid (midnight). Since there's only one possible arrangement, this is our answer.

Visualization

Tap to expand

Understanding the Visualization

Collect the digits

We have 4 digit tiles that need to be arranged in HH:MM format

Try all arrangements

Test each of the 24 possible ways to arrange these 4 digits

Validate each time

Check if hours ≤ 23 and minutes ≤ 59 for each arrangement

Find maximum

Among all valid times, select the one closest to 23:59

Return result

Return the latest valid time or empty string if none exist

Key Takeaway

🎯 Key Insight: Since we have exactly 4 digits with only 24 possible arrangements, generating and testing all permutations is the most straightforward and efficient approach - sometimes brute force IS the optimal solution!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 24 permutations regardless of input, so constant time

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables and the result string

✓ Linear Space

Constraints

arr.length == 4
0 ≤ arr[i] ≤ 9
Each digit must be used exactly once
Time format must be HH:MM where HH ∈ [00,23] and MM ∈ [00,59]

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach is to generate all 24 permutations of the 4 digits and find the maximum valid time. Since there are only 4! = 24 possible arrangements, this brute force method runs in constant time O(1) and is actually the most efficient solution for this constrained problem.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(1)	O(1)	Generate all possible digit arrangements and find the maximum valid time

Generate All Permutations — Algorithm Steps

Generate all 24 permutations of the 4 digits
For each permutation, form a time string HH:MM
Check if the time is valid (HH ≤ 23 and MM ≤ 59)
Keep track of the maximum valid time found
Return the maximum time or empty string if none valid

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with digits [1,2,3,4]

We have 4 positions to fill: HH:MM

Generate permutation: 1234

Forms time 12:34 - Valid! (12 ≤ 23, 34 ≤ 59)

Generate permutation: 4321

Forms time 43:21 - Invalid! (43 > 23)

Continue for all 24 permutations

Test each arrangement and track the maximum valid time

Return maximum found

After checking all, return the latest valid time or empty string

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void generatePermutations(int arr[], int start, int end, char* maxTime) {
    if (start == end) {
        // Check if this permutation forms a valid time
        int hours = arr[0] * 10 + arr[1];
        int minutes = arr[2] * 10 + arr[3];
        
        if (hours <= 23 && minutes <= 59) {
            char timeStr[6];
            sprintf(timeStr, "%d%d:%d%d", arr[0], arr[1], arr[2], arr[3]);
            
            if (strcmp(timeStr, maxTime) > 0) {
                strcpy(maxTime, timeStr);
            }
        }
        return;
    }
    
    for (int i = start; i <= end; i++) {
        swap(&arr[start], &arr[i]);
        generatePermutations(arr, start + 1, end, maxTime);
        swap(&arr[start], &arr[i]);
    }
}

char* largestTimeFromDigits(int arr[]) {
    char* result = malloc(6 * sizeof(char));
    strcpy(result, "");
    
    generatePermutations(arr, 0, 3, result);
    return result;
}

int main() {
    int arr[4];
    scanf("[%d,%d,%d,%d]", &arr[0], &arr[1], &arr[2], &arr[3]);
    
    char* result = largestTimeFromDigits(arr);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 24 permutations regardless of input, so constant time

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables and the result string

✓ Linear Space

Constraints

arr.length == 4
0 ≤ arr[i] ≤ 9
Each digit must be used exactly once
Time format must be HH:MM where HH ∈ [00,23] and MM ∈ [00,59]

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler