Divide Array in Sets of K Consecutive Numbers

Divide Array in Sets of K Consecutive Numbers - Problem

Can you organize a deck of cards into perfect consecutive sequences?

Given an array of integers nums and a positive integer k, your task is to determine whether it's possible to divide this array into groups of exactly k consecutive numbers.

For example, if you have [1, 2, 3, 6, 2, 3, 4, 7, 8] and k = 3, you need to check if you can form groups like [1, 2, 3], [2, 3, 4], and [6, 7, 8] using all numbers exactly once.

Goal: Return true if such a division is possible, false otherwise.

Key constraints: Each number must be used exactly once, and each group must contain exactly k consecutive integers.

Input & Output

example_1.py — Basic consecutive groups

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

› Output: true

💡 Note: We can divide the array into two groups: [1,2,3,4] and [3,4,5,6]. Each group has exactly 4 consecutive numbers.

example_2.py — Impossible division

$ Input: nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3

› Output: true

💡 Note: We can form groups: [1,2,3], [2,3,4], [3,4,5], and [9,10,11]. All groups have exactly 3 consecutive numbers.

example_3.py — Array length not divisible by k

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

› Output: false

💡 Note: Array length (4) is not divisible by k (3), so it's impossible to divide into groups of size 3.

Visualization

Tap to expand

Understanding the Visualization

Count Your Cards

First, count how many of each card value you have

Start from Smallest

Always begin forming sequences from the smallest available card

Form Complete Sequences

Create groups of exactly k consecutive cards

Remove Used Cards

Remove cards from your pile as they're used in sequences

Repeat Until Done

Continue until all cards are used or impossible to proceed

Key Takeaway

🎯 Key Insight: The greedy approach of always starting from the smallest available number is optimal because it ensures we never waste opportunities to form valid consecutive sequences.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(log n) per insertion/deletion in TreeMap, O(n) total operations

⚡ Linearithmic

Space Complexity

O(n)

TreeMap stores at most n unique numbers with their counts

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length
Each number in nums can be used exactly once
Groups must contain exactly k consecutive integers

Asked in

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

The optimal solution uses a greedy approach with TreeMap to maintain sorted order of numbers. Key insight: always start forming consecutive sequences from the smallest available number. This ensures we never miss a valid grouping and achieves O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n!)	O(n)	Try every possible way to group numbers into consecutive sequences
Optimized Greedy (Min-Heap)	O(n log n)	O(n)	Use min-heap to always process smallest available number first
Two-Pass Hash Table (Count & Consume)	O(n log n)	O(n)	First count all numbers, then greedily form consecutive sequences

Brute Force (Try All Combinations) — Algorithm Steps

Try each number as a potential start of a sequence
For each starting number, check if we can form k consecutive numbers
If successful, recursively solve the problem with remaining numbers
Backtrack if current path doesn't lead to solution

Visualization

Tap to expand

Step-by-Step Walkthrough

Try First Sequence

Attempt to form a sequence starting from first available number

Recursive Exploration

Recursively solve with remaining numbers

Backtrack

If current path fails, try next possible sequence

Code -

solution.c — C

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

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

bool backtrack(int* remaining, int size, int k) {
    if (size == 0) return true;
    
    // Sort to get minimum element
    qsort(remaining, size, sizeof(int), compare);
    int start = remaining[0];
    
    // Try to form sequence starting from minimum
    int tempRemaining[1000];
    int tempSize = size;
    
    for (int i = 0; i < size; i++) {
        tempRemaining[i] = remaining[i];
    }
    
    // Try to remove k consecutive numbers
    for (int i = 0; i < k; i++) {
        int target = start + i;
        bool found = false;
        
        for (int j = 0; j < tempSize; j++) {
            if (tempRemaining[j] == target) {
                // Remove element
                for (int l = j; l < tempSize - 1; l++) {
                    tempRemaining[l] = tempRemaining[l + 1];
                }
                tempSize--;
                found = true;
                break;
            }
        }
        
        if (!found) return false;
    }
    
    return backtrack(tempRemaining, tempSize, k);
}

bool isPossibleDivide(int* nums, int numsSize, int k) {
    if (numsSize % k != 0) return false;
    return backtrack(nums, numsSize, k);
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, we try all permutations of arrangements

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary arrays for tracking used numbers

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length
Each number in nums can be used exactly once
Groups must contain exactly k consecutive integers

78.4K Views

Medium-High Frequency

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

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler