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

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])

    # Print 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)