Divide Array in Sets of K Consecutive Numbers

Divide Array in Sets of K Consecutive Numbers - Problem

Given an array of integers nums and a positive integer k, determine whether it's possible to divide the array into sets of k consecutive numbers.

Return true if it's possible to divide the array into such sets, otherwise return false.

Example: If nums = [1,2,3,3,4,4,5,6] and k = 4, we can form two sets: [1,2,3,4] and [3,4,5,6], so return true.

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: We can form two groups of 4 consecutive numbers: [1,2,3,4] and [3,4,5,6]. Each number is used exactly once.

Example 2 — Impossible Case

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

› Output: false

💡 Note: We have 12 numbers, so we need 4 groups of 3. However, we can't form 4 complete consecutive sequences due to the gap at 9,10,11.

Example 3 — Single Group

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

› Output: true

💡 Note: Perfect case: exactly one group of 4 consecutive numbers [1,2,3,4].

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

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

The key insight is to use frequency counting with greedy selection - always start forming groups from the smallest available number. The optimal approach counts frequencies and repeatedly selects the minimum number to start consecutive sequences. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force with Backtracking

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

Generate all possible combinations of k consecutive numbers and use backtracking to see if we can partition the entire array. This explores every possible grouping systematically.

Frequency Count with Greedy Selection

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

Count the frequency of each number, then repeatedly select the smallest available number and try to form a consecutive group of size k. This greedy approach works because we must use the smallest number in some group.

Sort and Check Consecutive Sequences

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

Sort the array first, then use a frequency map. Process numbers in sorted order and for each number, if it's the start of a potential sequence, try to form a complete sequence of k consecutive numbers.

Brute Force with Backtracking — Algorithm Steps

Sort the array
Use backtracking to try forming each possible group
Check if all numbers are used exactly once

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Elements

Count frequency of each number

Try Grouping

Start with smallest number, try to form consecutive group

Backtrack

If grouping fails, restore and try different combination

Code -

solution.c — C

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

#define MAX_NUMS 10000
#define MAX_VAL 1000000

static int counter[2*MAX_VAL + 1];
static int offset = MAX_VAL;

bool solution(int* nums, int numsSize, int k) {
    if (numsSize % k != 0) return false;
    
    // Clear counter array
    memset(counter, 0, sizeof(counter));
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        counter[nums[i] + offset]++;
    }
    
    // Find min and max values
    int minVal = MAX_VAL, maxVal = -MAX_VAL;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    // Greedy approach: always start with the smallest available number
    for (int num = minVal; num <= maxVal; num++) {
        int count = counter[num + offset];
        if (count > 0) {
            // We need to form 'count' sets starting with 'num'
            for (int j = 0; j < k; j++) {
                if (counter[num + j + offset] < count) {
                    return false;
                }
                counter[num + j + offset] -= count;
            }
        }
    }
    
    return true;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_NUMS];
    int numsSize = 0;
    
    // Parse array manually
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int num = 0;
        int sign = 1;
        if (*p == '-') {
            sign = -1;
            p++;
        }
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        nums[numsSize++] = sign * num;
    }
    
    int k;
    scanf("%d", &k);
    
    bool result = solution(nums, numsSize, k);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Exponential combinations of grouping n elements into sets of size k

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth and temporary arrays for tracking used elements

⚡ Linearithmic Space

78.9K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler