Ways to obtain a combined total array from three sets of two-dimensional arrays

Question

Ways to obtain a combined total array from three sets of two-dimensional arrays

I have a total of 3 arrays containing two-dimensional data which represent series data for plotting lines on a graph. Each array consists of timestamps as keys.

const arr1 = [[1641013200000,1881],[1643691600000,38993],[1646110800000,41337],[1648785600000,78856],[1651377600000,117738],[1654056000000,119869],[1656648000000,157799],[1659326400000,196752],[1662004800000,199061],[1664596800000,237034],[1667275200000,239153],[1669870800000,269967]]

const arr2 = [[1641013200000,1302],[1643691600000,3347],[1646110800000,4754],[1648785600000,6948],[1651377600000,9725],[1654056000000,11314],[1656648000000,13787],[1659326400000,16666],[1662004800000,18370],[1664596800000,20876],[1667275200000,22384],[1669870800000,23560]]

const arr3 = [[1643691600000,67350],[1648785600000,134700],[1651377600000,202148],[1654056000000,202270],[1656648000000,269843],[1659326400000,337346],[1662004800000,337470],[1664596800000,404861],[1667275200000,404889],[1669870800000,472239]]

I am looking to plot an additional line series that represents the cumulative total of all three arrays' values by timestamp. If a timestamp is missing in any of the arrays, I would like to add the previous index value.

const totalArray = [
[1641013200000,3183],[1643691600000, 109690],[1646110800000, 113441],[1648785600000, 220504],
[1651377600000, 329611],[1654056000000, 333453],[1656648000000, 441429],[1659326400000, 550764],
[1662004800000, 554901],[1664596800000, 662771],[1667275200000, 666426],[1669870800000, 765766]
]

Although I attempted to do this, there are some incorrect values due to missing timestamps in one of the arrays.

My Approach:

const arr1 = [
  [1641013200000, 1881],
  [1643691600000, 38993],
  [1646110800000, 41337],
  [1648785600000, 78856],
  [1651377600000, 117738],
  [1654056000000, 119869],
  [1656648000000, 157799],
  [1659326400000, 196752],
  [1662004800000, 199061],
  [1664596800000, 237034],
  [1667275200000, 239153],
  [1669870800000, 269967]
];
const arr2 = [
  [1641013200000, 1302],
  [1643691600000, 3347],
  [1646110800000, 4754],
  [1648785600000, 6948],
  [1651377600000, 9725],
  [1654056000000, 11314],
  [1656648000000, 13787],
  [1659326400000, 16666],
  [1662004800000, 18370],
  [1664596800000, 20876],
  [1667275200000, 22384],
  [1669870800000, 23560]
];
const arr3 = [
  [1643691600000, 67350],
  [1648785600000, 134700],
  [1651377600000, 202148],
  [1654056000000, 202270],
  [1656648000000, 269843],
  [1659326400000, 337346],
  [1662004800000, 337470],
  [1664596800000, 404861],
  [1667275200000, 404889],
  [1669870800000, 472239]
];

const calculateTotal = () => {
  var ret;

  for (let a3 of arr3) {
    var index = arr1.map(function(el) {
      return el[0];
    }).indexOf(a3[0]);
    console.log(index);
    if (index === -1) {
      ret = arr1[index][0];
      console.log(ret);
    }
  }
  let unsortedArr = arr1.concat(arr2, arr3);
  var sortedArray = unsortedArr.sort((a, b) => a[0] - b[0]);
  var added = addArray(sortedArray);
  console.log("Current Output: " + JSON.stringify(added));
}

const addArray = (tuples) => {
  var hash = {},
    keys = [];
  tuples.forEach(function(tuple) {
    var key = tuple[0],
      value = tuple[1];
    if (hash[key] === undefined) {
      keys.push(key);
      hash[key] = value;
    } else {
      hash[key] += value;
    }
  });
  return keys.map(function(key) {
    return ([key, hash[key]]);
  });
}

calculateTotal();

Can this be achieved successfully?

javascript arrays multidimensional-array

Answer 1

Answer №1

Your code is currently containing the following lines:

if (index === -1) {
    ret = arr1[index][0];

However, this assignment will not work because arr1[-1] is not defined.

Subsequently, when you perform:

let unsortedArr = arr1.concat(arr2, arr3);

...you are creating an array that lacks the ability to utilize default values (from a preceding index) if any of the three arrays have a "missing" timestamp.

I recommend the following approach:

Gather all unique timestamps (from all arrays) into a Map and assign empty arrays to each of those keys initially.
Add the timestamps from the original arrays to their respective arrays in the map.
Retrieve a sorted list of entries from the map.
Fill in the "gaps" by carrying forward values to the next array when the corresponding slot is undefined. Simultaneously, accumulate these values for the final output.

Below is an implementation example:

function mergeArrays(...arrays) {
    const map = new Map(arrays.flatMap(arr => arr.map(([stamp]) => [stamp, []]));
    arrays.forEach((arr, i) => {
        for (const [timeStamp, value] of arr) {
            map.get(timeStamp)[i] = value;
        }
    });
    const state = Array(arrays.length).fill(0);
    return Array.from(map).sort(([a], [b]) => a - b).map(([timeStamp, arr], i) =>
        [timeStamp, state.reduce((sum, prev, j) => sum + (state[j] = arr[j] ?? prev), 0)]
    );
} 

// Example usage
const arr1 = [[1641013200000,1881],[1643691600000,38993],[1646110800000,41337],[1648785600000,78856],[1651377600000,117738],[1654056000000,119869],[1656648000000,157799],[1659326400000,196752],[1662004800000,199061],[1664596800000,237034],[1667275200000,239153],[1669870800000,269967]];
const arr2 = [[1641013200000,1302],[1643691600000,3347],[1646110800000,4754],[1648785600000,6948],[1651377600000,9725],[1654056000000,11314],[1656648000000,13787],[1659326400000,16666],[1662004800000,18370],[1664596800000,20876],[1667275200000,22384],[1669870800000,23560]];
const arr3 = [[1643691600000,67350],[1648785600000,134700],[1651377600000,202148],[1654056000000,202270],[1656648000000,269843],[1659326400000,337346],[1662004800000,337470],[1664596800000,404861],[1667275200000,404889],[1669870800000,472239]];

const result = mergeArrays(arr1, arr2, arr3);
console.log(result);

Answer 2

Your code is currently containing the following lines:

if (index === -1) {
    ret = arr1[index][0];

However, this assignment will not work because arr1[-1] is not defined.

Subsequently, when you perform:

let unsortedArr = arr1.concat(arr2, arr3);

...you are creating an array that lacks the ability to utilize default values (from a preceding index) if any of the three arrays have a "missing" timestamp.

I recommend the following approach:

Gather all unique timestamps (from all arrays) into a Map and assign empty arrays to each of those keys initially.
Add the timestamps from the original arrays to their respective arrays in the map.
Retrieve a sorted list of entries from the map.
Fill in the "gaps" by carrying forward values to the next array when the corresponding slot is undefined. Simultaneously, accumulate these values for the final output.

Below is an implementation example:

function mergeArrays(...arrays) {
    const map = new Map(arrays.flatMap(arr => arr.map(([stamp]) => [stamp, []]));
    arrays.forEach((arr, i) => {
        for (const [timeStamp, value] of arr) {
            map.get(timeStamp)[i] = value;
        }
    });
    const state = Array(arrays.length).fill(0);
    return Array.from(map).sort(([a], [b]) => a - b).map(([timeStamp, arr], i) =>
        [timeStamp, state.reduce((sum, prev, j) => sum + (state[j] = arr[j] ?? prev), 0)]
    );
} 

// Example usage
const arr1 = [[1641013200000,1881],[1643691600000,38993],[1646110800000,41337],[1648785600000,78856],[1651377600000,117738],[1654056000000,119869],[1656648000000,157799],[1659326400000,196752],[1662004800000,199061],[1664596800000,237034],[1667275200000,239153],[1669870800000,269967]];
const arr2 = [[1641013200000,1302],[1643691600000,3347],[1646110800000,4754],[1648785600000,6948],[1651377600000,9725],[1654056000000,11314],[1656648000000,13787],[1659326400000,16666],[1662004800000,18370],[1664596800000,20876],[1667275200000,22384],[1669870800000,23560]];
const arr3 = [[1643691600000,67350],[1648785600000,134700],[1651377600000,202148],[1654056000000,202270],[1656648000000,269843],[1659326400000,337346],[1662004800000,337470],[1664596800000,404861],[1667275200000,404889],[1669870800000,472239]];

const result = mergeArrays(arr1, arr2, arr3);
console.log(result);

Ways to obtain a combined total array from three sets of two-dimensional arrays

Answer №1

Similar questions

Tips for sending a form with the <button type="submit"> element

Troubleshooting Next.js and NextAuth.js Authentication Redirect Issue

Direct your attention to alternative data sources following the selection of an item in the typeahead search feature

Mobile Chrome allows users to utilize the IFrame player API for enhanced video

Unable to include an element into a vacant array becomes the root of discussion on contrasts between inserting, appending, and concatenating

Troubleshooting issues with logging out in AngularJS

Tips for sending information to afterClosed() within Angular Material Dialog on Angular 6

Python Selenium code is encountering a "Element not found" exception

Whenever I press a button, my desire is for each picture to seamlessly reposition itself in the exact same spot on the screen

JQuery appended Bootstrap Modal to Body, but it refuses to close

Pause and anticipate a request in MongoDB

What is the process for retrieving data from multiple tables within a database using Node.js, MySQL, and Express.js?

Tips for efficiently handling navigation re-rendering on a Single Page Application using Vue.js

Opening a fresh window with HTML content extracted from the existing page

Discovering the best way to display information in two separate cards using the JSON response in Next.js

Determine the Button's State by Monitoring Changes in the TextBox Text

Traverse through an array of pictures and add the data to a Bootstrap placeholder within HTML markup

Managing the invocation of a promise multiple times in AngularJS, and handling some specific exceptions

Tips for preventing a promise from being executed more than once within an observable while being subscribed to a BehaviorSubject

What are the steps to effectively utilize the $filter('filter') function when filtering multiple columns with OR as the condition?