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

Understanding the Visualization

Input

Current time 02:30, target time 03:00

Process

Calculate 30 minute difference, apply greedy strategy

Output

Minimum 2 operations needed

Key Takeaway

🎯 Key Insight: Greedy algorithm works because larger operations never conflict with optimal solutions

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

Approach	Time	Space	Notes
✓ Greedy - Use Largest Operations First	O(1)	O(1)	Use largest possible operations first (60, then 15, then 5, then 1)
Brute Force - Try All Combinations	O(d⁴)	O(1)	Try all possible combinations of operations to reach target time

Greedy - Use Largest Operations First — Algorithm Steps

Convert times to minutes
Calculate difference
Use maximum 60-minute operations
Use maximum 15-minute operations
Use maximum 5-minute operations
Use 1-minute operations for remainder

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Difference

Convert times to minutes and find difference

Apply Greedy Strategy

Use largest operations first: 60→15→5→1

Count Operations

Sum all operations used

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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;
}

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 case
    }
    
    int operations = 0;
    
    // Use greedy approach: largest operations first
    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;
    
    int result = solution(current, correct);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only performs constant arithmetic operations regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Uses only a few variables to store intermediate calculations

✓ 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

Greedy - Use Largest Operations First — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler