Pour Water Between Buckets to Make Water Levels Equal

Pour Water Between Buckets to Make Water Levels Equal - Problem

You have n buckets arranged in a row, each containing a different amount of water measured in gallons. Your goal is to equalize the water levels across all buckets by pouring water from one bucket to another.

However, there's a catch! Every time you pour k gallons of water from one bucket to another, you lose a certain percentage of that water due to spillage. If the loss percentage is loss, then only k × (100 - loss) / 100 gallons actually reach the destination bucket.

Given an array buckets where buckets[i] represents the initial water amount in the i-th bucket, and an integer loss representing the spillage percentage, find the maximum possible water level that can be achieved in each bucket when all buckets have equal amounts.

Note: You can pour any fractional amount of water, and answers within 10^-5 of the actual answer will be accepted.

Input & Output

example_1.py — Basic Case

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

› Output: 2.00000

💡 Note: We can pour 5 gallons from bucket 2 to bucket 0 (4 gallons lost, 1 gallon reaches). Final: [2, 2, 2]. Each bucket has 2 gallons.

example_2.py — No Transfer Needed

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

› Output: 3.66667

💡 Note: Pour 1.33 from bucket 2 to bucket 0 (0.67 reaches), and 0.33 from bucket 1 to bucket 0 (0.17 reaches). We can achieve approximately 3.67 gallons in each bucket.

example_3.py — High Loss Rate

$ Input: buckets = [100], loss = 0

› Output: 100.00000

💡 Note: Only one bucket, no transfer needed. The water level remains 100 gallons.

Constraints

1 ≤ n ≤ 10³
0 ≤ buckets[i] ≤ 10⁵
0 ≤ loss < 100
Answers within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with buckets containing different water amounts

Binary Search Bounds

Set left=0, right=max_bucket_value

Test Mid Level

Check if we can achieve the middle value in all buckets

Calculate Excess/Deficit

Sum excess water above level and deficit below level

Account for Loss

Apply loss percentage: can excess×(1-loss%) fill deficit?

Update Bounds

Narrow search space based on feasibility

Converge to Answer

Continue until finding the maximum achievable level

Key Takeaway

🎯 Key Insight: Binary search efficiently finds the maximum achievable water level by testing feasibility through excess/deficit calculation with loss consideration.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses binary search on the possible water level values. For each candidate level, we check feasibility by calculating the excess water from buckets above the level and the deficit water needed for buckets below the level. The level is achievable if excess × retention_rate ≥ deficit. Time complexity: O(n log V) where V is the value range.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(V × n)	O(1)	Try every possible water level with small increments
Binary Search (Optimal)	O(n log V)	O(1)	Binary search on the final water level with feasibility checking

Brute Force (Linear Search) — Algorithm Steps

Iterate through possible water levels with small increments (e.g., 0.00001)
For each level, check if it's achievable by simulating water transfers
Calculate excess water from buckets above the level
Try to fill buckets below the level using the excess water (accounting for loss)
Return the highest achievable level

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with level 0

Begin testing from water level 0

Increment by small amount

Move to next level (current + epsilon)

Check feasibility

Test if this level is achievable with current buckets

Update best

If achievable, update the best known level

Continue until max

Repeat until reaching maximum possible level

Code -

solution.c — C

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

bool canAchieve(int* buckets, int n, int loss, double target) {
    double excess = 0, deficit = 0;
    double retention = (100.0 - loss) / 100.0;
    
    for (int i = 0; i < n; i++) {
        if (buckets[i] > target) {
            excess += buckets[i] - target;
        } else {
            deficit += target - buckets[i];
        }
    }
    
    return excess * retention >= deficit;
}

double equalizeWater(int* buckets, int n, int loss) {
    double maxWater = buckets[0];
    for (int i = 1; i < n; i++) {
        if (buckets[i] > maxWater) {
            maxWater = buckets[i];
        }
    }
    
    double epsilon = 1e-5;
    double best = 0;
    
    for (double current = 0; current <= maxWater; current += epsilon) {
        if (canAchieve(buckets, n, loss, current)) {
            best = current;
        }
    }
    
    return best;
}

Time & Space Complexity

Time Complexity

⏱️

O(V × n)

V is the number of values to test (depends on precision), n is the number of buckets for each feasibility check

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for computation

✓ Linear Space

23.8K Views

Medium Frequency

~25 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 (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler