2357. Make Array Zero by Subtracting Equal Amounts

EasyGreedyArrayHash TableSortingSimulationHeap (Priority Queue)

Problem Description

In this problem, we are given an array nums containing non-negative integers. Our task is to perform a series of operations to make all elements in the array equal to zero. An operation consists of two steps:

Choose a positive integer x that is no greater than the smallest non-zero element in nums.
Subtract this x from every positive element in nums.

The goal is to find the minimum number of such operations required to reduce all elements in the array to zero.

Intuition

To approach this problem, we observe that each operation will reduce all non-zero elements by the same amount: the smallest non-zero number in the array. This implies that each unique non-zero number in the array will eventually need to become the smallest non-zero element through these operations, and be reduced to zero.

Given this, intuitively, if we repeatedly perform the operation on the current smallest non-zero element, we would effectively eliminate that element in the next step (since it will become zero). In the case of duplicate non-zero elements, these can be removed in the same operation. Therefore, the minimum number of operations needed will be equal to the number of unique non-zero values in the array.

The Python solution reflects this intuition by first filtering out all the zeros and then transforming the remaining numbers into a set, which automatically removes duplicates, leaving us with unique non-zero numbers. The length of this resultant set is exactly the number of operations needed since that's the number of unique non-zero elements we will need to reduce to zero, one by one.

Learn more about Greedy, Sorting and Heap (Priority Queue) patterns.

Solution Approach

The implementation of the solution is quite straightforward, leveraging Python's set data structure and list comprehension.

Here's a step-by-step breakdown of the solution code:

return len({x for x in nums if x}): This line of code encapsulates the entire solution in a compact form.
- {x for x in nums if x} is a set comprehension, which iterates over each element x in the list nums.
- The if x part is a conditional that filters out all zero elements. This is important because the problem specifies that we should only consider positive elements for subtraction operations.
- By using a set rather than a list, duplicate non-zero values are automatically eliminated. This is crucial to finding the unique non-zero values.
len(...): After the set is created with only unique non-zero values, the len function is used to count the number of elements in this set.

No additional algorithms or complex patterns are required for this operation; the solution is primarily based on the properties of sets in Python that give us unique values naturally.

The algorithm's complexity is O(n), where n is the number of elements in the input list nums. This is because the set comprehension iterates over the list once, and set operations are generally O(1) on average. Therefore, the overall computation is very efficient for this problem.

Ready to land your dream job?

Unlock your dream job with a 2-minute evaluator for a personalized learning plan!

Start Evaluator

Example Walkthrough

Let's consider the example array nums with the following integers:

nums = [1, 2, 0, 2, 3]

To follow the solution approach using the Python code mentioned earlier, we perform the following steps:

The set comprehension {x for x in nums if x} evaluates as follows:
- Begin iterating over each element x in nums.
- Check if x to filter out zeroes, leaving us with just the positive integers [1, 2, 2, 3].
- As these values are being added to a set, the duplicates are removed, resulting in the unique non-zero values: {1, 2, 3}.
Now, we apply the len(...) function on this resulting set {1, 2, 3}.
- The len function counts the number of unique non-zero elements, resulting in 3.

Therefore, the minimum number of operations required to reduce all elements in nums to zero is 3. These operations would be performed as follows:

First operation: Choose x = 1, the smallest positive integer in nums. Subtract 1 from all positive elements to get [0, 1, 0, 1, 2].
Second operation: Now the smallest non-zero element is 1. Subtract 1 again from all positive elements to get [0, 0, 0, 0, 1].
Third operation: Finally, choose x = 1 one last time to subtract from the remaining positive element. The resulting array is [0, 0, 0, 0, 0].

Now all elements in the array are zero, and it took us 3 operations, which is consistent with the length of the set computed earlier.

Solution Implementation

1from typing import List
2
3class Solution:
4    def minimumOperations(self, nums: List[int]) -> int:
5        # Create a set comprehension to filter out all non-zero unique elements.
6        unique_non_zero_numbers = {number for number in nums if number}
7
8        # The length of this set represents the minimum number of operations needed,
9        # since each unique non-zero number can be reduced to zero in one operation.
10        return len(unique_non_zero_numbers)
11
12# Example usage:
13# sol = Solution()
14# result = sol.minimumOperations([1, 5, 0, 1, 0])
15# print(result)  # Output would be 2 (for the numbers 1 and 5)
16

1class Solution {
2    public int minimumOperations(int[] nums) {
3        // Initialize a boolean array to keep track of visited numbers
4        boolean[] seenNumbers = new boolean[101]; 
5        seenNumbers[0] = true; // Assuming 0 is not considered as an operation
6        int operationCount = 0; // Initialize a counter for the minimum number of operations
7      
8        // Loop through each number in the input array
9        for (int number : nums) {
10            // If the number has not been seen before
11            if (!seenNumbers[number]) {
12                operationCount++; // Increment the operation count
13                seenNumbers[number] = true; // Mark the number as seen
14            }
15        }
16        // Return the count of the minimum number of operations needed
17        return operationCount;
18    }
19}
20

1#include <vector> // Required for std::vector
2
3// Definition of the Solution class
4class Solution {
5public:
6    // Function to find the minimum number of operations needed to make all elements in an array unique
7    int minimumOperations(std::vector<int>& nums) {
8        // Create an array to keep track of numbers we've seen
9        bool seen[101] = {false}; 
10        seen[0] = true; // We start by marking 0 as seen (if we're assuming that nums only contains positive integers, 
11                        // then this is redundant as it would never be used)
12      
13        int operations = 0; // Initialize the count of operations to 0
14
15        // Loop through each number in the input vector
16        for (int& num : nums) {
17            // If we haven't seen this number before
18            if (!seen[num]) {
19                operations++;     // Increment the count of operations
20                seen[num] = true; // Mark the number as seen
21            }
22        }
23
24        // Return the total number of operations required
25        return operations;
26    }
27};
28

1/**
2 * This function calculates the minimum number of operations to make all elements of an array equal.
3 * An operation is defined as incrementing n - 1 elements by 1.
4 * 
5 * @param {number[]} nums - The input array of numbers.
6 * @returns {number} The minimum number of operations to make all elements equal.
7 */
8function minimumOperations(nums: number[]): number {
9    // Initialize a set to store unique non-zero elements
10    const uniqueNonZeroElements = new Set<number>();
11
12    // Iterate through the input array
13    for (let num of nums) {
14        // If the current number is not zero, add it to the set
15        if (num !== 0) {
16            uniqueNonZeroElements.add(num);
17        }
18    }
19
20    // The size of the set gives the minimum number of operations
21    // since we need to make only the unique non-zero elements equal
22    return uniqueNonZeroElements.size;
23}
24

Time and Space Complexity

The given Python code defines a method called minimumOperations that calculates the minimum number of operations needed to make all elements in the array nums equal to zero, under the assumption that in one operation, you can choose any non-zero element and reduce it to zero. This is inferred by the requirement to count unique non-zero elements, as setting each unique non-zero number to zero is effectively the operation implied.

Time Complexity

The time complexity of the code is dominated by the comprehension {x for x in nums if x} which iterates through each element of the nums list once. The membership check for sets in Python is O(1) on average. Therefore, the overall time complexity of creating this set is O(n), where n is the length of the nums list.

Space Complexity

The space complexity is influenced by the additional set that is being created to store the unique non-zero elements. In the worst case, if all elements are unique and non-zero, the set will grow to the same size as the input list. Thus, the space complexity is O(n), where n is the size of the input list. If the input list has many zeros or duplicate elements, the space used will be less than n.

Learn more about how to find time and space complexity quickly using problem constraints.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:

Question 1 out of 10

Given a sorted array of integers and an integer called target, find the element that equals to the target and return its index. Select the correct code that fills the ___ in the given code snippet.

1def binary_search(arr, target):
2    left, right = 0, len(arr) - 1
3    while left ___ right:
4        mid = (left + right) // 2
5        if arr[mid] == target:
6            return mid
7        if arr[mid] < target:
8            ___ = mid + 1
9        else:
10            ___ = mid - 1
11    return -1
12

1public static int binarySearch(int[] arr, int target) {
2    int left = 0;
3    int right = arr.length - 1;
4
5    while (left ___ right) {
6        int mid = left + (right - left) / 2;
7        if (arr[mid] == target) return mid;
8        if (arr[mid] < target) {
9            ___ = mid + 1;
10        } else {
11            ___ = mid - 1;
12        }
13    }
14    return -1;
15}
16

1function binarySearch(arr, target) {
2    let left = 0;
3    let right = arr.length - 1;
4
5    while (left ___ right) {
6        let mid = left + Math.trunc((right - left) / 2);
7        if (arr[mid] == target) return mid;
8        if (arr[mid] < target) {
9            ___ = mid + 1;
10        } else {
11            ___ = mid - 1;
12        }
13    }
14    return -1;
15}
16

<=, left, right

<, left, right

<=, right, left

<, right, left

I don’t know