Array of Objects to Matrix

Problem

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 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 lexographically ascending order.

Examples

Example 1:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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

Explanation:
There are two unique column names in the two objects: "a" and "b".
"a" corresponds with [2, 4].
"b" coresponds with [1, 3].

Example 2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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

Explanation:
There are 4 unique column names: "a", "b", "c", "d".
The first object has values associated with "a" and "b".
The second object has values associated with "c" and "d".
The third object has no keys, so it is just a row of empty strings.

Example 3:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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

Explanation:
In this example, the objects are nested. The keys represent the full path to each value separated by periods.
There are three paths: "a.b", "a.c", "a.d".

Example 4:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


Input: 
arr = [
  [{"a": null}],
  [{"b": true}],
  [{"c": "x"}]
]
Output: 
[
  ["0.a", "0.b", "0.c"],
  [null, "", ""],
  ["", true, ""],
  ["", "", "x"]
]

Explanation:
Arrays are also considered objects with their keys being their indices.
Each array has one element so the keys are "0.a", "0.b", and "0.c".

Example 5:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


Input: 
arr = [
  {},
  {},
  {},
]
Output: 
[
  [],
  [],
  [],
  []
]

Explanation:
There are no keys so every row is an empty array.

Constraints:

arr is a valid JSON array
1 <= arr.length <= 1000
unique keys <= 1000

Solution

Method 1 - Recursive Flattening and Matrix Construction (JavaScript)

Intuition: To convert an array of (possibly nested) objects/arrays into a matrix, we need to flatten each object to get all possible key paths, collect all unique keys, and then build the matrix row by row.

Approach:

For each object in the array, recursively flatten it, using dot notation for nested keys and indices for arrays.
Collect all unique key paths across all objects.
Sort the keys lexicographically for the header row.
For each object, build a row by mapping each key to its value (or empty string if missing).
Return the matrix.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


function arrayToMatrix(arr) {
    // Helper to flatten an object/array
    function flatten(obj, prefix = '', out = {}) {
        if (typeof obj !== 'object' || obj === null) {
            out[prefix] = obj;
            return;
        }
        if (Array.isArray(obj)) {
            obj.forEach((v, i) => {
                flatten(v, prefix ? `${prefix}.${i}` : `${i}`, out);
            });
        } else {
            for (const k in obj) {
                flatten(obj[k], prefix ? `${prefix}.${k}` : k, out);
            }
        }
    }

    const keySet = new Set();
    const flatArr = arr.map(obj => {
        const flat = {};
        flatten(obj, '', flat);
        Object.keys(flat).forEach(k => keySet.add(k));
        return flat;
    });
    const keys = Array.from(keySet).sort();
    const matrix = [keys];
    for (const flat of flatArr) {
        matrix.push(keys.map(k => (k in flat ? flat[k] : "")));
    }
    return matrix;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


function arrayToMatrix(arr: any[]): any[][] {
    function flatten(obj: any, prefix = '', out: Record<string, any> = {}) {
        if (typeof obj !== 'object' || obj === null) {
            out[prefix] = obj;
            return;
        }
        if (Array.isArray(obj)) {
            obj.forEach((v, i) => {
                flatten(v, prefix ? `${prefix}.${i}` : `${i}`, out);
            });
        } else {
            for (const k in obj) {
                flatten(obj[k], prefix ? `${prefix}.${k}` : k, out);
            }
        }
    }
    const keySet = new Set<string>();
    const flatArr = arr.map(obj => {
        const flat: Record<string, any> = {};
        flatten(obj, '', flat);
        Object.keys(flat).forEach(k => keySet.add(k));
        return flat;
    });
    const keys = Array.from(keySet).sort();
    const matrix: any[][] = [keys];
    for (const flat of flatArr) {
        matrix.push(keys.map(k => (k in flat ? flat[k] : "")));
    }
    return matrix;
}

Complexity

⏰ Time complexity: O(N * K) where N = arr.length and K = number of unique key paths (flattening and row construction dominate).
🧺 Space complexity: O(N * K) for storing the flattened objects and the result matrix.

Problem#

Examples#

Solution#

Method 1 - Recursive Flattening and Matrix Construction (JavaScript)#

Code#

Complexity#