Skip to content
Related Articles

Related Articles

Calculate GCD of all pairwise sum of given two Arrays

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 04 May, 2022
View Discussion
Improve Article
Save Article

Given two arrays A[] and B[] of size N and M calculate GCD of all pairwise sum of (A[i]+B[j]) 1<=i<=N and 1<=j<=M.

Examples: 

Input: A[] = {1, 7, 25, 55}, B[] = {1, 3, 5}
Output: 2
Explanation: The GCD of all pairwise sum of (A[i]+B[j]) is equals to 
GCD(1+1, 1+3, 1+5, 7+1, 7+3, 7+5, 25+1, 25+3, 25+5, 55+1, 55+3, 55+5)
GCD(2, 4, 6, 8, 10, 12, 26, 28, 30, 56, 58, 60) = 2

Input: A[] = {8, 16, 20}, B[] = {12, 24}
Output: 4 

 

Naive Approach: The simple approach of this problem is to calculate all pairwise sums and then calculate their GCD.

Below is the implementation of this approach.

C++




// C++ code to implement the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate gcd
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to calculate the GCD
// of all pairwise sums
int calculateGCD(vector<int>& a,
                 vector<int>& b,
                 int N, int M)
{
    int ans = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
 
            // Pairwise sum of all elements
            int sum = a[i] + b[j];
 
            // Finding gcd of the elements
            ans = gcd(ans, sum);
        }
    }
    return ans;
}
 
// Driver code
int main()
{
    int N = 4, M = 3;
    // Initialization of the vector
    vector<int> A = { 1, 7, 25, 55 };
    vector<int> B = { 1, 3, 5 };
 
    // output
    cout << calculateGCD(A, B, N, M);
    return 0;
}


Java




// Java code to implement the approach
import java.util.*;
 
class GFG {
 
  // Function to calculate gcd
  static int gcd(int a, int b)
  {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
 
  // Function to calculate the GCD
  // of all pairwise sums
  static int calculateGCD(int a[],
                          int b[],
                          int N, int M)
  {
    int ans = 0;
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
 
        // Pairwise sum of all elements
        int sum = a[i] + b[j];
 
        // Finding gcd of the elements
        ans = gcd(ans, sum);
      }
    }
    return ans;
  }
 
  // Driver code
  public static void main (String[] args) {
    int N = 4, M = 3;
 
    // Initialization of the vector
    int A[] = { 1, 7, 25, 55 };
    int B[] = { 1, 3, 5 };
 
    // output
    System.out.print(calculateGCD(A, B, N, M));
  }
}
 
// This code is contributed by hrithikgarg03188.


Python3




# Python code to implement the approach
# Function to calculate gcd
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
   
# Function to calculate the GCD
# of all pairwise sums
def calculateGCD(a, b, N, M):
    ans = 0
    for i in range(N):
        for j in range(M):
           
            # Pairwise sum of all elements
            sum = a[i]+b[j]
             
            # Finding gcd of the elements
            ans = gcd(ans, sum)
    return ans
 
# Driver code
N = 4
M = 3
A = [1, 7, 25, 55]
B = [1, 3, 5]
print(calculateGCD(A, B, N, M))
 
'''This Code is contributed by Rajat Kumar'''


C#




// C# code to implement the approach
using System;
using System.Numerics;
using System.Collections.Generic;
 
public class GFG {
 
  // Function to calculate gcd
  static int gcd(int a, int b)
  {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
 
  // Function to calculate the GCD
  // of all pairwise sums
  static int calculateGCD(int[] a, int[] b, int N, int M)
  {
    int ans = 0;
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
 
        // Pairwise sum of all elements
        int sum = a[i] + b[j];
 
        // Finding gcd of the elements
        ans = gcd(ans, sum);
      }
    }
    return ans;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    int N = 4, M = 3;
     
    // Initialization of the vector
    int[] A = { 1, 7, 25, 55 };
    int[] B = { 1, 3, 5 };
 
    // output
    Console.WriteLine(calculateGCD(A, B, N, M));
  }
}
 
// This code is contributed by phasing17


Javascript




<script>
    // JavaScript code to implement the approach
 
    // Function to calculate gcd
    const gcd = (a, b) => {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to calculate the GCD
    // of all pairwise sums
    const calculateGCD = (a, b, N, M) => {
        let ans = 0;
        for (let i = 0; i < N; i++) {
            for (let j = 0; j < M; j++) {
 
                // Pairwise sum of all elements
                let sum = a[i] + b[j];
 
                // Finding gcd of the elements
                ans = gcd(ans, sum);
            }
        }
        return ans;
    }
 
    // Driver code
 
    let N = 4, M = 3;
    // Initialization of the vector
    let A = [1, 7, 25, 55];
    let B = [1, 3, 5];
 
    // output
    document.write(calculateGCD(A, B, N, M));
 
// This code is contributed by rakeshsahni
 
</script>


Output

2

Time Complexity: O(N*M)
Auxiliary Space: O(N)

Efficient Approach: The problem can be solved efficiently based on the following mathematical observation:

Observation

  • By Euclidean algorithm it can be said that GCD( a, b) =  GCD(a-b, b) where(a>b) .   
  • Then for any j
    GCD(A[0] + B[j], A[1] + B[j], . . ., A[N-1] + B[j]) = GCD(A[0]+B[j], A[1]-A[0], A[2]-A[0], . . ., A[N]-A[0]). 
    The term GCD(A[1]-A[0], A[2]-A[0], . . ., A[N]-A[0]) is common for all j from 0 to M-1 (say this is X)
  • This leaves us with only the elements of type (A[0] + B[j]) for which will calculate their GCD and will get the desired GCD upon calculating their GCD with X

Follow the below steps to solve this problem: 

  • First sort both the arrays.
  • Then iterate through i = 1 to N-1 and calculate GCD of all pairs of A[i] -A[0] (say X).
  • Then iterate through i = 1 to M-1 and calculate GCD of all pairs of A[0] +B[i] (say Y).
  • Return the final answer which is GCD of (X and Y).

Below is the implementation of this approach.

C++




// C++ code to implement the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function for calculating gcd
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to calculate the required GCD
int calculateGCD(vector<int>& a,
                 vector<int>& b, int N, int M)
{
    int ans = 0;
 
    // Sorting the arrays
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
 
    // Calculating the gcd of all the elements
    // of type (i, j) i>0 and j>=0
    // Using the property
    // gcd(a[0]+b[j], a[i]+b[j])
    // =gcd(a[0]+b[j], a[i]-a[0])
    for (int i = 1; i < N; i++) {
        ans = gcd(ans, a[i] - a[0]);
    }
 
    // Calculating the gcd of the remaining
    // elements of the type (a[0]+b[j])
    for (int i = 0; i < M; i++) {
        ans = gcd(ans, a[0] + b[i]);
    }
    return ans;
}
 
// Driver code
int main()
{
    int N = 4, M = 3;
    // Initialization of the array
    vector<int> A = { 1, 7, 25, 55 };
    vector<int> B = { 1, 3, 5 };
 
    // Function call
    cout << calculateGCD(A, B, N, M);
    return 0;
}


Java




// JAVA code to implement the above approach
import java.util.*;
class GFG {
  // Function to calculate gcd
  static int gcd(int a, int b)
  {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
 
  // Function to calculate the GCD
  // of all pairwise sums
  static int calculateGCD(int a[],
                          int b[],
                          int N, int M)
  {
    int ans = 0;
 
    // Sorting the arrays
    Arrays.sort(a);
    Arrays.sort(b);
 
    // Calculating the gcd of all the elements
    // of type (i, j) i>0 and j>=0
    // Using the property
    // gcd(a[0]+b[j], a[i]+b[j])
    // =gcd(a[0]+b[j], a[i]-a[0])
    for (int i = 1; i < N; i++) {
      ans = gcd(ans, a[i] - a[0]);
    }
 
    // Calculating the gcd of the remaining
    // elements of the type (a[0]+b[j])
    for (int i = 0; i < M; i++) {
      ans = gcd(ans, a[0] + b[i]);
    }
    return ans;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int N = 4, M = 3;
 
    // Initialization of the vector
    int A[] = { 1, 7, 25, 55 };
    int B[] = { 1, 3, 5 };
 
    // output
    System.out.print(calculateGCD(A, B, N, M));
  }
}
 
// This code is contributed by sanjoy_62.


Python3




# Python3 code to implement the approach
 
# Function for calculating gcd
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
 
# Function to calculate the required GCD
def calculateGCD(a, b, N, M):
    ans = 0
     
    # sorting the arrays
    a.sort()
    b.sort()
     
    # calculating the gcd of all the elements
    # of type (i, j) i>0 and j>=0
    # Using the property
    # gcd(a[0]+b[j], a[i]+b[j])
    # =gcd(a[0]+b[j], a[i]-a[0])
    for i in range(1, N):
        ans = gcd(ans, a[i] - a[0])
         
    # Calculating the gcd of the remaining
    # elements of the type (a[0]+b[j])
    for i in range(M):
        ans = gcd(ans, a[0] + b[i])
    return ans
 
# Driver code
N, M = 4, 3
A = [1, 7, 25, 55]
B = [1, 3, 5]
 
# function all
print(calculateGCD(A, B, N, M))
 
# This code is contributed by phasing17.


C#




// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
  // Function to calculate gcd
  static int gcd(int a, int b)
  {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
 
  // Function to calculate the GCD
  // of all pairwise sums
  static int calculateGCD(int[] a,
                          int[] b,
                          int N, int M)
  {
    int ans = 0;
 
    // Sorting the arrays
    Array.Sort(a);
    Array.Sort(b);
 
    // Calculating the gcd of all the elements
    // of type (i, j) i>0 and j>=0
    // Using the property
    // gcd(a[0]+b[j], a[i]+b[j])
    // =gcd(a[0]+b[j], a[i]-a[0])
    for (int i = 1; i < N; i++) {
      ans = gcd(ans, a[i] - a[0]);
    }
 
    // Calculating the gcd of the remaining
    // elements of the type (a[0]+b[j])
    for (int i = 0; i < M; i++) {
      ans = gcd(ans, a[0] + b[i]);
    }
    return ans;
  }
 
  // Driver Code
  public static void Main()
  {
    int N = 4, M = 3;
 
    // Initialization of the vector
    int[] A = { 1, 7, 25, 55 };
    int[] B = { 1, 3, 5 };
 
    // output
    Console.Write(calculateGCD(A, B, N, M));
  }
}
 
// This code is contributed by sanjoy_62.


Javascript




<script>
// JavaScript code to implement the approach
 
// Function for calculating gcd
function gcd(a, b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to calculate the required GCD
function calculateGCD(a, b, N, M)
{
    var ans = 0;
     
    // sorting the arrays
    a.sort()
    b.sort()
     
    // calculating the gcd of all the elements
    // of type (i, j) i>0 and j>=0
    // Using the property
    // gcd(a[0]+b[j], a[i]+b[j])
    // =gcd(a[0]+b[j], a[i]-a[0])
    for (var i = 1; i < N; i++)
        ans = gcd(ans, a[i] - a[0]);
         
    // Calculating the gcd of the remaining
    // elements of the type (a[0]+b[j])
    for (var i = 0; i < M; i++)
        ans = gcd(ans, a[0] + b[i]);
    return ans;
}
 
// Driver code
var N = 4;
var M =  3;
var A = [1, 7, 25, 55];
var B = [1, 3, 5];
 
// function all
document.write(calculateGCD(A, B, N, M))
 
// This code is contributed by phasing17.
</script>


Output

2

Time Complexity : O(N*logN + M*logM) 
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!