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.

You can apply the following operation on the array any number of times:

Choose any subarray of size k from the array and decrease all its elements by 1.

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

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

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: Apply operation on [2,1,3] twice to get [0,0,1,4], then on [0,1,4] once to get [0,0,0,3], then on [0,0,3] three times to get [0,0,0,0]

Example 2 — Impossible Case

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

› Output: false

💡 Note: Cannot make all elements zero because the last element cannot be part of any k-sized subarray when operations are constrained

Example 3 — Edge Case

$ Input: nums = [0,0,0], k = 1

› Output: true

💡 Note: All elements are already zero, no operations needed

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to use a prefix sum approach to track operations efficiently rather than simulating each operation. We maintain a running count of active operations and check if each element can be reduced to zero. Best approach is prefix sum with difference array technique. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n × max(nums)) Space: O(1)

Try all possible positions to apply the operation until no positive elements remain or determine it's impossible. For each iteration, find the first positive element and apply the operation starting from that position.

Prefix Sum Difference Array

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

Convert the problem to a difference array where we track the net effect of all operations. Each operation affects a range, so we use prefix sum to efficiently calculate the cumulative effect at each position.

Brute Force Simulation — Algorithm Steps

Find first positive element in array
Apply operation (decrease k consecutive elements by 1)
Repeat until all elements are 0 or operation fails

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First Positive

Scan array to find first element > 0

Apply Operation

Decrease k consecutive elements by 1

Repeat

Continue until all zeros or impossible

Code -

solution.c — C

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

bool solution(int* nums, int numsSize, int k) {
    // Create copy
    int* numsCopy = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        numsCopy[i] = nums[i];
    }
    
    while (true) {
        // Find first positive element
        int firstPos = -1;
        for (int i = 0; i < numsSize; i++) {
            if (numsCopy[i] > 0) {
                firstPos = i;
                break;
            }
        }
        
        // If no positive elements, we're done
        if (firstPos == -1) {
            free(numsCopy);
            return true;
        }
        
        // Check if we can apply operation
        if (firstPos + k > numsSize) {
            free(numsCopy);
            return false;
        }
        
        // Apply operation
        for (int i = firstPos; i < firstPos + k; i++) {
            numsCopy[i] -= 1;
            if (numsCopy[i] < 0) {
                free(numsCopy);
                return false;
            }
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int num = atoi(token);
        if (num != 0 || strcmp(token, "0") == 0) {
            nums[numsSize++] = num;
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    bool result = solution(nums, numsSize, k);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max(nums))

For each element's value, we may need to scan the entire array

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

18.0K Views

Medium Frequency

~15 min Avg. Time

450 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