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

Number of Subarrays With LCM Equal to K - Problem

Given an integer array nums and an integer k, return the number of subarrays where the least common multiple (LCM) of all elements in the subarray equals k.

A subarray is a contiguous non-empty sequence of elements within an array. For example, in array [1,2,3,4], the subarrays include [1], [1,2], [2,3,4], etc.

The least common multiple (LCM) of an array is the smallest positive integer that is divisible by all elements in the array. For instance, LCM of [2,3] is 6, and LCM of [4,6] is 12.

Challenge: Find all contiguous subarrays whose LCM equals exactly k!

Input & Output

example_1.py — Basic Example

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

› Output: 1

💡 Note: Only the subarray [2,3] has LCM equal to 6. LCM(2,3) = 6.

example_2.py — Multiple Subarrays

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

› Output: 4

💡 Note: The subarrays with LCM equal to 6 are: [6], [3,2], [2,3], and [6] (if 6 appears multiple times).

example_3.py — Single Element

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

› Output: 1

💡 Note: The only subarray [3] has LCM equal to 3.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i], k ≤ 1000
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Start Fresh

Begin with each array element as a potential starting point

Extend Gradually

Add one ingredient (element) at a time, updating the serving count (LCM)

Check Target

If serving count equals target k, count this combination

Smart Stop

If serving count exceeds k, stop extending - no point in adding more ingredients

Key Takeaway

🎯 Key Insight: LCM only increases or stays same when adding elements, allowing early termination optimization

Asked in

G Google 25 f Meta 18 ⊞ Microsoft 15 a Amazon 12

The optimal approach uses an optimized brute force method with early termination. We check each subarray incrementally, building the LCM step by step. Since LCM can only increase or stay the same when adding elements, we can stop extending a subarray once its LCM exceeds k, significantly reducing unnecessary calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray and calculate its LCM
Optimized Brute Force (Early Termination)	O(n²)	O(1)	Calculate LCM incrementally and stop when LCM exceeds k

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop for starting index of subarray
Use inner loop for ending index of subarray
For each subarray, calculate LCM of all elements
If LCM equals k, increment counter
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin checking subarrays starting from index 0

Extend subarray

For each starting position, try all possible ending positions

Calculate LCM

Compute LCM of all elements in current subarray

Check if equals k

If LCM equals k, increment counter

Code -

solution.c — C

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

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

long long lcm(long long a, long long b) {
    return a * b / gcd(a, b);
}

int subarrayLCM(int* nums, int numsSize, int k) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            long long currentLcm = nums[i];
            for (int p = i + 1; p <= j; p++) {
                currentLcm = lcm(currentLcm, nums[p]);
            }
            if (currentLcm == k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    // Simple input parsing
    int nums[] = {1, 2, 3};
    int k = 6;
    int numsSize = 3;
    
    printf("%d\n", subarrayLCM(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating subarrays, O(n) for calculating LCM of each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

23.3K Views

Medium Frequency

~18 min Avg. Time

847 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler