# Maximum GCD of N integers with given product

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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 P ` `int` `maxGCD(``int` `N, ``int` `P) ` `{ ` ` `  `    ``int` `ans = 1; ` ` `  `    ``// map to store prime factors of P ` `    ``unordered_map<``int``, ``int``> 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 code ` `int` `main() ` `{ ` `    ``int` `N = 3, P = 24; ` ` `  `    ``cout << maxGCD(N, P); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach  ` `import` `java.util.*; ` `class` `Solution ` `{ ` `// Function to find maximum GCD  ` `// of N integers with product P  ` `static` `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 code  ` `public` `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 approach  ` `from` `math ``import` `sqrt ` ` `  `# Function to find maximum GCD  ` `# of N integers with product P  ` `def` `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 code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``N, P ``=` `3``, ``24` ` `  `    ``print``(maxGCD(N, P)) ` ` `  `# This code is contributed by Ryuga `

## C#

 `// C# implementation of above approach  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to find maximum GCD  ` `// of N integers with product P  ` `static` `int` `maxGCD(``int` `N, ``int` `P)  ` `{  ` ` `  `    ``int` `ans = 1;  ` ` `  `    ``// map to store prime factors of P  ` `    ``Dictionary<``int``, ``int``> 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<``int``, ``int``> me ``in` `prime_factors)  ` `    ``{  ` `             `  `        ``ans *= (``int``)Math.Pow(me.Key,me.Value / N);  ` `    ``} ` ` `  `    ``return` `ans;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String []args) ` `{  ` `    ``int` `N = 3, P = 24;  ` ` `  `    ``Console.WriteLine( maxGCD(N, P));  ` `}  ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```2
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.