Skip to content
Related Articles
Open in App
Not now

Related Articles

Calculate GCD of all pairwise sum of given two Arrays

Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 04 May, 2022
Improve Article
Save Article
Like 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
Like Article

Save Article

Related Articles
1.
XOR of all possible pairwise sum from two given Arrays
2.
Kth largest pairwise product possible from given two Arrays
3.
Maximize sum of pairwise products generated from the given Arrays
4.
Pair of integers having least GCD among all given pairs having GCD exceeding K
5.
Calculate the Sum of GCD over all subarrays
6.
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
7.
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
8.
Smallest subsequence having GCD equal to GCD of given array
9.
Generate an N-length sequence from two given arrays whose GCD is K
10.
Find all pairwise sum possible using elements at opposite ends with minimum replacements
Previous
Longest Substring with at most X 0s and Y 1s of given String
Next

Minimize operations to make all elements equal by replacing left half of Subarray with right half
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rudrachhangani
@rudrachhangani
Vote for difficulty
Current difficulty :
Medium





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!