Array of Objects to Matrix - Practice Coding Problems

Array of Objects to Matrix - Problem

JavaScript Hard

Transform an array of nested objects into a structured matrix format! This problem challenges you to flatten complex, deeply nested data structures into a readable tabular format.

Given an array arr containing objects or arrays with potentially deep nesting (including child arrays, objects, numbers, strings, booleans, and null values), your task is to:

Extract all possible paths from the nested structures
Create column headers using dot notation for nested paths (e.g., "user.address.city")
Build a matrix where the first row contains sorted column names
Populate data rows with values from each object, using empty strings for missing values

The columns must be arranged in lexicographically ascending order, making the output predictable and organized.

Example: [{"name": "John", "address": {"city": "NYC"}}, {"name": "Jane", "age": 25}] becomes a matrix with headers ["address.city", "age", "name"] and corresponding data rows.

Input & Output

example_1.py — Basic Objects

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

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

💡 Note: Two objects with different keys. Columns sorted: a, b, c. Missing values filled with empty strings.

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Iterations)	O(n * m * d)	O(m)	Extract all paths first, then rebuild objects multiple times to populate matrix
One-Pass Streaming (Optimal)	O(n * d + m²)	O(n * m)	Stream process objects while dynamically building paths and matrix structure
Two-Pass Optimization	O(n * d + m log m)	O(n * m)	First pass discovers all paths efficiently, second pass builds the matrix

Brute Force (Multiple Iterations) — Algorithm Steps

Iterate through all objects to collect every possible path
Sort all discovered paths lexicographically
For each object, iterate through all paths to extract values
Build the result matrix with headers and data rows

Visualization

Tap to expand

Step-by-Step Walkthrough

Path Discovery

Traverse each object to find all possible paths like 'user.name', 'user.address.city'

Path Sorting

Sort all discovered paths in lexicographic order

Value Extraction

For each object, traverse every path to extract values or empty strings

Code -

solution.c — C

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

// Simplified C implementation for basic objects
char*** jsonToMatrix(char** keys[], char** values[], int* sizes, int numObjects, int* resultRows, int* resultCols) {
    // This is a simplified version for demonstration
    // Full implementation would require complex JSON parsing
    
    char** allKeys = malloc(1000 * sizeof(char*));
    int keyCount = 0;
    
    // Collect all unique keys
    for (int i = 0; i < numObjects; i++) {
        for (int j = 0; j < sizes[i]; j++) {
            int found = 0;
            for (int k = 0; k < keyCount; k++) {
                if (strcmp(allKeys[k], keys[i][j]) == 0) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                allKeys[keyCount] = malloc(strlen(keys[i][j]) + 1);
                strcpy(allKeys[keyCount], keys[i][j]);
                keyCount++;
            }
        }
    }
    
    // Sort keys (simple bubble sort)
    for (int i = 0; i < keyCount - 1; i++) {
        for (int j = 0; j < keyCount - i - 1; j++) {
            if (strcmp(allKeys[j], allKeys[j + 1]) > 0) {
                char* temp = allKeys[j];
                allKeys[j] = allKeys[j + 1];
                allKeys[j + 1] = temp;
            }
        }
    }
    
    // Build result matrix
    *resultRows = numObjects + 1;
    *resultCols = keyCount;
    
    char*** result = malloc(*resultRows * sizeof(char**));
    for (int i = 0; i < *resultRows; i++) {
        result[i] = malloc(*resultCols * sizeof(char*));
    }
    
    // Set headers
    for (int i = 0; i < keyCount; i++) {
        result[0][i] = malloc(strlen(allKeys[i]) + 1);
        strcpy(result[0][i], allKeys[i]);
    }
    
    // Set data rows
    for (int i = 0; i < numObjects; i++) {
        for (int j = 0; j < keyCount; j++) {
            result[i + 1][j] = malloc(2);
            strcpy(result[i + 1][j], "");
            
            // Find value for this key
            for (int k = 0; k < sizes[i]; k++) {
                if (strcmp(keys[i][k], allKeys[j]) == 0) {
                    free(result[i + 1][j]);
                    result[i + 1][j] = malloc(strlen(values[i][k]) + 1);
                    strcpy(result[i + 1][j], values[i][k]);
                    break;
                }
            }
        }
    }
    
    free(allKeys);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * d)

n objects, m unique paths, d average depth - we traverse each path for each object

✓ Linear Growth

Space Complexity

O(m)

Store all unique paths and the result matrix

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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