Question

我在尝试解决数组问题时遇到一些问题。好吧，我有一个这样的整数数组和一个要添加的块：

var model = [1,2,1,0,1]; var block = 1;

现在我必须向每个元素添加一次，并且我应该得到如下结果：

[1,2,1,0,1] + [0,0,0,0,0] = [1,2,1,0,1]
[1,2,1,0,1] + [1,0,0,0,0] = [2,2,1,0,1]
[1,2,1,0,1] + [0,1,0,0,0] = [1,3,1,0,1]
[1,2,1,0,1] + [0,0,1,0,0] = [1,2,2,0,1]
[1,2,1,0,1] + [0,0,0,1,0] = [1,2,1,1,1]
[1,2,1,0,1] + [0,0,0,0,1] = [1,2,1,0,2]

结果应为5x5的数组。当我必须添加多次迭代超过1次时，问题变得更加复杂。

var model = [1,2,1,0,1]; var block = 2;

现在我具有相同的数组，但是我必须以这种方式添加2个块：

[1,2,1,0,1] + [0,0,0,0,0] + [0,0,0,0,0] = [1,2,1,0,1]
[1,2,1,0,1] + [1,0,0,0,0] + [0,0,0,0,0] = [2,2,1,0,1]
[1,2,1,0,1] + [0,1,0,0,0] + [0,0,0,0,0] = [1,3,1,0,1]
[1,2,1,0,1] + [0,0,1,0,0] + [0,0,0,0,0] = [1,2,2,0,1]
[1,2,1,0,1] + [0,0,0,1,0] + [0,0,0,0,0] = [1,2,1,1,1]
[1,2,1,0,1] + [0,0,0,0,1] + [0,0,0,0,0] = [1,2,1,0,2]

[1,2,1,0,1] + [0,0,0,0,0] + [1,0,0,0,0] = [2,2,1,0,1]
[1,2,1,0,1] + [1,0,0,0,0] + [1,0,0,0,0] = [3,2,1,0,1]
[1,2,1,0,1] + [0,1,0,0,0] + [1,0,0,0,0] = [2,3,1,0,1]
[1,2,1,0,1] + [0,0,1,0,0] + [1,0,0,0,0] = [2,2,2,0,1]
[1,2,1,0,1] + [0,0,0,1,0] + [1,0,0,0,0] = [2,2,1,1,1]
[1,2,1,0,1] + [0,0,0,0,1] + [1,0,0,0,0] = [2,2,1,0,2]
     .             .             .             .
     .             .             .             .
     .             .             .             .
[1,2,1,0,1] + [0,0,0,1,0] + [0,0,0,0,1] = [1,2,1,1,2]
[1,2,1,0,1] + [0,0,0,0,1] + [0,0,0,0,1] = [1,2,1,0,4]

我有一个解决第一部分的函数，当我需要迭代1个块时就可以做到。像这样：

    function iterateOneBlock(in_array){

       n_out_array = [];

       for(i=0; i<in_array.length; i++){
            tmp_array = in_array;
            tmp_array[i]++;
            n_out_array[i] = tmp_array;
       }
       return n_out_array;
    }

    const myarray = [1,2,1,0,1];
    var myarrayofarray = iterateOneBlock(myarray);

    console.log(myarrayofarray);

Answer 1

您也可以使用递归函数来做到这一点。在下面的代码中，有3个简单函数，

arsum(ar1,ar2)计算两个数组ar1和ar2

的和

getArr(n,i)返回一个大小为n的数组，其所有元素都为零，唯一的元素为i（即1）

iterateNBlock(inArray, block)是起点

calculate(arrayOfArray, block)是递归函数。当block===0输入的数组是结果时。

在您的示例中，当block为1时，您将计算一些数组作为结果，而当block为2时，您将对所有这些数组执行操作，即对第一个数组执行的操作。

因此对于block=n，您对block=n-1的时间做相同的事情。

function arsum(ar1, ar2){
    let sum = [];
    for(let i=0; i<ar1.length; i++){
        sum.push(ar1[i]+ar2[i]);
    }
    return sum;
}
function getArr(n,i){
    let ar = new Array(n).fill(0);
    if(i>=0 && i<ar.length)
        ar[i]=1;
    return ar;
}
function calculate(arrayOfArray, block){
    if(block===0)return arrayOfArray;

    let n = arrayOfArray[0].length;
    let next = [];

    for(let i=-1; i<n; i++){
        let ar = getArr(n, i);
        for(let j=0 ; j<arrayOfArray.length; j++){
            next.push(arsum(arrayOfArray[j], ar));
        }
    }
    return calculate(next, block-1);
}
function iterateNBlock(inArray, block){
    return calculate([inArray], block);
}

我很难解释它，希望对您有帮助！

Answer 2

这是我能制作的最接近您的代码的代码。 iterateOneBlock基本上是您的职责。第一行添加Array.from的副本（按in_array）（添加[0, 0, 0, 0, 0]的情况）。同样，在循环内部，我们必须再次复制in_array，以避免一遍又一遍地添加对同一数组的引用。下一个函数对直觉进行编码，即每个添加的块基本上是乘以结果中的条目数：如果从1开始，则对于一个块（假设长度为5），您有6个条目；添加另一个块，您将为每个现有条目获得6个条目；等等。最后一个函数只是一个包装器，因为主力函数需要一个数组数组，但是我们只收到一个数组。

function iterateOneBlock(in_array) {
  let out_array = [Array.from(in_array)];
  for (let i = 0; i < in_array.length; i++) {
    let tmp_array = Array.from(in_array);
    tmp_array[i] += 1;
    out_array.push(tmp_array);
  }
  return out_array;
}
function iterateMultipleBlocksOnArrayOfArrays(in_array_array, blocks) {
  let tmp_array_array = [];
  for (let n = 0; n < blocks; n++) {
    for (let i = 0; i < in_array_array.length; i++) {
      tmp_array_array.push(...iterateOneBlock(in_array_array[i]));
    }
    in_array_array = tmp_array_array;
    tmp_array_array = [];
  }
  return in_array_array;
}
function iterateMultipleBlocks(in_array, blocks) {
  return iterateMultipleBlocksOnArrayOfArrays([in_array], blocks);
}
console.log(iterateMultipleBlocks([0, 0, 0], 2))

迭代数组并对每个元素求和1

2 个答案: