Find integers that divides maximum number of elements of the array
Last Updated :
15 Sep, 2022
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++
#include<bits/stdc++.h>
using namespace std;
void maximumFactor(vector< int >arr)
{
int n = arr.size();
vector< int > rank;
vector< int > factors;
int max = *max_element(arr.begin(), arr.end());
for ( int i = 2; i <= max; i++)
{
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);
}
}
int m = *max_element(rank.begin(),rank.end());
for ( int i = 0; i < rank.size(); i++)
{
if (rank[i] == m)
cout << factors[i] << " " ;
}
}
int main()
{
vector< int >arr = {120, 15, 24, 63, 18};
maximumFactor(arr);
}
|
Java
import java.util.*;
class GFG
{
static void maximumFactor( int []arr)
{
int [] rank = new int [Arrays.stream(arr).max().getAsInt() + 1 ];
int [] factors = new int [Arrays.stream(arr).max().getAsInt() + 1 ];
int g = 0 ;
for ( int i = 2 ;
i <= Arrays.stream(arr).max().getAsInt(); i++)
{
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++;
}
int m = Arrays.stream(rank).max().getAsInt();
for ( int i = 0 ; i < rank.length; i++)
{
if (rank[i] == m)
System.out.print(factors[i] + " " );
}
}
public static void main (String[] args)
{
int []arr = { 120 , 15 , 24 , 63 , 18 };
maximumFactor(arr);
}
}
|
Python
def maximumFactor(arr):
rank, factors = [], []
for i in range ( 2 , max (arr) + 1 ):
count = 0
for j in arr:
if j % i = = 0 :count + = 1
rank.append(count)
factors.append(i)
m = max (rank)
for i in range ( len (rank)):
if rank[i] = = m:
print (factors[i], end = " " )
arr = [ 120 , 15 , 24 , 63 , 18 ]
maximumFactor(arr)
|
C#
using System;
using System.Collections;
using System.Linq;
class GFG
{
static void maximumFactor( int []arr)
{
int [] rank = new int [arr.Max() + 1];
int [] factors = new int [arr.Max() + 1];
int g = 0;
for ( int i = 2; i <= arr.Max(); i++)
{
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++;
}
int m = rank.Max();
for ( int i = 0; i < rank.Length; i++)
{
if (( int )rank[i] == m)
Console.Write(factors[i]+ " " );
}
}
static void Main()
{
int []arr = {120, 15, 24, 63, 18};
maximumFactor(arr);
}
}
|
PHP
<?php
function maximumFactor( $arr )
{
$rank = array ();
$factors = array ();
for ( $i = 2; $i <= max( $arr ); $i ++)
{
$count = 0 ;
for ( $j = 0; $j < sizeof( $arr ); $j ++)
if ( $arr [ $j ] % $i == 0)
$count += 1;
array_push ( $rank , $count );
array_push ( $factors , $i );
}
$m = max( $rank );
for ( $i = 0; $i < sizeof( $rank ); $i ++)
{
if ( $rank [ $i ] == $m )
echo $factors [ $i ], " " ;
}
}
$arr = array (120, 15, 24, 63, 18);
maximumFactor( $arr )
?>
|
Javascript
<script>
function maximumFactor(arr)
{
var n = arr.length;
var rank = [];
var factors = [];
var max = arr.reduce((a,b)=> Math.max(a,b));
for ( var i = 2; i <= max; i++)
{
var count = 0;
for ( var j = 0; j < n; j++)
{
if (arr[j] % i == 0)
count+= 1;
rank.push(count);
factors.push(i);
}
}
var m = rank.reduce((a,b)=>Math.max(a,b));
for ( var i = 0; i < rank.length; i++)
{
if (rank[i] == m)
document.write( factors[i] + " " );
}
}
var arr = [120, 15, 24, 63, 18];
maximumFactor(arr);
</script>
|
Complexity Analysis:
- Time Complexity: O(n * max(arr)), where max(arr) is the largest element of the array arr.
- Auxiliary Space: O(n * max(arr))
Share your thoughts in the comments
Please Login to comment...