Open In App

Generate an N-length sequence from two given arrays whose GCD is K

Improve
Improve
Like Article
Like
Save
Share
Report

Given two arrays A[] and B[], both of size N, the task is to generate a sequence of length N comprising elements from the two arrays such that the GCD of the generated sequence is K. If it is not possible to generate such a sequence, then print “-1”.

Examples:

Input: A[] = {5, 3, 6, 2, 9}, B[] = {21, 7, 14, 12, 28}, K = 3
Output: 21, 3, 6, 12, 9
Explanation: 
ans[0] = 21 (= B[0])
ans[1] = 3 (= A[1])
ans[2] = 6 (= A[2])
ans[3] = 12 (= B[3])
ans[4] = 9 (= A[4])
Therefore, GCD of the generated sequence is {21, 3, 6, 12, 9} is 3.

Input: A[] = {3, 4, 5, 6, 7}, B[] = {8, 7, 5, 2, 3}, K = 2
Output: -1

Naive Approach: The simplest approach to solve the problem is to use Recursion. Recursively check for all the possible combinations of the given conditions.
Follow the steps below to solve the problem:

  • Define a function to recursively generate all possible combinations and perform the following steps:
    • The base condition is when the length of the current combination is equal to N and check if the GCD of the current combination is equal to K.
    • If the GCD is equal to K, print the combination and return True. Otherwise, return False.
    • Add an element from the array A[] to the combination and proceed further.
    • Remove the added element after the recursive call.
    • Add an element from the array B[] to the combination and proceed further.
    • Remove the added element after the recursive call.
  • If GCD is not equal to K for any combination, then print -1.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate
// GCD of two integers
int GCD(int a, int b)
{
    if (!b)
        return a;
    return GCD(b, a % b);
}
 
// Function to calculate
// GCD of a given array
int GCDArr(vector<int> a)
{
    int ans = a[0];
    for (int i:a)
        ans = GCD(ans, i);
    return ans;
}
 
// Utility function to check for
// all the possible combinations
bool findSubseqUtil(vector<int>  a,vector<int>  b,
                    vector<int>  &ans,int k,int i)
{
 
    // If an N-length sequence
    // is obtained
    if (ans.size() == a.size())
    {
 
        // If GCD of the sequence is K
        if (GCDArr(ans) == k)
        {
           cout << "[";
           int m = ans.size();
           for(int i = 0; i < m - 1; i++)
             cout << ans[i] << ", ";
           cout << ans[m - 1] << "]";
            return true;
          }
       
        // Otherwise
        else
            return false;
      }
 
    // Add an element from the first array
    ans.push_back(a[i]);
 
    // Recursively proceed further
    bool temp = findSubseqUtil(a, b, ans, k, i + 1);
 
    // If combination satisfies
    // the necessary condition
    if (temp)
        return true;
 
    // Remove the element
    // from the combination
    ans.pop_back();
 
    // Add an element from the second array
    ans.push_back(b[i]);
 
    // Recursive proceed further
    temp = findSubseqUtil(a, b, ans, k, i + 1);
 
    // If combination satisfies
    // the necessary condition
    if (temp)
        return true;
 
    // Remove the element
    // from the combination
    ans.pop_back();
    return false;
}
 
// Function to check all the
// possible combinations
void findSubseq(vector<int> A, vector<int>  B,
                int K, int i)
{
 
    // Stores the subsequence
    vector<int>  ans;
 
    findSubseqUtil(A, B, ans, K, i);
 
    // If GCD is not equal to K
    // for any combination
    if (!ans.size())
        cout << -1;
}
 
// Driver Code
int main()
{
 
  // Given arrays
  vector<int> A = {5, 3, 6, 2, 9};
  vector<int>  B = {21, 7, 14, 12, 28};
 
  // Given value of K
  int K = 3;
 
  // Function call to generate
  // the required subsequence
  findSubseq(A, B, K, 0);
 
  return 0;
}
 
// This code is contributed by mohit kumar 29.


Java




// Java program for the above approach
import java.util.*;
import java.lang.*;
class GFG
{
 
  // Function to calculate
  // GCD of two integers
  static int GCD(int a, int b)
  {
    if (b < 1)
      return a;
    return GCD(b, a % b);
  }
 
  // Function to calculate
  // GCD of a given array
  static int GCDArr(ArrayList<Integer> a)
  {
    int ans = a.get(0);
    for(int i : a) ans = GCD(ans, i);
    return ans;
  }
 
  // Utility function to check for
  // all the possible combinations
  static boolean findSubseqUtil(ArrayList<Integer> a, ArrayList<Integer> b,
                                ArrayList<Integer> ans, int k, int i)
  {
 
    // If an N-length sequence
    // is obtained
    if (ans.size() == a.size()) {
 
      // If GCD of the sequence is K
      if (GCDArr(ans) == k) {
        System.out.print("[");
        int m = ans.size();
        for (int j = 0; j < m - 1; j++)
          System.out.print(ans.get(j) + ", ");
        System.out.print(ans.get(m-1) + "]");
        return true;
      }
 
      // Otherwise
      else
        return false;
    }
 
    // Add an element from the first array
    ans.add(a.get(i));
 
    // Recursively proceed further
    boolean temp = findSubseqUtil(a, b, ans, k, i + 1);
 
    // If combination satisfies
    // the necessary condition
    if (temp)
      return true;
 
    // Remove the element
    // from the combination
    ans.remove(ans.size() - 1);
 
    // Add an element from the second array
    ans.add(b.get(i));
 
    // Recursive proceed further
    temp = findSubseqUtil(a, b, ans, k, i + 1);
 
    // If combination satisfies
    // the necessary condition
    if (temp)
      return true;
 
    // Remove the element
    // from the combination
    ans.remove(ans.size() - 1);
    return false;
  }
 
  // Function to check all the
  // possible combinations
  static void findSubseq(ArrayList<Integer> A, ArrayList<Integer> B, int K,
                         int i)
  {
 
    // Stores the subsequence
    ArrayList<Integer> ans = new ArrayList<Integer>();
 
    findSubseqUtil(A, B, ans, K, i);
 
    // If GCD is not equal to K
    // for any combination
    if (ans.size() < 1)
      System.out.println(-1);
  }
 
  // Driver code
  public static void main(String[] args)
  {
    // Given arrays
    ArrayList<Integer> A = new ArrayList<>();
    A.add(5);
    A.add(3);
    A.add(6);
    A.add(2);
    A.add(9);
 
    ArrayList<Integer> B = new ArrayList<Integer>();
    B.add(21);
    B.add(7);
    B.add(14);
    B.add(12);
    B.add(28);
 
    // Given value of K
    int K = 3;
 
    // Function call to generate
    // the required subsequence
    findSubseq(A, B, K, 0);
  }
}
 
// This code is contributed by sanjoy_62.


Python3




# Python3 program for the above approach
 
# Function to calculate
# GCD of two integers
 
 
def GCD(a, b):
    if not b:
        return a
    return GCD(b, a % b)
 
# Function to calculate
# GCD of a given array
 
 
def GCDArr(a):
    ans = a[0]
    for i in a:
        ans = GCD(ans, i)
    return ans
 
# Utility function to check for
# all the possible combinations
 
 
def findSubseqUtil(a, b, ans, k, i):
 
    # If an N-length sequence
    # is obtained
    if len(ans) == len(a):
 
        # If GCD of the sequence is K
        if GCDArr(ans) == k:
            print(ans)
            return True
 
        # Otherwise
        else:
            return False
 
    # Add an element from the first array
    ans.append(a[i])
 
    # Recursively proceed further
    temp = findSubseqUtil(a, b, ans, k, i+1)
 
    # If combination satisfies
    # the necessary condition
    if temp == True:
        return True
 
    # Remove the element
    # from the combination
    ans.pop()
 
    # Add an element from the second array
    ans.append(b[i])
 
    # Recursive proceed further
    temp = findSubseqUtil(a, b, ans, k, i+1)
 
    # If combination satisfies
    # the necessary condition
    if temp == True:
        return True
 
    # Remove the element
    # from the combination
    ans.pop()
 
# Function to check all the
# possible combinations
 
 
def findSubseq(A, B, K, i):
 
    # Stores the subsequence
    ans = []
 
    findSubseqUtil(A, B, ans, K, i)
 
    # If GCD is not equal to K
    # for any combination
    if not ans:
        print(-1)
 
# Driver Code
 
 
# Given arrays
A = [5, 3, 6, 2, 9]
B = [21, 7, 14, 12, 28]
 
# Given value of K
K = 3
 
# Function call to generate
# the required subsequence
ans = findSubseq(A, B, K, 0)


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
  // Function to calculate
  // GCD of two integers
  static int GCD(int a, int b)
  {
    if (b < 1)
      return a;
    return GCD(b, a % b);
  }
 
  // Function to calculate
  // GCD of a given array
  static int GCDArr(List<int> a)
  {
    int ans = a[0];
    foreach(int i in a) ans = GCD(ans, i);
    return ans;
  }
 
  // Utility function to check for
  // all the possible combinations
  static bool findSubseqUtil(List<int> a, List<int> b,
                             List<int> ans, int k, int i)
  {
 
    // If an N-length sequence
    // is obtained
    if (ans.Count == a.Count) {
 
      // If GCD of the sequence is K
      if (GCDArr(ans) == k) {
        Console.Write("[");
        int m = ans.Count;
        for (int j = 0; j < m - 1; j++)
          Console.Write(ans[j] + ", ");
        Console.Write(ans[m - 1] + "]");
        return true;
      }
 
      // Otherwise
      else
        return false;
    }
 
    // Add an element from the first array
    ans.Add(a[i]);
 
    // Recursively proceed further
    bool temp = findSubseqUtil(a, b, ans, k, i + 1);
 
    // If combination satisfies
    // the necessary condition
    if (temp)
      return true;
 
    // Remove the element
    // from the combination
    ans.RemoveAt(ans.Count - 1);
 
    // Add an element from the second array
    ans.Add(b[i]);
 
    // Recursive proceed further
    temp = findSubseqUtil(a, b, ans, k, i + 1);
 
    // If combination satisfies
    // the necessary condition
    if (temp)
      return true;
 
    // Remove the element
    // from the combination
    ans.RemoveAt(ans.Count - 1);
    return false;
  }
 
  // Function to check all the
  // possible combinations
  static void findSubseq(List<int> A, List<int> B, int K,
                         int i)
  {
 
    // Stores the subsequence
    List<int> ans = new List<int>();
 
    findSubseqUtil(A, B, ans, K, i);
 
    // If GCD is not equal to K
    // for any combination
    if (ans.Count < 1)
      Console.WriteLine(-1);
  }
 
  // Driver Code
  public static void Main()
  {
 
    // Given arrays
    List<int> A = new List<int>{ 5, 3, 6, 2, 9 };
    List<int> B = new List<int>{ 21, 7, 14, 12, 28 };
 
    // Given value of K
    int K = 3;
 
    // Function call to generate
    // the required subsequence
    findSubseq(A, B, K, 0);
  }
}
 
// This code is contributed by ukasp.


Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to calculate
  // GCD of two integers
function GCD(a,b)
{
    if (b < 1)
      return a;
    return GCD(b, a % b);
}
 
// Function to calculate
  // GCD of a given array
function GCDArr(a)
{
    let ans = a[0];
    for(let i=0;i<a.length;i++)
        ans = GCD(ans, a[i]);
    return ans;
}
 
// Utility function to check for
  // all the possible combinations
function findSubseqUtil(a,b,ans,k,i)
{
    // If an N-length sequence
    // is obtained
    if (ans.length == a.length) {
  
      // If GCD of the sequence is K
      if (GCDArr(ans) == k) {
        document.write("[");
        let m = ans.length;
        for (let j = 0; j < m - 1; j++)
          document.write(ans[j] + ", ");
        document.write(ans[m-1] + "]");
        return true;
      }
  
      // Otherwise
      else
        return false;
    }
  
    // Add an element from the first array
    ans.push(a[i]);
  
    // Recursively proceed further
    let temp = findSubseqUtil(a, b, ans, k, i + 1);
  
    // If combination satisfies
    // the necessary condition
    if (temp)
      return true;
  
    // Remove the element
    // from the combination
    ans.splice(ans.length - 1,1);
  
    // Add an element from the second array
    ans.push(b[i]);
  
    // Recursive proceed further
    temp = findSubseqUtil(a, b, ans, k, i + 1);
  
    // If combination satisfies
    // the necessary condition
    if (temp)
      return true;
  
    // Remove the element
    // from the combination
    ans.splice(ans.length - 1,1);
    return false;
}
 
// Function to check all the
  // possible combinations
function findSubseq(A,B,K,i)
{
    // Stores the subsequence
    let ans = [];
  
    findSubseqUtil(A, B, ans, K, i);
  
    // If GCD is not equal to K
    // for any combination
    if (ans.length < 1)
      document.write(-1);
}
 
// Driver code
 
// Given arrays
let A = [5, 3, 6, 2, 9];
let B = [21, 7, 14, 12, 28];
 
// Given value of K
let K = 3;
 
// Function call to generate
// the required subsequence
findSubseq(A, B, K, 0);
         
// This code is contributed by patel2127
 
</script>


Output: 

[21, 3, 6, 12, 9]

 

Time Complexity: O(2N * N * logN)
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, follow the steps below to solve the problem:

  • The GCD of the sequence will be equal to K, only if all the elements present in the sequence are divisible by K.
  • Traverse the arrays simultaneously and perform the following steps:
    • Check if the current element in the array A[] is divisible by K. If found to be true, then make a recursive call.  Otherwise, return false.
    • Check if the current element in the array B[] is divisible by K. If found to be true, then make a recursive call. Otherwise, return false.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
int GCD(int a, int b)
{
    if (b == 0)
        return a;
         
    return GCD(b, a % b);
}
 
// Function to calculate
// GCD of given array
int GCDArr(vector<int> a)
{
    int ans = a[0];
    for(auto val : a)
    {
        ans = GCD(ans, val);
    }
    return ans;
}
 
// Utility function to check for
// all the combinations
bool findSubseqUtil(int a[], int b[], vector<int> ans,
                    int k, int i, int N)
{
 
    // If a sequence of size N
    // is obtained
    if (ans.size() == N)
    {
         
        // If gcd of current
        // combination is K
        if (GCDArr(ans) == k)
        {
            for(auto val : ans)
                cout << val << " ";
                 
            return true;
        }
        else
        {
            return false;
        }
    }
     
    // If current element from
    // first array is divisible by K
    if (a[i] % k == 0)
    {
        ans.push_back(a[i]);
 
        // Recursively proceed further
        bool temp = findSubseqUtil(a, b, ans, k,
                                   i + 1, N);
 
        // If current combination
        // satisfies given condition
        if (temp == true)
            return true;
 
        // Remove the element
        // from the combination
        ans.pop_back();
    }
 
    // If current element from
    // second array is divisible by K
    if (b[i] % k == 0)
    {
        ans.push_back(b[i]);
 
        // Recursively proceed further
        bool temp = findSubseqUtil(a, b, ans, k,
                                   i + 1, N);
 
        // If current combination
        // satisfies given condition
        if (temp == true)
            return true;
 
        // Remove the element
        // from the combination
        ans.pop_back();
    }
    return false;
}
 
// Function to check for all
// possible combinations
void findSubseq(int A[], int B[], int K,
                int i, int N)
{
 
    // Stores the subsequence
    vector<int> ans;
 
    bool ret = findSubseqUtil(A, B, ans,
                              K, i, N);
 
    // If GCD of any sequence
    // is not equal to K
    if (ret == false)
        cout << -1 << "\n";
}
 
// Driver Code
int main()
{
     
    // Given arrays
    int A[] = { 5, 3, 6, 2, 9 };
    int B[] = { 21, 7, 14, 12, 28 };
 
    // size of the array
    int N = sizeof(A) / sizeof(A[0]);
 
    // Given value of K
    int K = 3;
 
    // Function call to generate a
    // subsequence whose GCD is K
    findSubseq(A, B, K, 0, N);
 
    return 0;
}
 
// This code is contributed by Kingash


Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
static int GCD(int a, int b)
{
    if (b == 0)
        return a;
         
    return GCD(b, a % b);
}
 
// Function to calculate
// GCD of given array
static int GCDArr(ArrayList<Integer> a)
{
    int ans = a.get(0);
    for(int val : a)
    {
        ans = GCD(ans, val);
    }
    return ans;
}
 
// Utility function to check for
// all the combinations
static boolean findSubseqUtil(int a[], int b[],
                              ArrayList<Integer> ans,
                              int k, int i)
{
     
    // If a sequence of size N
    // is obtained
    if (ans.size() == a.length)
    {
         
        // If gcd of current
        // combination is K
        if (GCDArr(ans) == k)
        {
            System.out.println(ans);
            return true;
        }
        else
        {
            return false;
        }
    }
     
    // If current element from
    // first array is divisible by K
    if (a[i] % k == 0)
    {
        ans.add(a[i]);
 
        // Recursively proceed further
        boolean temp = findSubseqUtil(a, b, ans,
                                      k, i + 1);
 
        // If current combination
        // satisfies given condition
        if (temp == true)
            return true;
 
        // Remove the element
        // from the combination
        ans.remove(ans.size() - 1);
    }
 
    // If current element from
    // second array is divisible by K
    if (b[i] % k == 0)
    {
        ans.add(b[i]);
 
        // Recursively proceed further
        boolean temp = findSubseqUtil(a, b, ans,
                                      k, i + 1);
 
        // If current combination
        // satisfies given condition
        if (temp == true)
            return true;
 
        // Remove the element
        // from the combination
        ans.remove(ans.size() - 1);
    }
    return false;
}
 
// Function to check for all
// possible combinations
static void findSubseq(int A[], int B[],
                       int K, int i)
{
     
    // Stores the subsequence
    ArrayList<Integer> ans = new ArrayList<>();
 
    boolean ret = findSubseqUtil(A, B, ans, K, i);
 
    // If GCD of any sequence
    // is not equal to K
    if (ret == false)
        System.out.println(-1);
}
 
// Driver Code
public static void main(String[] args)
{
 
    // Given arrays
    int A[] = { 5, 3, 6, 2, 9 };
    int B[] = { 21, 7, 14, 12, 28 };
 
    // Given value of K
    int K = 3;
 
    // Function call to generate a
    // subsequence whose GCD is K
    findSubseq(A, B, K, 0);
}
}
 
// This code is contributed by Kingash


Python3




# Python3 program for the above approach
 
# Function to calculate
# GCD of two integers
 
 
def GCD(a, b):
    if not b:
        return a
    return GCD(b, a % b)
 
# Function to calculate
# GCD of given array
def GCDArr(a):
    ans = a[0]
    for i in a:
        ans = GCD(ans, i)
    return ans
 
# Utility function to check for
# all the combinations
def findSubseqUtil(a, b, ans, k, i):
 
    # If a sequence of size N
    # is obtained
    if len(ans) == len(a):
 
        # If gcd of current
        # combination is K
        if GCDArr(ans) == k:
            print(ans)
            return True
 
        else:
            return False
 
    # If current element from
    # first array is divisible by K
    if not a[i] % K:
        ans.append(a[i])
 
        # Recursively proceed further
        temp = findSubseqUtil(a, b, ans, k, i+1)
 
        # If current combination
        # satisfies given condition
        if temp == True:
            return True
 
        # Remove the element
        # from the combination
        ans.pop()
 
    # If current element from
    # second array is divisible by K
    if not b[i] % k:
 
        ans.append(b[i])
 
        # Recursively proceed further
        temp = findSubseqUtil(a, b, ans, k, i+1)
 
        # If current combination
        # satisfies given condition
        if temp == True:
            return True
 
        # Remove the element
        # from the combination
        ans.pop()
 
    return False
 
# Function to check for all
# possible combinations
def findSubseq(A, B, K, i):
 
    # Stores the subsequence
    ans = []
 
    findSubseqUtil(A, B, ans, K, i)
 
    # If GCD of any sequence
    # is not equal to K
    if not ans:
        print(-1)
 
# Driver Code
 
 
# Given arrays
A = [5, 3, 6, 2, 9]
B = [21, 7, 14, 12, 28]
 
# Given value of K
K = 3
 
# Function call to generate a
# subsequence whose GCD is K
ans = findSubseq(A, B, K, 0)


C#




// C# program for the above approach
 
using System;
using System.Collections.Generic;
 
class GFG{
 
static int GCD(int a, int b)
{
    if (b == 0)
        return a;
         
    return GCD(b, a % b);
}
 
// Function to calculate
// GCD of given array
static int GCDArr(List<int> a)
{
    int ans = a[0];
    foreach (int val in a)
    {
        ans = GCD(ans, val);
    }
    return ans;
}
 
// Utility function to check for
// all the combinations
static bool findSubseqUtil(int []a, int []b, List<int> ans,
                    int k, int i, int N)
{
 
    // If a sequence of size N
    // is obtained
    if (ans.Count == N)
    {
         
        // If gcd of current
        // combination is K
        if (GCDArr(ans) == k)
        {
            foreach(int val in ans)
               Console.Write(val+" ");
                 
            return true;
        }
        else
        {
            return false;
        }
    }
     
    // If current element from
    // first array is divisible by K
    if (a[i] % k == 0)
    {
        ans.Add(a[i]);
 
        // Recursively proceed further
        bool temp = findSubseqUtil(a, b, ans, k,
                                   i + 1, N);
 
        // If current combination
        // satisfies given condition
        if (temp == true)
            return true;
 
        // Remove the element
        // from the combination
        ans.RemoveAt(ans.Count - 1);
    }
 
    // If current element from
    // second array is divisible by K
    if (b[i] % k == 0)
    {
        ans.Add(b[i]);
 
        // Recursively proceed further
        bool temp = findSubseqUtil(a, b, ans, k,
                                   i + 1, N);
 
        // If current combination
        // satisfies given condition
        if (temp == true)
            return true;
 
        // Remove the element
        // from the combination
        ans.RemoveAt(ans.Count - 1);
    }
    return false;
}
 
// Function to check for all
// possible combinations
static void findSubseq(int []A, int []B, int K,
                int i, int N)
{
 
    // Stores the subsequence
    List<int> ans = new List<int>();
 
    bool ret = findSubseqUtil(A, B, ans,
                              K, i, N);
 
    // If GCD of any sequence
    // is not equal to K
    if (ret == false)
        Console.Write(-1);
}
 
// Driver Code
public static void Main()
{
     
    // Given arrays
    int []A = { 5, 3, 6, 2, 9 };
    int []B = { 21, 7, 14, 12, 28 };
   
    // size of the array
    int N = A.Length;
   
    // Given value of K
    int K = 3;
   
    // Function call to generate a
    // subsequence whose GCD is K
    findSubseq(A, B, K, 0, N);
}
}
 
// This code is contributed by ipg2016107.


Javascript




<script>
 
      // JavaScript program for the above approach
 
      function GCD(a, b) {
        if (b === 0) return a;
 
        return GCD(b, a % b);
      }
 
      // Function to calculate
      // GCD of given array
      function GCDArr(a) {
        var ans = a[0];
        for (const val of a) {
          ans = GCD(ans, val);
        }
        return ans;
      }
 
      // Utility function to check for
      // all the combinations
      function findSubseqUtil(a, b, ans, k, i, N) {
        // If a sequence of size N
        // is obtained
        if (ans.length === N) {
          // If gcd of current
          // combination is K
          if (GCDArr(ans) === k) {
            document.write("[" + ans + "]");
            return true;
          } else {
            return false;
          }
        }
 
        // If current element from
        // first array is divisible by K
        if (a[i] % k === 0) {
          ans.push(a[i]);
 
          // Recursively proceed further
          var temp = findSubseqUtil(a, b, ans, k, i + 1, N);
 
          // If current combination
          // satisfies given condition
          if (temp === true) return true;
 
          // Remove the element
          // from the combination
          delete ans[ans.length - 1];
        }
 
        // If current element from
        // second array is divisible by K
        if (b[i] % k === 0) {
          ans.push(b[i]);
 
          // Recursively proceed further
          var temp = findSubseqUtil(a, b, ans, k, i + 1, N);
 
          // If current combination
          // satisfies given condition
          if (temp === true) return true;
 
          // Remove the element
          // from the combination
          delete ans[ans.length - 1];
        }
        return false;
      }
 
      // Function to check for all
      // possible combinations
      function findSubseq(A, B, K, i, N) {
        // Stores the subsequence
        var ans = [];
 
        var ret = findSubseqUtil(A, B, ans, K, i, N);
 
        // If GCD of any sequence
        // is not equal to K
        if (ret === false) document.write(-1);
      }
 
      // Driver Code
      // Given arrays
      var A = [5, 3, 6, 2, 9];
      var B = [21, 7, 14, 12, 28];
 
      // size of the array
      var N = A.length;
 
      // Given value of K
      var K = 3;
 
      // Function call to generate a
      // subsequence whose GCD is K
      findSubseq(A, B, K, 0, N);
       
</script>


Output: 

[21, 3, 6, 12, 9]

 

Time Complexity: O(2N * N * logN)
Auxiliary Space: O(N)



Last Updated : 26 May, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads