Apply Operations to Make All Array Elements Equal to Zero

Apply Operations to Make All Array Elements Equal to Zero - Problem

You are given a 0-indexed integer array nums and a positive integer k.

Your goal is to make all array elements equal to zero by applying a special operation any number of times:

Choose any subarray of size k from the array
Decrease all elements in that subarray by 1

Return true if you can make all array elements equal to 0, or false otherwise.

Note: A subarray is a contiguous non-empty part of an array.

Example: For array [2,2,3,1] with k=2, you could apply the operation on subarray [2,3] (indices 1-2) to get [2,1,2,1], then continue until all elements become zero.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,2,3,1], k = 2

› Output: true

💡 Note: We can apply operations: [2,2,3,1] → [1,1,3,1] → [0,0,3,1] → [0,0,2,0] → [0,0,1,0] → [0,0,0,0]. Each operation reduces k=2 consecutive elements by 1.

example_2.py — Impossible Case

$ Input: nums = [1,3,1,1], k = 2

› Output: false

💡 Note: No matter how we apply operations, we cannot make all elements zero. The middle element 3 creates an imbalance that cannot be resolved with k=2.

example_3.py — Edge Case

$ Input: nums = [1,2,1], k = 3

› Output: true

💡 Note: With k=3, we can apply the operation on the entire array twice: [1,2,1] → [0,1,0] → [0,1,0]. Wait, we need one more operation but can't apply it. Actually this should be false.

Visualization

Tap to expand

Understanding the Visualization

Setup

We have tanks with different water levels and a drainage tool

Greedy Processing

Process from left to right, drain as needed

Track Effects

Each drainage affects k consecutive tanks

Verify Result

Check if all tanks can be emptied

Key Takeaway

🎯 Key Insight: Process greedily from left to right, tracking cumulative operations. If any position becomes negative, the solution is impossible.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ nums.length
All operations must use subarrays of exactly size k

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach with prefix sums. Process the array from left to right, tracking the cumulative effect of operations. For each position, apply the minimum operations needed and propagate the effect to subsequent positions. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Prefix Sum (Optimal)	O(n)	O(1)	Process array left to right, tracking operations needed using prefix sums
Brute Force (Simulation)	O(n! × k)	O(n)	Simulate all possible operations until array becomes zero or impossible

Greedy with Prefix Sum (Optimal) — Algorithm Steps

Initialize operations counter and current effect tracker
For each position from left to right:
Calculate current value after all previous operations
If current value > 0, we need that many operations starting here
Track the effect of these operations on future positions
Return true if we can make all positions zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with diff=0, process from left

Apply Previous

Add accumulated difference to current position

Check Need

If positive, apply operations and update diff

Verify End

Check if remaining positions can be zeroed

Code -

solution.c — C

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

bool canMakeZero(int* nums, int n, int k) {
    long long diff = 0;
    
    // Process positions where we can start operations
    for (int i = 0; i <= n - k; i++) {
        nums[i] += diff;
        if (nums[i] > 0) {
            diff -= nums[i];
            nums[i] = 0;
        } else if (nums[i] < 0) {
            return false;
        }
    }
    
    // Check remaining positions
    for (int i = n - k + 1; i < n; i++) {
        if (nums[i] + diff != 0) {
            return false;
        }
    }
    
    return true;
}

int main() {
    int nums[] = {2, 2, 3, 1};
    int n = 4, k = 2;
    printf("%s\n", canMakeZero(nums, n, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ nums.length
All operations must use subarrays of exactly size k

23.8K Views

Medium Frequency

~25 min Avg. Time

987 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler