Max Chunks To Make Sorted - Practice Coding Problems

Max Chunks To Make Sorted - Problem

Imagine you have an array that's a permutation of integers from 0 to n-1 (each number appears exactly once). Your goal is to divide this array into chunks such that when you sort each chunk individually and then concatenate them together, you get the sorted array [0, 1, 2, ..., n-1].

The challenge is to find the maximum number of chunks you can create. More chunks means more flexibility in sorting!

Example: For array [1, 0, 3, 2, 4], you can split it as [1, 0] | [3, 2] | [4]. After sorting each chunk: [0, 1] | [2, 3] | [4], which concatenates to [0, 1, 2, 3, 4] ✓

This gives us 3 chunks - and that's the maximum possible!

Input & Output

example_1.py — Basic Case

$ Input: [1, 0, 3, 2, 4]

› Output: 3

💡 Note: We can split as [1,0] | [3,2] | [4]. After sorting each chunk: [0,1] | [2,3] | [4], which gives us [0,1,2,3,4]. This is 3 chunks, which is maximum possible.

example_2.py — Already Sorted

$ Input: [0, 1, 2, 3, 4]

› Output: 5

💡 Note: Array is already sorted, so we can make each element its own chunk: [0] | [1] | [2] | [3] | [4]. This gives us the maximum of 5 chunks.

example_3.py — Reverse Sorted

$ Input: [4, 3, 2, 1, 0]

› Output: 1

💡 Note: The array is completely reverse sorted. We can only make 1 chunk [4,3,2,1,0] because any smaller chunk would not contain the proper elements to sort correctly.

Visualization

Tap to expand

Understanding the Visualization

Walk the Shelf

Start from the left, keeping track of the highest book number you've seen

Find Boundaries

When the highest number equals your position, you can end a section

Why It Works

This ensures all books 0 through position i are in the first i+1 spots

Count Sections

Each valid boundary gives you one more section to work with

Key Takeaway

🎯 Key Insight: We can end a chunk at position i when max_seen_so_far equals i, because this guarantees all elements 0 through i are present in positions 0 through i.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track maximum and chunk count

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] < arr.length
arr is a permutation of [0, 1, ..., arr.length - 1]

Asked in

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

The optimal solution uses a single pass through the array, tracking the running maximum. We can end a chunk at position i if and only if the maximum value seen so far equals i, ensuring all values 0 through i are present. This elegant approach runs in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Partitions)	O(n × 2^n)	O(n)	Generate all possible ways to partition the array and check each one
Single Pass Max Tracking (Optimal)	O(n)	O(1)	Track running maximum and create chunk when max equals current index

Brute Force (Try All Partitions) — Algorithm Steps

Generate all possible partition points using bit manipulation or recursion
For each partition, create the chunks
Sort each chunk individually
Concatenate sorted chunks and compare with target [0,1,2...n-1]
Track the maximum number of valid chunks found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Use bit mask to generate all 2^(n-1) ways to split the array

Create Chunks

For each partition, split array into chunks at marked positions

Sort & Concatenate

Sort each chunk individually and join them together

Validate

Check if result equals [0,1,2,...,n-1] and track max chunks

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int maxChunksToSorted(int* arr, int n) {
    int maxChunks = 0;
    
    // Try all possible partitions
    for (int mask = 0; mask < (1 << (n-1)); mask++) {
        int chunks[1000][1000]; // chunks[i] stores chunk i
        int chunkSizes[1000] = {0};
        int numChunks = 0;
        int start = 0;
        
        // Create chunks based on bit mask
        for (int i = 0; i < n-1; i++) {
            if (mask & (1 << i)) {
                for (int j = start; j <= i; j++) {
                    chunks[numChunks][chunkSizes[numChunks]++] = arr[j];
                }
                numChunks++;
                start = i + 1;
            }
        }
        // Add last chunk
        for (int j = start; j < n; j++) {
            chunks[numChunks][chunkSizes[numChunks]++] = arr[j];
        }
        numChunks++;
        
        // Sort each chunk and build result
        int result[1000];
        int resultIdx = 0;
        
        for (int i = 0; i < numChunks; i++) {
            qsort(chunks[i], chunkSizes[i], sizeof(int), compare);
            for (int j = 0; j < chunkSizes[i]; j++) {
                result[resultIdx++] = chunks[i][j];
            }
        }
        
        // Check if result equals sorted array
        int isValid = 1;
        for (int i = 0; i < n; i++) {
            if (result[i] != i) {
                isValid = 0;
                break;
            }
        }
        
        if (isValid && numChunks > maxChunks) {
            maxChunks = numChunks;
        }
    }
    
    return maxChunks;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input array
    int arr[1000];
    int n = 0;
    char* token = strtok(line, "[],");
    
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", maxChunksToSorted(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

2^n possible partitions, each taking O(n log n) to sort chunks

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing chunks and sorted arrays

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] < arr.length
arr is a permutation of [0, 1, ..., arr.length - 1]

43.2K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler