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.

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

Example: If current is "02:30" and correct is "04:35", you need to add 125 minutes total. The optimal way is: 2 operations of 60 minutes + 1 operation of 5 minutes = 3 operations.

Input & Output

example_1.py — Basic Example

$ Input: current = "02:30", correct = "04:35"

› Output: 3

💡 Note: We need to add 125 minutes total. Optimal: 2×60 + 1×5 = 125 minutes in 3 operations.

example_2.py — No Operations Needed

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

› Output: 1

💡 Note: Only 1 minute difference, so we need exactly 1 operation of +1 minute.

example_3.py — Multiple Denominations

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

› Output: 32

💡 Note: 1439 minutes total. Optimal: 23×60 + 3×15 + 4×1 = 1380+45+4 = 1439 minutes in 30 operations.

Constraints

current and correct are in the format "HH:MM"
current <= correct
HH is between 00 and 23
MM is between 00 and 59
Time difference is at most 23:59 (1439 minutes)

Visualization

Tap to expand

Understanding the Visualization

Calculate Total Amount

Find the time difference in minutes (like calculating total change needed)

Use Largest Denomination

Use as many 60-minute operations as possible (like using $60 bills first)

Handle Remainder

Use 15-minute, then 5-minute, then 1-minute operations for the remainder

Count Total Operations

Sum up all operations used (like counting total bills given)

Key Takeaway

🎯 Key Insight: This greedy approach works perfectly because 60, 15, 5, and 1 form a 'canonical coin system' where using the largest denomination first always leads to the optimal solution - just like making change with standard currency!

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a greedy algorithm that works like making change with coins. Since the time increments (60, 15, 5, 1) form a canonical coin system where larger denominations are multiples of smaller ones, we can greedily use the largest denomination first to minimize operations. This achieves O(1) time complexity and guarantees the optimal solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(4^n)	O(n)	Generate all possible combinations of operations and find the minimum
Greedy Algorithm (Optimal)	O(1)	O(1)	Use largest denominations first - like making change with coins

Brute Force (Try All Combinations) — Algorithm Steps

Parse both time strings into total minutes
Calculate the difference in minutes
Use recursion or dynamic programming to try all combinations
Track the minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Difference

Find total minutes needed: 125 minutes

Explore All Paths

Try every combination of 1, 5, 15, 60 minute operations

Find Minimum

Compare all valid paths and return minimum operations

Code -

solution.c — C

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

int timeToMinutes(char* time) {
    int h, m;
    sscanf(time, "%d:%d", &h, &m);
    return h * 60 + m;
}

int minOps(int remaining) {
    if (remaining == 0) return 0;
    if (remaining < 0) return INT_MAX;
    
    int result = INT_MAX;
    int increments[] = {60, 15, 5, 1};
    
    for (int i = 0; i < 4; i++) {
        int subResult = minOps(remaining - increments[i]);
        if (subResult != INT_MAX && 1 + subResult < result) {
            result = 1 + subResult;
        }
    }
    
    return result;
}

int convertTime(char* current, char* correct) {
    int currentMin = timeToMinutes(current);
    int correctMin = timeToMinutes(correct);
    int diff = correctMin - currentMin;
    
    return minOps(diff);
}

int main() {
    printf("%d\n", convertTime("02:30", "04:35")); // Output: 3
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

Each minute difference can be made in up to 4 ways, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to the time difference

⚡ Linearithmic Space

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