Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Last Updated : 26 May, 2021

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)



My Personal Notes
arrow_drop_up
Previous
Calculate time required to type a word using given single-row keyboard
Next

Sort a string without altering the position of vowels
Recommended Articles
Page :
Generate a sequence X from given sequence Y such that Yi = gcd(X1, X2 , ... , Xi)
09, Dec 21
Find N distinct integers with GCD of sequence as 1 and GCD of each pair greater than 1
07, Dec 21
Generate all possible sorted arrays from alternate elements of two given sorted arrays
01, Jul 15
Find two numbers whose sum and GCD are given
21, Nov 18
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Smallest subsequence having GCD equal to GCD of given array
20, Oct 20
Generate an N-length array having GCD of all its pairs present in a given 2D array
30, Jul 21
Program to generate an array having convolution of two given arrays
09, Mar 21
Increasing sequence with given GCD
24, Jan 19
Modify sequence of first N natural numbers to a given array by replacing pairs with their GCD
02, Dec 20
Generate Bitonic Sequence of length N from integers in a given range
17, Nov 20
Generate a sequence determined by the characters of a given string
18, Jan 21
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
13, Jan 21
Pair with maximum GCD from two arrays
22, Oct 17
Generate an array representing GCD of nodes of each vertical level of a Binary Tree
13, May 21
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
k-th missing element in increasing sequence which is not present in a given sequence
17, Oct 17
Count of pairs in given Array whose GCD is not prime
12, Aug 21
Given two arrays count all pairs whose sum is an odd number
26, Apr 19
Count pairs from two sorted arrays whose sum is equal to a given value x
23, Jun 17
Given two unsorted arrays, find all pairs whose sum is x
17, Mar 17
Longest sub-sequence with maximum GCD
31, Oct 19
Generate Array whose difference of each element with its left yields the given Array
03, Jul 20
Generate an array of minimum sum whose XOR of same-indexed elements with given array are Prime Numbers
06, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rohitsingh07052
@rohitsingh07052
Vote for difficulty





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!