Group the People Given the Group Size They Belong To

Group the People Given the Group Size They Belong To - Problem

Imagine you're organizing a team-building event where n people need to be divided into groups based on their preferences. Each person has a unique ID from 0 to n-1, and they've told you exactly what group size they want to be in.

You're given an array groupSizes where groupSizes[i] represents the desired group size for person i. For example, if groupSizes[1] = 3, then person 1 wants to be in a group of exactly 3 people.

Your goal: Create groups where every person gets their desired group size. Each person must appear in exactly one group, and the actual size of each group must match what its members requested.

Since multiple valid groupings might exist, you can return any valid solution. The problem guarantees that at least one solution always exists.

Input & Output

example_1.py — Basic Grouping

$ Input: groupSizes = [3,3,3,3,3,1,3]

› Output: [[5],[0,1,2],[3,4,6]]

💡 Note: Person 5 wants to be in a group of size 1, so they form their own group. People 0,1,2 all want groups of size 3 and can be grouped together. Similarly, people 3,4,6 form another group of size 3. The grouping satisfies everyone's preferences.

example_2.py — Mixed Group Sizes

$ Input: groupSizes = [2,1,3,3,3,2]

› Output: [[1],[0,5],[2,3,4]]

💡 Note: Person 1 wants a group of size 1, so they're alone. People 0 and 5 both want groups of size 2, so they pair up. People 2,3,4 all want groups of size 3, forming the final group. Each person gets exactly the group size they requested.

example_3.py — All Same Size

$ Input: groupSizes = [2,2,2,2]

› Output: [[0,1],[2,3]]

💡 Note: Everyone wants to be in groups of size 2. We can form two groups: [0,1] and [2,3]. Both groups have exactly 2 members as requested by all participants.

Constraints

1 ≤ groupSizes.length ≤ 500
1 ≤ groupSizes[i] ≤ groupSizes.length
Important: It's guaranteed that there will be at least one valid solution

Visualization

Tap to expand

Understanding the Visualization

Customer Arrives

Each customer tells you their preferred table size (like person i wanting groupSizes[i])

Find Available Table

Check if there's a partially filled table of that size, or start a new one

Seat Customer

Add the customer to the appropriate table

Complete Tables

When a table reaches its target size, it's complete - move to next customers

Key Takeaway

🎯 Key Insight: Use a hash map to track partially filled groups by size. Complete and output groups immediately when they reach target size, making this an optimal O(n) solution.

Asked in

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

The optimal solution uses a one-pass hash map approach. As we iterate through each person, we add them to a partial group of their desired size. When a partial group reaches its target size, we immediately add it to our results and reset the partial group. This gives us O(n) time complexity and efficiently handles all cases with minimal memory overhead.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Group people by their desired group size and fill groups as we go
Brute Force (Try All Combinations)	O(B(n) × n)	O(n!)	Generate all possible groupings and check if any satisfies the requirements

One-Pass Hash Table (Optimal) — Algorithm Steps

Create a hash map to track partially filled groups for each size
Iterate through each person and their desired group size
Add person to an existing partial group of that size, or create new one
When a group reaches its target size, add it to results and remove from hash map
Continue until all people are grouped

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hash Map

Create map to store partial groups by desired size

Process Each Person

Add person to partial group of their desired size

Complete Groups

When group reaches target size, add to results

Reset Partial Group

Clear the partial group to start collecting for next group

Code -

solution.c — C

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

#define MAX_N 500
#define MAX_GROUP_SIZE 500

// Hash table entry
struct HashEntry {
    int size;
    int people[MAX_GROUP_SIZE];
    int count;
};

struct HashEntry sizeMap[MAX_GROUP_SIZE + 1];
int result[MAX_N][MAX_N];
int resultSizes[MAX_N];
int numGroups = 0;

int** groupThePeople(int* groupSizes, int groupSizesSize, int* returnSize, int** returnColumnSizes) {
    // Initialize hash table
    memset(sizeMap, 0, sizeof(sizeMap));
    numGroups = 0;
    
    for (int person = 0; person < groupSizesSize; person++) {
        int desiredSize = groupSizes[person];
        
        // Add person to partial group of this size
        sizeMap[desiredSize].people[sizeMap[desiredSize].count++] = person;
        sizeMap[desiredSize].size = desiredSize;
        
        // If group is complete, add to result and reset
        if (sizeMap[desiredSize].count == desiredSize) {
            // Copy to result
            resultSizes[numGroups] = desiredSize;
            for (int i = 0; i < desiredSize; i++) {
                result[numGroups][i] = sizeMap[desiredSize].people[i];
            }
            numGroups++;
            
            // Reset for next group of this size
            sizeMap[desiredSize].count = 0;
        }
    }
    
    // Prepare return values
    int** returnArray = (int**)malloc(numGroups * sizeof(int*));
    *returnColumnSizes = (int*)malloc(numGroups * sizeof(int));
    
    for (int i = 0; i < numGroups; i++) {
        (*returnColumnSizes)[i] = resultSizes[i];
        returnArray[i] = (int*)malloc(resultSizes[i] * sizeof(int));
        for (int j = 0; j < resultSizes[i]; j++) {
            returnArray[i][j] = result[i][j];
        }
    }
    
    *returnSize = numGroups;
    return returnArray;
}

int main() {
    char input[1000];
    if (!fgets(input, sizeof(input), stdin)) {
        printf("Error reading input\n");
        return 1;
    }
    
    // Parse input array [1,2,3,4] format
    int groupSizes[MAX_N];
    int count = 0;
    
    // Simple parsing - find numbers between brackets
    char* ptr = strchr(input, '[');
    if (ptr) {
        ptr++; // Skip [
        char* end = strchr(ptr, ']');
        if (end) {
            *end = '\0'; // Null terminate
            
            char* token = strtok(ptr, ",");
            while (token && count < MAX_N) {
                groupSizes[count++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = groupThePeople(groupSizes, count, &returnSize, &returnColumnSizes);
    
    // Output result in JSON format
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Clean up
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all people, with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most one partial group per unique group size, plus result space

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler