Split Array into Consecutive Subsequences

Split Array into Consecutive Subsequences - Problem

You are given an integer array nums that is sorted in non-decreasing order. Determine if it is possible to split nums into one or more subsequences such that both of the following conditions are true:

Each subsequence is a consecutive increasing sequence (i.e. each integer is exactly one more than the previous integer).
All subsequences have a length of 3 or more.

Return true if you can split nums according to the above conditions, or false otherwise.

A subsequence of an array is a new array that is formed from the original array by deleting some (can be none) of the elements without disturbing the relative positions of the remaining elements.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3,3,4,5]

› Output: true

💡 Note: Can split into [1,2,3] and [3,4,5], both consecutive sequences of length ≥ 3

Example 2 — Cannot Split

$ Input: nums = [1,2,3,3,4,4,5,5]

› Output: true

💡 Note: Can split into [1,2,3] and [3,4,5] and [4,5] - wait, [4,5] has length 2, so actually can split into [1,2,3,4,5] and [3,4,5]

Example 3 — Impossible Case

$ Input: nums = [1,2,3,4,4,5]

› Output: false

💡 Note: Cannot form valid consecutive subsequences - one 4 would be left alone or in length-2 sequence

Constraints

1 ≤ nums.length ≤ 10⁴
-1000 ≤ nums[i] ≤ 1000
nums is sorted in non-decreasing order

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 A Amazon 8 M Microsoft 6

The key insight is to use a greedy approach with two hash maps: one tracks available numbers, the other tracks subsequence tails. Always prefer extending existing sequences over starting new ones. Best approach is Greedy: Time O(n), Space O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n) Space: O(n)

Generate all possible ways to partition the array into subsequences and check if each partition satisfies our conditions. This involves exponential combinations.

Greedy with Two Hash Maps

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

Use two hash maps: one for counting available numbers, another for tracking subsequence tails. Always prefer extending existing sequences over starting new ones.

Two-Pass Frequency Count

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

First pass counts how many times each number appears. Second pass tries to greedily build consecutive sequences by checking if we can form sequences of length 3 starting from each number.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible partitions of the array
For each partition, check if all subsequences are consecutive and length >= 3
Return true if any valid partition exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Start with sorted array [1,2,3,3,4,5]

Try Partitions

Generate all ways to split into groups

Check Valid

Verify each group is consecutive with length ≥ 3

Code -

solution.c — C

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

bool isConsecutive(int* seq, int len) {
    if (len < 3) return false;
    for (int i = 1; i < len; i++) {
        if (seq[i] != seq[i-1] + 1) return false;
    }
    return true;
}

bool backtrack(int* nums, int numsSize, int index, int** partition, int* partitionSizes, int partitionCount) {
    if (index == numsSize) {
        for (int i = 0; i < partitionCount; i++) {
            if (partitionSizes[i] > 0 && !isConsecutive(partition[i], partitionSizes[i])) {
                return false;
            }
        }
        return true;
    }
    
    // Try adding to existing subsequences
    for (int i = 0; i < partitionCount; i++) {
        partition[i][partitionSizes[i]] = nums[index];
        partitionSizes[i]++;
        if (backtrack(nums, numsSize, index + 1, partition, partitionSizes, partitionCount)) {
            return true;
        }
        partitionSizes[i]--;
    }
    
    // Try starting new subsequence (simplified for C)
    if (partitionCount < numsSize) {
        partition[partitionCount][0] = nums[index];
        partitionSizes[partitionCount] = 1;
        if (backtrack(nums, numsSize, index + 1, partition, partitionSizes, partitionCount + 1)) {
            return true;
        }
        partitionSizes[partitionCount] = 0;
    }
    
    return false;
}

bool solution(int* nums, int numsSize) {
    int** partition = (int**)malloc(numsSize * sizeof(int*));
    int* partitionSizes = (int*)calloc(numsSize, sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        partition[i] = (int*)malloc(numsSize * sizeof(int));
    }
    
    bool result = backtrack(nums, numsSize, 0, partition, partitionSizes, 0);
    
    for (int i = 0; i < numsSize; i++) {
        free(partition[i]);
    }
    free(partition);
    free(partitionSizes);
    
    return result;
}

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);
    
    // Simple parsing for [1,2,3] format
    int nums[1000];
    int count = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    bool result = solution(nums, count);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all 2^n possible ways to partition the array

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary partition storage

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler