Minimum Amount of Time to Fill Cups - Practice Coding Problems

Minimum Amount of Time to Fill Cups - Problem

You're operating a smart water dispenser at a busy office that can dispense cold, warm, and hot water. The dispenser has an intelligent optimization feature that allows you to:

Fill 2 cups simultaneously if they require different types of water
Fill 1 cup of any type if you can't fill two different types

Given an array amount of length 3 where:

amount[0] = number of cold water cups needed
amount[1] = number of warm water cups needed
amount[2] = number of hot water cups needed

Your goal is to find the minimum number of seconds needed to fill all cups efficiently.

Example: If you need [1, 4, 2] cups, you can fill warm+hot simultaneously for 2 seconds, then warm+cold for 1 second, leaving 2 warm cups that take 2 more seconds. Total: 5 seconds.

Input & Output

example_1.py — Balanced Distribution

$ Input: [1, 4, 2]

› Output: 4

💡 Note: We can fill optimally: Second 1-2: fill warm+hot simultaneously (leaving [1,2,0]). Second 3: fill warm+cold (leaving [0,1,0]). Second 4: fill remaining warm cup. Total: 4 seconds.

example_2.py — Perfect Pairing

$ Input: [5, 4, 4]

› Output: 7

💡 Note: Total = 13 cups. We can pair different types for 4 seconds (filling 8 cups), then need 5 more seconds for remaining cold cups. max(5, ⌈13/2⌉) = max(5, 7) = 7 seconds.

example_3.py — Single Type Dominates

$ Input: [5, 0, 1]

› Output: 5

💡 Note: Hot and cold can be paired once (1 second), but then we need 4 more seconds for the remaining cold cups. The cold requirement dominates, so answer = max(5, ⌈6/2⌉) = 5 seconds.

Constraints

amount.length == 3
0 ≤ amount[i] ≤ 100
At least one element in amount is strictly greater than 0

Visualization

Tap to expand

Understanding the Visualization

Analyze Requirements

Identify the largest single requirement and total cups needed

Apply Strategy

Use greedy pairing when possible, single filling when necessary

Calculate Minimum

The answer is the maximum of bottleneck time vs optimal pairing time

Key Takeaway

🎯 Key Insight: The optimal strategy balances between maximizing simultaneous filling (2 cups/second) and recognizing when a single type becomes the limiting bottleneck.

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a mathematical greedy approach with O(1) time complexity. The key insight is that the minimum time equals max(largest_single_requirement, ⌈total_cups/2⌉). This handles both scenarios: when types are balanced (pairing is always possible) and when one type dominates (becomes a bottleneck).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Greedy (Optimal)	O(1)	O(1)	Use mathematical insight to calculate minimum time without simulation
Simulation Approach	O(sum of all amounts)	O(1)	Simulate the filling process second by second until all cups are filled

Mathematical Greedy (Optimal) — Algorithm Steps

Find the maximum cups needed for any single type
Calculate the total cups needed across all types
The minimum time is max(largest_single_type, ceiling(total/2))
Return this calculated value

Visualization

Tap to expand

Step-by-Step Walkthrough

Case 1: Balanced Load

When no single type dominates, we can always fill 2 cups simultaneously

Case 2: Single Type Dominates

When one type has more cups than others combined, it becomes the bottleneck

Formula Application

The maximum of these two cases gives us the optimal answer

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int fillCups(int amount[3]) {
    int maxSingle = max(amount[0], max(amount[1], amount[2]));
    int total = amount[0] + amount[1] + amount[2];
    return max(maxSingle, (total + 1) / 2);
}

int main() {
    int amount[3];
    scanf("[%d,%d,%d]", &amount[0], &amount[1], &amount[2]);
    printf("%d\n", fillCups(amount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only need to find max of 3 elements and calculate sum, both constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

52.1K Views

Medium Frequency

~15 min Avg. Time

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

Mathematical Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler