Skip to content
Related Articles

Related Articles

Improve Article

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 <bits/stdc++.h>
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[0]);
    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<Integer> unique = new HashSet<Integer>();
 
 
    // 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




<?php
// PHP 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
function check( &$arr, $N, $K)
{
     
    // Add in Set only unique elements
    $unique = array_unique($arr);
 
    // Count of all the unique elements
    // in the array
    if (count($unique) == $K)
        return true;
    return false;
}
 
// Driver code
$arr = array( 1, 1, 2, 3 );
$N = count($arr);
$K = 3;
if (check($arr, $N, $K))
    echo "Yes";
else
    echo "No";
     
// This code has been contributed
// by Rajput-Ji
?>

Javascript




<script>
 
// Javascript 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
function check(arr, N, K)
{
    // Set to store unique elements
    var unique = new Set();
 
    // Add every element of the array
    // to the set
    for (var 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
var arr = [1, 1, 2, 3];
var N = arr.length;
var K = 3;
if (check(arr, N, K))
    document.write( "Yes");
else
    document.write( "No");
 
</script>
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
Recommended Articles
Page :