Watering Plants - Practice Coding Problems

Watering Plants - Problem

Array Simulation Medium

Imagine you're a dedicated gardener with n plants arranged in a perfect row in your garden. Each plant has its own unique watering needs, and you want to take the best care of them using your trusty watering can.

Here's your setup: Plants are positioned at coordinates x = 0, 1, 2, ..., n-1, and there's a river at position x = -1 where you can refill your watering can to full capacity.

The Rules:

🌱 Water plants strictly from left to right (you can't skip ahead)
💧 If you don't have enough water for the next plant, you must return to the river to refill
🚫 No early refills allowed - only refill when absolutely necessary
📍 You start at the river (position -1)
👣 Each move between adjacent positions costs 1 step

Goal: Calculate the minimum total steps needed to water all plants completely.

Input & Output

example_1.py — Basic Garden

$ Input: plants = [2,2,3,3], capacity = 5

› Output: 14

💡 Note: Start at river(-1)→P0(1 step)→water P0(capacity=3)→P1(1 step)→water P1(capacity=1)→can't water P2→river(2 steps)→refill→P2(3 steps)→water P2→P3(1 step)→water P3. Total: 1+1+2+3+1+3=14 steps

example_2.py — No Refill Needed

$ Input: plants = [1,1,1,4,2,3], capacity = 4

› Output: 30

💡 Note: Multiple refill trips are needed due to the plant at index 3 requiring 4 units of water, which uses the full capacity

example_3.py — Single Plant

$ Input: plants = [7], capacity = 7

› Output: 1

💡 Note: Only need to move from river(-1) to plant 0, which takes 1 step. No refill needed since we have exactly enough water

Constraints

1 ≤ plants.length ≤ 1000
1 ≤ plants[i] ≤ 10⁶
max(plants[i]) ≤ capacity ≤ 10⁹
Important: The capacity is always sufficient to water any individual plant

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start at the river with full watering can, ready to begin the journey

Water Plants

Move to each plant in order, watering them and tracking remaining capacity

Smart Refilling

When water runs low for the next plant, return to river to refill

Complete Mission

Continue until all plants are properly watered

Key Takeaway

🎯 Key Insight: This is a pure simulation problem where the optimal strategy is to faithfully follow the watering rules while carefully tracking our position and remaining water capacity.

Asked in

a Amazon 45 G Google 35 ⊞ Microsoft 25 f Meta 20

The optimal approach is simulation - faithfully following the watering rules while tracking position and water level. Since we must water plants in order and follow specific refill rules, simulation gives us the exact answer in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach (Optimal)	O(n)	O(1)	Simulate the watering process step by step, tracking position and water level

Simulation Approach (Optimal) — Algorithm Steps

Start at river (-1) with full watering can
For each plant from left to right:
Move to current plant and water it
Check if we have enough water for the next plant
If not enough water: return to river, refill, then continue
Count all steps taken during the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at River

Begin at position -1 with full watering can

Water Plant 0

Move to position 0, water the plant, check remaining water

Continue or Refill

If enough water for next plant, continue; otherwise return to river

Repeat Process

Continue until all plants are watered

Code -

solution.c — C

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

int wateringPlants(int* plants, int plantsSize, int capacity) {
    int steps = 0;
    int currentWater = capacity;
    int currentPos = -1; // Start at river
    
    for (int i = 0; i < plantsSize; i++) {
        // Move to plant i
        steps += abs(i - currentPos);
        currentPos = i;
        
        // Water the plant
        currentWater -= plants[i];
        
        // Check if we need to refill for next plant
        if (i < plantsSize - 1 && currentWater < plants[i + 1]) {
            // Go back to river
            steps += abs(-1 - currentPos);
            currentPos = -1;
            currentWater = capacity;
        }
    }
    
    return steps;
}

int main() {
    int n, capacity;
    scanf("%d %d", &n, &capacity);
    int* plants = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &plants[i]);
    }
    printf("%d\n", wateringPlants(plants, n, capacity));
    free(plants);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each plant exactly once, with potential trips back to river

✓ Linear Growth

Space Complexity

O(1)

Only need to track current position, water level, and step count

✓ Linear Space

38.4K Views

Medium Frequency

~15 min Avg. Time

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

Simulation Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler