Split Array into Consecutive Subsequences

Split Array into Consecutive Subsequences - Problem

Imagine you have a sorted array of integers and need to organize them into consecutive sequences like a card player arranging cards into runs. Your goal is to determine if you can split the entire array into one or more subsequences where:

Each subsequence contains consecutive integers (each number is exactly one more than the previous)
Every subsequence has at least 3 elements

For example, the array [1,2,3,3,4,5] can be split into [1,2,3] and [3,4,5] - both are consecutive sequences of length 3 or more!

The Challenge: Given a sorted array nums, return true if such a split is possible, false otherwise.

Key Insight: This is a greedy problem disguised as a splitting problem. The trick is to always try to extend existing sequences before starting new ones!

Input & Output

example_1.py — Basic Valid Split

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

› Output: true

💡 Note: We can split this into [1,2,3] and [3,4,5]. Both subsequences are consecutive and have length ≥ 3.

example_2.py — Invalid Split

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

› Output: true

💡 Note: We can form [1,2,3,4,5] and [3,4,5]. The key insight is we can extend the first sequence to length 5.

example_3.py — Cannot Form Valid Split

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

› Output: false

💡 Note: After forming [1,2,3,4], we have [4,5] left, but this has length < 3, so it's invalid.

Visualization

Tap to expand

Understanding the Visualization

Count Your Cards

First, count how many of each card value you have

Track Incomplete Runs

Keep track of which runs need specific cards to continue

Greedy Extension

For each card, always extend existing runs first

Start New Runs

Only start new 3-card runs if you can't extend existing ones

Key Takeaway

🎯 Key Insight: The greedy strategy works because extending existing sequences maximizes our chances of using all numbers, since incomplete short sequences are harder to complete later!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through unique numbers, each hash map operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

Two hash maps storing at most n unique numbers

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a greedy approach with two hash maps: one for counting numbers and another for tracking sequence tails. The key insight is to always try to extend existing sequences before starting new ones, maximizing our chances of using all numbers effectively in valid consecutive subsequences of length 3+.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Hash Maps (Optimal)	O(n)	O(n)	Use frequency map and tail tracking to greedily build sequences
Brute Force (Generate All Partitions)	O(2^n)	O(n)	Generate all possible ways to partition the array and check validity

Greedy with Hash Maps (Optimal) — Algorithm Steps

Count frequency of each number in a hash map
Create a 'tail' map to track sequences waiting for their next number
For each unique number, try to extend existing sequences first
If can't extend, try to start new sequences of length 3
Update both maps accordingly
Return true if all numbers are used successfully

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Numbers

Build frequency map of all numbers

Process Each Number

Try to extend existing sequences first, then start new ones

Update Maps

Decrease counts and update tail tracking

Code -

solution.c — C

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

// Simple hash table implementation for this problem
#define MAX_SIZE 10000

typedef struct {
    int key;
    int value;
    bool used;
} HashEntry;

typedef struct {
    HashEntry entries[MAX_SIZE];
} HashMap;

int hash(int key) {
    return abs(key) % MAX_SIZE;
}

void put(HashMap* map, int key, int value) {
    int idx = hash(key);
    while (map->entries[idx].used && map->entries[idx].key != key) {
        idx = (idx + 1) % MAX_SIZE;
    }
    map->entries[idx].key = key;
    map->entries[idx].value = value;
    map->entries[idx].used = true;
}

int get(HashMap* map, int key) {
    int idx = hash(key);
    while (map->entries[idx].used) {
        if (map->entries[idx].key == key) {
            return map->entries[idx].value;
        }
        idx = (idx + 1) % MAX_SIZE;
    }
    return 0;
}

bool isPossible(int* nums, int numsSize) {
    HashMap count = {0};
    HashMap tail = {0};
    
    // Count frequency
    for (int i = 0; i < numsSize; i++) {
        put(&count, nums[i], get(&count, nums[i]) + 1);
    }
    
    // Simplified version - full implementation would iterate through unique keys
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        int cnt = get(&count, num);
        if (cnt <= 0) continue;
        
        if (get(&tail, num) > 0) {
            put(&tail, num, get(&tail, num) - 1);
            put(&tail, num + 1, get(&tail, num + 1) + 1);
        } else if (get(&count, num + 1) > 0 && get(&count, num + 2) > 0) {
            put(&count, num + 1, get(&count, num + 1) - 1);
            put(&count, num + 2, get(&count, num + 2) - 1);
            put(&tail, num + 3, get(&tail, num + 3) + 1);
        } else {
            return false;
        }
        put(&count, num, cnt - 1);
    }
    
    return true;
}

int main() {
    int nums[] = {1,2,3,3,4,5};
    int size = 6;
    printf("%s\n", isPossible(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through unique numbers, each hash map operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

Two hash maps storing at most n unique numbers

⚡ Linearithmic Space

Constraints

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

127.5K Views

Medium Frequency

~25 min Avg. Time

2.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

Greedy with Hash Maps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler