如何对数组的连续数字求和，直到只剩下一个

Question

我想在javascript中对数组的数量求和，并创建这个总和的其他行，直到它只得到一个 我想根据之前的总和生成新行。 它仅用于训练算法

EX: [1,2,3,4,5,6,7,8] 
     [3,7,11,15]
      [10,26]
       [36]

function retsum(x) {
    for(let i = 0; i < x.length - 1; i++) {
        console.log(x[i] + x[i + 1] )
    }
}
retsum([2,3,5,6,10,20])

这是我的代码。我不知道如何生成其他循环或其他解决方案，继续做这个求和，直到只剩下一个数字 如果你能帮助我，谢谢

Answer 1

您可以使用 while 循环检查数组大小是否大于 1

function retsum(x) {
    const result = [];
    for(let i = 0; i < x.length - 1; i++) {
        console.log(x[i] + x[i + 1] )
        result.push(x[i] + x[i + 1] )
    }
     return result
}
let arr = [2,3,5,6,10,20];
while (arr.length > 1) { 
    arr = retsum(arr)
    console.log(arr)
}

Answer 2

您可以采用递归方法并在递归结束时返回单个值。

function sum(numbers) {
    console.log(...numbers);
    if (numbers.length === 1) return numbers[0];
    const result = [];
    for (let i = 0; i < numbers.length; i += 2) {
        result.push(numbers[i] + (numbers[i + 1] || 0));
    }
    return sum(result);
}

console.log(sum([1, 2, 3, 4, 5, 6, 7, 8]));

Answer 3

如果你想对数组中的数字对求和，你必须决定是从左到右还是从右到左。根据您走的路线，初始输入和最终结果之间的所有间歇数组都会有所不同。请注意下面每个 sn-p 的输出。

递归将是解决这个问题的最简单方法。这一切都取决于你如何增加/减少你的 for 循环。

从左到右（递增）

const print = (arr) => console.log(...arr.map(JSON.stringify));

const recursiveSums = (numbers, result = [numbers]) => {
  if (numbers == null || numbers.length === 0) throw new Error('array length less than 1');
  if (numbers.length === 1) return result;
  const subResult = [];
  for (let i = 0; i < numbers.length; i += 2) {
    subResult.push(numbers[i] + (numbers[i+1] ?? 0));
  };
  result.push(subResult);
  return recursiveSums(subResult, result);
};

print(recursiveSums([1, 2, 3, 4, 5, 6, 7, 8])); // even
print(recursiveSums([5, 3, 8, 4, 1]));          // odd

try { recursiveSums([]) }                       // error!
catch (e) { console.log(e.message); }

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

输出

[1,2,3,4,5,6,7,8] [3,7,11,15] [10,26] [36]
[5,3,8,4,1] [8,12,1] [20,1] [21]
array length less than 1

从右到左（递减）

const print = (arr) => console.log(...arr.map(JSON.stringify));

const recursiveSums = (numbers, result = [numbers]) => {
  if (numbers == null || numbers.length === 0) throw new Error('array length less than 1');
  if (numbers.length === 1) return result;
  const subResult = [];
  for (let i = numbers.length - 1; i >= 0; i -= 2) {
    subResult.unshift((numbers[i-1] ?? 0) + numbers[i]);
  };
  result.push(subResult);
  return recursiveSums(subResult, result);
};

print(recursiveSums([1, 2, 3, 4, 5, 6, 7, 8])); // even
print(recursiveSums([5, 3, 8, 4, 1]));          // odd

try { recursiveSums([]) }                       // error!
catch (e) { console.log(e.message); }

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

输出

[1,2,3,4,5,6,7,8] [3,7,11,15] [10,26] [36]
[5,3,8,4,1] [5,11,5] [5,16] [21]
array length less than 1

Answer 4

这是我使用reduce 得出的结论。它涵盖空或奇数输入数组。

function addPairs(nums,left_to_right)
{
  nums=nums.length>0?nums:[0]
  const evenNumberOfItems=[...(nums.length%2===0?nums:left_to_right?[...nums,0]:[0,...nums])]
  const pairs=evenNumberOfItems.reduce((previous,current,index,array)=>{
    if(index%2===0)
      previous.push([current,array[index+1]])
    return previous
  },[])
  const addedPairs=pairs.reduce((previous,current)=>{    
    previous.push(current[0]+current[1])
    return previous
  },[]);
  console.log(addedPairs)
  return addedPairs.length===1?addedPairs[0]:addPairs(addedPairs);
}
console.log(addPairs([]))
console.log(addPairs([2,3,5,6,10,20,13],true))
console.log(addPairs([2,3,5,6,10,20,13],false))