Javascript – Find Largest Value in Array of Multi Dimensional Array, with Different Object names

As colleagues rightly mentioned in the comments, you need to leverage three things:

1. Create an array or map (in this version of the implementation) to keep track only of the delay values
2. Map is used to keep serialized coordinates as keys (x,y,z) and
   values are corresponding data objects. It will allow you to avoid
   nested arrays and use the capabilities of Map to make an
   efficient lookup.
3. Leverage Math.max function to find the maximum in an subset

InitializeMap function:

Creates a transformed set with key as coordinates string and corresponding value.

function InitializeMap() {
    const entries = [
        { x: 127, y: 1, z: 0, data: {name:"Gl", ss:["Z0",127,"B0",1,[58,0]], delay:{first:60, term:220, slow:240, med:188, fast:188}}},
        { x: 127, y: 127, z: 0, data: {name:"Gl Co", ss:["Z0",127,"B0",127,[58,0]], delay:{first:60, term:220, slow:240, med:188, fast:188}}},
        { x: 127, y: 1, z: 6, data: {name:"Gl El", ss:["Z0",127,"B0",1,[58,6]], delay:{first:60, term:310, slow:360, med:245, fast:145}}},
        { x: 127, y: 127, z: 6, data: {name:"Gl El Co", ss:["Z0",127,"B0",127,[58,6]], delay:{first:60, term:310, slow:330, med:245, fast:145}}}
    ];

    entries.forEach(entry => {
        const key = `${entry.x},${entry.y},${entry.z}`;
        ARR_Map.set(key, entry.data.delay); // Store only delay objects
    });
}

Search Max Value

Iterate over the transformed map and search the max value within each set. Then find the largest value of all.

// Function to find the maximum delay using Map
function findMaxDelayUsingMap(arrMap) {
    let maxDelay = -Infinity;
    for (let delayObj of arrMap.values()) {
        const localMax = Math.max(...Object.values(delayObj).filter(val => typeof val === 'number'));
        if (localMax > maxDelay) {
            maxDelay = localMax;
        }
    }
    return maxDelay;
}

Complete code example:

// Initialize a Map to store only initialized entries
const ARR_Map = new Map();

// Modified Initialize function to use Map
function InitializeMap() {
    const entries = [
        { x: 127, y: 1, z: 0, data: {name:"Gl", ss:["Z0",127,"B0",1,[58,0]], delay:{first:60, term:220, slow:240, med:188, fast:188}}},
        { x: 127, y: 127, z: 0, data: {name:"Gl Co", ss:["Z0",127,"B0",127,[58,0]], delay:{first:60, term:220, slow:240, med:188, fast:188}}},
        { x: 127, y: 1, z: 6, data: {name:"Gl El", ss:["Z0",127,"B0",1,[58,6]], delay:{first:60, term:310, slow:360, med:245, fast:145}}},
        { x: 127, y: 127, z: 6, data: {name:"Gl El Co", ss:["Z0",127,"B0",127,[58,6]], delay:{first:60, term:310, slow:330, med:245, fast:145}}}
    ];

    entries.forEach(entry => {
        const key = `${entry.x},${entry.y},${entry.z}`;
        ARR_Map.set(key, entry.data.delay); // Store only delay objects
    });
}
 
InitializeMap();

// Function to find the maximum delay using Map
function findMaxDelayUsingMap(arrMap) {
    let maxDelay = -Infinity;
    for (let delayObj of arrMap.values()) {
        const localMax = Math.max(...Object.values(delayObj).filter(val => typeof val === 'number'));
        if (localMax > maxDelay) {
            maxDelay = localMax;
        }
    }
    return maxDelay;
}

let maximumDelayMap = findMaxDelayUsingMap(ARR_Map);
console.log("The maximum delay using Map is:", maximumDelayMap);

Actually, after giving it a good thought, it can be implemented even in a simpler manner compared to previous answer. The difference here is that we can leverage array and flatMap() to avoid another lookup of a max value from local ones (as in previous answer).

const ARR_SIZE = 128;

// Initialize the ARR 3D array with nulls for uninitialized entries
const ARR = Array.from({ length: ARR_SIZE }, () =>
    Array.from({ length: ARR_SIZE }, () =>
        Array.from({ length: ARR_SIZE }, () => null)
    )
);


let initializedEntriesFunctional = [];

function InitializeFunctional() {
    const entries = [
        {
            x: 127, y: 1, z: 0,
            data: { name: "Gl", ss: ["Z0", 127, "B0", 1, [58, 0]], delay:{ first: 60, term: 220, slow: 240, med: 188, fast: 188 }
        }
    ]

    entries.forEach(entry => {
        // Populate the ARR array with the data object
        ARR[entry.x][entry.y][entry.z] = entry.data;

        // Track only the delay objects for efficient processing
        initializedEntriesFunctional.push(entry.data.delay);
    });
}

// Execute the initialization
InitializeFunctional();


function findMaxDelayFunctional(initializedDelays) {
    // Extract all numerical delay values and flatten them into a single array
    const allDelays = initializedDelays.flatMap(delayObj =>
        Object.values(delayObj).filter(val => typeof val === 'number')
    );

    // Use Math.max to find the largest delay value
    return Math.max(...allDelays);
}

const maximumDelayFunctional = findMaxDelayFunctional(initializedEntriesFunctional);
console.log("The maximum delay using Functional Programming is:", maximumDelayFunctional);