Array of Objects to Matrix

Problem Statement

The task is to develop a function designed to transform a potentially complex structure: an array of objects, arr, into a simplified two-dimensional matrix, m. Each element within the array, arr, can vary in type and depth, including nested arrays or objects, alongside primitives like numbers, strings, booleans, and null values. The top row of the resultant matrix m should represent column headers, which are derived from the keys found in the objects within arr. These keys are adjusted to reflect the nesting by using a dot notation, which forms a path-like structure for nested objects (e.g., "parent.child"). For flat structures, the keys are direct and unique. Every ensuing row in m represents values from these keys for each corresponding object in arr. If an object lacks a particular key, its respective matrix cell should return an empty string. The columns need to be sorted lexicographically, ensuring an orderly data representation.

Examples

Example 1

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

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

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

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

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

Approach and Intuition

The transformation of a varied, nested JSON object array into a clear and organized matrix format involves several calculated steps, primarily focusing on:

1. Extraction and Sorting of Keys:

   • Traverse each object within arr to extract all available keys. For nested objects, recursively determine the keys and format them in dot notation. Aggregate these keys across all objects, ensuring each is represented only once.
   • Once gathered, sort these unique keys lexicographically to determine the column order in the matrix.

2. Matrix Construction:

   • Initialize the matrix with the first row containing the sorted keys.
   • For each object in the input array arr, create a new row in the matrix:
     • For each key (column), check if the object has a value for that key; if it does, add it to the matrix. If the key does not exist in the object, insert an empty string in the corresponding slot.

3. Handling Special Elements:

   • Ensure that null values are treated distinctly from empty strings, maintaining their presence in the matrix as null.
   • For arrays or lists nested within arr, the indexing convention (e.g., "0.a") should be applied, allowing these elements' inclusion with appropriate labeling that reflects their position within a parent array.

This approach maintains data integrity while offering a structured transformation that clarifies complex JSON data formats into more interpretable and tabular forms.

Solutions

function* generateMatrixRows(inputObj, path = []) {
    if (inputObj != null && Array.isArray(inputObj)) {
        for (let index = 0; index < inputObj.length; index++) {
            path.push(index);
            yield* generateMatrixRows(inputObj[index], path);
            path.pop();
        }
    } else if (inputObj != null && typeof inputObj === 'object') {
        for (const property of Object.keys(inputObj)) {
            path.push(property);
            yield* generateMatrixRows(inputObj[property], path);
            path.pop();
        }
    } else if (path.length > 0) {
        yield [path.join('.'), inputObj];
    }
}

var arrayToMatrix = function(data) {
    const matrix = new Array(data.length + 1).fill(null).map(() => []);
    const rowMaps = new Array(data.length).fill(null).map(() => new Map());
    const columnSet = new Set();

    for (let rowIndex = 0; rowIndex < data.length; rowIndex++) {
        for (const [key, value] of generateMatrixRows(data[rowIndex])) {
            rowMaps[rowIndex].set(key, value);
            columnSet.add(key);
        }
    }

    const columns = [...columnSet].sort();
    matrix[0] = columns;

    for (let rowIndex = 0; rowIndex < data.length; rowIndex++) {
        for (const column of columns) {
            if (rowMaps[rowIndex].has(column)) {
                matrix[rowIndex + 1].push(rowMaps[rowIndex].get(column));
            } else {
                matrix[rowIndex + 1].push('');
            }
        }
    }

    return matrix;
};