Find all numbers that divide maximum array elements

Last Updated : 11 Jul, 2025

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

Approach:

Use hashing to store the count of all the factors of every array element. We can find all the factors of number in O(sqrt N).
Traverse for all factors, and find the count of maximum array elements which are divided by numbers.
Again re-traverse for all factors and print the factors that occur the maximum number of times.

Below is the implementation of the above approach.

C++

// C++ program to print all the numbers
// that divides maximum of array elements
#include <bits/stdc++.h>
using namespace std;

// Function that prints all the numbers
// which divides maximum of array elements
void printNumbers(int a[], int n)
{

    // hash to store the number of times
    // a factor is there
    unordered_map<int, int> mpp;

    for (int i = 0; i < n; i++) {
        int num = a[i];

        // find all the factors
        for (int j = 1; j * j <= num; j++) {

            // if j is factor of num
            if (num % j == 0) {
                if (j != 1)
                    mpp[j]++;

                if ((num / j) != j)
                    mpp[num / j]++;
            }
        }
    }

    // find the maximum times
    // it can divide
    int maxi = 0;
    for (auto it : mpp) {
        maxi = max(it.second, maxi);
    }

    // print all the factors of
    // numbers which divides the
    // maximum array elements
    for (auto it : mpp) {
        if (it.second == maxi)
            cout << it.first << " ";
    }
}

// Driver Code
int main()
{

    int a[] = { 12, 15, 27, 20, 40 };
    int n = sizeof(a) / sizeof(a[0]);
    printNumbers(a, n);
}

Java

// Java program to print all the numbers
// that divides maximum of array elements
import java.util.*;

class GFG
{
    
// Function that prints all the numbers
// which divides maximum of array elements
static void printNumbers(int a[], int n)
{

    // hash to store the number of times
    // a factor is there
    Map<Integer, 
        Integer> mpp = new HashMap<>();

    for (int i = 0; i < n; i++) 
    {
        int num = a[i];

        // find all the factors
        for (int j = 1; j * j <= num; j++) 
        {

            // if j is factor of num
            if (num % j == 0) 
            {
                if (j != 1)
                {
                    if(mpp.containsKey(j))
                    {
                        mpp.put(j, mpp.get(j) + 1);
                    }
                    else
                    {
                        mpp.put(j, 1);
                    }
                }
                
                if ((num / j) != j)
                {
                    if(mpp.containsKey(num / j))
                    {
                        mpp.put(num / j, mpp.get(num / j) + 1);
                    }
                    else
                    {
                        mpp.put(num / j, 1);
                    }
                }
            }
        }
    }

    // find the maximum times
    // it can divide
    int maxi = 0;
    for (Map.Entry<Integer,
                   Integer> it : mpp.entrySet())
    {
        maxi = Math.max(it.getValue(), maxi);
    }

    // print all the factors of
    // numbers which divides the
    // maximum array elements
    for (Map.Entry<Integer,
                   Integer> it : mpp.entrySet())
    {
        if (it.getValue() == maxi)
            System.out.print(it.getKey() + " ");
    }
}

// Driver Code
public static void main(String[] args) 
{
    int a[] = { 12, 15, 27, 20, 40 };
    int n = a.length;
    printNumbers(a, n);
}
}

// This code is contributed by Princi Singh

Python3

# Python3 program to print all the numbers
# that divides maximum of array elements

# Function that prints all the numbers
# which divides maximum of array elements
def printNumbers(a, n):

    # hash to store the number of times
    # a factor is there
    mpp = dict()

    for i in range(n):
        num = a[i]

        # find all the factors
        for j in range(1, num + 1):

            if j * j > num:
                break

            # if j is factor of num
            if (num % j == 0):
                if (j != 1):
                    mpp[j]=mpp.get(j, 0) + 1

                if ((num // j) != j):
                    mpp[num // j]=mpp.get(num//j, 0) + 1
            
    # find the maximum times
    # it can divide
    maxi = 0
    for it in mpp:
        maxi = max(mpp[it], maxi)

    # print all the factors of
    # numbers which divides the
    # maximum array elements
    for it in mpp:
        if (mpp[it] == maxi):
            print(it,end=" ")
    
# Driver Code
a = [12, 15, 27, 20, 40 ]
n = len(a)
printNumbers(a, n)

# This code is contributed by mohit kumar

// C# program to print all the numbers
// that divides maximum of array elements
using System;
using System.Collections.Generic; 

class GFG
{
    
// Function that prints all the numbers
// which divides maximum of array elements
static void printNumbers(int []a, int n)
{

    // hash to store the number of times
    // a factor is there
    Dictionary<int,int> mpp = new Dictionary<int,int>();

    for (int i = 0; i < n; i++) 
    {
        int num = a[i];

        // find all the factors
        for (int j = 1; j * j <= num; j++) 
        {

            // if j is factor of num
            if (num % j == 0) 
            {
                if (j != 1)
                {
                    if(mpp.ContainsKey(j))
                    {
                        var v = mpp[j];
                        mpp.Remove(j);
                        mpp.Add(j, v + 1);
                    }
                    else
                    {
                        mpp.Add(j, 1);
                    }
                }
                
                if ((num / j) != j)
                {
                    if(mpp.ContainsKey(num / j))
                    {
                        var v = mpp[num/j];
                        mpp.Remove(num/j);
                        mpp.Add(num / j, v + 1);
                    }
                    else
                    {
                        mpp.Add(num / j, 1);
                    }
                }
            }
        }
    }

    // find the maximum times
    // it can divide
    int maxi = 0;
    foreach(KeyValuePair<int, int> it in mpp)
    {
        maxi = Math.Max(it.Value, maxi);
    }

    // print all the factors of
    // numbers which divides the
    // maximum array elements
    foreach(KeyValuePair<int, int> it in mpp)
    {
        if (it.Value == maxi)
            Console.Write(it.Key + " ");
    }
}

// Driver Code
public static void Main(String[] args) 
{
    int []a = { 12, 15, 27, 20, 40 };
    int n = a.Length;
    printNumbers(a, n);
}
}

// This code is contributed by 29AjayKumar

JavaScript

<script>

// JavaScript program to print all the numbers
// that divides maximum of array elements

// Function that prints all the numbers
// which divides maximum of array elements
function printNumbers(a, n)
{

    // hash to store the number of times
    // a factor is there
    var mpp = new Map();

    for (var i = 0; i < n; i++) {
        var num = a[i];

        // find all the factors
        for (var j = 1; j * j <= num; j++) {

            // if j is factor of num
            if (num % j == 0) {
                if (j != 1)
                {
                    if(mpp.has(j))
                        mpp.set(j, mpp.get(j)+1)
                    else    
                        mpp.set(j, 1)
                }

                if ((num / j) != j)
                {
                    if(mpp.has(parseInt(num / j)))
                        mpp.set(parseInt(num / j), 
                        mpp.get(parseInt(num / j))+1)
                    else    
                        mpp.set(parseInt(num / j), 1)
                }
            }
        }
    }

    // find the maximum times
    // it can divide
    var maxi = 0;

    mpp.forEach((value, key) => {
        maxi = Math.max(value, maxi);
    });

    // print all the factors of
    // numbers which divides the
    // maximum array elements
    mpp.forEach((value,key) => {
        
        if (value == maxi)
        {
            document.write(key+ " ");
        }
    });
}

// Driver Code
var a = [12, 15, 27, 20, 40];
var n = a.length;
printNumbers(a, n);


</script>

Output

2 3 5 4

Complexity Analysis:

Time Complexity: O(N * sqrt(max(array element))), as we are using nested loops where the outer loop traverses N times and in the inner loop, the condition is j*j<=num, square rooting both the sides we will have j<=sqrt(num), so the inner loop traverses sqrt (num) times. Where N is the number of elements in the array and num is the maximum element of the array.
Auxiliary Space: O(N * sqrt(max(array element))), as we are using extra space for the map.

Find element in array that divides all array elements

Striver

Improve

Article Tags :

Find all numbers that divide maximum array elements

Similar Reads

Thank You!

What kind of Experience do you want to share?