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 <bits/stdc++.h>
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[0]);
    int n = sizeof(b)/sizeof(b[0]);
    int max_gcd = INT_MIN;
    int num1, num2;
    for (int i=0; i<m; i++) {
        for (int j=0; j<n; j++) {
            int g = gcd(a[i], b[j]);
            if (g > 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<m; i++) {
            for (int j=0; j<n; j++) {
                int g = GCD(a[i], b[j]); // Compute the GCD of the two numbers
                if (g > 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<m; i++) {
    for (let j=0; j<n; j++) {
        let g = gcd(a[i], b[j]);
        if (g > 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 <bits/stdc++.h>
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[0]);

    // 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

<?php
// PHP program to find
// maximum GCD pair
// from two arrays

// Find the maximum GCD
// pair with maximum
// sum
function gcdMax($a, $b, $n, $N)
{
    // array to keep a count
    // of existing elements
    $cnt = array_fill(0, $N, 0);

    // first[i] and second[i] are
    // going to store maximum
    // multiples of i in a[] and
    // b[] respectively.
    $first = array_fill(0, $N, 0);
    $second = array_fill(0, $N, 0);

    // traverse through the first
    // array to mark the elements
    // in cnt
    for ($i = 0; $i < $n; ++$i)
        $cnt[$a[$i]] = 1;

    // Find maximum multiple
    // of every number in
    // first array
    for ($i = 1; $i < $N; ++$i)
        for ($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
    $cnt = array_fill(0, $N, 0);
    for ($i = 0; $i < $n; $i++)
        $cnt[$b[$i]] = 1;
    for ($i = 1; $i < $N; $i++)
        for ($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
    $x = $N - 1;
    for (; $x >= 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

<script>

// Javascript program to find maximum
// GCD pair from two arrays

// Find the maximum GCD
// pair with maximum sum
function gcdMax(a, b, n, N)
{
    // array to keep a count
    // of existing elements
    let cnt = Array.from({length: N},
             (_, i) => 0);

    // first[i] and second[i]
    // are going to store
    // maximum multiples of
    // i in a[] and b[]
    // respectively.
    let first = Array.from({length: N}, (_, i) => 0);
    let second = Array.from({length: N}, (_, i) => 0);

    // traverse through the
    // first array to mark
    // the elements in cnt
    for (let i = 0; i < n; ++i)
        cnt[a[i]] = 1;

    // Find maximum multiple
    // of every number in
    // first array
    for (let i = 1; i < N; ++i)
        for (let 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 = Array.from({length: N}, (_, i) => 0);
    for (let i = 0; i < n; ++i)
        cnt[b[i]] = 1;
    for (let i = 1; i < N; ++i)
        for (let 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
    let x;
    for (x = N - 1; x >= 0; x--)
        if (first[x] > 0 &&
            second[x] > 0)
            break;

    document.write(first[x] + " " +
                            second[x]);
}

// driver program

    let a = [ 3, 1, 4, 2, 8 ];
    let b = [ 5, 2, 12, 8, 3 ];
    let n = a.length;

    // Maximum possible
    // value of elements
    // in both arrays.
    let N = 20;

    gcdMax(a, b, n, N);

</script>

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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.