Split the Array to Make Coprime Products - Practice Coding Problems

Split the Array to Make Coprime Products - Problem

You are given a 0-indexed integer array nums of length n.

Your task is to find the smallest valid split index where you can divide the array into two parts such that the product of all elements in the left part and the product of all elements in the right part are coprime (their greatest common divisor is 1).

A split at index i (where 0 ≤ i ≤ n-2) divides the array into:

Left part: elements from index 0 to i (inclusive)
Right part: elements from index i+1 to n-1 (inclusive)

Example: If nums = [2, 3, 3]:

Split at i = 0: Left product = 2, Right product = 3 × 3 = 9. Since gcd(2, 9) = 1, this is valid ✅
Split at i = 1: Left product = 2 × 3 = 6, Right product = 3. Since gcd(6, 3) = 3 ≠ 1, this is invalid ❌

Return the smallest index i where a valid split exists, or -1 if no valid split is possible.

Two numbers are coprime if their greatest common divisor (GCD) equals 1.

Input & Output

example_1.py — Basic Valid Split

$ Input: [2, 3, 3]

› Output: 0

💡 Note: Split at index 0: Left product = 2, Right product = 3 × 3 = 9. Since gcd(2, 9) = 1, they are coprime. This is the smallest valid index.

example_2.py — No Valid Split

$ Input: [4, 7, 8, 15, 3, 5]

› Output: -1

💡 Note: For every possible split, the left and right products share at least one common prime factor, so no valid split exists.

example_3.py — Multiple Options

$ Input: [4, 7, 15, 8, 3, 5]

› Output: 0

💡 Note: Split at index 0: Left = 4 (prime factors: {2}), Right = 7×15×8×3×5 (prime factors: {3,5,7,2}). Wait, they share factor 2, so this is invalid. Need to check all splits carefully.

Constraints

2 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁶
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Extract the Gems

Break down each number into its prime factor 'gems': 2→{blue gem}, 3→{red gem}, 6→{blue gem, red gem}

Split the Collection

Try splitting at each position, collecting gems on the left vs right

Check for Color Conflicts

If left and right collections share any gem color, they're not coprime

Find Pure Separation

Return the first split where left and right have completely different colored gems

Key Takeaway

🎯 Key Insight: Instead of calculating huge products that might overflow, we only need to track which prime factors exist on each side. Two numbers are coprime exactly when their prime factor sets don't overlap!

Asked in

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

The optimal solution uses prime factorization to avoid integer overflow. Instead of computing actual products, we track prime factors on each side of potential splits. Two numbers are coprime if and only if they share no common prime factors. The key insight is to efficiently manage factor sets as we iterate through split positions, achieving O(n × √max_val) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with GCD Calculation	O(n² × log(max_product))	O(1)	Calculate products for each split and check GCD
Two-Pass Prime Factor Tracking	O(n × √max_val + n × factors)	O(n × factors)	Track prime factors instead of products to avoid overflow
Optimized Prime Factor Tracking	O(n × √max_val)	O(total_unique_factors)	Efficiently track prime factors using prefix computation

Brute Force with GCD Calculation — Algorithm Steps

Iterate through all possible split indices from 0 to n-2
For each split, calculate the product of elements from 0 to i
Calculate the product of elements from i+1 to n-1
Compute GCD of both products
If GCD equals 1, return the current index
If no valid split found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Split at Index 0

Left: [2], Right: [3,3] → Products: 2 and 9

Calculate GCD

gcd(2, 9) = 1, so this split is valid

Return First Valid Index

Since i=0 gives valid split, return 0

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 findValidSplit(int* nums, int n) {
    for (int i = 0; i < n - 1; i++) {
        int leftProduct = 1;
        int rightProduct = 1;
        
        // Calculate left product
        for (int j = 0; j <= i; j++) {
            leftProduct *= nums[j];
        }
        
        // Calculate right product
        for (int j = i + 1; j < n; j++) {
            rightProduct *= nums[j];
        }
        
        // Check if products are coprime
        if (gcd(leftProduct, rightProduct) == 1) {
            return i;
        }
    }
    
    return -1;
}

int main() {
    // Simple input parsing for demo
    int nums[] = {2, 3, 3};
    int n = 3;
    printf("%d\n", findValidSplit(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × log(max_product))

O(n²) for nested loops to calculate products, multiplied by O(log(max_product)) for GCD computation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

26.1K Views

Medium Frequency

~35 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 with GCD Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler