Make Array Elements Equal to Zero

Make Array Elements Equal to Zero - Problem

You are given an integer array nums. Start by selecting a starting position curr such that nums[curr] == 0, and choose a movement direction of either left or right.

After that, you repeat the following process:

If curr is out of the range [0, n - 1], this process ends.
If nums[curr] == 0, move in the current direction by incrementing curr if you are moving right, or decrementing curr if you are moving left.
Else if nums[curr] > 0: Decrement nums[curr] by 1. Reverse your movement direction (left becomes right and vice versa). Take a step in your new direction.

A selection of the initial position curr and movement direction is considered valid if every element in nums becomes 0 by the end of the process.

Return the number of possible valid selections.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Start at index 1 going right, or start at index 3 going left. Both configurations can make all elements zero through the bouncing process.

Example 2 — Single Zero

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

› Output: 2

💡 Note: Can start at index 1 going either left or right. Both directions eventually make all elements zero.

Example 3 — No Valid Configurations

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

› Output: 0

💡 Note: No zero positions exist, so no valid starting configurations are possible.

Constraints

1 ≤ nums.length ≤ 2000
0 ≤ nums[i] ≤ 1000
At least one element in nums is 0

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 f Meta 5

The key insight is that we must simulate the bouncing robot process for each possible starting configuration. The robot starts at zero positions and bounces between positive elements, decrementing them. Best approach is simulation with O(n × s) time complexity where s is the sum of elements.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Pattern Recognition	O(n²)	O(1)	Use mathematical analysis to determine valid configurations without full simulation
Simulation for Each Starting Configuration	O(n × s)	O(n)	Try every possible starting position and direction, simulate the entire process

Mathematical Pattern Recognition — Algorithm Steps

Calculate total work needed (sum of all elements)
For each zero position, calculate work capacity in each direction
Check if work can be distributed without conflicts
Count valid configurations mathematically

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Sums

Find left_sum and right_sum for each zero position

Analyze Capacity

Check if starting direction can handle required work

Count Valid

Mathematical validation instead of simulation

Code -

solution.c — C

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

int simulateAll(int* nums, int n) {
    int count = 0;
    
    for (int start = 0; start < n; start++) {
        if (nums[start] != 0) continue;
        
        int directions[2] = {-1, 1};
        for (int d = 0; d < 2; d++) {
            int direction = directions[d];
            
            int* temp = (int*)malloc(n * sizeof(int));
            memcpy(temp, nums, n * sizeof(int));
            
            int curr = start;
            int currDir = direction;
            
            int sum = 0;
            for (int i = 0; i < n; i++) sum += temp[i];
            int maxSteps = sum * 2 + n;
            int steps = 0;
            
            while (steps < maxSteps) {
                steps++;
                if (curr < 0 || curr >= n) break;
                if (temp[curr] == 0) {
                    curr += currDir;
                } else {
                    temp[curr]--;
                    currDir = -currDir;
                    curr += currDir;
                }
            }
            
            bool allZero = true;
            for (int i = 0; i < n; i++) {
                if (temp[i] != 0) {
                    allZero = false;
                    break;
                }
            }
            
            if (allZero) count++;
            free(temp);
        }
    }
    
    return count;
}

int solution(int* nums, int n) {
    int count = 0;
    
    // Find zero positions
    int zeros[1000];
    int zeroCount = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] == 0) zeros[zeroCount++] = i;
    }
    
    for (int z = 0; z < zeroCount; z++) {
        int start = zeros[z];
        int directions[2] = {-1, 1};
        for (int d = 0; d < 2; d++) {
            int direction = directions[d];
            
            int leftSum = 0, rightSum = 0;
            for (int i = 0; i < start; i++) leftSum += nums[i];
            for (int i = start + 1; i < n; i++) rightSum += nums[i];
            
            if (direction == 1) {
                if (rightSum == 0 || start < n - 1) {
                    int totalWork = leftSum + rightSum;
                    if (totalWork >= 0) {
                        count++;
                    }
                }
            } else {
                if (leftSum == 0 || start > 0) {
                    int totalWork = leftSum + rightSum;
                    if (totalWork >= 0) {
                        count++;
                    }
                }
            }
        }
    }
    
    // Fall back to simulation
    return simulateAll(nums, n);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && (token[0] >= '0' && token[0] <= '9')) {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each zero position (O(n)), calculate prefix and suffix sums (O(n))

⚠ Quadratic Growth

Space Complexity

O(1)

Only use constant extra space for calculations

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

234 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

Mathematical Pattern Recognition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler