Assign Elements to Groups with Constraints

Assign Elements to Groups with Constraints - Problem

You are the organizer of a team-building event where you need to assign equipment to different activity groups based on their capacity and specific rules.

Given an integer array groups where groups[i] represents the size of the i-th group, and an integer array elements containing available equipment pieces, your task is to assign one piece of equipment to each group following these rules:

📏 An equipment piece at index j can be assigned to group i if groups[i] is divisible by elements[j]
🎯 If multiple equipment pieces can be assigned, choose the one with the smallest index (first available)
❌ If no equipment satisfies the condition for a group, assign -1 to that group
♻️ The same equipment piece can be assigned to multiple groups

Return an integer array assigned where assigned[i] is the index of the equipment chosen for group i, or -1 if no suitable equipment exists.

Example: If groups = [12, 8, 15] and elements = [2, 3, 4, 5], then group 0 (size 12) can use equipment at indices 0, 1, 2 (since 12 % 2 = 0, 12 % 3 = 0, 12 % 4 = 0), so we pick index 0 (smallest).

Input & Output

example_1.py — Basic Assignment

$ Input: groups = [12, 8, 15], elements = [2, 3, 4, 5]

› Output: [0, 0, 1]

💡 Note: Group 12: divisible by elements[0]=2, elements[1]=3, elements[2]=4, choose smallest index 0. Group 8: divisible by elements[0]=2, elements[2]=4, choose smallest index 0. Group 15: divisible by elements[1]=3, elements[3]=5, choose smallest index 1.

example_2.py — No Valid Assignment

$ Input: groups = [7, 11], elements = [2, 4, 6]

› Output: [-1, -1]

💡 Note: Group 7: not divisible by 2, 4, or 6, so assign -1. Group 11: not divisible by 2, 4, or 6, so assign -1. Both groups have prime sizes that don't match any available elements.

example_3.py — All Ones

$ Input: groups = [5, 10, 15], elements = [1, 2, 3]

› Output: [0, 0, 0]

💡 Note: Since 1 divides every positive integer, all groups can use elements[0]=1, which has the smallest index. Every group gets assigned index 0.

Visualization

Tap to expand

Understanding the Visualization

Team Assessment

Evaluate each team's size and requirements

Equipment Check

For each team, check available equipment in priority order

Assignment

Assign the first suitable equipment piece to each team

Result

Each team gets optimal equipment or marked as unassignable

Key Takeaway

🎯 Key Insight: Always check equipment in order of priority (smallest index first) to ensure optimal assignment for each team

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Must check elements in order for each group to ensure smallest index, where n = groups.length, m = elements.length

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space beyond the result array

✓ Linear Space

Constraints

1 ≤ groups.length ≤ 10³
1 ≤ elements.length ≤ 10³
1 ≤ groups[i] ≤ 10⁶
1 ≤ elements[i] ≤ 10⁶
Elements array contains no duplicates

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 29 f Meta 25

The optimal approach is a direct assignment algorithm that processes each group sequentially and finds the first matching element by checking divisibility. Since we need the smallest index and elements can be reused, we must examine elements in order for each group, making this O(n×m) unavoidable but optimal for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Assignment (Optimal)	O(n * m)	O(1)	Process each group and find first matching element in single pass
Brute Force (Nested Loops)	O(n * m)	O(1)	For each group, iterate through all elements to find the first divisor

Direct Assignment (Optimal) — Algorithm Steps

Initialize result array for storing assignments
For each group, iterate elements from index 0
Check divisibility condition for current element
Assign first valid element index or -1 if none found
Continue until all groups are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Group 12

Check elements: 2✓ (12%2=0, assign index 0)

Process Group 8

Check elements: 2✓ (8%2=0, assign index 0)

Process Group 15

Check elements: 2✗, 3✓ (15%3=0, assign index 1)

Complete

Result: [0, 0, 1]

Code -

solution.c — C

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

int* assignElements(int* groups, int groupsSize, int* elements, int elementsSize, int* returnSize) {
    int* result = (int*)malloc(groupsSize * sizeof(int));
    *returnSize = groupsSize;
    
    for (int i = 0; i < groupsSize; i++) {
        result[i] = -1;
        
        // Find first element that divides groups[i]
        for (int j = 0; j < elementsSize; j++) {
            if (elements[j] > 0 && groups[i] % elements[j] == 0) {
                result[i] = j;
                break;
            }
        }
    }
    
    return result;
}

int main() {
    int groups[] = {12, 8, 15};
    int elements[] = {2, 3, 4, 5};
    int returnSize;
    int* result = assignElements(groups, 3, elements, 4, &returnSize);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Must check elements in order for each group to ensure smallest index, where n = groups.length, m = elements.length

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space beyond the result array

✓ Linear Space

Constraints

1 ≤ groups.length ≤ 10³
1 ≤ elements.length ≤ 10³
1 ≤ groups[i] ≤ 10⁶
1 ≤ elements[i] ≤ 10⁶
Elements array contains no duplicates

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Direct Assignment (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler