Split the Array to Make Coprime Products

Split the Array to Make Coprime Products - Problem

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

A split at an index i where 0 <= i <= n - 2 is called valid if the product of the first i + 1 elements and the product of the remaining elements are coprime.

For example, if nums = [2, 3, 3], then a split at the index i = 0 is valid because 2 and 9 are coprime, while a split at the index i = 1 is not valid because 6 and 3 are not coprime. A split at the index i = 2 is not valid because i == n - 1.

Return the smallest index i at which the array can be split validly or -1 if there is no such split.

Two values val1 and val2 are coprime if gcd(val1, val2) == 1 where gcd(val1, val2) is the greatest common divisor of val1 and val2.

Input & Output

Example 1 — Basic Valid Split

$ Input: nums = [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.

Example 2 — No Valid Split

$ Input: nums = [2, 6, 3, 4]

› Output: -1

💡 Note: No split position creates coprime products. All splits share common factors between left and right products.

Example 3 — Later Valid Split

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

› Output: 2

💡 Note: Split at index 2: left product = 4×7×8 = 224 (prime factors: 2⁵×7), right product = 15×3×5 = 225 (prime factors: 3²×5²). No common prime factors, so they are coprime.

Constraints

2 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that two numbers are coprime if they share no common prime factors. Instead of calculating potentially large products, we can track prime factors and check for intersections. The optimal approach uses prime factorization with hash sets to avoid integer overflow. Time: O(n² × √M), Space: O(n × P).

Common Approaches

✓ Brute Force Product Calculation

⏱️ Time: O(n²) Space: O(1)

For each possible split position, calculate the product of left elements and right elements, then check if their GCD equals 1. This approach directly implements the problem definition but may overflow for large products.

Prime Factorization with Sets

⏱️ Time: O(n² × √M) Space: O(P)

Instead of computing actual products which may overflow, we track the prime factors of left and right sides. Two numbers are coprime if and only if they share no common prime factors. We can represent prime factors as sets and check for intersection.

Two-Pass Prime Factor Optimization

⏱️ Time: O(n² × √M) Space: O(n × P)

First pass: compute prime factors for all elements. Second pass: for each split, maintain cumulative prime factor sets for left side and calculate right side factors on-demand. This avoids recalculating overlapping work.

Brute Force Product Calculation — Algorithm Steps

Try each split position from 0 to n-2
Calculate left product and right product
Check if GCD(left_product, right_product) == 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Split i=0

Left: [2], Right: [3,3] → Products: 2, 9 → GCD(2,9)=1 ✓

Try Split i=1

Left: [2,3], Right: [3] → Products: 6, 3 → GCD(6,3)=3 ✗

Result

First valid split found at index 0

Code -

solution.c — C

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

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

int solution(int* nums, int n) {
    for (int i = 0; i < n - 1; i++) {
        long long leftProduct = 1;
        for (int j = 0; j <= i; j++) {
            leftProduct *= nums[j];
        }
        
        long long rightProduct = 1;
        for (int j = i + 1; j < n; j++) {
            rightProduct *= nums[j];
        }
        
        if (gcd(leftProduct, rightProduct) == 1) {
            return i;
        }
    }
    
    return -1;
}

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[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop tries n-1 splits, inner calculation takes O(n) time per split

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for products and GCD calculation

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

342 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 Product Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler