Find a number that divides maximum array elements
Last Updated :
05 May, 2025
Given an array A[] of N non-negative integers. Find an Integer greater than 1, such that maximum array elements are divisible by it. In case of same answer print the smaller one.
Examples:
Input : A[] = { 2, 4, 5, 10, 8, 15, 16 };
Output : 2
Explanation: 2 divides [ 2, 4, 10, 8, 16] no other element divides greater than 5 numbers.'
Input : A[] = { 2, 5, 10 }
Output : 2
Explanation: 2 divides [2, 10] and 5 divides [5, 10], but 2 is smaller.
Brute Force Approach:
Brute force approach to solve this problem would be to iterate over all the numbers from 2 to the maximum element in the array and check if each number is a factor of all the elements in the array. We can keep track of the number that has the maximum number of factors and return that number.
Below is the implementation of the above approach:
C++
// CPP program to find a number that
// divides maximum array elements
#include <bits/stdc++.h>
using namespace std;
// Function to find a number that
// divides maximum array elements
int maxElement(int A[], int n)
{
int maxCount = 0, ans = 0;
for (int i = 2; i <= *max_element(A, A + n); i++) {
int count = 0;
for (int j = 0; j < n; j++) {
if (A[j] % i == 0) {
count++;
}
}
if (count > maxCount) {
maxCount = count;
ans = i;
}
}
return ans;
}
// Driver program
int main()
{
int A[] = { 2, 4, 5, 10, 8, 15, 16 };
int n = sizeof(A) / sizeof(A[0]);
cout << maxElement(A, n);
return 0;
}
import java.util.*;
class Main
{
// Function to find a number that
// divides maximum array elements
static int maxElement(int[] A, int n) {
int maxCount = 0, ans = 0;
for (int i = 2; i <= Arrays.stream(A).max().getAsInt(); i++) {
int count = 0;
for (int j = 0; j < n; j++) {
if (A[j] % i == 0) {
count++;
}
}
if (count > maxCount) {
maxCount = count;
ans = i;
}
}
return ans;
}
// Driver program
public static void main(String[] args) {
int[] A = { 2, 4, 5, 10, 8, 15, 16 };
int n = A.length;
System.out.println(maxElement(A, n));
}
}
# Python program to find a number that
# divides maximum array elements
import sys
# Function to find a number that
# divides maximum array elements
def maxElement(A, n):
maxCount = 0
ans = 0
for i in range(2, max(A) + 1):
count = 0
for j in range(n):
if A[j] % i == 0:
count += 1
if count > maxCount:
maxCount = count
ans = i
return ans
# Driver program
if __name__ == '__main__':
A = [2, 4, 5, 10, 8, 15, 16]
n = len(A)
print(maxElement(A, n))
using System;
using System.Linq;
public class Program
{
// Function to find a number that
// divides maximum array elements
public static int MaxElement(int[] A, int n)
{
int maxCount = 0, ans = 0;
for (int i = 2; i <= A.Max(); i++)
{
int count = 0;
for (int j = 0; j < n; j++)
{
if (A[j] % i == 0)
{
count++;
}
}
if (count > maxCount)
{
maxCount = count;
ans = i;
}
}
return ans;
}
// Driver program
public static void Main()
{
int[] A = { 2, 4, 5, 10, 8, 15, 16 };
int n = A.Length;
Console.WriteLine(MaxElement(A, n));
}
}
// Function to find a number that
// divides maximum array elements
function maxElement(A) {
let maxCount = 0;
let ans = 0;
for (let i = 2; i <= Math.max(...A); i++) {
let count = 0;
for (let j = 0; j < A.length; j++) {
if (A[j] % i === 0) {
count++;
}
}
if (count > maxCount) {
maxCount = count;
ans = i;
}
}
return ans;
}
// Driver program
const A = [2, 4, 5, 10, 8, 15, 16];
const n = A.length;
console.log(maxElement(A));
Output: 2
Time Complexity: O(N^2)
Space Complexity: O(1)
Efficient Approach: We know that a number can be divisible only by elements which can be formed by their prime factors.
Thus we find the prime factors of all elements of the array and store their frequency in the hash. Finally, we return the element with maximum frequency among them.
You can use factorization-using-sieve to find prime factors in Log(n).
Below is the implementation of above approach:
C++
// CPP program to find a number that
// divides maximum array elements
#include <bits/stdc++.h>
using namespace std;
#define MAXN 100001
// stores smallest prime factor for every number
int spf[MAXN];
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
void sieve()
{
spf[1] = 1;
for (int i = 2; i < MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (int i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (int i = 3; i * i < MAXN; i++) {
// checking if i is prime
if (spf[i] == i) {
// marking SPF for all numbers divisible by i
for (int j = i * i; j < MAXN; j += i)
// marking spf[j] if it is not
// previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// A O(log n) function returning primefactorization
// by dividing by smallest prime factor at every step
vector<int> getFactorization(int x)
{
vector<int> ret;
while (x != 1) {
int temp = spf[x];
ret.push_back(temp);
while (x % temp == 0)
x = x / temp;
}
return ret;
}
// Function to find a number that
// divides maximum array elements
int maxElement(int A[], int n)
{
// precalculating Smallest Prime Factor
sieve();
// Hash to store frequency of each divisors
map<int, int> m;
// Traverse the array and get spf of each element
for (int i = 0; i < n; ++i) {
// calling getFactorization function
vector<int> p = getFactorization(A[i]);
for (int i = 0; i < p.size(); i++)
m[p[i]]++;
}
int cnt = 0, ans = 1e+7;
for (auto i : m) {
if (i.second >= cnt) {
cnt = i.second;
ans > i.first ? ans = i.first : ans = ans;
}
}
return ans;
}
// Driver program
int main()
{
int A[] = { 2, 5, 10 };
int n = sizeof(A) / sizeof(A[0]);
cout << maxElement(A, n);
return 0;
}
// Java program to find a number that
// divides maximum array elements
import java.util.*;
class Solution
{
static final int MAXN=100001;
// stores smallest prime factor for every number
static int spf[]= new int[MAXN];
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
static void sieve()
{
spf[1] = 1;
for (int i = 2; i < MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (int i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (int i = 3; i * i < MAXN; i++) {
// checking if i is prime
if (spf[i] == i) {
// marking SPF for all numbers divisible by i
for (int j = i * i; j < MAXN; j += i)
// marking spf[j] if it is not
// previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// A O(log n) function returning primefactorization
// by dividing by smallest prime factor at every step
static Vector<Integer> getFactorization(int x)
{
Vector<Integer> ret= new Vector<Integer>();
while (x != 1) {
int temp = spf[x];
ret.add(temp);
while (x % temp == 0)
x = x / temp;
}
return ret;
}
// Function to find a number that
// divides maximum array elements
static int maxElement(int A[], int n)
{
// precalculating Smallest Prime Factor
sieve();
// Hash to store frequency of each divisors
Map<Integer, Integer> m= new HashMap<Integer, Integer>();
// Traverse the array and get spf of each element
for (int j = 0; j < n; ++j) {
// calling getFactorization function
Vector<Integer> p = getFactorization(A[j]);
for (int i = 0; i < p.size(); i++)
m.put(p.get(i),m.get(p.get(i))==null?0:m.get(p.get(i))+1);
}
int cnt = 0, ans = 10000000;
// Returns Set view
Set< Map.Entry< Integer,Integer> > st = m.entrySet();
for (Map.Entry< Integer,Integer> me:st)
{
if (me.getValue() >= cnt) {
cnt = me.getValue();
if(ans > me.getKey())
ans = me.getKey() ;
else
ans = ans;
}
}
return ans;
}
// Driver program
public static void main(String args[])
{
int A[] = { 2, 5, 10 };
int n =A.length;
System.out.print(maxElement(A, n));
}
}
//contributed by Arnab Kundu
# Python3 program to find a number that
# divides maximum array elements
import math as mt
MAXN = 100001
# stores smallest prime factor for
# every number
spf = [0 for i in range(MAXN)]
# Calculating SPF (Smallest Prime Factor)
# for every number till MAXN.
# Time Complexity : O(nloglogn)
def sieve():
spf[1] = 1
for i in range(2, MAXN):
# marking smallest prime factor for
# every number to be itself.
spf[i] = i
# separately marking spf for every
# even number as 2
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, mt.ceil(mt.sqrt(MAXN + 1))):
# checking if i is prime
if (spf[i] == i):
# marking SPF for all numbers divisible by i
for j in range(2 * i, MAXN, i):
# marking spf[j] if it is not
# previously marked
if (spf[j] == j):
spf[j] = i
# A O(log n) function returning primefactorization
# by dividing by smallest prime factor at every step
def getFactorization (x):
ret = list()
while (x != 1):
temp = spf[x]
ret.append(temp)
while (x % temp == 0):
x = x //temp
return ret
# Function to find a number that
# divides maximum array elements
def maxElement (A, n):
# precalculating Smallest Prime Factor
sieve()
# Hash to store frequency of each divisors
m = dict()
# Traverse the array and get spf of each element
for i in range(n):
# calling getFactorization function
p = getFactorization(A[i])
for i in range(len(p)):
if p[i] in m.keys():
m[p[i]] += 1
else:
m[p[i]] = 1
cnt = 0
ans = 10**9+7
for i in m:
if (m[i] >= cnt):
cnt = m[i]
if ans > i:
ans = i
else:
ans = ans
return ans
# Driver Code
A = [2, 5, 10 ]
n = len(A)
print(maxElement(A, n))
# This code is contributed by Mohit kumar 29
// C# program to find a number that
// divides maximum array elements
using System;
using System.Collections.Generic;
class Solution
{
static readonly int MAXN = 100001;
// stores smallest prime factor for every number
static int []spf = new int[MAXN];
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
static void sieve()
{
spf[1] = 1;
for (int i = 2; i < MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (int i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (int i = 3; i * i < MAXN; i++)
{
// checking if i is prime
if (spf[i] == i)
{
// marking SPF for all numbers divisible by i
for (int j = i * i; j < MAXN; j += i)
// marking spf[j] if it is not
// previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// A O(log n) function returning primefactorization
// by dividing by smallest prime factor at every step
static List<int> getFactorization(int x)
{
List<int> ret= new List<int>();
while (x != 1)
{
int temp = spf[x];
ret.Add(temp);
while (x % temp == 0)
x = x / temp;
}
return ret;
}
// Function to find a number that
// divides maximum array elements
static int maxElement(int []A, int n)
{
// precalculating Smallest Prime Factor
sieve();
// Hash to store frequency of each divisors
Dictionary<int, int> m= new Dictionary<int, int>();
// Traverse the array and get spf of each element
for (int j = 0; j < n; ++j)
{
// calling getFactorization function
List<int> p = getFactorization(A[j]);
for (int i = 0; i < p.Count; i++)
if(m.ContainsKey(p[i]))
m[p[i]] = m[p[i]] + 1;
else
m.Add(p[i], 1);
}
int cnt = 0, ans = 10000000;
// Returns Set view
foreach(KeyValuePair<int, int> me in m)
{
if (me.Value >= cnt)
{
cnt = me.Value;
if(ans > me.Key)
ans = me.Key ;
else
ans = ans;
}
}
return ans;
}
// Driver program
public static void Main(String []args)
{
int []A = { 2, 5, 10 };
int n =A.Length;
Console.Write(maxElement(A, n));
}
}
// This code is contributed by 29AjayKumar
<script>
// JavaScript program to find a number that
// divides maximum array elements
let MAXN=100001;
// stores smallest prime factor for every number
let spf= new Array(MAXN);
for(let i=0;i<MAXN;i++)
{
spf[i]=0;
}
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
function sieve()
{
spf[1] = 1;
for (let i = 2; i < MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (let i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (let i = 3; i * i < MAXN; i++) {
// checking if i is prime
if (spf[i] == i) {
// marking SPF for all numbers divisible by i
for (let j = i * i; j < MAXN; j += i)
// marking spf[j] if it is not
// previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// A O(log n) function returning primefactorization
// by dividing by smallest prime factor at every step
function getFactorization(x)
{
let ret= [];
while (x != 1) {
let temp = spf[x];
ret.push(temp);
while (x % temp == 0)
x = Math.floor(x / temp);
}
return ret;
}
// Function to find a number that
// divides maximum array elements
function maxElement(A,n)
{
// precalculating Smallest Prime Factor
sieve();
// Hash to store frequency of each divisors
let m= new Map();
// Traverse the array and get spf of each element
for (let j = 0; j < n; ++j) {
// calling getFactorization function
let p = getFactorization(A[j]);
for (let i = 0; i < p.length; i++)
m.set(p[i],m.get(p[i])==null?0:m.get(p[i])+1);
}
let cnt = 0, ans = 10000000;
// Returns Set view
for (let [key, value] of m.entries())
{
if (value >= cnt) {
cnt = value;
if(ans > key)
ans = key ;
else
ans = ans;
}
}
return ans;
}
// Driver program
let A=[ 2, 5, 10];
let n =A.length;
document.write(maxElement(A, n));
// This code is contributed by patel2127
</script>
Time Complexity:O(N*log(N))
Similar Reads
Find all numbers that divide maximum array elements
Given an array of N numbers, the task is to print all the numbers greater than 1 which divides the maximum of array elements. Examples: Input: a[] = {6, 6, 12, 18, 13} Output: 2 3 6 All the numbers divide the maximum of array elements i.e., 4 Input: a[] = {12, 15, 27, 20, 40} Output: 2 3 4 5 Approac
7 min read
Find integers that divides maximum number of elements of the array
Given an array arr[] of integers, the task is to find the element (other than 1) which is the factor of the maximum number of elements in the array. If multiple such factors exist, print all the factors in ascending order. Examples: Input: arr[] = {10, 20} Output: 2 5 10 The factors of 10 are 1, 2,
7 min read
Find the maximum number of elements divisible by 3
Given an array of size N. The task to find the maximum possible number of elements divisible by 3 that are in the array after performing the operation an arbitrary (possibly, zero) number of times. In each operation, one can add any two elements of the array. Examples: Input : a[] = {1, 2, 3} Output
6 min read
Largest number dividing maximum number of elements in the array
Given an array arr[] of length N, the task is to find the largest number dividing the maximum number of elements from the array. Examples: Input: arr[] = {2, 12, 6} Output: 2 1 and 2 are the only integers which divide the maximum number of elements from the array (i.e. all the elements) and 2 is the
4 min read
Find element in array that divides all array elements
Given an array of n non-negative integers. Find such element in the array, that all array elements are divisible by it. Examples : Input : arr[] = {2, 2, 4}Output : 2 Input : arr[] = {2, 1, 3, 1, 6}Output : 1 Input: arr[] = {2, 3, 5}Output : -1 Brute Force Approach: The brute force approach to solve
7 min read
Maximize array elements upto given number
Given an array of integers, a number and a maximum value, task is to compute the maximum value that can be obtained from the array elements. Every value on the array traversing from the beginning can be either added to or subtracted from the result obtained from previous index such that at any point
15+ min read
Maximum sum of elements divisible by K from the given array
Given an array of integers and a number K. The task is to find the maximum sum which is divisible by K from the given array.Examples: Input: arr[] = {3, 6, 5, 1, 8}, k = 3 Output: 18 Explanation: 18 is formed by the elements 3, 6, 1, 8.Input: arr = { 43, 1, 17, 26, 15 } , k = 16 Output: 32 Explanati
15 min read
Maximum value of division of two numbers in an Array
Given an array A of size N (> 2). The task is to find the maximum value of A[i] / A[j]Note: A[i] ? 0. Examples: Input : A[] = {1, 2, 3, 4} Output : 4 4 / 1 = 4 is maximum possible value. Input : A[] = {3, 7, 9, 3, 11} Output : 3 Naive Approach: A naive approach is to run nested loops and find the
4 min read
Smallest number dividing minimum number of elements in the array | Set 2
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 divide
6 min read
Smallest number dividing minimum number of elements in the Array
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
6 min read