Pour Water Between Buckets to Make Water Levels Equal - Problem

You have n buckets each containing some gallons of water in it, represented by a 0-indexed integer array buckets, where the ith bucket contains buckets[i] gallons of water.

You are also given an integer loss. You want to make the amount of water in each bucket equal. You can pour any amount of water from one bucket to another bucket (not necessarily an integer).

However, every time you pour k gallons of water, you spill loss percent of k. Return the maximum amount of water in each bucket after making the amount of water equal.

Answers within 10^-5 of the actual answer will be accepted.

Input & Output

Example 1 — Basic Case

$ Input: buckets = [1,2,7], loss = 80

› Output: 2.00000

💡 Note: Pour 5 gallons from bucket 2 to bucket 0. 80% is lost, so bucket 0 gets 1 gallon (total 2), bucket 2 has 2 gallons left. All buckets now have 2 gallons.

Example 2 — High Loss Rate

$ Input: buckets = [2,4,5], loss = 100

› Output: 2.00000

💡 Note: With 100% loss, no water can be transferred. The maximum equal level is the minimum value: 2.

Example 3 — No Loss Case

$ Input: buckets = [3,1,3,4,5], loss = 0

› Output: 3.20000

💡 Note: With 0% loss, we can perfectly redistribute water. Total water is 16, so each bucket gets 16/5 = 3.2 gallons.

Constraints

1 ≤ buckets.length ≤ 10³
0 ≤ buckets[i] ≤ 10⁵
0 ≤ loss ≤ 99

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 8

The key insight is to use binary search on the answer space. Since we want the maximum achievable water level, we can binary search between 0 and the theoretical maximum (average), testing each candidate level by simulating water transfers with loss. Best approach is Binary Search: Time O(n × log(max_water)), Space O(n).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n × log(max_water)) Space: O(n)

Use binary search on the possible water levels (0 to average). For each candidate level, check if it's achievable by simulating water transfers with loss. This converges much faster than brute force.

Brute Force Simulation

⏱️ Time: O(n × iterations) Space: O(1)

For each potential final water level, simulate pouring water from buckets above the level to those below, accounting for loss. Check if we can achieve exactly that level.

Binary Search on Answer — Algorithm Steps

Step 1: Set search range from 0 to total_water/n
Step 2: For mid-point level, simulate pouring with loss
Step 3: If achievable, search higher; otherwise search lower
Step 4: Continue until precision threshold reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Range

Search between 0 and average (2.0)

Test Mid

Try mid-point level 1.0, check if achievable

Narrow

If achievable, search higher range [1.0, 2.0]

Code -

solution.c — C

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

bool canAchieve(int* buckets, int n, double efficiency, double target) {
    double totalExcess = 0.0;
    double totalDeficit = 0.0;
    
    for (int i = 0; i < n; i++) {
        double water = (double) buckets[i];
        if (water > target) {
            totalExcess += water - target;
        } else if (water < target) {
            totalDeficit += target - water;
        }
    }
    
    return totalExcess * efficiency >= totalDeficit;
}

double solution(int* buckets, int n, int loss) {
    if (loss >= 100) {
        int minVal = buckets[0];
        for (int i = 1; i < n; i++) {
            if (buckets[i] < minVal) {
                minVal = buckets[i];
            }
        }
        return (double) minVal;
    }
    
    double lossRate = loss / 100.0;
    double efficiency = 1.0 - lossRate;
    
    int minVal = buckets[0];
    int maxVal = buckets[0];
    for (int i = 1; i < n; i++) {
        if (buckets[i] < minVal) minVal = buckets[i];
        if (buckets[i] > maxVal) maxVal = buckets[i];
    }
    
    double left = (double) minVal;
    double right = (double) maxVal;
    
    for (int iter = 0; iter < 100; iter++) {
        if (right - left < 1e-12) break;
        double mid = (left + right) / 2;
        if (canAchieve(buckets, n, efficiency, mid)) {
            left = mid;
        } else {
            right = mid - 1e-12;
        }
    }
    
    return left;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    static int buckets[1000];
    int n = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']') break;
        
        // Parse number
        char* start = ptr;
        while (*ptr && *ptr != ',' && *ptr != ']' && *ptr != ' ') ptr++;
        
        if (ptr > start) {
            char temp = *ptr;
            *ptr = '\0';
            buckets[n++] = atoi(start);
            *ptr = temp;
        }
    }
    
    int loss;
    scanf("%d", &loss);
    
    double result = solution(buckets, n, loss);
    printf("%.15f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_water))

Binary search takes O(log(max_water)) iterations, each requiring O(n) simulation

✓ Linear Growth

Space Complexity

O(n)

Need temporary array to simulate water transfers

✓ Linear Space

8.2K Views

Medium Frequency

~35 min Avg. Time

245 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

Pour Water Between Buckets to Make Water Levels Equal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler