Convert an Array Into a 2D Array With Conditions

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

You are given an integer array nums. You need to create a 2D array from nums satisfying the following conditions:

The 2D array should contain only the elements of the array nums.
Each row in the 2D array contains distinct integers.
The number of rows in the 2D array should be minimal.

Return the resulting array. If there are multiple answers, return any of them.

Note that the 2D array can have a different number of elements on each row.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Number 1 appears 3 times (most frequent), so we need 3 rows minimum. Distribute: Row 1 gets [1,3,4,2], Row 2 gets [1,3], Row 3 gets [1]

Example 2 — All Unique

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

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

💡 Note: All numbers are unique, so only 1 row needed containing all elements

Example 3 — All Same

$ Input: nums = [1,1,1,1]

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

💡 Note: All numbers are the same, so each must go in a separate row to maintain distinctness

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that the minimum number of rows equals the maximum frequency of any element. The frequency counting approach is optimal: count each element's frequency, create that many rows, then distribute elements round-robin style. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each element, try placing it in each existing row. If it can't fit in any row (due to duplicates), create a new row. This explores all possible arrangements.

Frequency Count Optimization

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

Count how many times each number appears, then create exactly as many rows as the maximum frequency. Distribute elements in round-robin fashion to ensure distinct elements per row.

Brute Force - Try All Combinations — Algorithm Steps

For each element in nums
Try to place it in each existing row
If no valid row found, create new row
Continue until all elements placed

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Element

Go through nums one by one

Check Existing Rows

Try to place in each row if no duplicate

Create New Row

If can't place anywhere, make new row

Code -

solution.c — C

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

static int result[200][200];
static int rowSizes[200];
static int numRows = 0;

int findInRow(int row, int num) {
    for (int i = 0; i < rowSizes[row]; i++) {
        if (result[row][i] == num) {
            return 1;
        }
    }
    return 0;
}

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array [a,b,c,d]
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++; // skip '['
    
    numRows = 0;
    for (int i = 0; i < 200; i++) rowSizes[i] = 0;
    
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            int num = strtol(ptr, &ptr, 10);
            
            int placed = 0;
            // Try to place num in existing rows
            for (int row = 0; row < numRows; row++) {
                if (!findInRow(row, num)) {
                    result[row][rowSizes[row]] = num;
                    rowSizes[row]++;
                    placed = 1;
                    break;
                }
            }
            
            // If can't place in any existing row, create new row
            if (!placed) {
                result[numRows][0] = num;
                rowSizes[numRows] = 1;
                numRows++;
            }
        } else {
            ptr++;
        }
    }
    
    // Print result
    printf("[");
    for (int i = 0; i < numRows; i++) {
        printf("[");
        for (int j = 0; j < rowSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < rowSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < numRows - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we might check all existing rows, leading to quadratic time

⚠ Quadratic Growth

Space Complexity

O(n)

Result array stores all n elements

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

234 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler