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: 5
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 = 5Input: arr[] = {1, 7, 9}
Output: 2
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++ 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 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 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# 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 |
<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> |
5
Time Complexity: O(Mlog(M) + N)
Auxiliary Space: O(M), where M is the maximum element in the given array.