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.

Time & Space Complexity

Time Complexity

⏱️

O(n * d + m²)

n*d for processing objects, m² for dynamic column insertions in worst case

✓ Linear Growth

Space Complexity

O(n * m)

Result matrix plus temporary path storage

⚡ Linearithmic Space

Constraints

Asked in

Common Approaches

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

One-Pass Streaming (Optimal) — Algorithm Steps

Initialize dynamic matrix with empty headers
For each object, flatten and discover new paths on-the-fly
Dynamically expand matrix columns for new paths
Insert new columns in correct lexicographic position
Fill matrix values using efficient indexing

Visualization

Tap to expand

Step-by-Step Walkthrough

Stream Processing

Process each object once, discovering paths on-the-fly

Dynamic Expansion

Add new columns immediately when discovered, maintaining sort order

Efficient Insertion

Use binary search for optimal column insertion position

Code -

solution.c — C

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

// Simplified single-pass C implementation
char*** jsonToMatrix(char** keys[], char** values[], int* sizes, int numObjects, int* resultRows, int* resultCols) {
    if (numObjects == 0) {
        *resultRows = 0;
        *resultCols = 0;
        return NULL;
    }
    
    // Dynamic structures
    char** pathList = malloc(1000 * sizeof(char*));
    int pathCount = 0;
    
    // Initial matrix allocation
    char*** matrix = malloc(1000 * sizeof(char**));
    int matrixRows = 1; // Start with header
    
    // Header row
    matrix[0] = malloc(1000 * sizeof(char*));
    
    // Process each object in single pass
    for (int objIndex = 0; objIndex < numObjects; objIndex++) {
        // Find new paths in current object
        for (int j = 0; j < sizes[objIndex]; j++) {
            char* currentKey = keys[objIndex][j];
            
            // Check if path already exists
            int found = 0;
            int insertPos = 0;
            for (int k = 0; k < pathCount; k++) {
                int cmp = strcmp(pathList[k], currentKey);
                if (cmp == 0) {
                    found = 1;
                    break;
                } else if (cmp > 0) {
                    insertPos = k;
                    break;
                } else {
                    insertPos = k + 1;
                }
            }
            
            if (!found) {
                // Insert new path at correct sorted position
                for (int k = pathCount; k > insertPos; k--) {
                    pathList[k] = pathList[k-1];
                }
                pathList[insertPos] = malloc(strlen(currentKey) + 1);
                strcpy(pathList[insertPos], currentKey);
                pathCount++;
                
                // Expand all existing matrix rows
                for (int rowIndex = 0; rowIndex < matrixRows; rowIndex++) {
                    // Reallocate row
                    char** newRow = malloc(pathCount * sizeof(char*));
                    
                    // Copy existing values with insertion
                    for (int col = 0; col < pathCount; col++) {
                        if (col < insertPos) {
                            newRow[col] = matrix[rowIndex][col];
                        } else if (col == insertPos) {
                            if (rowIndex == 0) {
                                // Header row
                                newRow[col] = malloc(strlen(currentKey) + 1);
                                strcpy(newRow[col], currentKey);
                            } else {
                                // Data row - fill later
                                newRow[col] = malloc(2);
                                strcpy(newRow[col], "");
                            }
                        } else {
                            newRow[col] = matrix[rowIndex][col-1];
                        }
                    }
                    
                    free(matrix[rowIndex]);
                    matrix[rowIndex] = newRow;
                }
            }
        }
        
        // Add new data row for current object
        matrix[matrixRows] = malloc(pathCount * sizeof(char*));
        
        for (int col = 0; col < pathCount; col++) {
            matrix[matrixRows][col] = malloc(2);
            strcpy(matrix[matrixRows][col], "");
            
            // Find value for this path in current object
            for (int k = 0; k < sizes[objIndex]; k++) {
                if (strcmp(keys[objIndex][k], pathList[col]) == 0) {
                    free(matrix[matrixRows][col]);
                    matrix[matrixRows][col] = malloc(strlen(values[objIndex][k]) + 1);
                    strcpy(matrix[matrixRows][col], values[objIndex][k]);
                    break;
                }
            }
        }
        matrixRows++;
    }
    
    *resultRows = matrixRows;
    *resultCols = pathCount;
    
    free(pathList);
    return matrix;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * d + m²)

n*d for processing objects, m² for dynamic column insertions in worst case

✓ Linear Growth

Space Complexity

O(n * m)

Result matrix plus temporary path storage

⚡ Linearithmic Space

Constraints

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

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Streaming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler