Minimum Number of Operations to Convert Time

Minimum Number of Operations to Convert Time - Problem

String Greedy Easy

You are given two strings current and correct representing two 24-hour times.

24-hour times are formatted as "HH:MM", where HH is between 00 and 23, and MM is between 00 and 59. The earliest 24-hour time is 00:00, and the latest is 23:59.

In one operation you can increase the time current by 1, 5, 15, or 60 minutes. You can perform this operation any number of times.

Return the minimum number of operations needed to convert current to correct.

Input & Output

Example 1 — Basic Case

$ Input: current = "02:30", correct = "03:00"

› Output: 2

💡 Note: Need 30 minutes difference. Use 2 operations of 15 minutes each: 02:30 → 02:45 → 03:00

Example 2 — Mixed Operations

$ Input: current = "11:00", correct = "11:01"

› Output: 1

💡 Note: Need 1 minute difference. Use 1 operation of 1 minute: 11:00 → 11:01

Example 3 — Next Day Edge Case

$ Input: current = "23:59", correct = "00:00"

› Output: 1

💡 Note: Need 1 minute to go from 23:59 to 00:00 (next day). Use 1 operation of 1 minute.

Constraints

current and correct are valid 24-hour times
current ≠ correct is not guaranteed (can be equal)

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12

The key insight is to use a greedy approach - always use the largest possible operation first. Convert times to minutes, calculate the difference, then use 60-minute operations first, followed by 15-minute, 5-minute, and 1-minute operations. Best approach is Greedy with Time: O(1), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

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

For each possible number of 60-minute, 15-minute, 5-minute, and 1-minute operations, check if they sum to the target difference. This explores all possibilities but is inefficient.

Greedy - Use Largest Operations First

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

Calculate the time difference in minutes, then greedily use the largest operations first. Use as many 60-minute operations as possible, then 15-minute, then 5-minute, and finally 1-minute operations for the remainder.

Brute Force - Try All Combinations — Algorithm Steps

Convert times to minutes
Calculate difference
Try all combinations of operations
Return minimum operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Difference

Find minutes between current and target time

Try All Combinations

Test every possible mix of 60, 15, 5, 1 minute operations

Find Minimum

Return the combination with fewest total operations

Code -

solution.c — C

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

int timeToMinutes(const char* timeStr) {
    int hours = (timeStr[0] - '0') * 10 + (timeStr[1] - '0');
    int minutes = (timeStr[3] - '0') * 10 + (timeStr[4] - '0');
    return hours * 60 + minutes;
}

void removeQuotes(char* str) {
    int len = strlen(str);
    if (len >= 2 && str[0] == '"' && str[len-1] == '"') {
        memmove(str, str + 1, len - 2);
        str[len - 2] = '\0';
    }
}

int solution(char* current, char* correct) {
    int currentMins = timeToMinutes(current);
    int correctMins = timeToMinutes(correct);
    int diff = correctMins - currentMins;
    
    if (diff < 0) {
        diff += 24 * 60; // Handle next day
    }
    
    if (diff == 0) {
        return 0;
    }
    
    // Greedy approach: use largest denominations first
    int operations = 0;
    operations += diff / 60;
    diff %= 60;
    operations += diff / 15;
    diff %= 15;
    operations += diff / 5;
    diff %= 5;
    operations += diff; // remaining minutes using 1-minute operations
    
    return operations;
}

int main() {
    char current[10], correct[10];
    fgets(current, sizeof(current), stdin);
    fgets(correct, sizeof(correct), stdin);
    
    current[strcspn(current, "\n")] = 0;
    correct[strcspn(correct, "\n")] = 0;
    
    removeQuotes(current);
    removeQuotes(correct);
    
    int result = solution(current, correct);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d⁴)

Four nested loops iterating up to d times each, where d is time difference

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting operations

✓ Linear Space

28.5K Views

Medium Frequency

~8 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler