# 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 ` `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 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 a, ArrayList b,` `                                ``ArrayList 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 A, ArrayList B, ``int` `K,` `                         ``int` `i)` `  ``{`   `    ``// Stores the subsequence` `    ``ArrayList ans = ``new` `ArrayList();`   `    ``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 A = ``new` `ArrayList<>();` `    ``A.add(``5``);` `    ``A.add(``3``);` `    ``A.add(``6``);` `    ``A.add(``2``);` `    ``A.add(``9``);`   `    ``ArrayList B = ``new` `ArrayList();` `    ``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

 ``

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 ` `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 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 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 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

 ``

Output:

`[21, 3, 6, 12, 9]`

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

My Personal Notes arrow_drop_up
Related Articles