Skip to content
Related Articles

Related Articles

Table of Contents

Pair with maximum GCD from two arrays

Improve Article
Save Article
Like Article
  • Last Updated : 28 Apr, 2021

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.
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
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 : 
8 8
Time complexity : O(N Log N + n). Note that N + (N/2) + (N/3) + ….. + 1 = N log N.
Auxiliary Space : O(N)
This article is contributed by Raj. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes
arrow_drop_up
Next

Find pair with maximum GCD in an array
Recommended Articles
Page :
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Find N distinct integers with GCD of sequence as 1 and GCD of each pair greater than 1
07, Dec 21
Find pair with maximum GCD in an array
23, Jul 17
Find pair with maximum GCD for integers in range 2 to N
30, Jun 20
Maximum possible GCD for a pair of integers with product N
18, Jul 20
Maximum possible GCD for a pair of integers with sum N
18, Jul 20
Longest subsequence having maximum GCD between any pair of distinct elements
27, Oct 20
Find the maximum GCD possible for some pair in a given range [L, R]
23, Jun 21
Smallest subsequence having GCD equal to GCD of given array
20, Oct 20
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
13, Jan 21
Generate an N-length sequence from two given arrays whose GCD is K
04, Mar 21
Calculate GCD of all pairwise sum of given two Arrays
29, Mar 22
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Find any pair with given GCD and LCM
07, Oct 18
Print N lines of 4 numbers such that every pair among 4 numbers has a GCD K
27, Oct 18
Check if there is any pair in a given range with GCD is divisible by k
08, Nov 18
Find original numbers from gcd() every pair
01, Apr 19
Print any pair of integers with sum of GCD and LCM equals to N
09, May 20
Count pairs from an array having GCD equal to the minimum element in the pair
27, Apr 21
Find N - 1 pairs from given array such that GCD of all pair-sums is greater than 1
31, Jan 22
Find minimum sum Pair whose GCD is greater than 1
19, Apr 22
Generate Array of distinct elements with GCD as 1 and no Coprime pair
16, Mar 22
Count of distinct pair sum between two 1 to N value Arrays
21, May 20
Divide array into two arrays which does not contain any pair with sum K
03, Nov 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!