Watering Plants - Practice Coding Problems

Watering Plants - Problem

Array Simulation Medium

You want to water n plants in your garden with a watering can. The plants are arranged in a row and are labeled from 0 to n - 1 from left to right where the ith plant is located at x = i. There is a river at x = -1 that you can refill your watering can at.

Each plant needs a specific amount of water. You will water the plants in the following way:

Water the plants in order from left to right.
After watering the current plant, if you do not have enough water to completely water the next plant, return to the river to fully refill the watering can.
You cannot refill the watering can early.

You are initially at the river (i.e., x = -1). It takes one step to move one unit on the x-axis.

Given a 0-indexed integer array plants of n integers, where plants[i] is the amount of water the ith plant needs, and an integer capacity representing the watering can capacity, return the number of steps needed to water all the plants.

Input & Output

Example 1 — Basic Case

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

› Output: 14

💡 Note: Start at river (-1) with 5 units. Go to plant 0 (+1 step), water with 2 units, 3 left. Go to plant 1 (+1 step), water with 2 units, 1 left. Can't water plant 2 (needs 3), so go back to river (+2 steps) and forward to plant 2 (+3 steps), water with 3 units, 2 left. Go to plant 3 (+1 step), can't water (needs 3), go back to river (+3 steps) and forward to plant 3 (+4 steps), water plant 3. Total: 1+1+2+3+1+3+4 = 15... wait let me recalculate: 1+1+(2+3)+1+(3+4) = 14 steps

Example 2 — No Refill Needed

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

› Output: 4

💡 Note: Start with capacity 4. Each plant needs 1 unit. Move and water each: 1+1+1+1 = 4 steps total, no refills needed

Example 3 — Refill Every Plant

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

› Output: 1

💡 Note: Single plant needs exactly our capacity. Move from river to plant 0 in 1 step, water it. Total: 1 step

Constraints

1 ≤ plants.length ≤ 1000
1 ≤ plants[i] ≤ 10⁶
plants[i] ≤ capacity ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input

Plants array [2,2,3,3] and capacity 5

Process

Water plants left-to-right, refill when needed

Output

Total steps taken including refill trips

Key Takeaway

🎯 Key Insight: Simulate the process step by step, adding refill roundtrips when water is insufficient

Asked in

a Amazon 15 M Microsoft 8

The key insight is to simulate the watering process while tracking water level and counting steps. When water is insufficient for the next plant, add roundtrip steps back to river. Best approach uses single-pass simulation with O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n)	O(1)	Simulate each plant watering and river trip separately
Optimized Simulation	O(n)	O(1)	Single pass simulation with efficient step counting

Brute Force Simulation — Algorithm Steps

Start at river with full capacity
For each plant, check if refill needed
If needed, count steps: current_pos → river → plant
Water plant and update position

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at river with full capacity

Check

For each plant, check if refill needed

Move

Count steps for each movement separately

Code -

solution.c — C

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

int solution(int* plants, int plantsSize, int capacity) {
    int steps = 0;
    int currentWater = capacity;
    int position = -1;
    
    for (int i = 0; i < plantsSize; i++) {
        // Check if we need to refill
        if (currentWater < plants[i]) {
            // Go back to river and then to plant i
            steps += position - (-1);  // back to river
            steps += i - (-1);  // river to plant i
            currentWater = capacity;
            position = i;
        } else {
            // Just move to next plant
            steps += i - position;
            position = i;
        }
        
        // Water the plant
        currentWater -= plants[i];
    }
    
    return steps;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse plants array
    int plants[1000];
    int plantsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        plants[plantsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int capacity;
    scanf("%d", &capacity);
    
    int result = solution(plants, plantsSize, capacity);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through plants array

✓ Linear Growth

Space Complexity

O(1)

Only using variables for position and water tracking

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

985 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