Convert an Array Into a 2D Array With Conditions

Convert an Array Into a 2D Array With Conditions - Problem

Transform Array Into Optimal 2D Matrix

You're given an integer array nums and need to reorganize it into a 2D array following specific rules:

📋 Requirements:

Use all elements from the original array
Each row must contain distinct integers (no duplicates within a row)
Minimize the number of rows in the result

Your task is to return the resulting 2D array. Multiple valid answers may exist - return any of them.

💡 Key Insight: The minimum number of rows equals the frequency of the most common element!

Example: [1,3,4,1,2,3,1] → [[1,3,4,2],[1,3],[1]]
Since 1 appears 3 times, we need at least 3 rows.

Input & Output

example_1.py — Python

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

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

💡 Note: Element 1 appears 3 times, so we need at least 3 rows. We distribute: first row gets one occurrence of each element [1,3,4,2], second row gets remaining occurrences [1,3], third row gets the final [1].

example_2.py — Python

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

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

💡 Note: All elements are unique (frequency = 1), so we only need one row containing all elements.

example_3.py — Python

$ Input: [1,1,1,1]

› Output: [[1],[1],[1],[1]]

💡 Note: Element 1 appears 4 times, and each row can only contain distinct elements, so we need 4 rows with one element each.

Visualization

Tap to expand

Understanding the Visualization

Count Customer Types

Count how many customers have each badge number

Determine Tables Needed

The badge number that appears most frequently determines minimum tables needed

Seat Customers

Use round-robin to seat customers - place one of each badge type at each table

Final Arrangement

All customers are seated with no duplicate badges at any table

Key Takeaway

🎯 Key Insight: The frequency of the most common element determines the minimum number of rows needed, and round-robin distribution ensures optimal placement.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, single pass to place elements

✓ Linear Growth

Space Complexity

O(k)

Where k is number of unique elements, for the frequency map

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ nums.length
Each row must contain distinct integers
Minimize the number of rows in the result

Asked in

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

The optimal solution uses frequency counting to determine the minimum rows needed (equal to max frequency), then distributes elements using a round-robin approach in O(n) time. The key insight is that the most frequent element determines the minimum number of rows required.

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Counting (Optimal)	O(n)	O(k)	Count frequencies first, then distribute elements optimally using round-robin
Brute Force (Check Each Row)	O(n²)	O(1)	For each element, find the first row where it doesn't already exist

Frequency Counting (Optimal) — Algorithm Steps

Count frequency of each element in the input array
Find the maximum frequency - this is the minimum number of rows needed
Create the required number of empty rows
For each unique element, distribute its occurrences across different rows
Place one occurrence of each element per row until all are placed

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each element appears

Determine Rows

Max frequency determines minimum rows needed

Distribute Elements

Place each element occurrence in different rows

Final Result

All elements distributed with no duplicates per row

Code -

solution.c — C

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

int** findMatrix(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    // Simple frequency counting using array (assuming nums[i] <= 1000)
    int freq[1001] = {0};
    int maxFreq = 0;
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
        if (freq[nums[i]] > maxFreq) {
            maxFreq = freq[nums[i]];
        }
    }
    
    // Initialize result
    *returnSize = maxFreq;
    *returnColumnSizes = (int*)calloc(maxFreq, sizeof(int));
    int** result = (int**)malloc(maxFreq * sizeof(int*));
    
    for (int i = 0; i < maxFreq; i++) {
        result[i] = (int*)malloc(numsSize * sizeof(int));
    }
    
    // Distribute elements
    for (int num = 0; num <= 1000; num++) {
        for (int i = 0; i < freq[num]; i++) {
            result[i][(*returnColumnSizes)[i]] = num;
            (*returnColumnSizes)[i]++;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {1, 3, 4, 1, 2, 3, 1};
    int numsSize = 7;
    int returnSize;
    int* returnColumnSizes;
    
    int** result = findMatrix(nums, numsSize, &returnSize, &returnColumnSizes);
    
    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");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, single pass to place elements

✓ Linear Growth

Space Complexity

O(k)

Where k is number of unique elements, for the frequency map

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ nums.length
Each row must contain distinct integers
Minimize the number of rows in the result

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Frequency Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler