# Check if the given array can be reduced to zeros with the given operation performed given number of times

• Difficulty Level : Medium
• Last Updated : 28 May, 2022

Given an array arr[] of N integers and an integer K, the task is to find whether the given array elements can be made 0 if the given operation is applied exactly K times. In a single operation, the smallest element from the array will be subtracted from all the non-zero elements of the array.
Examples:

Input: arr[] = {1, 1, 2, 3}, K = 3
Output: Yes
K = 1 -> arr[] = {0, 0, 1, 2}
K = 2 -> arr[] = {0, 0, 0, 1}
K = 3 -> arr[] = {0, 0, 0, 0}
Input: arr[] = {11, 2, 3, 4}, K = 3
Output: No
The array requires 4 operations.

Approach:

• Major observation here is that the minimum number does not matter at each operation, suppose X is the minimum number then all the occurrences of X will be 0 in the current operation and other elements will reduce by X.
• We can conclude that all the identical elements will be 0 at the same operation.
• So, say in Q operations the entire array becomes 0, it is equal to the number of unique elements in the array.
• If Q = K then the answer is Yes else print No.
• Number of unique elements can be obtained using set.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function that returns true if the array``// can be reduced to 0s with the given``// operation performed given number of times``bool` `check(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Set to store unique elements``    ``set<``int``> unique;` `    ``// Add every element of the array``    ``// to the set``    ``for` `(``int` `i = 0; i < N; i++)``        ``unique.insert(arr[i]);` `    ``// Count of all the unique elements``    ``// in the array``    ``if` `(unique.size() == K)``        ``return` `true``;``    ``return` `false``;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 1, 2, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = 3;``    ``if` `(check(arr, N, K))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{``    ` `// Function that returns true if the array``// can be reduced to 0s with the given``// operation performed given number of times``static` `boolean` `check(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Set to store unique elements``    ``HashSet unique = ``new` `HashSet();`  `    ``// Add every element of the array``    ``// to the set``    ``for` `(``int` `i = ``0``; i < N; i++)``        ``unique.add(arr[i]);` `    ``// Count of all the unique elements``    ``// in the array``    ``if` `(unique.size() == K)``        ``return` `true``;``    ``return` `false``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``1``, ``2``, ``3` `};``    ``int` `N = arr.length;``    ``int` `K = ``3``;``    ``if` `(check(arr, N, K))``        ``System.out.println(``"Yes"``);``    ``else``        ``System.out.println(``"No"``);``}``}` `// This code has been contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach` `# Function that returns true if the array``# can be reduced to 0s with the given``# operation performed given number of times``def` `check(arr, N, K):``    ` `    ``# Set to store unique elements``    ``unique ``=` `dict``()` `    ``# Add every element of the array``    ``# to the set``    ``for` `i ``in` `range``(N):``        ``unique[arr[i]] ``=` `1` `    ``# Count of all the unique elements``    ``# in the array``    ``if` `len``(unique) ``=``=` `K:``        ``return` `True``    ``return` `False` `# Driver code``arr ``=` `[``1``, ``1``, ``2``, ``3``]``N ``=` `len``(arr)``K ``=` `3``if` `(check(arr, N, K) ``=``=` `True``):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)` `# This code is contributed by mohit kumar`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Function that returns true if the array``// can be reduced to 0s with the given``// operation performed given number of times``public` `static` `bool` `check(``int``[] arr, ``int` `N, ``int` `K)``{``    ``// Set to store unique elements``    ``HashSet<``int``> unique = ``new` `HashSet<``int``>();`  `    ``// Add every element of the array``    ``// to the set``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``unique.Add(arr[i]);``    ``}` `    ``// Count of all the unique elements``    ``// in the array``    ``if` `(unique.Count == K)``    ``{``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = ``new` `int``[] {1, 1, 2, 3};``    ``int` `N = arr.Length;``    ``int` `K = 3;``    ``if` `(check(arr, N, K))``    ``{``        ``Console.WriteLine(``"Yes"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"No"``);``    ``}``}``}` `// This code is contributed by shrikanth13`

## PHP

 ``

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(nlogn), where n is the size of the given array.
Auxiliary Space: O(n),  where extra space of size n is used to create a set.

My Personal Notes arrow_drop_up