Watering Plants

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

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

✓ Brute Force Simulation

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

For each plant, check if we need to refill first. If so, calculate steps back to river and forward to plant. Then water the plant and continue.

Optimized Simulation

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

Simulate the watering process in one pass, directly counting steps as we move. Track current position and water level, adding steps for each movement.

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;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse plants array
    int plants[1000];
    int plantsSize = 0;
    parseArray(line, plants, &plantsSize);
    
    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