Make Array Zero by Subtracting Equal Amounts

You are given a non-negative integer array nums. In one operation, you must:

1. Choose a positive integer x such that x is less than or equal to the smallest non-zero element in nums.
2. Subtract x from every positive element in nums.

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

Example 1:

Input: nums = [1,5,0,3,5]
Output: 3
Explanation:
In the first operation, choose x = 1. Now, nums = [0,4,0,2,4].
In the second operation, choose x = 2. Now, nums = [0,2,0,0,2].
In the third operation, choose x = 2. Now, nums = [0,0,0,0,0].

Example 2:

Input: nums = [0]
Output: 0
Explanation: Each element in nums is already 0 so no operations are needed.

First Approach:

  Action:
            1. choose a minim num
            2. substract it
            3. choose another minimum number
            4. substract it
            5. choose minimum 
            5. substract it

        It's a recursive operation, we can utlize a dynicamic programming here

let count = 0

function findMin(array) {
    let min = Infinity
    for (let i = 0; i < array.length; i++) {
        if (0 < array[i]) {
            min = Math.min(min, array[i])
        }
    }
    return min
}

function reducer(array) {
    let min = findMin(array)
    let max = Math.max(...array)
    if (max === 0) {
        return count
    }
    for (let i = 0; i < array.length; i++) {
        if (0 < array[i]) {
            array[i] -= min
        }
    }
    count++
    reducer(array)
}
reducer(nums)
return count

Analysis:

1. Finding the Minimum Non-zero Element:
2. The findMin function scans the entire array each time to find the smallest non-zero element, which is O(n) per operation.
3. In the worst case, this could lead to O(n^2) time complexity if the array has many distinct elements.
4. Subtracting the Minimum: The reducer function subtracts the found minimum from all non-zero elements, which is another O(n) operation per step.
5. Recursion: The use of recursion here is unnecessary and could lead to stack overflow for very large arrays.
6. An iterative approach would be more efficient and safer.

1. Each recursive call does O(N) work because:
2. findMin() scans entire array → O(N)
3. Math.max() scans entire array → O(N)
4. Subtraction loop → O(N)
5. Total per call: O(N) + O(N) + O(N) = O(N)
6. Number of recursive calls:
7. In worst case (all elements unique): N calls
8. Example: [5,4,3,2,1] needs 5 operations
9. Total time complexity:
10. O(N work per call) × O(N calls) = O(N²)

The quadratic complexity comes from:

• Doing O(N) work
• O(N) times
• Hence O(N²)

Why Unique Elements = Operations:

1. Each operation eliminates one unique value and all its duplicates
2. First operation removes the smallest number (and its copies)
3. Next operation removes the new smallest number (after subtraction)
4. Repeat until all numbers are zero

Example:
[1, 1, 3, 5] (3 unique values: 1,3,5)
Operation 1: Subtract 1 → removes all 1s → [0,0,2,4]
Operation 2: Subtract 2 → removes original 3s → [0,0,0,2]
Operation 3: Subtract 2 → removes original 5 → [0,0,0,0]

Key Point:

Each unique value needs exactly one operation to eliminate it and all its copies. That's why:

Number of operations = Number of unique non-zero values

var minimumOperations = function(nums) {
   nums.sort((a, b) => a -b)

    let prev = 0
    let count = 0

    for(let i = 0; i < nums.length; i++){
        if(prev<nums[i]){
            count++
            prev = nums[i]
        }
    }
    return count
};

var minimumOperations = function(nums) {
    const set = new Set(nums)
   return set.has(0)? set.size - 1 : set.size
};