Skip to content
Related Articles

Related Articles

Improve Article

Minimum number of operations required to delete all elements of the array

  • Difficulty Level : Easy
  • Last Updated : 30 Apr, 2021

Given an integer array arr, the task is to print the minimum number of operations required to delete all elements of the array. 
In an operation, any element from the array can be chosen at random and every element divisible by it can be removed from the array.
Examples: 
 

Input: arr[] = {2, 4, 6, 3, 5, 10} 
Output: 3 
Choosing 2 as the first element will remove 2, 4, 6 and 10 from the array. 
Now choose 3 which will result in the removal of 3. 
Finally, the only element left to choose is 5.
Input: arr[] = {2, 5, 3, 7, 11} 
Output: 5 
 

 

Approach: For optimal results, the smallest element from the array should be chosen from the remaining elements one after another until all the elements of the array are deleted. 
 

  • Sort the array in ascending order and prepare a hash for occurrences.
  • For each unmarked element starting from beginning mark all elements which are divisible by choose element, and increase the result counter.

Below is the implementstion of the above approach
 



C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
#define MAX 10000
 
using namespace std;
 
int hashTable[MAX];
 
// function to find minimum operations
int minOperations(int arr[], int n)
{
    // sort array
    sort(arr, arr + n);
 
    // prepare hash of array
    for (int i = 0; i < n; i++)
        hashTable[arr[i]]++;
 
    int res = 0;
    for (int i = 0; i < n; i++) {
        if (hashTable[arr[i]]) {
            for (int j = i; j < n; j++)
                if (arr[j] % arr[i] == 0)
                    hashTable[arr[j]] = 0;
            res++;
        }
    }
 
    return res;
}
 
// Driver program
int main()
{
    int arr[] = { 4, 6, 2, 8, 7, 21, 24, 49, 44 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << minOperations(arr, n);
    return 0;
}
Java



//Java implementation of the above approach
import java.util.*;
class Solution
{
static final int MAX=10000;
 
static int hashTable[]= new int[MAX];
 
// function to find minimum operations
static int minOperations(int arr[], int n)
{
    // sort array
    Arrays.sort(arr);
 
    // prepare hash of array
    for (int i = 0; i < n; i++)
        hashTable[arr[i]]++;
 
    int res = 0;
    for (int i = 0; i < n; i++) {
        if (hashTable[arr[i]]!=0) {
            for (int j = i; j < n; j++)
                if (arr[j] % arr[i] == 0)
                    hashTable[arr[j]] = 0;
            res++;
        }
    }
 
    return res;
}
 
// Driver program
public static void main(String args[])
{
    int arr[] = { 4, 6, 2, 8, 7, 21, 24, 49, 44 };
    int n = arr.length;
 
    System.out.print( minOperations(arr, n));
  
}
}
// This code is contributed by Arnab Kundu
Python 3



# Python 3 implementation of
# the above approach
MAX = 10000
 
hashTable = [0] * MAX
 
# function to find minimum operations
def minOperations(arr, n):
     
    # sort array
    arr.sort()
 
    # prepare hash of array
    for i in range(n):
        hashTable[arr[i]] += 1
 
    res = 0
    for i in range(n) :
        if (hashTable[arr[i]]) :
            for j in range(i, n):
                if (arr[j] % arr[i] == 0):
                    hashTable[arr[j]] = 0
            res += 1
 
    return res
 
# Driver Code
if __name__ == "__main__":
    arr = [ 4, 6, 2, 8, 7, 21, 24, 49, 44 ]
    n = len(arr)
 
    print(minOperations(arr, n))
 
# This code is contributed
# by ChitraNayal
C#



using System;
 
// C# implementation of the above approach 
public class Solution
{
public const int MAX = 10000;
 
public static int[] hashTable = new int[MAX];
 
// function to find minimum operations 
public static int minOperations(int[] arr, int n)
{
    // sort array 
    Array.Sort(arr);
 
    // prepare hash of array 
    for (int i = 0; i < n; i++)
    {
        hashTable[arr[i]]++;
    }
 
    int res = 0;
    for (int i = 0; i < n; i++)
    {
        if (hashTable[arr[i]] != 0)
        {
            for (int j = i; j < n; j++)
            {
                if (arr[j] % arr[i] == 0)
                {
                    hashTable[arr[j]] = 0;
                }
            }
            res++;
        }
    }
 
    return res;
}
 
// Driver program 
public static void Main(string[] args)
{
    int[] arr = new int[] {4, 6, 2, 8, 7, 21, 24, 49, 44};
    int n = arr.Length;
 
    Console.Write(minOperations(arr, n));
 
}
}
 
// This code is contributed by Shrikant13
PHP



<?php
// PHP implementation of the
// above approach
 
// function to find minimum operations
function minOperations(&$arr, $n)
{
    $hashTable = array();
     
    // sort array
    sort($arr);
 
    // prepare hash of array
    for ($i = 0; $i < $n; $i++)
        $hashTable[$arr[$i]]++;
 
    $res = 0;
    for ($i = 0; $i < $n; $i++)
    {
        if ($hashTable[$arr[$i]])
        {
            for ($j = $i; $j < $n; $j++)
                if ($arr[$j] % $arr[$i] == 0)
                    $hashTable[$arr[$j]] = 0;
            $res++;
        }
    }
 
    return $res;
}
 
// Driver Code
$arr = array(4, 6, 2, 8, 7, 21,
                    24, 49, 44);
$n = sizeof($arr);
 
echo minOperations($arr, $n);
 
// This code is contributed
// by Shivi_Aggarwal
?>
Javascript



<script>
 
// javascript implementation of the above approach
 
var MAX = 10000;
 
var hashTable = Array(MAX).fill(0);
 
// function to find minimum operations
function minOperations(arr, n)
{
    // sort array
    arr.sort((a,b)=>a-b);
 
    // prepare hash of array
    for (var i = 0; i < n; i++)
        hashTable[arr[i]]++;
 
    var res = 0;
    for (var i = 0; i < n; i++) {
        if (hashTable[arr[i]]) {
            for (var j = i; j < n; j++)
                if (arr[j] % arr[i] == 0)
                    hashTable[arr[j]] = 0;
            res++;
        }
    }
 
    return res;
}
 
// Driver program
var arr = [ 4, 6, 2, 8, 7, 21, 24, 49, 44 ];
var n = arr.length;
document.write( minOperations(arr, n));
 
</script>
Output: 
2
 
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
Previous
Check whether all the rotations of a given number is greater than or equal to the given number or not
Next

Python program to interchange first and last elements in a list
Recommended Articles
Page :
Minimum delete operations to make all elements of array same
09, Dec 16
Minimum operations required to make all Array elements divisible by K
02, Jul 20
Minimum operations required to make all elements of Array less than equal to 0
05, Jul 21
Minimum count of elements required to obtain the given Array by repeated mirror operations
31, Jul 20
Minimize count of given operations required to be performed to make all array elements equal to 1
13, Jan 21
Minimum number of given operations required to reduce the array to 0 element
07, May 19
Minimum number of steps required to obtain the given Array by the given operations
03, Aug 20
Minimum increment and decrement by K of each pair elements required to make all array elements equal
31, Jan 21
Minimum cost to convert one given string to another using swap, insert or delete operations
23, Nov 20
Minimum operations required to convert all characters of a String to a given Character
15, Aug 20
Minimum prefix increments required to make all elements of an array multiples of another array
31, Jan 21
Minimum number of operations required to reduce N to 1
13, Nov 18
Minimum number of given operations required to convert a permutation into an identity permutation
02, Apr 19
Minimum number of operations required to obtain a given Binary String
27, Jul 20
Minimum number of operations required to reduce N to 0
05, Aug 20
Minimum number of operations required to maximize the Binary String
14, Aug 20
Minimum number of operations required to make a permutation of first N natural numbers equal
18, May 21
Minimum swaps of similar indexed elements required to make all elements of one of the two given arrays equal
02, Dec 20
Minimum increment/decrement operations required on Array to satisfy given conditions
19, Aug 20
Make all the array elements odd with minimum operations of given type
13, Jan 20
Minimum operations to make all elements equal using the second array
07, May 20
Make all array elements equal by reducing array elements to half minimum number of times
31, Jan 21
Minimum steps required to reduce all the elements of the array to zero
10, Oct 19
Minimum increments or decrements by D required to make all array elements equal
13, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Shivam.Pradhan
@Shivam.Pradhan
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox