Maximum GCD of N integers with given product

• Last Updated : 20 May, 2021

Given N integers with unknown values (ai > 0) having product P. The task is to find the maximum possible greatest common divisor of these N integers.
Examples:

Input : N = 3, P = 24
Output : 2
The integers will have maximum GCD of 2 when a1 = 2, a2 = 2, a3 = 6.

Input : N = 2, P = 1
Output : 1
Only possibility is a1 = 1 and a2 = 1.

Approach:

• First find all the prime factors of product P and store it in a Hashmap.
• The N integers will have maximum GCD when a prime factor will be common in all the integers.
• So if P = p1k1 * p2k2 * p3k3 …. where p1, p2 … are prime numbers then, maximum GCD which can be obtained will be ans = p1k1 / N * p2k2 / N * p3k3 / N ….

Below is the implementation of the above approach:

C++

 // C++ implementation of above approach#include using namespace std; // Function to find maximum GCD// of N integers with product Pint maxGCD(int N, int P){     int ans = 1;     // map to store prime factors of P    unordered_map prime_factors;     // prime factorization of P    for (int i = 2; i * i <= P; i++) {         while (P % i == 0) {             prime_factors[i]++;             P /= i;        }    }     if (P != 1)        prime_factors[P]++;     // traverse all prime factors and    // multiply its 1/N power to the result    for (auto v : prime_factors)        ans *= pow(v.first, v.second / N);        return ans;} // Driver codeint main(){    int N = 3, P = 24;     cout << maxGCD(N, P);     return 0;}

Java

 // Java implementation of above approachimport java.util.*;class Solution{// Function to find maximum GCD// of N integers with product Pstatic int maxGCD(int N, int P){     int ans = 1;     // map to store prime factors of P    Map prime_factors =                         new HashMap< Integer,Integer>();     // prime factorization of P    for (int i = 2; i * i <= P; i++) {         while (P % i == 0) {             if(prime_factors.get(i)==null)            prime_factors.put(i,1);            else            prime_factors.put(i,(prime_factors.get(i)+1));                          P /= i;        }    }     if (P != 1)            if(prime_factors.get(P)==null)            prime_factors.put(P,1);            else            prime_factors.put(P,(prime_factors.get(P)+1));     // traverse all prime factors and    // multiply its 1/N power to the result        Set< Map.Entry< Integer,Integer> > st = prime_factors.entrySet();             for (Map.Entry< Integer,Integer> me:st)       {                    ans *= Math.pow(me.getKey(),me.getValue() / N);           }     return ans;} // Driver codepublic static void main(String args[]){    int N = 3, P = 24;     System.out.println( maxGCD(N, P)); }}//contributed by Arnab Kundu

Python3

 # Python3 implementation of# above approachfrom math import sqrt # Function to find maximum GCD# of N integers with product Pdef maxGCD(N, P):     ans = 1     # map to store prime factors of P    prime_factors = {}         # prime factorization of P    for i in range(2, int(sqrt(P) + 1)) :         while (P % i == 0) :                         if i not in prime_factors :                prime_factors[i] = 0                     prime_factors[i] += 1            P //= i             if (P != 1) :        prime_factors[P] += 1     # traverse all prime factors and    # multiply its 1/N power to the result    for key, value in prime_factors.items() :        ans *= pow(key, value // N)     return ans # Driver codeif __name__ == "__main__" :     N, P = 3, 24     print(maxGCD(N, P)) # This code is contributed by Ryuga

C#

 // C# implementation of above approachusing System;using System.Collections.Generic; class GFG{     // Function to find maximum GCD// of N integers with product Pstatic int maxGCD(int N, int P){     int ans = 1;     // map to store prime factors of P    Dictionary prime_factors =                        new Dictionary< int,int>();     // prime factorization of P    for (int i = 2; i * i <= P; i++)    {         while (P % i == 0)        {             if(!prime_factors.ContainsKey(i))                prime_factors.Add(i, 1);            else            prime_factors[i] = prime_factors[i] + 1;                         P /= i;        }    }     if (P != 1)            if(!prime_factors.ContainsKey(P))                prime_factors.Add(P, 1);            else            prime_factors[P] = prime_factors[P] + 1;     // traverse all prime factors and    // multiply its 1/N power to the result    foreach(KeyValuePair me in prime_factors)    {                     ans *= (int)Math.Pow(me.Key,me.Value / N);    }     return ans;} // Driver codepublic static void Main(String []args){    int N = 3, P = 24;     Console.WriteLine( maxGCD(N, P));}} // This code is contributed by PrinciRaj1992

Javascript


Output:
2

My Personal Notes arrow_drop_up