Pour Water - Practice Coding Problems

Pour Water - Problem

Array Simulation Medium

Imagine you're standing on a mountainous terrain with an elevation map represented as an integer array heights, where heights[i] represents the height at position i. Each position has a width of 1 unit.

You have volume units of water that will be poured at position k. Each water droplet follows realistic physics:

🌊 Water flows left first: If moving left would eventually lead to a lower level, the water flows left
🌊 Otherwise flows right: If left doesn't work but right leads to lower ground, water flows right
🌊 Otherwise stays put: If neither direction leads downhill, water accumulates at the current position

The terrain extends infinitely high on both sides, so water can't escape the boundaries. Your task is to simulate the water flow and return the final state of the terrain with accumulated water.

Note: Water cannot be split - each unit must occupy exactly one position at its final resting place.

Input & Output

example_1.py — Basic Water Flow

$ Input: heights = [2,1,1,2,1,2,2], volume = 4, k = 3

› Output: [2,2,2,3,1,2,2]

💡 Note: Water starts at index 3. First droplet flows left to index 1 (lowest point). Second droplet flows left to index 2. Third droplet flows left but both positions are filled, so stays at index 3. Fourth droplet also stays at index 3.

example_2.py — Right Flow

$ Input: heights = [1,2,3,4], volume = 2, k = 2

› Output: [3,2,3,4]

💡 Note: Water at index 2 cannot flow left (uphill), cannot flow right (uphill), so it accumulates at the starting position k=2.

example_3.py — Mixed Flow

$ Input: heights = [3,1,3], volume = 5, k = 1

› Output: [3,6,3]

💡 Note: Position 1 is surrounded by higher terrain, so all water accumulates there forming a deep pool.

Constraints

1 ≤ heights.length ≤ 100
0 ≤ heights[i] ≤ 99
0 ≤ volume ≤ 2000
0 ≤ k < heights.length
Water cannot be split between positions

Visualization

Tap to expand

Understanding the Visualization

Initial State

Terrain with varying heights, water ready to drop at position k

Left Search

Water checks left direction for lowest reachable position

Right Search

If left doesn't work, check right direction

Settlement

Water settles at chosen position, increasing height

Repeat

Process continues for all remaining water units

Key Takeaway

🎯 Key Insight: Water simulation requires checking left first (preferred direction), then right, mimicking real physics where water seeks the lowest available position.

Asked in

G Google 32 f Facebook 28 A Amazon 24 🍎 Apple 18

The optimal approach is direct simulation of water physics. For each water droplet, we find the lowest reachable position going left first, then right if left doesn't work. This gives us O(volume × n) time complexity, which is optimal since we must process each water unit individually.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(volume × n)	O(1)	Simulate each water droplet individually with naive search

Brute Force Simulation — Algorithm Steps

For each unit of water (repeat 'volume' times)
Start at position k and try to flow left first
Find the lowest reachable position going left
If no lower position left, try flowing right
Find the lowest reachable position going right
If neither direction works, stay at position k
Add water unit to the chosen position

Visualization

Tap to expand

Step-by-Step Walkthrough

Drop Water

Water starts at position k

Check Left

Find lowest reachable position going left

Check Right

If left fails, find lowest position going right

Settle

Water settles at the chosen position

Code -

solution.c — C

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

void dropWater(int* heights, int size, int k) {
    // Try flowing left first
    int leftPos = k;
    for (int i = k - 1; i >= 0; i--) {
        if (heights[i] < heights[leftPos]) {
            leftPos = i;
        } else if (heights[i] > heights[leftPos]) {
            break;
        }
    }
    
    // If we found a lower position to the left, place water there
    if (leftPos != k) {
        heights[leftPos]++;
        return;
    }
    
    // Try flowing right
    int rightPos = k;
    for (int i = k + 1; i < size; i++) {
        if (heights[i] < heights[rightPos]) {
            rightPos = i;
        } else if (heights[i] > heights[rightPos]) {
            break;
        }
    }
    
    // Place water at the chosen position
    heights[rightPos]++;
}

int* pourWater(int* heights, int heightsSize, int volume, int k) {
    for (int v = 0; v < volume; v++) {
        dropWater(heights, heightsSize, k);
    }
    return heights;
}

int main() {
    // Simplified input parsing
    int heights[] = {2, 1, 1, 2, 1, 2, 2};
    int size = 7;
    int volume = 4;
    int k = 3;
    
    pourWater(heights, size, volume, k);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", heights[i]);
        if (i < size - 1) printf(", ");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(volume × n)

For each water unit, we potentially scan the entire array to find settling position

✓ Linear Growth

Space Complexity

O(1)

Only using the input array to track water levels, no extra data structures

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

986 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler