什么是基于第 n 个元素合并数组的有效方法？

Question

这相对简单，但让我烦恼的是我找不到更优雅的解决方案。

假设您有一个 n 维数组的数组，并且您想通过某种方法（比如加法）将具有匹配第 m 个元素的数组压缩在一起。

示例：[[1, 100], [1, 200], [2, 100], [2, 105], [3, 202], [4, 133]]

结果： [[1, 300], [2, 205], [3, 202], [4, 133]]

我想出的解决方案对我来说似乎真的不优雅。有没有办法用更少的代码或更有效的方式来做到这一点？

function mergePairs(originalArray) {
  const newArray = [];
  originalArray.forEach((pair) => {
    const foundPair = newArray.find((newPair) => {
      return newPair[0] === pair[0];
    });
    if (foundPair) {
      foundPair[1] += pair[1];
    } else {
      newArray.push(pair);
    }
  });
  return newArray;
}

顺便说一句：如果 lodash 中有一个厚脸皮的单线人以一种超级低效的方式完成同样的事情，我也很高兴。

Answer 1

如果您只对数字进行排序，并且您希望数组已经按升序排序（如您的示例）：

function mergePairs(arr) {
  return arr.sort((a, b) => {
    if (a[0] === b[0]){
      a[1] += b[1];
      b[0] = 'del'
    }
  }).filter(val => val[0] !== 'del');
}

或者您可以对其进行排序以确保安全：

function mergePairs(arr) {
  arr.sort((a, b) => a[0] === b[0]);
  return arr.sort((a, b) => {
    if (a[0] === b[0]){
      a[1] += b[1];
      b[0] = 'del'
    }
  }).filter(val => val[0] !== 'del');
}

Answer 2

就我个人而言，我发现将配对拆分然后重新组合更有意义。我使用 indexOf 匹配数组，因为它比整个原始数组列表更有效。每次遇到新值时，我都会将其添加到匹配列表中。匹配值可以是任何东西，而不仅仅是数字，并且不必避开任何关键字。 ~ 将 -1 从 not found 转换为 0 这是错误的。

function combine (complexArray){
    var matches = [];
    var totals = [];

    complexArray.forEach(simplify);

    function simplify(item) {
        var match = matches.indexOf(item[0]);
        if(~match) {
            totals[match] += item[1];
        } else {
            matches.push(item[0]);
            totals.push(item[1]);
        }
    }

    return matches.map(function(value, index) {
        return [value, totals[index]];
    });
}

Answer 3

对于您的具体情况，您可以使用 reduce 和 map：

function mergePairs (originalArray) {
  const o = originalArray.reduce((a, e) => (a[e[0]] = ~~a[e[0]] + e[1]) && a, {});
  return Object.keys(o).map(k => [+k, o[k]]);
}

console.log(mergePairs ([[1, 100], [1, 200], [2, 100], [2, 105], [3, 202], [4, 133]]))