# Maximum possible GCD for a pair of integers with product N

Last Updated : 18 Apr, 2023

Given an integer N, the task is to find the maximum possible GCD among all pair of integers with product N.
Examples:

Input: N=12
Output:
Explanation:
All possible pairs with product 12 are {1, 12}, {2, 6}, {3, 4}
GCD(1, 12) = 1
GCD(2, 6) = 2
GCD(3, 4) = 1
Therefore, the maximum possible GCD = maximum(1, 2, 1) = 2

Input:
Output: 2
Explanation:
All possible pairs with product 4 are {1, 4}, {2, 2}
GCD(1, 4) = 1
GCD(2, 2) = 2
Hence, maximum possible GCD = maximum(1, 2) = 2

Naive Approach:
The simplest approach to solve this problem is to generate all possible pairs with product N and calculate GCD of all such pairs. Finally, print the maximum GCD obtained.
Time Complexity: O(NlogN)
Auxiliary Space: O(1)
Efficient Approach:
The above approach can be optimized by finding all divisors of the given number N. For each pair of divisors obtained, calculate their GCD. Finally, print the maximum GCD obtained.
Follow the steps below to solve the problem:

• Declare a variable maxGcd to keep track of maximum GCD.
• Iterate up to ?N and for every integer, check if it is a factor of N.
• If N is divisible by i, calculate GCD of the pair of factors (i, N / i).
• Compare with GCD(i, N / i) and update maxGcd.
• Finally, print maxGcd.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to return` `/// the maximum GCD` `int` `getMaxGcd(``int` `N)` `{` `    ``int` `maxGcd = INT_MIN, A, B;`   `    ``// To find all divisors of N` `    ``for` `(``int` `i = 1; i <= ``sqrt``(N); i++) {`   `        ``// If i is a factor` `        ``if` `(N % i == 0) {` `            ``// Store the pair of factors` `            ``A = i, B = N / i;`   `            ``// Store the maximum GCD` `            ``maxGcd = max(maxGcd, __gcd(A, B));` `        ``}` `    ``}`   `    ``// Return the maximum GCD` `    ``return` `maxGcd;` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `N = 18;` `    ``cout << getMaxGcd(N);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `GFG{` `    `  `static` `int` `gcd(``int` `a, ``int` `b)` `{` `    ``if` `(b == ``0``) ` `        ``return` `a;` `    ``return` `gcd(b, a % b);` `}` `    `  `// Function to return` `// the maximum GCD` `static` `int` `getMaxGcd(``int` `N)` `{` `    ``int` `maxGcd = Integer.MIN_VALUE, A, B;` `    `  `    ``// To find all divisors of N` `    ``for``(``int` `i = ``1``; i <= Math.sqrt(N); i++) ` `    ``{` `        `  `        ``// If i is a factor` `        ``if` `(N % i == ``0``) ` `        ``{` `            `  `            ``// Store the pair of factors` `            ``A = i;` `            ``B = N / i;` `        `  `            ``// Store the maximum GCD` `            ``maxGcd = Math.max(maxGcd, gcd(A, B));` `        ``}` `    ``}` `    `  `    ``// Return the maximum GCD` `    ``return` `maxGcd;` `}` `    `  `// Driver Code` `public` `static` `void` `main(String s[])` `{` `    ``int` `N = ``18``;` `    `  `    ``System.out.println(getMaxGcd(N));` `} ` `}`   `// This code is contributed by rutvik_56`

## Python3

 `# Python3 program to implement` `# the above approach` `import` `sys` `import` `math`   `# Function to return` `# the maximum GCD` `def` `getMaxGcd(N):` `    `  `    ``maxGcd ``=` `-``sys.maxsize ``-` `1`   `    ``# To find all divisors of N` `    ``for` `i ``in` `range``(``1``, ``int``(math.sqrt(N)) ``+` `1``):`   `        ``# If i is a factor` `        ``if` `(N ``%` `i ``=``=` `0``):` `            `  `            ``# Store the pair of factors` `            ``A ``=` `i` `            ``B ``=` `N ``/``/` `i`   `            ``# Store the maximum GCD` `            ``maxGcd ``=` `max``(maxGcd, math.gcd(A, B))` `        `  `    ``# Return the maximum GCD` `    ``return` `maxGcd`   `# Driver Code` `N ``=` `18`   `print``(getMaxGcd(N))`   `# This code is contributed by code_hunt`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `    `  `static` `int` `gcd(``int` `a, ``int` `b)` `{` `    ``if` `(b == 0) ` `        ``return` `a;` `    ``return` `gcd(b, a % b);` `}` `    `  `// Function to return` `// the maximum GCD` `static` `int` `getMaxGcd(``int` `N)` `{` `    ``int` `maxGcd = ``int``.MinValue, A, B;` `    `  `    ``// To find all divisors of N` `    ``for``(``int` `i = 1; i <= Math.Sqrt(N); i++) ` `    ``{` `        `  `        ``// If i is a factor` `        ``if` `(N % i == 0) ` `        ``{` `            `  `            ``// Store the pair of factors` `            ``A = i;` `            ``B = N / i;` `        `  `            ``// Store the maximum GCD` `            ``maxGcd = Math.Max(maxGcd, gcd(A, B));` `        ``}` `    ``}` `    `  `    ``// Return the maximum GCD` `    ``return` `maxGcd;` `}` `    `  `// Driver Code` `public` `static` `void` `Main(String []s)` `{` `    ``int` `N = 18;` `    `  `    ``Console.WriteLine(getMaxGcd(N));` `} ` `}`   `// This code is contributed by sapnasingh4991`

## Javascript

 ``

Output

`3`

Time Complexity: O(?N*log(N))
Auxiliary Space: O(1)

Prime Factorization Approach:-

We can factorize the given number N into its prime factors. Let’s say the prime factorization of N is:

• Define a static method called getMaxGcd that takes an integer N as input and returns an integer.
• Create a HashMap called primeFactors to store the prime factors of N and their exponents.
•  Initialize a temporary variable called temp to the value of N.
•  Use a for loop to factorize N into its prime factors. The loop starts at 2 and goes up to the square root of N.
•  Inside the for loop, use a while loop to divide temp by i as long as temp is divisible by i. For each iteration of the while loop, add i to the primeFactors HashMap with its value as the current count plus 1.
•  If temp is still greater than 1 after the for loop, add it to the primeFactors HashMap with its value as the current count plus 1.
•  Initialize a variable called maxGcd to 1. This variable will be used to compute the maximum possible GCD.
•  Use a for-each loop to iterate over the keys in the primeFactors HashMap.
•  For each key, compute the exponent by getting the corresponding value from the HashMap.
•  Compute the maximum possible GCD by multiplying maxGcd by the factor raised to the exponent divided by 2.
•  Return maxGcd from the getMaxGcd method.
•  Create a main method to test the getMaxGcd method.
•  Set the value of N to 18.
•  Call the getMaxGcd method with N as the argument and print the result, which should be 3.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `int` `getMaxGcd(``int` `N) {` `    ``map<``int``, ``int``> primeFactors;` `    ``int` `temp = N;`   `    ``// Factorize N into its prime factors` `    ``for` `(``int` `i = 2; i <= ``sqrt``(N); i++) {` `        ``while` `(temp % i == 0) {` `            ``primeFactors[i]++;` `            ``temp /= i;` `        ``}` `    ``}` `    ``if` `(temp > 1) {` `        ``primeFactors[temp]++;` `    ``}`   `    ``// Compute the maximum possible GCD` `    ``int` `maxGcd = 1;` `    ``for` `(``auto` `factor : primeFactors) {` `        ``int` `exponent = factor.second;` `        ``maxGcd *= ``pow``(factor.first, exponent / 2);` `    ``}`   `    ``return` `maxGcd;` `}`   `int` `main() {` `    ``int` `N = 18;` `    ``cout << getMaxGcd(N) << endl;  ``// Output: 3` `}`

## Java

 `import` `java.util.*;`   `class` `GFG {` `    ``static` `int` `getMaxGcd(``int` `N) {` `        ``Map primeFactors = ``new` `HashMap<>();` `        ``int` `temp = N;` `        `  `        ``// Factorize N into its prime factors` `        ``for` `(``int` `i = ``2``; i <= Math.sqrt(N); i++) {` `            ``while` `(temp % i == ``0``) {` `                ``primeFactors.put(i, primeFactors.getOrDefault(i, ``0``) + ``1``);` `                ``temp /= i;` `            ``}` `        ``}` `        ``if` `(temp > ``1``) {` `            ``primeFactors.put(temp, primeFactors.getOrDefault(temp, ``0``) + ``1``);` `        ``}` `        `  `        ``// Compute the maximum possible GCD` `        ``int` `maxGcd = ``1``;` `        ``for` `(``int` `factor : primeFactors.keySet()) {` `            ``int` `exponent = primeFactors.get(factor);` `            ``maxGcd *= Math.pow(factor, exponent / ``2``);` `        ``}` `        `  `        ``return` `maxGcd;` `    ``}` `    `  `    ``public` `static` `void` `main(String[] args) {` `        ``int` `N = ``18``;` `        ``System.out.println(getMaxGcd(N));  ``// Output: 3` `    ``}` `}`   `// this code is contributed by Satyamn120`

## Python3

 `#Python equivalent` `import` `math`   `def` `getMaxGcd(N):` `    ``primeFactors ``=` `{}` `    ``temp ``=` `N` `    `  `    ``# Factorize N into its prime factors` `    ``for` `i ``in` `range``(``2``, ``int``(math.sqrt(N)) ``+` `1``):` `        ``while` `temp ``%` `i ``=``=` `0``:` `            ``primeFactors[i] ``=` `primeFactors.get(i, ``0``) ``+` `1` `            ``temp ``/``/``=` `i` `    ``if` `temp > ``1``:` `        ``primeFactors[temp] ``=` `primeFactors.get(temp, ``0``) ``+` `1` `    `  `    ``# Compute the maximum possible GCD` `    ``maxGcd ``=` `1` `    ``for` `factor ``in` `primeFactors.keys():` `        ``exponent ``=` `primeFactors[factor]` `        ``maxGcd ``*``=` `factor ``*``*` `(exponent ``/``/` `2``)` `        `  `    ``return` `maxGcd`   `N ``=` `18` `print``(getMaxGcd(N))  ``# Output: 3`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {` `    ``static` `int` `GetMaxGcd(``int` `N) {` `        ``Dictionary<``int``, ``int``> primeFactors = ``new` `Dictionary<``int``, ``int``>();` `        ``int` `temp = N;`   `        ``// Factorize N into its prime factors` `        ``for` `(``int` `i = 2; i <= Math.Sqrt(N); i++) {` `            ``while` `(temp % i == 0) {` `                ``if` `(primeFactors.ContainsKey(i)) {` `                    ``primeFactors[i]++;` `                ``} ``else` `{` `                    ``primeFactors.Add(i, 1);` `                ``}` `                ``temp /= i;` `            ``}` `        ``}` `        ``if` `(temp > 1) {` `            ``if` `(primeFactors.ContainsKey(temp)) {` `                ``primeFactors[temp]++;` `            ``} ``else` `{` `                ``primeFactors.Add(temp, 1);` `            ``}` `        ``}`   `        ``// Compute the maximum possible GCD` `        ``int` `maxGcd = 1;` `        ``foreach` `(``int` `factor ``in` `primeFactors.Keys) {` `            ``int` `exponent = primeFactors[factor];` `            ``maxGcd *= (``int``)Math.Pow(factor, exponent / 2);` `        ``}`   `        ``return` `maxGcd;` `    ``}`   `    ``static` `void` `Main(``string``[] args) {` `        ``int` `N = 18;` `        ``Console.WriteLine(GetMaxGcd(N)); ``// Output: 3` `    ``}` `}`

## Javascript

 `function` `getMaxGcd(N) {` `  ``let primeFactors = {};` `  ``let temp = N;` `  `  `  ``// Factorize N into its prime factors` `  ``for` `(let i = 2; i <= Math.sqrt(N); i++) {` `    ``while` `(temp % i === 0) {` `      ``primeFactors[i] = (primeFactors[i] || 0) + 1;` `      ``temp /= i;` `    ``}` `  ``}` `  ``if` `(temp > 1) {` `    ``primeFactors[temp] = (primeFactors[temp] || 0) + 1;` `  ``}` `  `  `  ``// Compute the maximum possible GCD` `  ``let maxGcd = 1;` `  ``for` `(let factor ``in` `primeFactors) {` `    ``let exponent = primeFactors[factor];` `    ``maxGcd *= Math.pow(factor, Math.floor(exponent / 2));` `  ``}` `  `  `  ``return` `maxGcd;` `}`   `const N = 18;` `console.log(getMaxGcd(N));`

Output

`3`

Time complexity:- The time complexity of the given implementation is O(sqrt(N)logN) because we loop from 2 to sqrt(N) to factorize N into its prime factors, and each factorization operation takes O(log N) time due to the division operation. The loop runs for at most sqrt(N) iterations, hence the overall time complexity is O(sqrt(N)logN).

Space Complexity:-The space complexity of the implementation is O(logN) due to the use of the HashMap to store the prime factors and their exponents.

Overall, the given implementation is efficient in terms of time and space complexity, and it can handle large values of N.