Как перебрать каждое число в массиве и суммировать их с другими числами в том же массиве - JS

Question

Я пытаюсь сложить каждое число в массиве со следующими числами и сохранить все результаты: Это мой пример:

var arr = [2, 3, -6, 2, -1, 6, 4];

Я должен сложить 2 + 3 и сохранить его, затем 2+ 3 - 6 сохранить его, затем 2 + 3 - 6 - 1 сохранить его и т. Д. До конца массива.Затем то же самое со вторым индексом 3 - 6 и сохраните его, 3 - 6 + 2 ... Я знаю, что это можно сделать с помощью двух вложенных циклов, но не знаю, как именно это сделать.Где я не прав?

const sequence = [2, 3, -6, 2, -1, 2, -1, 6, 4]
const sums = [];

for (let i = 0; i < sequence.length; i++) {

  for (let z = 1; z < sequence.length; z++) {
    let previous = sequence[z - 1] + sequence[z];
    sums.push(previous + sequence[z + 1])
  }
}

console.log(sums);

Answer 1

Вы можете отобразить значения путем итерации массива и взять подмножество массива для другого отображения.Возьмите значение внешнего массива в качестве аккумулятора для добавления внутренних значений и верните это значение.

var array = [2, 3, -6, 2, -1, 6, 4],
    result = [].concat(...array.map((s, i, a) => a.slice(i + 1).map(v => s += v)));

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

Вы можете использовать два цикла и всегда добавлять последнюю сумму одного и того же числа к текущему номеру:

const sequence = [2, 3, -6, 2, -1, 2, -1, 6, 4]
const sums = [];

for (let i = 0; i < sequence.length; i++) {

  let lastSum = sequence[i]; // initialize with the current number in the sequence
  
  // start from the next number in the sequence
  for (let z = i + 1; z < sequence.length; z++) {
    let sum = lastSum + sequence[z]; // add the previous sum + the current number
    sums.push(sum);
    lastSum = sum; // change base to the last sum
  }  
}

console.log(sums);

Answer 3

Вам не хватает петли.Вот ваш код с некоторыми изменениями.

const sequence = [2, 3, -6, 2, -1, 2, -1, 6, 4]
const sums = [];

for (let startIndex = 0; startIndex < sequence.length; startIndex++) {
    console.log('starting from index', startIndex, `i.e. number is (${sequence[startIndex]})`);
    for (let subSequenceLen = 1; subSequenceLen < sequence.length - startIndex; subSequenceLen++) {
        console.log('subsequence length is ', subSequenceLen);
        let sum = 0;
        for (let z = startIndex; z <= startIndex + subSequenceLen; z++) {
            sum += sequence[z];
        }
        console.log('sum is ', sum);
        sums.push(sum);
    }
}

console.log(sums);

Если мы запустим это с этой последовательностью примера, мы увидим следующие журналы:

starting from index 0 i.e. number is (2)
subsequence length is  1
sum is  5
subsequence length is  2
sum is  -1
subsequence length is  3
sum is  1
subsequence length is  4
sum is  0
subsequence length is  5
sum is  2
subsequence length is  6
sum is  1
subsequence length is  7
sum is  7
subsequence length is  8
sum is  11
starting from index 1 i.e. number is (3)
subsequence length is  1
sum is  -3
subsequence length is  2
sum is  -1
subsequence length is  3
sum is  -2
subsequence length is  4
sum is  0
subsequence length is  5
sum is  -1
subsequence length is  6
sum is  5
subsequence length is  7
sum is  9
starting from index 2 i.e. number is (-6)
subsequence length is  1
sum is  -4
subsequence length is  2
sum is  -5
subsequence length is  3
sum is  -3
subsequence length is  4
sum is  -4
subsequence length is  5
sum is  2
subsequence length is  6
sum is  6
starting from index 3 i.e. number is (2)
subsequence length is  1
sum is  1
subsequence length is  2
sum is  3
subsequence length is  3
sum is  2
subsequence length is  4
sum is  8
subsequence length is  5
sum is  12
starting from index 4 i.e. number is (-1)
subsequence length is  1
sum is  1
subsequence length is  2
sum is  0
subsequence length is  3
sum is  6
subsequence length is  4
sum is  10
starting from index 5 i.e. number is (2)
subsequence length is  1
sum is  1
subsequence length is  2
sum is  7
subsequence length is  3
sum is  11
starting from index 6 i.e. number is (-1)
subsequence length is  1
sum is  5
subsequence length is  2
sum is  9
starting from index 7 i.e. number is (6)
subsequence length is  1
sum is  10
starting from index 8 i.e. number is (4)

И окончательный массив сумм:

[5,-1,1,0,2,1,7,11,-3,-1,-2,0,-1,5,9,-4,-5,-3,-4,2,6,1,3,2,8,12,1,0,6,10,1,7,11,5,9,10]

Answer 4

Вам не нужны вложенные циклы, вам нужен один цикл со следующей логикой

• Добавьте 1-е + 2-е, сохраните его в x.
• Добавьте x + 3-е (что означает 1-й + 2-й + 3-й), сохраните его в y.
• Добавьте y + 4-й (что означает 1-й + 2-й + 3-й + 4-й), сохраните его в z.
• ...и т. д.

И сделать это, используя один цикл, вместо того, чтобы хранить их в x, y, z .. мы сохраняем его в массиве sums.

arr.forEach((number, index) =>
    sums.push(number + (sums[index-1] || 0))
)

Здесь sums[index-1] представляет x / y / z из алгоритма.И мы делаем sums[index-1] || 0, потому что когда индекс равен нулю, он будет искать sums[-1], который будет неопределенным, поэтому мы заменим его на 0.

Вот живой код ..

let arr = [2, 3, -6, 2, -1, 6, 4], sums = []
arr.forEach((number, index) =>
    sums.push(number + (sums[index-1] || 0))
)

console.log(sums.slice(1))

Answer 5

Далее используется функция для уменьшения массива в массив его постепенных сумм.

Вы можете вызывать эту функцию несколько раз, удаляя элементы из массива, чтобы суммировать всю вещь.

Вот краткая версия:

var arr = [2, 3, -6, 2, -1, 6, 4];

var listSums = (array) => array.reduce((a,b) => [...a, a[a.length-1]+b], [0]).slice(2);
var listAllSums = (array) => array.reduce((a, b, index) => [...a, ...listSums(array.slice(index))], []);

console.log(listAllSums(arr));

А вот расширенная версия для ясности.

Логика:

Add the sums of [2, 3, -6, 2, -1, 6, 4] to the list
Add the sums of [   3, -6, 2, -1, 6, 4] to the list
Add the sums of [      -6, 2, -1, 6, 4] to the list
...
Add the sums of [             -1, 6, 4] to the list
Add the sums of [                 6, 4] to the list

Output the list

Код:

var arr = [2, 3, -6, 2, -1, 6, 4];

function sumArray(array) {
    var result = array.reduce(function(accumulator,currentInt) {
      var lastSum = accumulator[accumulator.length-1];   //Get current sum
      var newSum = lastSum + currentInt;                 //Add next integer
      var resultingArray = [...accumulator, newSum];     //Combine them into an array
      return resultingArray;                             //Return the new array of sums
    }, [0]);                                             //Initialize accumulator
    return result.slice(2);
}

var result = arr.reduce(function(accumulator, currentInt, index) {  //For each item in our original array
    var toSum = arr.slice(index);               //Remove x number of items from the beginning (starting with 0)
    var sums = sumArray(toSum);                 //Sum the array using the function above
    var combined = [...accumulator, ...sums];   //Store the results
    return combined;                            //Return the results to the next iteration
  }, []);                                       //Initialize accumulator

console.log(result);