Related Articles

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

• Difficulty Level : Medium
• Last Updated : 14 May, 2021

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`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up