Minimum Cost to Set Cooking Time

Minimum Cost to Set Cooking Time - Problem

Math Enumeration Medium

A generic microwave supports cooking times for:

at least 1 second.
at most 99 minutes and 99 seconds.

To set the cooking time, you push at most four digits. The microwave normalizes what you push as four digits by prepending zeroes. It interprets the first two digits as the minutes and the last two digits as the seconds. It then adds them up as the cooking time.

For example:

You push 9 5 4 (three digits). It is normalized as 0954 and interpreted as 9 minutes and 54 seconds.
You push 0 0 0 8 (four digits). It is interpreted as 0 minutes and 8 seconds.
You push 8 0 9 0. It is interpreted as 80 minutes and 90 seconds.
You push 8 1 3 0. It is interpreted as 81 minutes and 30 seconds.

You are given integers startAt, moveCost, pushCost, and targetSeconds. Initially, your finger is on the digit startAt. Moving the finger above any specific digit costs moveCost units of fatigue. Pushing the digit below the finger once costs pushCost units of fatigue.

There can be multiple ways to set the microwave to cook for targetSeconds seconds but you are interested in the way with the minimum cost.

Return the minimum cost to set targetSeconds seconds of cooking time.

Remember that one minute consists of 60 seconds.

Input & Output

Example 1 — Basic Case

$ Input: startAt = 1, moveCost = 2, pushCost = 1, targetSeconds = 600

› Output: 6

💡 Note: 600 seconds = 10:00. Input digits [1,0,0,0]: move to 1→0 (cost 2), push 0 (cost 1), push 0 (cost 1), push 0 (cost 1). Total = 2+1+1+1 = 5. Wait, let me recalculate: we start at 1, move to 1 (cost 0), push 1 (cost 1), move to 0 (cost 2), push 0 (cost 1), push 0 (cost 1), push 0 (cost 1). Total = 0+1+2+1+1+1 = 6.

Example 2 — Multiple Options

$ Input: startAt = 0, moveCost = 1, pushCost = 2, targetSeconds = 76

› Output: 5

💡 Note: 76 seconds can be 01:16 or 00:76. For 01:16 → [0,1,1,6]: stay at 0 (cost 0), push 0 (cost 2), move to 1 (cost 1), push 1 (cost 2), stay at 1 (cost 0), push 1 (cost 2), move to 6 (cost 1), push 6 (cost 2). Total = 0+2+1+2+0+2+1+2 = 10. For 00:76 → [0,0,7,6]: we can use this instead, but 76 > 59 so invalid. Actually 01:16 is correct.

Example 3 — Same Digit Sequence

$ Input: startAt = 9, moveCost = 4, pushCost = 1, targetSeconds = 3600

› Output: 7

💡 Note: 3600 seconds = 60:00. Input digits [6,0,0,0]: move from 9→6 (cost 4), push 6 (cost 1), move to 0 (cost 4), push 0 (cost 1), stay at 0, push 0 (cost 1), stay at 0, push 0 (cost 1). Total = 4+1+4+1+1+1 = 12. Wait let me recalculate more carefully.

Constraints

0 ≤ startAt ≤ 9
1 ≤ moveCost, pushCost ≤ 10⁵
1 ≤ targetSeconds ≤ 6039

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that any target time has at most 2 valid representations: MM:SS and (MM-1):(SS+60). The optimal approach generates only these valid representations and computes the minimum input cost. Time: O(1), Space: O(1)

Common Approaches

✓ Generate Valid Time Representations

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

Instead of checking all combinations, generate the specific time representations that equal targetSeconds and calculate cost for each valid representation.

Try All 4-Digit Combinations

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

Generate all possible 4-digit combinations, convert each to seconds, and find the minimum cost among those that match targetSeconds.

Generate Valid Time Representations — Algorithm Steps

Calculate minutes and seconds for target
Try primary representation: MM:SS
Try alternative: (MM-1):(SS+60) if valid
Return minimum cost between valid options

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate

Find MM:SS from targetSeconds

Generate

Create both valid representations

Compare

Pick the cheaper option

Code -

solution.c — C

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

int getCost(int mm, int ss, int start, int move, int push) {
    char digits[5];
    sprintf(digits, "%02d%02d", mm, ss);
    
    int cost = 0;
    int current = start;
    for (int i = 0; i < 4; i++) {
        int digit = digits[i] - '0';
        if (digit != current) {
            cost += move;
            current = digit;
        }
        cost += push;
    }
    return cost;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int startAt, int moveCost, int pushCost, int targetSeconds) {
    if (targetSeconds > 99 * 60 + 99) return -1;
    
    int minCost = INT_MAX;
    
    // Try all possible minute values
    int maxMinutes = min(99, targetSeconds / 60 + 1);
    
    for (int mm = 0; mm <= maxMinutes; mm++) {
        int ss = targetSeconds - mm * 60;
        if (ss >= 0 && ss <= 99) {
            int cost = getCost(mm, ss, startAt, moveCost, pushCost);
            if (cost < minCost) {
                minCost = cost;
            }
        }
    }
    
    return minCost;
}

int main() {
    int startAt, moveCost, pushCost, targetSeconds;
    scanf("%d", &startAt);
    scanf("%d", &moveCost);
    scanf("%d", &pushCost);
    scanf("%d", &targetSeconds);
    
    int result = solution(startAt, moveCost, pushCost, targetSeconds);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

At most 2 representations to check regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only uses constant variables

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

456 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

Generate Valid Time Representations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler