Question

这是我所需要的简单代码示例：

var length = 5;
var arrays = [];


// our arrays

         slice1  
         ↓  slice2
            ↓  ↓ slice3
var a = [1, 1, 1, 1, 1];
var b =    [2, 2, 2, 2];
var c =       [3, 3, 3];
var d =          [4, 4];
var e =             [5];
                     ↑ slice5
// put all above arrays into one array
arrays = arrays.concat([a]);
arrays = arrays.concat([b]);
arrays = arrays.concat([c]);
arrays = arrays.concat([d]);
arrays = arrays.concat([e]);
console.log(arrays)

for (let i = 0; i < length; i++){
 /*         
I want a code here which does this:
var slice = [];
slice[0] = arrays[0][0] => 1
slice[1] = arrays[0][1] + arrays[1][0] => 1 + 2
slice[2] = arrays[0][2] + arrays[1][1] + arrays[2][0] => 1 + 2 + 3
...
*/
}

实际上，我想基于2D数组元素分配切片变量。但是如何？

注意：我可以登录arrays，但是问题是要计算for循环中的每个切片，因为我可能有不同的a，b，{{1 }}，c或其他d。

Answer 1

您可以减少数组，并通过从内部数组的末尾进行迭代来获取索引的偏移量。这适用于任意长度的数组。

一些不同的值可以证明计算结果。

B.m()

[[1, 10, 100, 1000, 10000],
    [20, 200, 2000, 20000],
        [300, 3000, 30000],
             [4000, 40000],
                   [50000]]

[ 1, 30, 600,10000, 150000]

Answer 2

我认为您所描述的算法的最佳方法是找到一个归纳规则，就像您想要的那样！

var length = 5;
var arrays = [];
var slices = new Array(length).fill(0);

// I thought this was a more elegant way of initializing
for (let i = length; i > 0; i--){
  arrays[length-i] = new Array(i).fill(length+1-i);
}

for (let i = 0; i < length; i++) {
  for (let j = 0; j <= i; j++) {
    slices[i] += arrays[j][i - j];
  }
}
console.log(slices);

Answer 3

这是对数组的任何排列进行此操作的方法。即使阵列以不同的顺序排列到不同的长度，它也应该起作用。如果未在特定索引处初始化数组，则诀窍是分配零。

var a = [1, 1, 1, 1, 1];
var b =    [2, 2, 2, 2];
var c =       [3, 3, 3];
var d =          [4, 4];
var e =             [5];
// put all above arrays into one array
let arrays = [a, b, c, d, e]

let sums = arrays.reduce((sums, arr) => {
    arr.reverse().forEach((n, i) => sums[i] = (sums[i] || 0) + n)
    return sums
}, []).reverse()

console.log(sums)

其他安排/长度将按预期工作：

var a =   [10, 2, 2, 2];
var b =[1, 20, 1, 1, 1];
var c =       [3, 3, 3];
var d =          [4, 4];
var e =       [5, 5, 5];

let arrays = [a, b, c, d, e] 

let sums = arrays.reduce((sums, arr) => {
    arr.reverse().forEach((n, i) => sums[i] = (sums[i] || 0) + n)
    return sums
}, []).reverse()

console.log(sums)

Answer 4

通过这种方式，您不必担心尺寸。复杂度时间O（n ^ 2）。虽然不是很好...

  let sum = 0;
arrays.forEach( (array) => {
  array.forEach(item => {
    sum+= item;
  });
});
console.log(sum);

如何将2D数组元素汇总在一起？

4 个答案: