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

## Javascript

 ``
Output:
`2`

My Personal Notes arrow_drop_up