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

• Last Updated : 22 Feb, 2022

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 ``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

 ``

Output:

`5`

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

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up