Maximum Subarray With Equal Products - Practice Coding Problems

Maximum Subarray With Equal Products - Problem

Array Math Sliding Window Enumeration Number Theory Easy

You are given an array of positive integers nums. Your task is to find the longest subarray that satisfies a special mathematical property.

A subarray is called product equivalent if it satisfies the equation:

product(arr) = lcm(arr) × gcd(arr)

Where:

product(arr) is the product of all elements in the subarray
gcd(arr) is the Greatest Common Divisor of all elements
lcm(arr) is the Least Common Multiple of all elements

Goal: Return the length of the longest product equivalent subarray.

Example: For array [6, 10, 15], we have gcd = 1, lcm = 30, product = 900. Since 30 × 1 ≠ 900, this subarray is not product equivalent.

Input & Output

example_1.py — Basic Case

$ Input: [6, 10, 15]

› Output: 2

💡 Note: The longest product equivalent subarray is [6,10] with length 2. For [6,10]: product=60, gcd=2, lcm=30, and 60 = 2×30. Also [10,15] works: product=150, gcd=5, lcm=30, and 150 = 5×30.

example_2.py — Single Element

$ Input: [12]

› Output: 0

💡 Note: For [12]: product=12, gcd=12, lcm=12, but 12 ≠ 12×12 = 144. So no valid subarray exists.

example_3.py — Multiple Valid Subarrays

$ Input: [2, 4, 6, 8]

› Output: 2

💡 Note: Several length-2 subarrays work: [2,4] has product=8, gcd=2, lcm=4, and 8 = 2×4. The maximum length is 2.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Calculate GCD

Find the greatest common divisor of all elements

Calculate LCM

Find the least common multiple of all elements

Calculate Product

Multiply all elements together

Check Equality

Verify if product equals gcd × lcm

Key Takeaway

🎯 Key Insight: The product = gcd × lcm property is mathematically rare, occurring mainly in small subarrays with special number relationships, making exhaustive search practical.

Asked in

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

The optimal approach uses brute force enumeration to check all possible subarrays. For each subarray, we calculate the product, GCD, and LCM and verify if product = gcd × lcm. The mathematical property is rare, making this enumeration approach reasonable for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray and calculate product, GCD, and LCM

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all starting positions i
For each starting position, iterate through all ending positions j ≥ i
For subarray nums[i:j+1], calculate product, GCD, and LCM
Check if product = gcd × lcm
Update maximum length if condition is satisfied

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Start with all subarrays of length 1, then 2, then 3, etc.

Calculate Values

For each subarray, calculate product, GCD, and LCM

Check Condition

Verify if product = gcd × lcm

Update Maximum

Keep track of the longest valid subarray found

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);
}

long long gcdArray(int* arr, int len) {
    long long result = arr[0];
    for (int i = 1; i < len; i++) {
        result = gcd(result, (long long)arr[i]);
    }
    return result;
}

long long lcmArray(int* arr, int len) {
    long long result = arr[0];
    for (int i = 1; i < len; i++) {
        result = lcm(result, (long long)arr[i]);
    }
    return result;
}

long long productArray(int* arr, int len) {
    long long result = 1;
    for (int i = 0; i < len; i++) {
        result *= arr[i];
    }
    return result;
}

int longestProductEqualSubarray(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Check all subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int subarrayLen = j - i + 1;
            
            long long gcdVal = gcdArray(nums + i, subarrayLen);
            long long lcmVal = lcmArray(nums + i, subarrayLen);
            long long prodVal = productArray(nums + i, subarrayLen);
            
            if (prodVal == gcdVal * lcmVal) {
                if (subarrayLen > maxLength) {
                    maxLength = subarrayLen;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    int nums[] = {6, 10, 15}; // Example input
    int size = 3;
    printf("%d\n", longestProductEqualSubarray(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for nested loops, O(n) for calculating GCD/LCM for each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K 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