 GFG App
Open App Browser
Continue

# Pair with maximum GCD from two arrays

Given two arrays of n integers with values of the array being small (values never exceed a small number say 100). Find the pair(x, y) which has maximum gcd. x and y cannot be of the same array. If multiple pairs have the same gcd, then consider the pair which has the maximum sum.
Examples:

```Input : a[] = {3, 1, 4, 2, 8}
b[] = {5, 2, 12, 8, 3}
Output : 8 8
Explanation: The maximum gcd is 8 which is
of pair(8, 8).

Input: a[] = {2, 3, 5}
b[] = {7, 11, 13}
Output: 5 13
Explanation: Every pair has a gcd of 1.
The maximum sum pair with GCD 1 is (5, 13)```

A naive approach will be to iterate for every pair in both the arrays and find out the maximum gcd possible. Below is the code for naive approach.

## C++

 `#include ` `using` `namespace` `std;`   `int` `gcd(``int` `a, ``int` `b) {` `    ``if` `(b == 0) ``return` `a;` `    ``return` `gcd(b, a % b);` `}`   `int` `main() {` `    ``int` `a[] = {12, 18, 24};` `    ``int` `b[] = {36, 8, 72};` `    ``int` `m = ``sizeof``(a)/``sizeof``(a);` `    ``int` `n = ``sizeof``(b)/``sizeof``(b);` `    ``int` `max_gcd = INT_MIN;` `    ``int` `num1, num2;` `    ``for` `(``int` `i=0; i max_gcd) {` `                ``max_gcd = g;` `                ``num1 = a[i];` `                ``num2 = b[j];` `            ``}` `        ``}` `    ``}` `    ``cout << ``"Pair with greatest GCD: ("` `<< num1 << ``", "` `<< num2 << ``") with GCD: "` `<< max_gcd << endl;` `    ``return` `0;` `}`

## Java

 `import` `java.lang.Math;`   `public` `class` `GCD {`   `    ``// Function to find the gcd of two numbers using` `    ``// Euclidean algorithm` `    ``public` `static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``// If b is 0, return a as gcd` `        ``if` `(b == ``0``) {` `            ``return` `a;` `        ``}` `        ``// Recursive call to find the gcd of b and a%b` `        ``return` `gcd(b, a % b);` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Initialize two arrays a and b` `        ``int``[] a = { ``12``, ``18``, ``24` `};` `        ``int``[] b = { ``36``, ``8``, ``72` `};`   `        ``// Set max_gcd to negative infinity, and initialize` `        ``// num1 and num2 to None` `        ``int` `max_gcd = Integer.MIN_VALUE;` `        ``Integer num1 = ``null``;` `        ``Integer num2 = ``null``;`   `        ``// Loop through elements of both arrays and find the` `        ``// maximum gcd` `        ``for` `(``int` `i = ``0``; i < a.length; i++) {` `            ``for` `(``int` `j = ``0``; j < b.length; j++) {` `                ``// Call gcd function to find the gcd of a[i]` `                ``// and b[j]` `                ``int` `g = gcd(a[i], b[j]);` `                ``// If current gcd is greater than the` `                ``// maximum, update max_gcd, num1 and num2` `                ``if` `(g > max_gcd) {` `                    ``max_gcd = g;` `                    ``num1 = a[i];` `                    ``num2 = b[j];` `                ``}` `            ``}` `        ``}` `        ``// Print the pair with the greatest GCD` `        ``System.out.println(``"Pair with greatest GCD: ("` `                           ``+ num1 + ``", "` `+ num2` `                           ``+ ``") with GCD: "` `+ max_gcd);` `    ``}` `}`

## Python3

 `import` `math`   `# Function to find the gcd of two numbers using Euclidean algorithm` `def` `gcd(a, b):` `    ``# If b is 0, return a as gcd` `    ``if` `b ``=``=` `0``:` `        ``return` `a` `    ``# Recursive call to find the gcd of b and a%b` `    ``return` `gcd(b, a ``%` `b)`   `# Initialize two arrays a and b` `a ``=` `[``12``, ``18``, ``24``]` `b ``=` `[``36``, ``8``, ``72``]`   `# Set max_gcd to negative infinity, and initialize num1 and num2 to None` `max_gcd ``=` `float``(``"-inf"``)` `num1, num2 ``=` `None``, ``None`   `# Loop through elements of both arrays and find the maximum gcd` `for` `i ``in` `range``(``len``(a)):` `    ``for` `j ``in` `range``(``len``(b)):` `        ``# Call gcd function to find the gcd of a[i] and b[j]` `        ``g ``=` `gcd(a[i], b[j])` `        ``# If current gcd is greater than the maximum, update max_gcd, num1 and num2` `        ``if` `g > max_gcd:` `            ``max_gcd ``=` `g` `            ``num1 ``=` `a[i]` `            ``num2 ``=` `b[j]`   `# Print the pair with the greatest GCD` `print``(f``"Pair with greatest GCD: ({num1}, {num2}) with GCD: {max_gcd}"``)`

## C#

 `using` `System;`   `class` `MainClass {` `    ``// Define a function to compute the greatest common divisor of two integers` `    ``static` `int` `GCD(``int` `a, ``int` `b) {` `        ``if` `(b == 0) ``return` `a;` `        ``return` `GCD(b, a % b);` `    ``}`   `    ``static` `void` `Main() {` `        ``// Define two arrays of integers` `        ``int``[] a = ``new` `int``[] {12, 18, 24};` `        ``int``[] b = ``new` `int``[] {36, 8, 72};` `        ``int` `m = a.Length; ``// Get the size of the first array` `        ``int` `n = b.Length; ``// Get the size of the second array` `        ``int` `max_gcd = ``int``.MinValue; ``// Initialize the maximum GCD to the smallest possible integer value` `        ``int` `num1 = 0, num2 = 0; ``// Initialize variables to store the two numbers with the greatest GCD` `        ``for` `(``int` `i=0; i max_gcd) { ``// If the GCD is greater than the current maximum GCD` `                    ``max_gcd = g; ``// Update the maximum GCD` `                    ``num1 = a[i]; ``// Update the first number with the greatest GCD` `                    ``num2 = b[j]; ``// Update the second number with the greatest GCD` `                ``}` `            ``}` `        ``}` `        ``// Output the two numbers with the greatest GCD and their GCD` `        ``Console.WriteLine(``"Pair with greatest GCD: ({0}, {1}) with GCD: {2}"``, num1, num2, max_gcd);` `    ``}` `}` `//This code is contributed by chinmaya121221`

## Javascript

 `function` `gcd(a, b) {` `    ``if` `(b == 0) ``return` `a;` `    ``return` `gcd(b, a % b);` `}`   `let a = [12, 18, 24];` `let b = [36, 8, 72];` `let m = a.length;` `let n = b.length;` `let max_gcd = Number.MIN_SAFE_INTEGER;` `let num1, num2;`   `for` `(let i=0; i max_gcd) {` `            ``max_gcd = g;` `            ``num1 = a[i];` `            ``num2 = b[j];` `        ``}` `    ``}` `}`   `console.log(``"Pair with greatest GCD: ("` `+ num1 + ``", "` `+ num2 + ``") with GCD: "` `+ max_gcd);`

Output

`Pair with greatest GCD: (24, 72) with GCD: 24`

Time complexity : O(M*N)  where M , N are the sizes of the array

Auxiliary space : O(1)

An efficient (only when elements are small) is to apply the sieve property and for that, we need to pre-calculate the following things.

1. A cnt array to mark the presence of array elements.
2. We check for all the numbers from 1 to N and for each multiple, we check that if the number exists then the max of the pre-existing number or the present existing multiple is stored.
3. Step 1 and 2 is repeated for the other array also.
4. At the end we check for the maximum multiple which is common in both first and second array to get the maximum GCD, and in the position of is stored the element, in first the element of an array is stored, and in second the element of b array is stored, so we print the pair.

Below is the implementation of the above approach :

## C++

 `// CPP program to find maximum GCD pair` `// from two arrays` `#include ` `using` `namespace` `std;`   `// Find the maximum GCD pair with maximum` `// sum` `void` `gcdMax(``int` `a[], ``int` `b[], ``int` `n, ``int` `N)` `{` `    ``// array to keep a count of existing elements` `    ``int` `cnt[N] = { 0 };`   `    ``// first[i] and second[i] are going to store` `    ``// maximum multiples of i in a[] and b[]` `    ``// respectively.` `    ``int` `first[N] = { 0 }, second[N] = { 0 };`   `    ``// traverse through the first array to` `    ``// mark the elements in cnt` `    ``for` `(``int` `i = 0; i < n; ++i)` `        ``cnt[a[i]] = 1;`   `    ``// Find maximum multiple of every number` `    ``// in first array` `    ``for` `(``int` `i = 1; i < N; ++i)` `        ``for` `(``int` `j = i; j < N; j += i)` `            ``if` `(cnt[j])` `                ``first[i] = max(first[i], j);`   `    ``// Find maximum multiple of every number` `    ``// in second array` `    ``// We re-initialise cnt[] and traverse` `    ``// through the second array to mark the` `    ``// elements in cnt` `    ``memset``(cnt, 0, ``sizeof``(cnt));` `    ``for` `(``int` `i = 0; i < n; ++i)` `        ``cnt[b[i]] = ``true``;` `    ``for` `(``int` `i = 1; i < N; ++i)` `        ``for` `(``int` `j = i; j < N; j += i)`   `            ``// if the multiple is present in the` `            ``// second array then store the  max` `            ``// of number or the  pre-existing` `            ``// element` `            ``if` `(cnt[j])` `                ``second[i] = max(second[i], j);`   `    ``// traverse for every elements and checks ` `    ``// the maximum N that is present in both ` `    ``// the arrays` `    ``int` `i;` `    ``for` `(i = N - 1; i >= 0; i--)` `        ``if` `(first[i] && second[i])` `            ``break``;`   `    ``cout << ``"Maximum GCD pair with maximum "` `            ``"sum is "` `<< first[i] << ``" "` `         ``<< second[i] << endl;` `}`   `// driver program to test the above function` `int` `main()` `{` `    ``int` `a[] = { 3, 1, 4, 2, 8 };` `    ``int` `b[] = { 5, 2, 12, 8, 3 };` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a);`   `    ``// Maximum possible value of elements` `    ``// in both arrays.` `    ``int` `N = 20;`   `    ``gcdMax(a, b, n, N);` `    ``return` `0;` `}`

## Java

 `// Java program to find maximum ` `// GCD pair from two arrays` `import` `java.io.*;` `public` `class` `GFG` `{` `    `  `// Find the maximum GCD` `// pair with maximum sum` `static` `void` `gcdMax(``int``[] a, ``int``[] b, ` `                   ``int` `n, ``int` `N)` `{` `    ``// array to keep a count ` `    ``// of existing elements` `    ``int``[] cnt = ``new` `int``[N];`   `    ``// first[i] and second[i] ` `    ``// are going to store` `    ``// maximum multiples of ` `    ``// i in a[] and b[]` `    ``// respectively.` `    ``int``[] first = ``new` `int``[N];` `    ``int``[] second = ``new` `int``[N];`   `    ``// traverse through the ` `    ``// first array to mark ` `    ``// the elements in cnt` `    ``for` `(``int` `i = ``0``; i < n; ++i)` `        ``cnt[a[i]] = ``1``;`   `    ``// Find maximum multiple ` `    ``// of every number in` `    ``// first array` `    ``for` `(``int` `i = ``1``; i < N; ++i)` `        ``for` `(``int` `j = i; j < N; j += i)` `            ``if` `(cnt[j] > ``0``)` `                ``first[i] = Math.max(first[i], j);`   `    ``// Find maximum multiple ` `    ``// of every number in second ` `    ``// array. We re-initialise ` `    ``// cnt[] and traverse through ` `    ``// the second array to mark ` `    ``// the elements in cnt` `    ``cnt = ``new` `int``[N];` `    ``for` `(``int` `i = ``0``; i < n; ++i)` `        ``cnt[b[i]] = ``1``;` `    ``for` `(``int` `i = ``1``; i < N; ++i)` `        ``for` `(``int` `j = i; j < N; j += i)`   `            ``// if the multiple is present ` `            ``// in the second array then ` `            ``// store the max of number or ` `            ``// the pre-existing element` `            ``if` `(cnt[j] > ``0``)` `                ``second[i] = Math.max(second[i], j);`   `    ``// traverse for every ` `    ``// elements and checks ` `    ``// the maximum N that` `    ``// is present in both ` `    ``// the arrays` `    ``int` `x;` `    ``for` `(x = N - ``1``; x >= ``0``; x--)` `        ``if` `(first[x] > ``0` `&& ` `            ``second[x] > ``0``)` `            ``break``;`   `    ``System.out.println(first[x] + ``" "` `+ ` `                            ``second[x]);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int``[] a = { ``3``, ``1``, ``4``, ``2``, ``8` `};` `    ``int``[] b = { ``5``, ``2``, ``12``, ``8``, ``3` `};` `    ``int` `n = a.length;`   `    ``// Maximum possible ` `    ``// value of elements` `    ``// in both arrays.` `    ``int` `N = ``20``;`   `    ``gcdMax(a, b, n, N);` `}` `}`   `// This code is contributed ` `// by mits`

## Python3

 `# Python 3 program to find maximum GCD pair` `# from two arrays`   `# Find the maximum GCD pair with maximum` `# sum` `def` `gcdMax(a, b, n, N):`   `    ``# array to keep a count of existing elements` `    ``cnt ``=` `[``0``]``*``N`   `    ``# first[i] and second[i] are going to store` `    ``# maximum multiples of i in a[] and b[]` `    ``# respectively.` `    ``first ``=` `[``0``]``*``N ` `    ``second ``=` `[``0``]``*``N`   `    ``# traverse through the first array to` `    ``# mark the elements in cnt` `    ``for` `i ``in` `range``(n):` `        ``cnt[a[i]] ``=` `1`   `    ``# Find maximum multiple of every number` `    ``# in first array` `    ``for` `i ``in` `range``(``1``,N):` `        ``for` `j ``in` `range``(i,N,i):` `            ``if` `(cnt[j]):` `                ``first[i] ``=` `max``(first[i], j)`   `    ``# Find maximum multiple of every number` `    ``# in second array` `    ``# We re-initialise cnt[] and traverse` `    ``# through the second array to mark the` `    ``# elements in cnt` `    ``cnt ``=` `[``0``]``*``N` `    ``for` `i ``in` `range``(n):` `        ``cnt[b[i]] ``=` `1` `    ``for` `i ``in` `range``(``1``,N):` `        ``for` `j ``in` `range``(i,N,i):`   `            ``# if the multiple is present in the` `            ``# second array then store the max` `            ``# of number or the pre-existing` `            ``# element` `            ``if` `(cnt[j]>``0``):` `                ``second[i] ``=` `max``(second[i], j)` `            `  `    ``# traverse for every elements and checks ` `    ``# the maximum N that is present in both ` `    ``# the arrays` `    `  `    ``i ``=` `N``-``1` `    ``while` `i>``=` `0``:` `        ``if` `(first[i]>``0` `and` `second[i]>``0``):` `            ``break` `        ``i ``-``=` `1` `    `  `    ``print``( ``str``(first[i]) ``+` `" "` `+` `str``(second[i]))`   `# driver program to test the above function` `if` `__name__ ``=``=` `"__main__"``:` `    ``a ``=` `[ ``3``, ``1``, ``4``, ``2``, ``8` `]` `    ``b ``=` `[ ``5``, ``2``, ``12``, ``8``, ``3` `]` `    ``n ``=` `len``(a)`   `    ``# Maximum possible value of elements` `    ``# in both arrays.` `    ``N ``=` `20` `    ``gcdMax(a, b, n, N)`   `# this code is contributed by ChitraNayal`

## C#

 `// C# program to find ` `// maximum GCD pair ` `// from two arrays` `using` `System;`   `class` `GFG` `{` `// Find the maximum GCD` `// pair with maximum sum` `static` `void` `gcdMax(``int``[] a, ``int``[] b, ` `                   ``int` `n, ``int` `N)` `{` `    ``// array to keep a count ` `    ``// of existing elements` `    ``int``[] cnt = ``new` `int``[N];`   `    ``// first[i] and second[i] ` `    ``// are going to store` `    ``// maximum multiples of ` `    ``// i in a[] and b[]` `    ``// respectively.` `    ``int``[] first = ``new` `int``[N];` `    ``int``[] second = ``new` `int``[N];`   `    ``// traverse through the ` `    ``// first array to mark ` `    ``// the elements in cnt` `    ``for` `(``int` `i = 0; i < n; ++i)` `        ``cnt[a[i]] = 1;`   `    ``// Find maximum multiple ` `    ``// of every number in` `    ``// first array` `    ``for` `(``int` `i = 1; i < N; ++i)` `        ``for` `(``int` `j = i; j < N; j += i)` `            ``if` `(cnt[j] > 0)` `                ``first[i] = Math.Max(first[i], j);`   `    ``// Find maximum multiple ` `    ``// of every number in second ` `    ``// array. We re-initialise ` `    ``// cnt[] and traverse through ` `    ``// the second array to mark ` `    ``// the elements in cnt` `    ``cnt = ``new` `int``[N];` `    ``for` `(``int` `i = 0; i < n; ++i)` `        ``cnt[b[i]] = 1;` `    ``for` `(``int` `i = 1; i < N; ++i)` `        ``for` `(``int` `j = i; j < N; j += i)`   `            ``// if the multiple is present ` `            ``// in the second array then ` `            ``// store the max of number or ` `            ``// the pre-existing element` `            ``if` `(cnt[j] > 0)` `                ``second[i] = Math.Max(second[i], j);`   `    ``// traverse for every ` `    ``// elements and checks ` `    ``// the maximum N that` `    ``// is present in both ` `    ``// the arrays` `    ``int` `x;` `    ``for` `(x = N - 1; x >= 0; x--)` `        ``if` `(first[x] > 0 && ` `            ``second[x] > 0)` `            ``break``;`   `    ``Console.WriteLine(first[x] + ` `                      ``" "` `+ second[x]);` `}`   `// Driver Code` `static` `int` `Main()` `{` `    ``int``[] a = { 3, 1, 4, 2, 8 };` `    ``int``[] b = { 5, 2, 12, 8, 3 };` `    ``int` `n = a.Length;`   `    ``// Maximum possible ` `    ``// value of elements` `    ``// in both arrays.` `    ``int` `N = 20;`   `    ``gcdMax(a, b, n, N);` `    ``return` `0;` `}` `}`   `// This code is contributed ` `// by mits`

## PHP

 `= 0; ``\$x``--)` `        ``if` `(``\$first``[``\$x``] && ``\$second``[``\$x``])` `            ``break``;`   `        ``echo` `\$first``[``\$x``] . ``" "` `.` `             ``\$second``[``\$x``] . ``"\n"``;` `}`   `// Driver code` `\$a` `= ``array``(3, 1, 4, 2, 8);` `\$b` `= ``array``(5, 2, 12, 8, 3);` `\$n` `= sizeof(``\$a``);`   `// Maximum possible value ` `// of elements in both arrays.` `\$N` `= 20;`   `gcdMax(``\$a``, ``\$b``, ``\$n``, ``\$N``);`   `// This code is contributed ` `// by mits` `?>`

## Javascript

 ``

Output

`Maximum GCD pair with maximum sum is 8 8`

Time complexity : O(N Log N + N), as we are using nested loops where outer loop traverses N times and inner loop traverses logN times (as N + (N/2) + (N/3) + ….. + 1 = N log N) and we are using extra Loop to traverse N times.
Auxiliary Space : O(N), as we are using extra space for cnt array.

This article is contributed by Raj. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.