Minimum Split Into Subarrays With GCD Greater Than One

Minimum Split Into Subarrays With GCD Greater Than One - Problem

Array Math Dynamic Programming Greedy Number Theory Medium

You are given an array nums consisting of positive integers. Your task is to split the array into the minimum number of contiguous subarrays such that:

Each element belongs to exactly one subarray
The GCD (Greatest Common Divisor) of each subarray is strictly greater than 1

The GCD of a subarray is the largest positive integer that evenly divides all elements in that subarray. For example, GCD of [6, 9, 12] is 3.

Goal: Return the minimum number of subarrays needed to satisfy the conditions.

Example: For [12, 6, 3, 14, 8], we could split into [12, 6, 3] (GCD=3) and [14, 8] (GCD=2), giving us 2 subarrays.

Input & Output

example_1.py — Basic Case

$ Input: [12, 6, 3, 14, 8]

› Output: 2

💡 Note: Split into [12,6,3] with GCD=3 and [14,8] with GCD=2. Both subarrays have GCD > 1, so minimum splits = 2.

example_2.py — All Even Numbers

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

› Output: 1

💡 Note: All numbers are even, so GCD of entire array is 2 > 1. Only need 1 subarray containing all elements.

example_3.py — Prime Numbers

$ Input: [2, 3, 5, 7]

› Output: 4

💡 Note: Each prime number must be in its own subarray since GCD of any two different primes is 1. Need 4 subarrays.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Start First Box

Place first cookie (12 ingredients) in box, shared ingredients = 12

Add Compatible Cookie

Cookie with 6 ingredients shares 6 ingredients with first cookie, add to box

Continue Extension

Cookie with 3 ingredients shares 3 ingredients with current box contents

Incompatible Cookie

Cookie with 14 ingredients shares only 1 ingredient (GCD=1), start new box

New Box Success

Last cookie (8 ingredients) shares 2 ingredients with cookie 14, add to second box

Key Takeaway

🎯 Key Insight: Greedy algorithm works because extending a valid subarray (keeping cookies in same box) is always optimal - we never benefit from starting a new box early when we could extend the current one.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses a greedy approach that extends subarrays as long as their GCD remains > 1. When adding the next element would make GCD = 1, we start a new subarray. This works because extending a valid subarray is always better than starting a new one, giving us the minimum number of splits in O(n log(max_val)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n log(max_val))	O(1)	Greedily extend subarrays as long as GCD > 1, start new subarray when needed
Brute Force (Dynamic Programming)	O(n³)	O(n)	Try all possible splits and find the minimum using recursive DP

Greedy Approach (Optimal) — Algorithm Steps

Initialize result counter and current subarray GCD
Iterate through array starting from first element
For each element, calculate GCD with current subarray
If GCD > 1, extend current subarray
If GCD = 1, start new subarray and increment counter
Return the total number of subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Start First Subarray

Begin with first element as current GCD

Try Extension

Calculate GCD with next element

Check Validity

If GCD > 1, extend subarray; else start new one

Continue Process

Repeat until all elements are processed

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 minimumSplit(int* nums, int n) {
    if (n == 0) return 0;
    
    int result = 1;
    int currentGcd = nums[0];
    
    for (int i = 1; i < n; i++) {
        int newGcd = gcd(currentGcd, nums[i]);
        
        if (newGcd > 1) {
            currentGcd = newGcd;
        } else {
            result++;
            currentGcd = nums[i];
        }
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", minimumSplit(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_val))

Single pass through array × O(log(max_val)) for each GCD calculation

⚡ Linearithmic

Space Complexity

O(1)

Only storing current GCD and counter variables

✓ Linear Space

42.3K Views

Medium-High Frequency

~18 min Avg. Time

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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler