Skip to content
Related Articles

Related Articles

Improve Article

Find integers that divides maximum number of elements of the array

  • Difficulty Level : Easy
  • Last Updated : 21 May, 2021
Geek Week

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, 5, 10. 
The factors of 20 are 1, 2, 4, 5, 10, 20. 
The factors other than 1, which occur the most times (twice) are 2, 5, 10.

Input: arr[] = {120, 15, 24, 63, 18} 
Output: 3 

Approach:  



  • Initialize two lists, one to store the rank (the number of elements that the integer is a factor of) of the factor and another to store the factor.
  • Start from 2 till the maximum element of the array.
  • Count the number of elements in the array. The current integer is a factor of.
  • Add the count to the rank list and the integers to the factor list.
  • Find the integer with the maximum rank.
  • Print all the elements with the same rank.

Below is the implementation of the above approach: 

C++




// CPP implementation of the approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to print the integers that divide
// the maximum number of elements from the array
void maximumFactor(vector<int>arr)
{
    // Initialize two lists
    // to store rank and factors
    int n = arr.size();
    vector<int> rank;
    vector<int> factors;
    int max = *max_element(arr.begin(), arr.end());
     
    // Start from 2 till the maximum element in arr
    for (int i = 2; i <= max; i++)
    {
        // Initialize a variable
        // to count the number of elements
        // it is a factor of
        int count = 0;
        for (int j = 0; j < n; j++)
        {
            if (arr[j] % i == 0)
                count+= 1;
            rank.push_back(count);
            factors.push_back(i);
        }
         
    }
         
         
     
    // Maximum rank in the rank list
    int m = *max_element(rank.begin(),rank.end());
    for (int i = 0; i < rank.size(); i++)
    {
        // Print all the elements with rank m
        if (rank[i] == m)
            cout << factors[i] <<" ";
    }
         
}
 
// Driver code
int main()
{
    vector<int>arr = {120, 15, 24, 63, 18};
    maximumFactor(arr);
}
 
// This code is contributed by
// Surendra_Gangwar
Java



// Java implementation of the approach
import java.util.*;
class GFG
{
     
// Function to print the integers that
// divide the maximum number of
// elements from the array
static void maximumFactor(int []arr)
{
     
    // Initialize two lists to store
    // rank and factors
    int[] rank = new int[Arrays.stream(arr).max().getAsInt() + 1];
    int[] factors = new int[Arrays.stream(arr).max().getAsInt() + 1];
    int g = 0;
     
    // Start from 2 till the maximum
    // element in arr
    for (int i = 2;
             i <= Arrays.stream(arr).max().getAsInt(); i++)
    {
        // Initialize a variable to count
        // the number of elements it is a
        // factor of
        int count = 0;
        for (int j = 0; j < arr.length; j++)
            if (arr[j] % i == 0)
                count += 1;
                 
        rank[g] = count;
        factors[g] = i;
        g++;
    }
     
    // Maximum rank in the rank list
    int m = Arrays.stream(rank).max().getAsInt();
    for (int i = 0; i < rank.length; i++)
    {
        // Print all the elements with rank m
        if (rank[i] == m)
            System.out.print(factors[i] + " ");
    }
}
 
// Driver code
public static void main (String[] args)
{
    int []arr = {120, 15, 24, 63, 18};
    maximumFactor(arr);
}
}
 
// This code is contributed by
// chandan_jnu
Python



# Python3 implementation of the approach
 
# Function to print the integers that divide
# the maximum number of elements from the array
def maximumFactor(arr):
     
    # Initialize two lists
    # to store rank and factors
    rank, factors = [], []
     
    # Start from 2 till the maximum element in arr
    for i in range(2, max(arr)+1):
         
        # Initialize a variable
        # to count the number of elements
        # it is a factor of
        count = 0
        for j in arr:
            if j % i == 0:count+= 1
        rank.append(count)
        factors.append(i)
     
    # Maximum rank in the rank list
    m = max(rank)
    for i in range(len(rank)):
         
        # Print all the elements with rank m
        if rank[i]== m:
            print(factors[i], end =" ")
 
# Driver code
arr = [120, 15, 24, 63, 18]
 
maximumFactor(arr)
C#



// C# implementation of the approach
using System;
using System.Collections;
using System.Linq;
 
class GFG
{
     
// Function to print the integers that
// divide the maximum number of
// elements from the array
static void maximumFactor(int []arr)
{
     
    // Initialize two lists to store
    // rank and factors
    int[] rank = new int[arr.Max() + 1];
    int[] factors = new int[arr.Max() + 1];
    int g = 0;
     
    // Start from 2 till the maximum
    // element in arr
    for (int i = 2; i <= arr.Max(); i++)
    {
        // Initialize a variable to count
        // the number of elements it is a
        // factor of
        int count = 0 ;
        for (int j = 0; j < arr.Length; j++)
            if (arr[j] % i == 0)
                count += 1;
                 
        rank[g]=count;
        factors[g]=i;
        g++;
    }
     
    // Maximum rank in the rank list
    int m = rank.Max();
    for (int i = 0; i < rank.Length; i++)
    {
        // Print all the elements with rank m
        if ((int)rank[i] == m)
            Console.Write(factors[i]+" ");
    }
}
 
// Driver code
static void Main()
{
 
int []arr = {120, 15, 24, 63, 18};
maximumFactor(arr);
}
}
 
// This code is contributed by chandan_jnu
PHP



<?php
// PHP implementation of the approach
 
// Function to print the integers that
// divide the maximum number of
// elements from the array
function maximumFactor($arr)
{
     
    // Initialize two lists to store
    // rank and factors
    $rank = array();
    $factors = array();
     
    // Start from 2 till the maximum
    // element in arr
    for ($i = 2; $i <= max($arr); $i++)
    {
        // Initialize a variable to count
        // the number of elements it is a
        // factor of
        $count = 0 ;
        for ($j = 0; $j < sizeof($arr); $j++)
            if ($arr[$j] % $i == 0)
                $count += 1;
                 
        array_push($rank, $count);
        array_push($factors, $i);
    }
     
    // Maximum rank in the rank list
    $m = max($rank);
    for ($i = 0; $i < sizeof($rank); $i++)
    {
        // Print all the elements with rank m
        if ($rank[$i] == $m)
            echo $factors[$i], " ";
    }
}
 
// Driver code
$arr = array(120, 15, 24, 63, 18);
 
maximumFactor($arr)
 
// This code is contributed by Ryuga
?>
Javascript



<script>
 
// Javascript implementation of the approach
 
// Function to print the integers that divide
// the maximum number of elements from the array
function maximumFactor(arr)
{
    // Initialize two lists
    // to store rank and factors
    var n = arr.length;
    var rank = [];
    var factors = [];
    var max = arr.reduce((a,b)=> Math.max(a,b));
     
    // Start from 2 till the maximum element in arr
    for (var i = 2; i <= max; i++)
    {
        // Initialize a variable
        // to count the number of elements
        // it is a factor of
        var count = 0;
        for (var j = 0; j < n; j++)
        {
            if (arr[j] % i == 0)
                count+= 1;
            rank.push(count);
            factors.push(i);
        }
         
    }
         
         
     
    // Maximum rank in the rank list
    var m = rank.reduce((a,b)=>Math.max(a,b));
    for (var i = 0; i < rank.length; i++)
    {
        // Print all the elements with rank m
        if (rank[i] == m)
            document.write( factors[i] + " ");
    }
         
}
 
// Driver code
var arr = [120, 15, 24, 63, 18];
maximumFactor(arr);
 
 
</script>
Output: 
3
 
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Previous
Find a number that divides maximum array elements
Next

Find element in array that divides all array elements
Recommended Articles
Page :
Find two co-prime integers such that the first divides A and the second divides B
09, Sep 19
Count of triplets (a, b, c) in the Array such that a divides b and b divides c
13, May 20
Find a number that divides maximum array elements
19, Nov 18
Find element in array that divides all array elements
22, Nov 17
Find maximum power of a number that divides a factorial
14, Jan 18
Find the index of the element in an array which divides most elements before it
09, Jan 20
Smallest positive integer that divides all array elements to generate quotients with sum not exceeding K
18, Dec 20
Find the largest composite number that divides N but is strictly lesser than N
18, Mar 20
Find the Smallest number that divides X^X
26, Apr 20
Find an element which divides the array in two subarrays with equal product
28, Jun 18
Check if a M-th fibonacci number divides N-th fibonacci number
11, Jul 18
Highest power of a number that divides other number
22, Apr 19
Count of prime digits of a Number which divides the number
03, Apr 20
Partitions possible such that the minimum element divides all the other elements of the partition
20, Jan 20
Legendre's formula (Given p and n, find the largest x such that p^x divides n!)
02, Jun 15
Find a distinct pair (x, y) in given range such that x divides y
13, Mar 19
Find the last digit when factorial of A divides factorial of B
08, Oct 17
Greatest divisor which divides all natural number in range [L, R]
04, Jan 19
Largest number that divides x and is co-prime with y
14, Dec 17
Check if the sum of digits of a number N divides it
25, Oct 18
Minimum value that divides one number and divisible by other
21, Dec 18
Check if a given number divides the sum of the factorials of its digits
01, Apr 19
Highest power of 2 that divides a number represented in binary
23, Apr 19
Count of pairs in an array such that the highest power of 2 that divides their product is 1
29, Oct 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
SanjayR
@SanjayR
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox