# Find all possible GCDs of every subsequences of given Array

• Difficulty Level : Hard
• Last Updated : 09 Aug, 2021

Given an array arr[] consisting of N positive integers, the task is to find all the possible distinct Greatest Common Divisors(GCDs) among all the non-empty subsequences of the array arr[].

Examples:

Input: arr[] = {3, 4, 8}
Output: 1 3 4 8
Explanation:
The non-empty subsequences possible are {3}, {4}, {8}, {3, 4}, {4, 8}, {3, 8}, {3, 4, 8} and their corresponding GCDs are 3, 4, 8, 1, 4, 1, 1.
Therefore, print all the GCDs as {1, 3, 4, 8}.

Input: arr[] = {3, 8, 9, 4, 13, 45, 6}
Output: 1 2 3 4 6 8 9 13 45

Naive Approach: The simplest approach to solve the given problem is to generate all possible subsequences of the given array and store all the GCDs of the subsequence in a set. After checking for all the subsequences, print the element stores in the set as all possible GCDs that can be formed.

Time Complexity: O(log M*2N), where M is the maximum element of the array.
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized using Greedy Approach by observing the fact that the GCD of any subsequence lies over the range [1, M] where M is the maximum element of the array. Therefore, the idea is to iterate over then range [1, M] and if any element in the range is a factor of an array element then print the current element as one of the resultant GCD. Follow the steps below to solve the problem:

• Store all the array elements in the HashSet, say s.
• Iterate over the range [1, M] using the variable i and perform the following steps:
• Iterate through all the multiples of i, if there exists any multiple which is present in the HashSet, then print the current element i as one of the possible GCD.

Below is an implementation of the above approach:

// C++ program for the above approach

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the different GCDs of` `// the subsequence of the given array` `void` `findGCDsSubsequence(vector<``int``> arr)` `{` `    `  `    ``// Stores all the possible GCDs` `    ``vector<``int``> ans;`   `    ``// Stores all array element in set` `    ``set<``int``> s;` `    ``for``(``int` `i : arr)` `        ``s.insert(i);` `        `  `    ``int` `M = *max_element(arr.begin(), arr.end());` `    `  `    ``// Iterate over the range [1, M]` `    ``for``(``int` `i = 1; i <= M; i++) ` `    ``{` `        ``int` `gcd = 0;`   `        ``// Check if i can be the GCD of` `        ``// any subsequence` `        ``for``(``int` `j = i; j < M + 1; j += i) ` `        ``{` `            ``if` `(s.find(j) != s.end())` `                ``gcd = __gcd(gcd, j);` `        ``}` `        ``if` `(gcd == i)` `            ``ans.push_back(i);` `    ``}` `    ``for``(``int` `i = 0; i < ans.size(); i++)` `        ``cout << ans[i] << ``" "``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 7;` `    ``vector<``int``> arr = { 3, 4, 8 };`   `    ``// Function Call` `    ``findGCDsSubsequence(arr);` `    ``return` `0;` `}`   `// This code is contributed by parthagarwal1962000`

## Java

 `// Java program for the above approach` `import` `java.util.*; ` `public` `class` `GFG {` `static` `int` `gcd1(``int` `a, ``int` `b)` `{` `    ``return` `b == ``0` `? a : gcd1(b, a % b);` `}`   `// Function to find the different GCDs of` `// the subsequence of the given array` `static` `void` `findGCDsSubsequence(ArrayList arr)` `{` `    `  `    ``// Stores all the possible GCDs` `    ``ArrayList ans = ``new` `ArrayList();`   `    ``// Stores all array element in set` `    ``HashSet s = ``new` `HashSet();` `    ``for``(``int` `i : arr)` `        ``s.add(i);` `        `  `    ``int` `M = Integer.MIN_VALUE;` `    ``for``(``int` `i : arr)` `    ``{` `        ``if` `(i > M)` `            ``M = i;` `    ``}`   `    ``// Iterate over the range [1, M]` `    ``for``(``int` `i = ``1``; i <= M; i++) ` `    ``{` `        ``int` `gcd = ``0``;`   `        ``// Check if i can be the GCD of` `        ``// any subsequence` `        ``for``(``int` `j = i; j < M + ``1``; j += i) ` `        ``{` `            ``if` `(s.contains(j))` `                ``gcd = gcd1(gcd, j);` `        ``}` `        ``if` `(gcd == i)` `            ``ans.add(i);` `    ``}` `    ``for``(``int` `i = ``0``; i < ans.size(); i++)` `       ``System.out.print(ans.get(i) + ``" "``);` `}`   `// Driver Code` ` ``public` `static` `void` `main(String args[]) ` `{` `    ``ArrayList arr = ``new` `ArrayList();` `    ``arr.add(``3``);` `    ``arr.add(``4``);` `    ``arr.add(``8``);`   `    ``// Function Call` `    ``findGCDsSubsequence(arr);` `}` `}` `// This code is contributed by SoumikMondal`

## Python3

 `# Python3 program for the above approach` `import` `math`   `# Function to find the different GCDs of` `# the subsequence of the given array` `def` `findGCDsSubsequence(nums):`   `        ``# Stores all the possible GCDs` `    ``Ans ``=` `[]`   `    ``# Stores all array element in set` `    ``s ``=` `set``(nums)`   `    ``# Find the maximum array element` `    ``M ``=` `max``(nums)`   `    ``# Iterate over the range [1, M]` `    ``for` `i ``in` `range``(``1``, M ``+` `1``):` `      `  `          ``# Stores the GCD of subsequence` `        ``gcd ``=` `0`   `        ``# Check if i can be the GCD of` `        ``# any subsequence` `        ``for` `j ``in` `range``(i, M ``+` `1``, i):` `            ``if` `j ``in` `s:` `                ``gcd ``=` `math.gcd(gcd, j)`   `        ``# Store the value i in Ans[]` `        ``# if it can be the GCD` `        ``if` `gcd ``=``=` `i:` `            ``Ans ``+``=` `[i]`   `    ``# Print all possible GCDs stored` `    ``print``(``*``Ans)`     `# Driver Code` `N ``=` `7` `arr ``=` `[``3``, ``4``, ``8``]`   `# Function Call` `findGCDsSubsequence(arr)`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `static` `int` `gcd1(``int` `a, ``int` `b)` `{` `    ``return` `b == 0 ? a : gcd1(b, a % b);` `}`   `// Function to find the different GCDs of` `// the subsequence of the given array` `static` `void` `findGCDsSubsequence(List<``int``> arr)` `{` `    `  `    ``// Stores all the possible GCDs` `    ``List<``int``> ans = ``new` `List<``int``>();`   `    ``// Stores all array element in set` `    ``HashSet<``int``> s = ``new` `HashSet<``int``>();` `    ``foreach``(``int` `i ``in` `arr)` `        ``s.Add(i);` `        `  `    ``int` `M = Int32.MinValue;` `    ``foreach``(``int` `i ``in` `arr)` `    ``{` `        ``if` `(i > M)` `            ``M = i;` `    ``}`   `    ``// Iterate over the range [1, M]` `    ``for``(``int` `i = 1; i <= M; i++) ` `    ``{` `        ``int` `gcd = 0;`   `        ``// Check if i can be the GCD of` `        ``// any subsequence` `        ``for``(``int` `j = i; j < M + 1; j += i) ` `        ``{` `            ``if` `(s.Contains(j))` `                ``gcd = gcd1(gcd, j);` `        ``}` `        ``if` `(gcd == i)` `            ``ans.Add(i);` `    ``}` `    ``for``(``int` `i = 0; i < ans.Count; i++)` `        ``Console.Write(ans[i] + ``" "``);` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``List<``int``> arr = ``new` `List<``int``>(){ 3, 4, 8 };`   `    ``// Function Call` `    ``findGCDsSubsequence(arr);` `}` `}`   `// This code is contributed by SURENDRA_GANGWAR`

## Javascript

 ``

Output

`1 3 4 8`

Time Complexity: O(M*log M), where M is the maximum element of the array.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :