Largest subsequence having GCD greater than 1

11 Aug, 2021
Given an array, arr[], find the largest subsequence such that GCD of all those subsequences are greater than 1. Examples:  
Input: 3, 6, 2, 5, 4
Output: 3
Explanation: There are only three elements(6, 
2, 4) having GCD greater than 1 i.e., 2. So the 
largest subsequence will be 3

Input: 10, 15, 7, 25, 9, 35
Output: 4
 
 
Naive Approach(Method 1)
Simple approach is to generate all the subsequence one by one and then find the GCD of all such generated set. Problem of this approach is that it grows exponentially in 2N 
Iterative Approach(Method 2)
If we observe then we will found that to make gcd greater than 1, all such elements must contain common factor greater than 1 which evenly divides all these values. So in order to get that factor we will iterate from 2 to Maximum element of array and then check for divisibility.  
C++
Java
Python3
C#
PHP
Javascript
// Simple C++ program to find length of// the largest subsequence with GCD greater// than 1.#include<bits/stdc++.h> using namespace std; // Returns length of the largest subsequence// with GCD more than 1.int largestGCDSubsequence(int arr[], int n){    int ans = 0;     // Finding the Maximum value in arr[]    int maxele = *max_element(arr, arr+n);     // Iterate from 2 to maximum possible    // divisor of all give values    for (int i=2; i<=maxele; ++i)    {        int count = 0;        for (int j=0; j<n; ++j)        {            // If we found divisor,            // increment count            if (arr[j]%i == 0)                ++count;        }        ans = max(ans, count);    }     return ans;} // Driver codeint main(){    int arr[] = {3, 6, 2, 5, 4};    int size = sizeof(arr) / sizeof(arr[0]);    cout << largestGCDSubsequence(arr, size);    return 0;}
// Efficient Java program to find length of// the largest subsequence with GCD greater// than 1.import java.util.Arrays; class GFG {// Returns length of the largest subsequence// with GCD more than 1.static int largestGCDSubsequence(int arr[], int n){    int ans = 0;      // Finding the Maximum value in arr[]    int maxele = Arrays.stream(arr).max().getAsInt();;      // Iterate from 2 to maximum possible    // divisor of all give values    for (int i=2; i<=maxele; ++i)    {        int count = 0;        for (int j=0; j<n; ++j)        {            // If we found divisor,            // increment count            if (arr[j]%i == 0)                ++count;        }        ans = Math.max(ans, count);    }      return ans;}// Driver program to test above     public static void main(String[] args) {         int arr[] = {3, 6, 2, 5, 4};        int size = arr.length;         System.out.println(largestGCDSubsequence(arr, size));    }} //this code contributed by Rajput-Ji
# Simple Python 3 program to find length of# the largest subsequence with GCD greater# than 1. # Returns length of the largest subsequence# with GCD more than 1.def largestGCDSubsequence(arr, n):    ans = 0     # Finding the Maximum value in arr[]    maxele = max(arr)     # Iterate from 2 to maximum possible    # divisor of all give values    for i in range(2, maxele + 1):        count = 0        for j in range(n):                         # If we found divisor,            # increment count            if (arr[j] % i == 0):                count += 1        ans = max(ans, count)     return ans # Driver codeif __name__ == '__main__':    arr = [3, 6, 2, 5, 4]    size = len(arr)    print(largestGCDSubsequence(arr, size)) # This code is contributed by Rajput-Ji
     // Efficient C# program to find length of// the largest subsequence with GCD greater// than 1.using System;using System.Linq;public class GFG {// Returns length of the largest subsequence// with GCD more than 1.static int largestGCDSubsequence(int []arr, int n){    int ans = 0;       // Finding the Maximum value in arr[]    int maxele = arr.Max();       // Iterate from 2 to maximum possible    // divisor of all give values    for (int i=2; i<=maxele; ++i)    {        int count = 0;        for (int j=0; j<n; ++j)        {            // If we found divisor,            // increment count            if (arr[j]%i == 0)                ++count;        }        ans = Math.Max(ans, count);    }       return ans;}// Driver program to test above      public static void Main() {          int []arr = {3, 6, 2, 5, 4};        int size = arr.Length;          Console.Write(largestGCDSubsequence(arr, size));    }}  //this code contributed by Rajput-Ji
<?php// Simple PHP program to find length of// the largest subsequence with GCD greater// than 1. // Returns length of the largest subsequence// with GCD more than 1.function largestGCDSubsequence($arr, $n){    $ans = 0;     // Finding the Maximum value in arr[]    $maxele = max($arr);     // Iterate from 2 to maximum possible    // divisor of all give values    for ($i = 2; $i <= $maxele; ++$i)    {        $count = 0;        for ($j = 0; $j < $n; ++$j)        {            // If we found divisor,            // increment count            if ($arr[$j] % $i == 0)                ++$count;        }        $ans = max($ans, $count);    }     return $ans;} // Driver code$arr = array(3, 6, 2, 5, 4);$size = count($arr);echo largestGCDSubsequence($arr, $size);     // This code is contributed by mits?>
<script>// Efficient javascript program to find length of// the largest subsequence with GCD greater// than 1. // Returns length of the largest subsequence    // with GCD more than 1.    function largestGCDSubsequence(arr , n)    {        var ans = 0;         // Finding the Maximum value in arr        var maxele =Math.max(...arr);                 // Iterate from 2 to maximum possible        // divisor of all give values        for ( var i = 2; i <= maxele; ++i)        {            var count = 0;            for (j = 0; j < n; ++j)            {                             // If we found divisor,                // increment count                if (arr[j] % i == 0)                    ++count;            }            ans = Math.max(ans, count);        }        return ans;    }         // Driver program to test above        var arr = [ 3, 6, 2, 5, 4 ];        var size = arr.length;         document.write(largestGCDSubsequence(arr, size)); // This code is contributed by aashish1995</script>
Output:  
3
Time Complexity: O(n * max(arr[i])) where n is size of array. Auxiliary Space: O(1) 
Best Approach(Method 3)
An efficient approach is to use prime factorization method with the help of Sieve of Eratosthenes. First of all we will find the smallest prime divisor of all elements by pre-computed sieve. After that we will mark all the prime divisor of every element of arr[] by factorizing it with the help of pre-computed prime[] array. Now we have all the marked primes occurring in all the array elements. The last step is to find the maximum count of all such prime factors.  
C++
Java
Python3
C#
PHP
Javascript
// Efficient C++ program to find length of// the largest subsequence with GCD greater// than 1.#include<bits/stdc++.h> using namespace std; #define MAX 100001 // prime[] for storing smallest prime divisor of element// count[] for storing the number of times a particular// divisor occurs in a subsequenceint prime[MAX], countdiv[MAX]; // Simple sieve to find smallest prime factors of numbers// smaller than MAXvoid SieveOfEratosthenes(){    for (int i = 2; i * i <= MAX; ++i)    {        if (!prime[i])            for (int j = i * 2; j <= MAX; j += i)                prime[j] = i;    }     // Prime number will have same divisor    for (int i = 1; i < MAX; ++i)        if (!prime[i])            prime[i] = i;} // Returns length of the largest subsequence// with GCD more than 1.int largestGCDSubsequence(int arr[], int n){    int ans = 0;    for (int i=0; i < n; ++i)    {        int element = arr[i];         // Fetch total unique prime divisor of element        while (element > 1)        {            int div = prime[element];             // Increment count[] of Every unique divisor            // we get till now            ++countdiv[div];             // Find maximum frequency of divisor            ans = max(ans, countdiv[div]);             while (element % div==0)                element /= div;        }    }     return ans;} // Driver codeint main(){    // Pre-compute smallest divisor of all numbers    SieveOfEratosthenes();     int arr[] = {10, 15, 7, 25, 9, 35};    int size = sizeof(arr) / sizeof(arr[0]);     cout << largestGCDSubsequence(arr, size);    return 0;}
// Efficient Java program to find length of// the largest subsequence with GCD greater// than 1. class GFG{static int MAX = 100001; // prime[] for storing smallest prime divisor// of element count[] for storing the number// of times a particular divisor occurs// in a subsequencestatic int[] prime = new int[MAX + 1];static int[] countdiv = new int[MAX + 1]; // Simple sieve to find smallest prime// factors of numbers smaller than MAXstatic void SieveOfEratosthenes(){    for (int i = 2; i * i <= MAX; ++i)    {        if (prime[i] == 0)            for (int j = i * 2; j <= MAX; j += i)                prime[j] = i;    }     // Prime number will have same divisor    for (int i = 1; i < MAX; ++i)        if (prime[i] == 0)            prime[i] = i;} // Returns length of the largest subsequence// with GCD more than 1.static int largestGCDSubsequence(int arr[], int n){    int ans = 0;    for (int i = 0; i < n; ++i)    {        int element = arr[i];         // Fetch total unique prime divisor of element        while (element > 1)        {            int div = prime[element];             // Increment count[] of Every unique divisor            // we get till now            ++countdiv[div];             // Find maximum frequency of divisor            ans = Math.max(ans, countdiv[div]);             while (element % div == 0)                element /= div;        }    }    return ans;} // Driver codepublic static void main (String[] args){    // Pre-compute smallest divisor of all numbers    SieveOfEratosthenes();     int arr[] = {10, 15, 7, 25, 9, 35};    int size = arr.length;     System.out.println(largestGCDSubsequence(arr, size));}} // This code is contributed by mits
# Efficient Python3 program to find length# of the largest subsequence with GCD# greater than 1.import math as mt MAX = 100001 # prime[] for storing smallest# prime divisor of element# count[] for storing the number# of times a particular divisor# occurs in a subsequenceprime = [0 for i in range(MAX + 1)]countdiv = [0 for i in range(MAX + 1)] # Simple sieve to find smallest prime# factors of numbers smaller than MAXdef SieveOfEratosthenes():     for i in range(2, mt.ceil(mt.sqrt(MAX + 1))):             if (prime[i] == 0):            for j in range(i * 2, MAX + 1, i):                prime[j] = i         # Prime number will have same divisor    for i in range(1, MAX):        if (prime[i] == 0):            prime[i] = i # Returns length of the largest# subsequence with GCD more than 1.def largestGCDSubsequence(arr, n):     ans = 0    for i in range(n):         element = arr[i]         # Fetch total unique prime        # divisor of element        while (element > 1):             div = prime[element]             # Increment count[] of Every            # unique divisor we get till now            countdiv[div] += 1             # Find maximum frequency of divisor            ans = max(ans, countdiv[div])             while (element % div == 0):                element = element // div             return ans # Driver code # Pre-compute smallest divisor# of all numbersSieveOfEratosthenes() arr= [10, 15, 7, 25, 9, 35]size = len(arr)print(largestGCDSubsequence(arr, size)) # This code is contributed# by Mohit kumar 29
// Efficient C# program to find length of// the largest subsequence with GCD greater// than 1.using System; class GFG{     static int MAX=100001; // prime[] for storing smallest// prime divisor of element count[]// for storing the number of times// a particular divisor occurs in a subsequencestatic int[] prime = new int[MAX + 1];static int[] countdiv = new int[MAX + 1]; // Simple sieve to find smallest prime//  factors of numbers smaller than MAXstatic void SieveOfEratosthenes(){    for (int i = 2; i * i <= MAX; ++i)    {        if (prime[i] == 0)            for (int j = i * 2; j <= MAX; j += i)                prime[j] = i;    }     // Prime number will have same divisor    for (int i = 1; i < MAX; ++i)        if (prime[i] == 0)            prime[i] = i;} // Returns length of the largest subsequence// with GCD more than 1.static int largestGCDSubsequence(int []arr, int n){    int ans = 0;    for (int i = 0; i < n; ++i)    {        int element = arr[i];         // Fetch total unique prime divisor of element        while (element > 1)        {            int div = prime[element];             // Increment count[] of Every unique divisor            // we get till now            ++countdiv[div];             // Find maximum frequency of divisor            ans = Math.Max(ans, countdiv[div]);             while (element % div==0)                element /= div;        }    }    return ans;} // Driver codepublic static void Main(){    // Pre-compute smallest    // divisor of all numbers    SieveOfEratosthenes();     int []arr = {10, 15, 7, 25, 9, 35};    int size = arr.Length;     Console.WriteLine(largestGCDSubsequence(arr, size));}} // This code is contributed by mits
<?php// Efficient PHP program to find length of// the largest subsequence with GCD greater// than 1. $MAX = 10001; // prime[] for storing smallest prime divisor of element// count[] for storing the number of times a particular// divisor occurs in a subsequence$prime = array_fill(0, $MAX, 0);$countdiv = array_fill(0, $MAX, 0); // Simple sieve to find smallest prime factors of numbers// smaller than MAXfunction SieveOfEratosthenes(){    global $MAX,$prime;    for ($i = 2; $i * $i <= $MAX; ++$i)    {        if ($prime[$i] == 0)            for ($j = $i * 2; $j <= $MAX; $j += $i)                $prime[$j] = $i;    }     // Prime number will have same divisor    for ($i = 1; $i < $MAX; ++$i)        if ($prime[$i] == 0)            $prime[$i] = $i;} // Returns length of the largest subsequence// with GCD more than 1.function largestGCDSubsequence($arr, $n){    global $countdiv,$prime;    $ans = 0;    for ($i = 0; $i < $n; ++$i)    {        $element = $arr[$i];         // Fetch total unique prime divisor of element        while ($element > 1)        {            $div = $prime[$element];             // Increment count[] of Every unique divisor            // we get till now            ++$countdiv[$div];             // Find maximum frequency of divisor            $ans = max($ans, $countdiv[$div]);             while ($element % $div == 0)                $element = (int)($element/$div);        }    }     return $ans;}     // Driver code    // Pre-compute smallest divisor of all numbers    SieveOfEratosthenes();     $arr = array(10, 15, 7, 25, 9, 35);    $size = count($arr);     echo largestGCDSubsequence($arr, $size); // This code is contributed by mits?>
<script>// Efficient Javascript program to find length of// the largest subsequence with GCD greater// than 1.      let MAX = 100001;// prime[] for storing smallest prime divisor// of element count[] for storing the number// of times a particular divisor occurs// in a subsequencelet prime = new Array(MAX + 1);let countdiv = new Array(MAX + 1);for(let i=0;i<MAX+1;i++){    prime[i]=0;    countdiv[i]=0;} // Simple sieve to find smallest prime// factors of numbers smaller than MAXfunction SieveOfEratosthenes(){    for (let i = 2; i * i <= MAX; ++i)    {        if (prime[i] == 0)            for (let j = i * 2; j <= MAX; j += i)                prime[j] = i;    }      // Prime number will have same divisor    for (let i = 1; i < MAX; ++i)        if (prime[i] == 0)            prime[i] = i;} // Returns length of the largest subsequence// with GCD more than 1.function largestGCDSubsequence(arr,n){    let ans = 0;    for (let i = 0; i < n; ++i)    {        let element = arr[i];          // Fetch total unique prime divisor of element        while (element > 1)        {            let div = prime[element];              // Increment count[] of Every unique divisor            // we get till now            ++countdiv[div];              // Find maximum frequency of divisor            ans = Math.max(ans, countdiv[div]);              while (element % div == 0)                element /= div;        }    }    return ans;} // Driver code// Pre-compute smallest divisor of all numbersSieveOfEratosthenes();let arr=[10, 15, 7, 25, 9, 35];let size = arr.length;document.write(largestGCDSubsequence(arr, size));      // This code is contributed by unknown2108</script>
Output:  
 4
Time complexity: O( n*log(max(arr[i])) ) + MAX*log(log(MAX)) Auxiliary space: O(MAX)This article is contributed by Shubham Bansal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
SHREYAS_SINGH
Rajput-Ji
Mithun Kumar
mohit kumar 29
aashish1995
unknown2108
surindertarika1234
GCD-LCM
prime-factor
Mathematical
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
Write a program to print all permutations of a given string
C++ Data Types
Merge two sorted arrays
Coin Change | DP-7
Operators in C / C++
Prime Numbers
Program to find GCD or HCF of two numbers
Find minimum number of coins that make a given value