Minimum Cost to Set Cooking Time - Practice Coding Problems

Minimum Cost to Set Cooking Time - Problem

Math Enumeration Medium

Imagine you're operating a digital microwave that accepts cooking times from 1 second to 99 minutes and 99 seconds. The microwave has a unique input system where you can push at most 4 digits, and it automatically normalizes your input by prepending zeros to make it exactly 4 digits.

Here's how the interpretation works:

954 becomes 0954 → 9 minutes and 54 seconds
0008 → 0 minutes and 8 seconds
8090 → 80 minutes and 90 seconds
8130 → 81 minutes and 30 seconds

Your finger starts at digit startAt, and you have two types of costs:

Move Cost: moveCost units to move your finger to any digit
Push Cost: pushCost units to press the current digit

Goal: Find the minimum cost to input a cooking time that equals exactly targetSeconds seconds. Remember that multiple digit combinations might produce the same cooking time (e.g., 90 seconds can be entered as 0130 or 0090).

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: Target is 600 seconds (10 minutes). Two ways to input: '1000' (10:00) or '0940' (09:40). For '1000': start at 1, push 1 (cost 1), push 0 (move + push = 3), push 0 (cost 1), push 0 (cost 1) = total 6. For '0940': costs more due to additional moves.

example_2.py — Small Target

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

› Output: 6

💡 Note: Target is 76 seconds. Can input as '0116' (01:16) or '0076' (00:76). For '0076': start at 0, push 0 (cost 2), push 0 (cost 2), move to 7 and push (cost 3), move to 6 and push (cost 3) = total 10. For '0116': total cost is 6, which is better.

example_3.py — Edge Case

$ Input: startAt = 9, moveCost = 4, pushCost = 9, targetSeconds = 60

› Output: 13

💡 Note: Target is 60 seconds (1 minute). Can input as '0100' (01:00) or '0060' (00:60). Starting at 9, both require significant moves. '0100' requires moving to 0, 1, 0, 0 while '0060' requires 0, 0, 6, 0. The optimal path gives cost 13.

Constraints

1 ≤ startAt ≤ 9
1 ≤ moveCost, pushCost ≤ 10⁵
1 ≤ targetSeconds ≤ 6039
Important: targetSeconds will always have at least one valid representation

Visualization

Tap to expand

Understanding the Visualization

Identify Target

You want to cook for exactly 90 seconds

Find Representations

90 seconds = 01:30 or 00:90 on the microwave

Calculate Costs

Starting from digit 1: '0130' vs '0090' - which path is cheaper?

Choose Optimal

Select the representation with minimum move + push costs

Key Takeaway

🎯 Key Insight: Any cooking time has at most 2 valid microwave representations. Generate both, calculate costs, pick the minimum!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses smart enumeration in O(1) time. Instead of checking all 10,000 possible inputs, we realize that any target time has at most 2 valid representations: the standard mm:ss format and an alternative where we 'borrow' 60 seconds from minutes. We generate both representations, validate them, calculate input costs, and return the minimum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(10000)	O(1)	Test all possible 4-digit combinations from 0000 to 9999
Optimized Enumeration (Smart Generation)	O(1)	O(1)	Generate only valid time representations instead of checking all combinations

Brute Force (Try All Combinations) — Algorithm Steps

Iterate through all numbers from 0 to 9999
For each number, extract minutes (first two digits) and seconds (last two digits)
Check if the total time equals targetSeconds and is within valid range
Calculate the cost to input this 4-digit sequence
Keep track of the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate 4-digit sequence

Start with 0000, then 0001, 0002, etc.

Parse minutes and seconds

Split the 4 digits: first 2 = minutes, last 2 = seconds

Validate cooking time

Check if total seconds equals target and within valid range

Calculate input cost

Sum up move costs and push costs for the digit sequence

Track minimum

Keep the lowest cost found so far

Code -

solution.c — C

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

int getCost(char* timeStr, int startAt, int moveCost, int pushCost) {
    int cost = 0;
    int currentPos = startAt;
    
    for (int i = 0; i < 4; i++) {
        int digitVal = timeStr[i] - '0';
        if (digitVal != currentPos) {
            cost += moveCost;
            currentPos = digitVal;
        }
        cost += pushCost;
    }
    
    return cost;
}

int minCostSetTime(int startAt, int moveCost, int pushCost, int targetSeconds) {
    int minCost = INT_MAX;
    
    // Try all possible 4-digit combinations
    for (int i = 0; i < 10000; i++) {
        char timeStr[5];
        sprintf(timeStr, "%04d", i);
        
        int minutes = (timeStr[0] - '0') * 10 + (timeStr[1] - '0');
        int seconds = (timeStr[2] - '0') * 10 + (timeStr[3] - '0');
        
        // Check if this represents a valid cooking time
        if (minutes <= 99 && seconds <= 99) {
            int totalSeconds = minutes * 60 + seconds;
            if (totalSeconds == targetSeconds && totalSeconds >= 1) {
                int cost = getCost(timeStr, startAt, moveCost, pushCost);
                if (cost < minCost) {
                    minCost = cost;
                }
            }
        }
    }
    
    return minCost;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(10000)

We check all possible 4-digit combinations (0000 to 9999)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track minimum cost and current position

✓ Linear Space

28.4K Views

Medium Frequency

~18 min Avg. Time

847 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