Number of Different Subsequences GCDs

Number of Different Subsequences GCDs - Problem

You are given an array nums that consists of positive integers.

The GCD of a sequence of numbers is defined as the greatest integer that divides all the numbers in the sequence evenly.

For example, the GCD of the sequence [4,6,16] is 2.

A subsequence of an array is a sequence that can be formed by removing some elements (possibly none) of the array.

For example, [2,5,10] is a subsequence of [1,2,1,2,4,1,5,10].

Return the number of different GCDs among all non-empty subsequences of nums.

Input & Output

Example 1 — Small Array

$ Input: nums = [6,10,3]

› Output: 5

💡 Note: All possible subsequences and their GCDs: [6]→6, [10]→10, [3]→3, [6,10]→2, [6,3]→3, [10,3]→1, [6,10,3]→1. Unique GCDs: {1,2,3,6,10}, so answer is 5.

Example 2 — Identical Elements

$ Input: nums = [5,15,40,5,6]

› Output: 7

💡 Note: With elements 5,15,40,5,6, we can form subsequences with GCDs: 1,2,3,5,6,15,40. Total unique GCDs = 7.

Example 3 — Single Element

$ Input: nums = [42]

› Output: 1

💡 Note: Only one subsequence [42] with GCD = 42. Answer is 1.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 2 × 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is to avoid generating all 2^n subsequences by instead testing each possible GCD value. For each candidate GCD g from 1 to max element, collect all array elements divisible by g and check if their actual GCD equals g. Best approach has Time: O(max × n), Space: O(n).

Common Approaches

✓ Divisor-Based Approach

⏱️ Time: O(max × n) Space: O(n)

Instead of generating subsequences, iterate through all possible GCD values (1 to max element). For each candidate GCD, collect all its multiples from the array and verify if their GCD equals the candidate.

Generate All Subsequences

⏱️ Time: O(2^n × n) Space: O(2^n)

For each of the 2^n - 1 non-empty subsequences, calculate the GCD of all elements in that subsequence. Store unique GCDs in a set and return the count.

Divisor-Based Approach — Algorithm Steps

Find maximum element to limit GCD search space
For each potential GCD g from 1 to max
Collect all array elements that are multiples of g
Compute GCD of collected elements and check if it equals g

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Array [6, 10, 3], max = 10

Test Each GCD

For g = 1 to 10, find multiples and compute their GCD

Valid GCDs

Count cases where computed GCD equals candidate g

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 solution(int* nums, int numsSize) {
    // Find max element
    int maxVal = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
        }
    }
    
    int count = 0;
    
    // Check each possible GCD from 1 to maxVal
    for (int g = 1; g <= maxVal; g++) {
        int multiples[200];
        int multiplesSize = 0;
        
        // Collect all multiples of g from nums
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] % g == 0) {
                multiples[multiplesSize++] = nums[i];
            }
        }
        
        // If we found multiples, check if their GCD is exactly g
        if (multiplesSize > 0) {
            int currentGcd = multiples[0];
            for (int i = 1; i < multiplesSize; i++) {
                currentGcd = gcd(currentGcd, multiples[i]);
            }
            
            if (currentGcd == g) {
                count++;
            }
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[200];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(nums, numsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max × n)

For each of max possible GCD values, scan array once

⚠ Quadratic Growth

Space Complexity

O(n)

Store elements that are multiples of current candidate GCD

⚠ Quadratic Space

25.0K Views

Medium Frequency

~35 min Avg. Time

890 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

Divisor-Based Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler