Number of Different Subsequences GCDs - Practice Coding Problems

Number of Different Subsequences GCDs - Problem

Given an array nums of positive integers, you need to find how many different GCD values can be formed by all possible non-empty subsequences.

What is GCD? The Greatest Common Divisor (GCD) of a sequence is the largest positive integer that divides all numbers in the sequence evenly. For example, GCD([4, 6, 16]) = 2 because 2 is the largest number that divides 4, 6, and 16.

What is a subsequence? A subsequence is formed by removing some (possibly zero) elements from the original array while maintaining the relative order. For example, [2, 5, 10] is a subsequence of [1, 2, 1, 2, 4, 1, 5, 10].

Your task: Count how many distinct GCD values are possible among all non-empty subsequences of the given array.

Input & Output

example_1.py — Basic Case

$ Input: [6,10,3]

› Output: 4

💡 Note: All possible subsequences: [6](GCD=6), [10](GCD=10), [3](GCD=3), [6,10](GCD=2), [6,3](GCD=3), [10,3](GCD=1), [6,10,3](GCD=1). Unique GCDs: {1,2,3,6} = 4 different values

example_2.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: Only one subsequence [5] with GCD=5, so answer is 1

example_3.py — Multiple Same Elements

$ Input: [4,4,4]

› Output: 1

💡 Note: All subsequences have the same GCD=4, regardless of how many 4's we pick

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2 × 10⁵
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Setup Treasure Map

Mark all numbers present in our array and find the highest number (our search boundary)

Visit Each Treasure

For each potential GCD from 1 to max, collect all its multiples from our array

Verify Treasure

Calculate the GCD of collected multiples. If it equals our target, we found a valid treasure!

Count Treasures

Sum up all valid GCD treasures we successfully found

Key Takeaway

🎯 Key Insight: Rather than exploring all 2^n possible subsequences (exponential time), we intelligently check each of the at most max(nums) possible GCD values, making the solution much more efficient!

Asked in

G Google 23 ⊞ Microsoft 15 a Amazon 12 f Meta 8

The optimal solution uses a mathematical insight: instead of generating all subsequences, we iterate through each possible GCD value from 1 to max(nums). For each candidate GCD g, we find all its multiples in the array and calculate their GCD. If the result equals g, then this GCD is achievable by some subsequence. This reduces complexity from O(2^n) to O(M × log M + N × M) where M = max(nums).

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Iterate Through Possible GCDs	O(M * log M + N * M)	O(M)	Check each possible GCD value from 1 to max(nums) to see if it can be formed
Brute Force (Generate All Subsequences)	O(2^n * n)	O(2^n)	Generate all possible subsequences and calculate GCD for each

Optimal: Iterate Through Possible GCDs — Algorithm Steps

Find the maximum element in the array to limit our search space
For each possible GCD value g from 1 to max_element:
Find all elements in nums that are multiples of g
Calculate the GCD of these multiples
If the calculated GCD equals g, then g is achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Element

Determine the upper bound for possible GCD values

Try Each GCD

For each candidate GCD from 1 to max, find its multiples

Check Multiples

Find all multiples of the candidate that exist in our array

Verify GCD

Calculate GCD of found multiples and check if it equals our candidate

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int countDifferentSubsequenceGCDs(int* nums, int n) {
    int maxVal = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
        }
    }
    
    // Create boolean array for presence check
    int* present = (int*)calloc(maxVal + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        present[nums[i]] = 1;
    }
    
    int count = 0;
    
    // Try each possible GCD from 1 to maxVal
    for (int gcdCandidate = 1; gcdCandidate <= maxVal; gcdCandidate++) {
        // Find all multiples of gcdCandidate in nums
        int currentGcd = 0;
        
        for (int multiple = gcdCandidate; multiple <= maxVal; multiple += gcdCandidate) {
            if (present[multiple]) {
                if (currentGcd == 0) {
                    currentGcd = multiple;
                } else {
                    currentGcd = gcd(currentGcd, multiple);
                }
                
                // Early termination
                if (currentGcd == gcdCandidate) {
                    break;
                }
            }
        }
        
        // If we found a subsequence with GCD exactly equal to gcdCandidate
        if (currentGcd == gcdCandidate) {
            count++;
        }
    }
    
    free(present);
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", countDifferentSubsequenceGCDs(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(M * log M + N * M)

M is max(nums). For each of M possible GCDs, we check all N elements and compute GCD

⚡ Linearithmic

Space Complexity

O(M)

Array to track which numbers are present, plus result set

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimal: Iterate Through Possible GCDs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler