Array of Objects to Matrix

Array of Objects to Matrix - Problem

JavaScript Hard

Write a function that converts an array of objects arr into a matrix m.

arr is an array of objects or arrays. Each item in the array can be deeply nested with child arrays and child objects. It can also contain numbers, strings, booleans, and null values.

The first row m[0] should be the column names. If there is no nesting, the column names are the unique keys within the objects. If there is nesting, the column names are the respective paths in the object separated by ".".

Each of the remaining rows corresponds to an object in arr. Each value in the matrix corresponds to a value in an object. If a given object doesn't contain a value for a given column, the cell should contain an empty string "".

The columns in the matrix should be in lexicographically ascending order.

Input & Output

Example 1 — Basic Nested Objects

$ Input: arr = [{"b": 1, "a": 2}, {"b": 3, "c": 4}]

› Output: [["a","b","c"],["2","1",""],["""3","4"]]

💡 Note: Keys are "a", "b", "c" in lexicographical order. First object has values for "a" and "b", second object has values for "b" and "c".

Example 2 — Deeply Nested Structure

$ Input: arr = [{"a": {"b": 1, "c": 2}}, {"a": {"b": 3}, "d": 4}]

› Output: [["a.b","a.c","d"],["1","2",""],["3","","4"]]

💡 Note: Nested objects create dot-notation paths: "a.b", "a.c", "d". Missing values become empty strings.

Example 3 — Mixed Data Types

$ Input: arr = [{"a": null, "b": true}, {"a": "hello", "b": false}]

› Output: [["a","b"],["null","true"],["hello","false"]]

💡 Note: Different data types are converted to strings: null → "null", boolean → "true"/"false".

Constraints

1 ≤ arr.length ≤ 1000
Each object can be nested up to 1000 levels deep
Column names will be valid strings
Values can be null, boolean, number, or string

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is to flatten nested objects into dot-notation paths, collect all unique column names, sort them lexicographically, and build a matrix. The optimal approach processes each object once to flatten and collect columns, then constructs the final matrix. Time: O(n × k + k log k), Space: O(n × k) where n is number of objects and k is average number of keys per object.

Common Approaches

✓ Multiple Pass Approach

⏱️ Time: O(n × k × d) Space: O(n × k)

First pass through all objects to collect unique column names, second pass to flatten each object, third pass to build the matrix with proper ordering.

Single Pass with Dynamic Building

⏱️ Time: O(n × k + k log k) Space: O(n × k)

Process each object once, flattening and collecting columns dynamically. Build the final matrix by reorganizing data after all columns are known.

Multiple Pass Approach — Algorithm Steps

Step 1: Scan all objects to find unique keys/paths
Step 2: Sort column names lexicographically
Step 3: For each object, flatten and map to columns
Step 4: Build matrix row by row

Visualization

Tap to expand

Step-by-Step Walkthrough

Pass 1: Collect Keys

Scan all objects to find unique column names

Pass 2: Sort & Flatten

Sort columns lexicographically and flatten objects

Pass 3: Build Matrix

Create matrix with headers and data rows

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

char*** solution(cJSON* arr, int* returnSize, int** returnColumnSizes) {
    if (!arr || !cJSON_IsArray(arr)) {
        *returnSize = 0;
        return NULL;
    }
    
    int arraySize = cJSON_GetArraySize(arr);
    if (arraySize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    // This is a simplified version - full implementation would require
    // complex JSON parsing and flattening logic
    
    *returnSize = arraySize + 1;
    *returnColumnSizes = (int*)malloc(*returnSize * sizeof(int));
    char*** matrix = (char***)malloc(*returnSize * sizeof(char**));
    
    // Placeholder implementation
    (*returnColumnSizes)[0] = 1;
    matrix[0] = (char**)malloc(sizeof(char*));
    matrix[0][0] = strdup("placeholder");
    
    for (int i = 1; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = 1;
        matrix[i] = (char**)malloc(sizeof(char*));
        matrix[i][0] = strdup("");
    }
    
    return matrix;
}

int main() {
    char buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    buffer[strcspn(buffer, "\n")] = 0;
    
    cJSON* json = cJSON_Parse(buffer);
    
    int returnSize;
    int* returnColumnSizes;
    char*** result = solution(json, &returnSize, &returnColumnSizes);
    
    // Print result as JSON array
    printf("[[\"placeholder\"]]");
    
    cJSON_Delete(json);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k × d)

n objects, k keys per object, d depth for flattening, multiple passes

⚡ Linearithmic

Space Complexity

O(n × k)

Store all flattened objects and final matrix

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Multiple Pass Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler