Make Array Zero by Subtracting Equal Amounts

Make Array Zero by Subtracting Equal Amounts - Problem

Array Hash Table Greedy Sorting Heap (Priority Queue) Simulation Easy

You are given a non-negative integer array nums. Your goal is to make all elements equal to zero by performing a series of special operations.

In each operation, you must:

Choose a positive integer x where x ≤ smallest non-zero element in the array
Subtract x from every positive element in the array

For example, if nums = [3, 1, 6], the smallest non-zero element is 1. You could choose x = 1 and subtract it from all positive elements: [3-1, 1-1, 6-1] = [2, 0, 5].

Return the minimum number of operations needed to make every element in nums equal to 0.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The unique non-zero values are {1, 5, 3}. Operation 1: subtract 1 → [0,4,0,2,4]. Operation 2: subtract 2 → [0,2,0,0,2]. Operation 3: subtract 2 → [0,0,0,0,0].

example_2.py — All Zeros

$ Input: nums = [0]

› Output: 0

💡 Note: The array already contains only zeros, so no operations are needed.

example_3.py — All Same Values

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

› Output: 1

💡 Note: All non-zero elements have the same value (3), so only one operation is needed to make all elements zero.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 100
Follow up: Can you solve this in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Initial State

Containers have water levels [3, 1, 6]. Lowest non-empty = 1

First Drain

Drain 1 unit from all → [2, 0, 5]. Container 2 is now empty

Second Drain

Drain 2 units from remaining → [0, 0, 3]. Container 1 is now empty

Final Drain

Drain 3 units from last container → [0, 0, 0]. All empty!

Key Takeaway

🎯 Key Insight: The number of operations equals the number of unique non-zero water levels, since each unique level requires exactly one draining operation to eliminate.

Asked in

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

The optimal solution uses a hash set to count unique non-zero values in O(n) time. The key insight is that each unique value requires exactly one operation to eliminate, regardless of how many times it appears in the array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n²)	O(1)	Simulate the process by repeatedly finding minimum and subtracting from all elements
Hash Set Counting (Optimal)	O(n)	O(n)	Count unique non-zero values using a hash set in one pass

Brute Force Simulation — Algorithm Steps

Initialize operation counter to 0
While array has non-zero elements:
Find the smallest non-zero element (min_val)
Subtract min_val from all positive elements
Increment operation counter
Return total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with [3, 1, 6], min non-zero = 1

After Operation 1

Subtract 1 from all: [2, 0, 5], min non-zero = 2

After Operation 2

Subtract 2 from positives: [0, 0, 3], min non-zero = 3

After Operation 3

Subtract 3 from positives: [0, 0, 0], done!

Code -

solution.c — C

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

int minimumOperations(int* nums, int numsSize) {
    int operations = 0;
    
    while (1) {
        // Find minimum non-zero element
        int minVal = INT_MAX;
        int hasPositive = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] > 0) {
                hasPositive = 1;
                if (nums[i] < minVal) {
                    minVal = nums[i];
                }
            }
        }
        
        // If no positive elements found, we're done
        if (!hasPositive) {
            break;
        }
        
        // Subtract minVal from all positive elements
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] > 0) {
                nums[i] -= minVal;
            }
        }
        
        operations++;
    }
    
    return operations;
}

int main() {
    int nums[] = {3, 1, 6};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", minimumOperations(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we need n operations (when all elements are distinct), and each operation scans the entire array of n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for tracking minimum and operations count

✓ Linear Space

52.3K Views

Medium Frequency

~8 min Avg. Time

1.8K 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