Number of Subarrays With GCD Equal to K - Practice Coding Problems

Number of Subarrays With GCD Equal to K - Problem

Given an integer array nums and an integer k, your task is to find how many contiguous subarrays have a greatest common divisor (GCD) equal to k.

A subarray is a contiguous sequence of elements within an array. The greatest common divisor (GCD) of an array is the largest positive integer that divides all elements in the array without remainder.

For example, if we have the array [9, 3, 1, 2, 6, 3] and k = 3, we need to count all subarrays where the GCD equals 3. The subarray [9, 3] has GCD = 3, while [3] also has GCD = 3.

Your goal: Return the total count of valid subarrays.

Input & Output

example_1.py — Basic Case

$ Input: nums = [9,3,1,2,6,3], k = 3

› Output: 4

💡 Note: The subarrays with GCD equal to 3 are: [9,3] (GCD = 3), [3] at index 1 (GCD = 3), [6,3] (GCD = 3), and [3] at index 5 (GCD = 3). Total count = 4.

example_2.py — Single Element

$ Input: nums = [4], k = 7

› Output: 0

💡 Note: The only subarray is [4] with GCD = 4, which is not equal to k = 7. Therefore, count = 0.

example_3.py — All Same Elements

$ Input: nums = [6,6,6], k = 6

› Output: 6

💡 Note: All possible subarrays have GCD = 6: [6] (3 times), [6,6] (2 times), and [6,6,6] (1 time). Total = 3 + 2 + 1 = 6.

Visualization

Tap to expand

Understanding the Visualization

Position Detective

Start at each array position as a potential subarray beginning

Extend Investigation

Add one element at a time, updating the GCD incrementally

Track Discoveries

Count when GCD equals k, terminate when GCD drops below k

Optimize Search

Skip further extensions once GCD becomes too small

Key Takeaway

🎯 Key Insight: GCD can only decrease or stay the same when adding elements, enabling early termination optimization

Time & Space Complexity

Time Complexity

⏱️

O(n² log(min(nums)))

O(n²) for nested loops, O(log(min)) for each GCD calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i], k ≤ 10⁹
At least one element must be divisible by k for any valid subarray to exist

Asked in

G Google 32 a Amazon 28 ⊞ Microsoft 24 f Meta 18

The key insight is to use incremental GCD calculation while extending subarrays. Start from each position and extend rightward, updating GCD with each new element. Since GCD can only decrease or stay the same, we can break early when GCD becomes smaller than k. This optimization reduces computation significantly compared to calculating GCD from scratch for each subarray.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray and calculate GCD from scratch
Optimized Nested Loop (Better Brute Force)	O(n² log(min(nums)))	O(1)	Calculate GCD incrementally while extending subarrays to avoid redundant computation

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop to fix starting position of subarray
Use inner loop to extend subarray to all possible ending positions
For each subarray, calculate GCD of all elements
If GCD equals k, increment counter
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Use nested loops to create all possible contiguous subarrays

Calculate GCD

For each subarray, compute GCD of all elements from scratch

Check Condition

Compare calculated GCD with target k and count matches

Code -

solution.c — C

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

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

int subarrayGCD(int* nums, int numsSize, int k) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int currentGcd = nums[i];
            for (int l = i; l <= j; l++) {
                currentGcd = gcd(currentGcd, nums[l]);
            }
            if (currentGcd == k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {9, 3, 1, 2, 6, 3};
    int k = 3;
    printf("%d\n", subarrayGCD(nums, 6, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all subarrays, O(n) for GCD calculation of each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i], k ≤ 10⁹
At least one element must be divisible by k for any valid subarray to exist

23.4K Views

Medium Frequency

~18 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler