Skip to content
Related Articles

Related Articles

Smallest number dividing minimum number of elements in the array | Set 2

View Discussion
Improve Article
Save Article
  • Last Updated : 22 Feb, 2022
View Discussion
Improve Article
Save Article

Given an array arr[] of N integers, the task is to find the smallest number that divides the minimum number of elements from the array.
Examples: 
 

Input: arr[] = {2, 12, 6} 
Output:
Here, 1 divides 3 elements 
2 divides 3 elements 
3 divides 2 elements 
4 divides 1 element 
5 divides no element 
6 divides 2 elements 
7 divides no element 
8 divides no element 
9 divides no element 
10 divides no element 
11 divides no element 
12 divides 1 element 
5 is the smallest number not dividing any 
number in the array. Thus, ans = 5
Input: arr[] = {1, 7, 9} 
Output:
 

Approach: Let’s observe some details first. A number that divides zero elements already exists i.e. max(arr) + 1. Now, we just need to find the minimum number which divides zero numbers in the array.
In this article, an approach to solving this problem in O(M*log(M) + N) time using a sieve (M = max(arr)) will be discussed. 
 

  • First, find the maximum element, M, in the array and create a frequency table freq[] of length M + 1 to store the frequency of the numbers between 1 to M.
  • Iterate the array and update freq[] as freq[arr[i]]++ for each index i.
  • Now, apply the sieve algorithm. Iterate between all the elements between 1 to M + 1
    • Let’s say we are iterating for a number X.
    • Create a temporary variable cnt.
    • For each multiple of X between X and M {X, 2X, 3X ….} update cnt as cnt = cnt + freq[kX].
    • If cnt = 0 then the answer will be X else continue iterating for the next value of X.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the smallest number
// that divides minimum number of elements
// in the given array
int findMin(int* arr, int n)
{
    // m stores the maximum in the array
    int m = 0;
    for (int i = 0; i < n; i++)
        m = max(m, arr[i]);
 
    // Frequency array
    int freq[m + 2] = { 0 };
    for (int i = 0; i < n; i++)
        freq[arr[i]]++;
 
    // Sieve
    for (int i = 1; i <= m + 1; i++) {
        int j = i;
        int cnt = 0;
         
        // Incrementing j
        while (j <= m) {
            cnt += freq[j];
            j += i;
        }
 
        // If no multiples of j are
        // in the array
        if (!cnt)
            return i;
    }
 
    return m + 1;
}
 
// Driver code
int main()
{
    int arr[] = { 2, 12, 6 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << findMin(arr, n);
     
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
     
    // Function to return the smallest number
    // that divides minimum number of elements
    // in the given array
    static int findMin(int arr[], int n)
    {
        // m stores the maximum in the array
        int m = 0;
        for (int i = 0; i < n; i++)
            m = Math.max(m, arr[i]);
     
        // Frequency array
        int freq [] = new int[m + 2];
        for (int i = 0; i < n; i++)
            freq[arr[i]]++;
     
        // Sieve
        for (int i = 1; i <= m + 1; i++)
        {
            int j = i;
            int cnt = 0;
             
            // Incrementing j
            while (j <= m)
            {
                cnt += freq[j];
                j += i;
            }
     
            // If no multiples of j are
            // in the array
            if (cnt == 0)
                return i;
        }
        return m + 1;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int arr[] = { 2, 12, 6 };
        int n = arr.length;
     
        System.out.println(findMin(arr, n));
    }
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of the approach
 
# Function to return the smallest number
# that divides minimum number of elements
# in the given array
def findMin(arr, n):
     
    # m stores the maximum in the array
    m = 0
    for i in range(n):
        m = max(m, arr[i])
 
    # Frequency array
    freq = [0] * (m + 2)
    for i in range(n):
        freq[arr[i]] += 1
 
    # Sieve
    for i in range(1, m + 2):
        j = i
        cnt = 0
 
        # Incrementing j
        while (j <= m):
            cnt += freq[j]
            j += i
 
        # If no multiples of j are
        # in the array
        if (not cnt):
            return i
 
    return m + 1
 
# Driver code
arr = [2, 12, 6]
n = len(arr)
 
print(findMin(arr, n))
 
# This code is contributed by Mohit Kumar

C#




// C# implementation of the approach
using System;
 
class GFG
{
     
    // Function to return the smallest number
    // that divides minimum number of elements
    // in the given array
    static int findMin(int []arr, int n)
    {
        // m stores the maximum in the array
        int m = 0;
        for (int i = 0; i < n; i++)
            m = Math.Max(m, arr[i]);
     
        // Frequency array
        int []freq = new int[m + 2];
        for (int i = 0; i < n; i++)
            freq[arr[i]]++;
     
        // Sieve
        for (int i = 1; i <= m + 1; i++)
        {
            int j = i;
            int cnt = 0;
             
            // Incrementing j
            while (j <= m)
            {
                cnt += freq[j];
                j += i;
            }
     
            // If no multiples of j are
            // in the array
            if (cnt == 0)
                return i;
        }
        return m + 1;
    }
     
    // Driver code
    public static void Main ()
    {
        int []arr = { 2, 12, 6 };
        int n = arr.Length;
     
        Console.WriteLine(findMin(arr, n));
    }
}
 
// This code is contributed by AnkitRai01

Javascript




<script>
 
// Javascript implementation of the approach
 
// Function to return the smallest number
// that divides minimum number of elements
// in the given array
function findMin(arr, n)
{
    // m stores the maximum in the array
    var m = 0;
    for (var i = 0; i < n; i++)
        m = Math.max(m, arr[i]);
 
    // Frequency array
    var freq = Array(m+2).fill(0);
    for (var i = 0; i < n; i++)
        freq[arr[i]]++;
 
    // Sieve
    for (var i = 1; i <= m + 1; i++) {
        var j = i;
        var cnt = 0;
         
        // Incrementing j
        while (j <= m) {
            cnt += freq[j];
            j += i;
        }
 
        // If no multiples of j are
        // in the array
        if (!cnt)
            return i;
    }
 
    return m + 1;
}
 
// Driver code
var arr = [2, 12, 6];
var n = arr.length;
document.write( findMin(arr, n));
 
</script>

Output:  

5

Time Complexity: O(Mlog(M) + N)

Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!