Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Move from brute-force thinking to an efficient approach using array strategy.
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:
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.
Example 1:
Input: plants = [2,2,3,3], capacity = 5 Output: 14 Explanation: Start at the river with a full watering can: - Walk to plant 0 (1 step) and water it. Watering can has 3 units of water. - Walk to plant 1 (1 step) and water it. Watering can has 1 unit of water. - Since you cannot completely water plant 2, walk back to the river to refill (2 steps). - Walk to plant 2 (3 steps) and water it. Watering can has 2 units of water. - Since you cannot completely water plant 3, walk back to the river to refill (3 steps). - Walk to plant 3 (4 steps) and water it. Steps needed = 1 + 1 + 2 + 3 + 3 + 4 = 14.
Example 2:
Input: plants = [1,1,1,4,2,3], capacity = 4 Output: 30 Explanation: Start at the river with a full watering can: - Water plants 0, 1, and 2 (3 steps). Return to river (3 steps). - Water plant 3 (4 steps). Return to river (4 steps). - Water plant 4 (5 steps). Return to river (5 steps). - Water plant 5 (6 steps). Steps needed = 3 + 3 + 4 + 4 + 5 + 5 + 6 = 30.
Example 3:
Input: plants = [7,7,7,7,7,7,7], capacity = 8 Output: 49 Explanation: You have to refill before watering each plant. Steps needed = 1 + 1 + 2 + 2 + 3 + 3 + 4 + 4 + 5 + 5 + 6 + 6 + 7 = 49.
Constraints:
n == plants.length1 <= n <= 10001 <= plants[i] <= 106max(plants[i]) <= capacity <= 109Problem summary: 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
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array
[2,2,3,3] 5
[1,1,1,4,2,3] 4
[7,7,7,7,7,7,7] 8
watering-plants-ii)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2079: Watering Plants
class Solution {
public int wateringPlants(int[] plants, int capacity) {
int ans = 0, water = capacity;
for (int i = 0; i < plants.length; ++i) {
if (water >= plants[i]) {
water -= plants[i];
ans += 1;
} else {
water = capacity - plants[i];
ans += i * 2 + 1;
}
}
return ans;
}
}
// Accepted solution for LeetCode #2079: Watering Plants
func wateringPlants(plants []int, capacity int) (ans int) {
water := capacity
for i, p := range plants {
if water >= p {
water -= p
ans++
} else {
water = capacity - p
ans += i*2 + 1
}
}
return
}
# Accepted solution for LeetCode #2079: Watering Plants
class Solution:
def wateringPlants(self, plants: List[int], capacity: int) -> int:
ans, water = 0, capacity
for i, p in enumerate(plants):
if water >= p:
water -= p
ans += 1
else:
water = capacity - p
ans += i * 2 + 1
return ans
// Accepted solution for LeetCode #2079: Watering Plants
impl Solution {
pub fn watering_plants(plants: Vec<i32>, capacity: i32) -> i32 {
let mut ans = 0;
let mut water = capacity;
for (i, &p) in plants.iter().enumerate() {
if water >= p {
water -= p;
ans += 1;
} else {
water = capacity - p;
ans += (i as i32) * 2 + 1;
}
}
ans
}
}
// Accepted solution for LeetCode #2079: Watering Plants
function wateringPlants(plants: number[], capacity: number): number {
let [ans, water] = [0, capacity];
for (let i = 0; i < plants.length; ++i) {
if (water >= plants[i]) {
water -= plants[i];
++ans;
} else {
water = capacity - plants[i];
ans += i * 2 + 1;
}
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair or subarray. The outer loop fixes a starting point, the inner loop extends or searches. For n elements this gives up to n²/2 operations. No extra space, but the quadratic time is prohibitive for large inputs.
Most array problems have an O(n²) brute force (nested loops) and an O(n) optimal (single pass with clever state tracking). The key is identifying what information to maintain as you scan: a running max, a prefix sum, a hash map of seen values, or two pointers.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.