Partition Array into Disjoint Intervals - Practice Coding Problems

Partition Array into Disjoint Intervals - Problem

Array Medium

Given an integer array nums, you need to partition it into two contiguous subarrays called left and right such that:

Every element in left is less than or equal to every element in right
Both left and right are non-empty
left has the smallest possible size

Your task is to return the length of the left subarray after such partitioning.

Example: For array [5,0,3,8,6], we can partition it as left = [5,0,3] and right = [8,6]. The maximum in left (5) ≤ minimum in right (6), and left has minimum possible size of 3.

Input & Output

example_1.py — Basic Case

$ Input: [5,0,3,8,6]

› Output: 3

💡 Note: We partition into left=[5,0,3] and right=[8,6]. The maximum in left (5) ≤ minimum in right (6), and this gives the smallest possible left partition.

example_2.py — Already Sorted

$ Input: [1,1,1,2]

› Output: 1

💡 Note: We can partition into left=[1] and right=[1,1,2]. The maximum in left (1) ≤ minimum in right (1), giving the minimum left size of 1.

example_3.py — Large Left Required

$ Input: [1,1,1,0,6,12]

› Output: 4

💡 Note: Due to the 0 in position 3, we need left=[1,1,1,0] and right=[6,12]. The maximum in left (1) ≤ minimum in right (6).

Constraints

2 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
A valid partitioning always exists

Visualization

Tap to expand

Understanding the Visualization

Build prefix maximums

For each position i, store the maximum element from start to i

Build suffix minimums

For each position i, store the minimum element from i to end

Find partition point

Look for first position where prefix_max[i] ≤ suffix_min[i+1]

Return result

The partition point + 1 gives us the length of the left subarray

Key Takeaway

🎯 Key Insight: We need to find the earliest position where the maximum element on the left is ≤ minimum element on the right, which can be efficiently computed using prefix maximums and suffix minimums.

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Facebook 22

The optimal solution uses two-pass precomputation to build prefix maximum and suffix minimum arrays in O(n) time. We find the first position where max(left) ≤ min(right) holds, ensuring the smallest valid left partition.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Precomputation	O(n)	O(n)	Precompute maximum prefixes and minimum suffixes, then find partition
Brute Force (Check All Partitions)	O(n²)	O(1)	Try every possible partition point and validate each one

Two-Pass Precomputation — Algorithm Steps

First pass: compute maxLeft[i] = maximum of nums[0:i+1]
Second pass: compute minRight[i] = minimum of nums[i:]
Find first position i where maxLeft[i] ≤ minRight[i+1]
Return i+1 as the length of left partition

Visualization

Tap to expand

Step-by-Step Walkthrough

Build prefix maximums

maxLeft[i] stores max of nums[0:i+1]

Build suffix minimums

minRight[i] stores min of nums[i:]

Find partition point

First i where maxLeft[i] ≤ minRight[i+1]

Code -

solution.c — C

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

int partitionDisjoint(int* nums, int numsSize) {
    // First pass: compute prefix maximums
    int* maxLeft = (int*)malloc(numsSize * sizeof(int));
    maxLeft[0] = nums[0];
    for (int i = 1; i < numsSize; i++) {
        maxLeft[i] = (nums[i] > maxLeft[i-1]) ? nums[i] : maxLeft[i-1];
    }
    
    // Second pass: compute suffix minimums
    int* minRight = (int*)malloc(numsSize * sizeof(int));
    minRight[numsSize-1] = nums[numsSize-1];
    for (int i = numsSize-2; i >= 0; i--) {
        minRight[i] = (nums[i] < minRight[i+1]) ? nums[i] : minRight[i+1];
    }
    
    // Find partition point
    int result = numsSize - 1;
    for (int i = 0; i < numsSize-1; i++) {
        if (maxLeft[i] <= minRight[i+1]) {
            result = i + 1;
            break;
        }
    }
    
    free(maxLeft);
    free(minRight);
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", partitionDisjoint(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three linear passes through the array

✓ Linear Growth

Space Complexity

O(n)

Two arrays of size n to store prefix max and suffix min

⚡ Linearithmic Space

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

Two-Pass Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler