Skip to content
Related Articles

Related Articles

Find GCD of each element of array B[] added to all elements of array A[]

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 24 Nov, 2021
Improve Article
Save Article

Given two arrays a[] and b[] of length n and m respectively, the task is to find Greatest Common Divisor(GCD) of {a[0] + b[i], a[1] + b[i], a[2] + b[i], …, a[n – 1] + b[i]} ( where 0 <= i <= m – 1).

Input: a[] = {1, 10, 22, 64},  b[] = {5, 23, 14, 13}
Output: 3 3 3 1  
Explanation:

  • i = 1 :  GCD(5+1, 5+10, 5+22, 5+64) = GCD(6, 15, 27, 69) = 3
  • i = 2 : GCD(23+1, 23+10, 23+22, 23+64) = GCD(24, 33, 45, 87) = 3
  • i = 3 : GCD(14+1, 14+10, 14+22, 14+64) = GCD(15, 24, 36, 78) = 3
  • i = 4 : GCD(13+1, 13+10, 13+22, 13+64) = GCD(14, 23, 35, 77) = 1

Input: a[] = {12, 30},  b[] = {5, 23, 14, 13}
Output: 1 1 2 1

Approach: The problem can be solved efficiently using the property of Euclidean GCD Algorithm which states GCD(x, y) = GCD(x−y, y). The same applies for multiple arguments GCD(x, y, z, …) = GCD(x−y. y, z, …). Applying this property, the problem can be solved using the steps given below:

  • To calculate GCD(a[0] + b[i], …, a[n – 1] + b[i]), subtract a[0] + b[i] from all other arguments.
  • Now, GCD ( a[0] + b[i], …, a[n – 1] + b[i]) = GCD ( a[0] + b[i], a[1] − a[0], …, a[n – 1] − a[0]).
  • Find G = GCD(a[1] − a[0], …, a[n – 1] − a[0]), then gcd for any i can be calculated to be GCD(a[0] + b[i], G).
  • Iterate over every possible value of i from 1 to m and calculate gcd as G(i) = GCD(a[1]+b[i], G), and print G(i).

Below is the implementation of the above approach.

C++




// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
 
// Function to calculate gcd for every i
void findGCDs(vector<ll> a, vector<ll> b)
{
    ll g = 0;
 
    int n = a.size();
    int m = b.size();
 
    // Update GCD of a[1] - a[0],
    // a[2] - a[0], .... a[n - 1] - a[0]
    for (int i = 1; i < n; i++) {
 
        g = __gcd(g, a[i] - a[0]);
    }
 
    // Print gcd(g, a[0] + b[j])
    for (int j = 0; j < m; j++) {
 
        cout << __gcd(g, a[0] + b[j]) << " ";
    }
}
 
// Driver Code
int main()
{
    // Given Input
    vector<ll> a = { 1, 10, 22, 64 },
               b = { 5, 23, 14, 13 };
 
    // Function Call
    findGCDs(a, b);
 
    return 0;
}

Java




// Java code for the above approach
public class GFG{
    static int gcd(int a, int b)
    {    
       if (b == 0)
          return a;
       return gcd(b, a % b);
    }
     
    // Function to calculate gcd for every i
    static void findGCDs(int[] a, int[] b)
    {
        int g = 0;
     
        int n = a.length;
        int m = b.length;
     
        // Update GCD of a[1] - a[0],
        // a[2] - a[0], .... a[n - 1] - a[0]
        for (int i = 1; i < n; i++) {
     
            g = gcd(g, a[i] - a[0]);
        }
     
        // Print gcd(g, a[0] + b[j])
        for (int j = 0; j < m; j++) {
     
            System.out.print(gcd(g, a[0] + b[j]) + " ");
        }
    }
     
    // Driver Code
public static void main(String args[])
   {
       
    // Given Input
    int[] a = { 1, 10, 22, 64 },
        b = { 5, 23, 14, 13 };
 
    // Function Call
    findGCDs(a, b);
   }
}
 
// This code is contributed by SoumikMondal.

Python3




# Python program for above approach
import math
 
# Function to calculate gcd for every i
def findGCDs( a,  b):
    g = 0
    n = len(a)
    m = len(b)
     
    # Update GCD of a[1] - a[0],
    # a[2] - a[0], .... a[n - 1] - a[0]
    for i in range(1,n):
        g = math.gcd(g, a[i] - a[0])
     
    # Pr gcd(g, a[0] + b[j])
    for j in range(m):
        print(math.gcd(g, a[0] + b[j]), end=" ")
     
# Driver Code
 
# Given Input
a = [1, 10, 22, 64]
b = [5, 23, 14, 13]
 
# Function Call
findGCDs(a, b)
 
#This code is contributed by shubhamsingh10

C#




//C# code for the above approach
using System;
 
public class GFG{
    static int gcd(int a, int b)
    {    
       if (b == 0)
          return a;
       return gcd(b, a % b);
    }
     
    // Function to calculate gcd for every i
    static void findGCDs(int[] a, int[] b)
    {
        int g = 0;
     
        int n = a.Length;
        int m = b.Length;
     
        // Update GCD of a[1] - a[0],
        // a[2] - a[0], .... a[n - 1] - a[0]
        for (int i = 1; i < n; i++) {
     
            g = gcd(g, a[i] - a[0]);
        }
     
        // Print gcd(g, a[0] + b[j])
        for (int j = 0; j < m; j++) {
     
            Console.Write(gcd(g, a[0] + b[j]) + " ");
        }
    }
     
    // Driver Code
    static public void Main ()
   {
       
    // Given Input
    int[] a = { 1, 10, 22, 64 },
        b = { 5, 23, 14, 13 };
 
    // Function Call
    findGCDs(a, b);
   }
}
 
// This code is contributed by shubhamsingh10.

Javascript




<script>
    // JavaScript Program for the above approach
 
    // Function to calculate gcd for every i
    function gcd(a, b)
    {
     
        // Everything divides 0
        if (a == 0)
            return b;
        if (b == 0)
            return a;
 
        // base case
        if (a == b)
            return a;
 
        // a is greater
        if (a > b)
            return gcd(a - b, b);
        return gcd(a, b - a);
    }
    function findGCDs(a, b) {
        let g = 0;
 
        let n = a.length;
        let m = b.length;
 
        // Update GCD of a[1] - a[0],
        // a[2] - a[0], .... a[n - 1] - a[0]
        for (let i = 1; i < n; i++) {
 
            g = gcd(g, a[i] - a[0]);
        }
 
        // Print gcd(g, a[0] + b[j])
        for (let j = 0; j < m; j++) {
 
            document.write(gcd(g, a[0] + b[j]) + " ");
        }
    }
 
    // Driver Code
 
    // Given Input
    let a = [1, 10, 22, 64]
    let b = [5, 23, 14, 13];
 
    // Function Call
    findGCDs(a, b);
 
// This code is contributed by Potta Lokesh
</script>

Output: 

3 3 3 1

 

Time Complexity: O((N + M) * log(X)), where M is the maximum element in the array a[].
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!