Javascript 如何返回一个数组可以拆分的位置，以使一边的和等于另一边的和

我正在尝试检查是否有一个位置可以拆分数组，以便一个数组上的数字之和 边等于另一边的数字之和，返回两个数组的长度作为数组，但 如果没有位置拆分数组，则返回-1

test('for an obvious case where the array can be split evenly', () => {
  expect(canBalance([1, 2, 3, 4, 5, 6, 6, 7, 8])).toEqual([6, 3]);
});

test('for an obvious case where the array cannot be split evenly', () => {
  expect(canBalance([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).toBe(-1);
});

test('for when the array has all zeros with a one at the end', () => {
  expect(canBalance([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])).toBe(-1);
});

test('for when the array has all ones but cannot be split', () => {
  expect(canBalance([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])).toBe(-1);
});

test('for when the array has all ones but can be split', () => {
  expect(canBalance([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])).toEqual([9, 9]);
});

test('for when the array some negative numbers', () => {
  expect(canBalance([3, 18, -5, -44, 23, 26, 20, -1, 0, -10, 30])).toEqual([10, 1]);
});

test('Alternating cases of positive and negative equivalent with 1 at the end', () => {
  expect(canBalance([-10, +10, -10, +10, -10, +10, -10, +10, -10, +10, -10, +10,
    -10, +10, -10, +10, -10, +10, -10, +10, -10, +10, 1])).toBe(-1);
});

test('for a simple case of positive and negative numbers', () => {
  expect(canBalance([1, 0, 0, -1])).toBe(-1);
});

test('for a tricky case of decimal numbers', () => {
  expect(canBalance([0.1, 0.2, 0.3])).toBe(-1);
});

到目前为止，我的方法是在一个变量中求出总数。然后将数组[0]相加到array.length-1，并将每次的值与total/2进行比较

function canBalance(array) {
  //Type your solutions here
  var arrayAdd = 0;
  for(var i = 0; i<array.length-1; i++) {
    arrayAdd+=array[i];
  }
  var total = 0;
  for(var j=0; j<array.length-1; j++)  {
    total+=array[j];
    if(total==arrayAdd/2) {
      return [j+1, array.length-j-1];
    }
  }
  return -1;
}
module.exports = canBalance;

函数canBalance（数组）{
//在此处键入您的解决方案
var arrayAdd=0；
对于（var i=0；i，您可以使用从开始到结束的所有元素的和构建一个数组，并检查是否存在相邻的和，HN将使用计数退出，否则返回
-1


函数canBalance（数组）{
var left=array.map（（s=>v=>s+=v）（0）），
右=0；
i=数组长度；
而(我--){
右+=数组[i]；
if（right==left[i-1]）返回[i，array.length-i]；
}
返回-1；
}
log（canBalance（[1,1,1,2,1]）；//[3,2]
log（canBalance（[2,1,1,2,1]）；/-1
log（canBalance（[10,10]）；//[1,1]
log（canBalance（[1,2,3,4,5,6,6,7,8]）；//[6,3]
log（canBalance（[1,2,3,4,5,6,7,8,9,10]）；/-1
log（canBalance（[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]）；/-1
log（canBalance（[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]）；/-1
log（canBalance（[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]）；//[9,9]
log（canBalance（[3,18，-5，-44,23,26,20，-1,0，-10,30]）；//[10,1]
日志（canBalance（[-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，+10，-10，+10，-10，+10，+10，+10，+10，1]）；/-1
log（canBalance（[1,0,0，-1]）；//-1
log（canBalance（[0.1,0.2,0.3]）；/-1
.as console wrapper{max height:100%！important；top:0；}
您可以构建一个数组，该数组包含从开始到结束的所有元素的和，并检查是否存在相邻的和，HN将与计数一起退出，否则返回
-1


函数canBalance（数组）{
var left=array.map（（s=>v=>s+=v）（0）），
右=0；
i=数组长度；
而(我--){
右+=数组[i]；
if（right==left[i-1]）返回[i，array.length-i]；
}
返回-1；
}
log（canBalance（[1,1,1,2,1]）；//[3,2]
log（canBalance（[2,1,1,2,1]）；/-1
log（canBalance（[10,10]）；//[1,1]
log（canBalance（[1,2,3,4,5,6,6,7,8]）；//[6,3]
log（canBalance（[1,2,3,4,5,6,7,8,9,10]）；/-1
log（canBalance（[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]）；/-1
log（canBalance（[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]）；/-1
log（canBalance（[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]）；//[9,9]
log（canBalance（[3,18，-5，-44,23,26,20，-1,0，-10,30]）；//[10,1]
日志（canBalance（[-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，+10，-10，+10，-10，+10，+10，+10，+10，1]）；/-1
log（canBalance（[1,0,0，-1]）；//-1
log（canBalance（[0.1,0.2,0.3]）；/-1
.as控制台包装{max height:100%！important；top:0；}
要获得预期结果，请使用下面的使用reduce的选项

reduce循环数组
仅通过另一个reduce计算一次数组的总数
计算每个索引的正向和反向总计，并分配给累加器对象-具有总计索引的正向和反向索引
检查正向和反向对象中是否存在总索引的一半
工作代码参考


功能canBalance（arr）{
让结果=arr.reduce（（acc，v，i，self）=>{
acc.tot=acc.tot | |自减（（ac，val）=>ac+val）
acc.forward=acc.forward |{}；
acc.backward=acc.backward |{}；
acc.forward.tot=acc.forward.tot？acc.forward.tot+v:0+v；
acc.forward[acc.forward.tot]=i+1；
acc.backward.tot=acc.backward.tot？acc.backward.tot+self[self.length-i-1]：0+self[self.length-i-1]；
acc.backward[acc.backward.tot]=i+1；
返回acc
},{});
//console.log（结果）
if（result.tot！==0&&result.forward[result.tot/2]&&result.backward[result.tot/2]）{
return[result.forward[result.tot/2]，result.backward[result.tot/2]]
}否则{
返回-1
}
}
log（canBalance（[1,2,3,4,5,6,6,7,8]）；
log（canBalance（[1,2,3,4,5,6,7,8,9,10]）；
log（canBalance（[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]））
log（canBalance（[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]）；
log（canBalance（[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]）；
log（canBalance（[3,18，-5，-44,23,26,20，-1,0，-10,30]）；
log（canBalance（[-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，-10，+10，+10，+10，1]）；
log（canBalance（[1,0,0，-1]）；
log（canBalance（[0.1,0.2,0.3]）；
要获得预期的结果，请使用下面使用reduce的选项

reduce循环数组
仅通过另一个reduce计算一次数组的总数
计算每个索引的正向和反向总计，并分配给累加器对象-具有总计索引的正向和反向索引
检查正向和反向对象中是否存在总索引的一半
工作代码参考


功能canBalance（arr）{
让结果=arr.reduce（（acc，v，i，self）=>{
acc.tot=acc.tot | |自减（（ac，val）=>ac+val）
acc.forward=acc.forward |{}；
acc.backward=acc.backward |{}；
前进
array 1, 1, 1, 2, 1
sums  1  2  3  5  6  left
sums           3  1  right
            ^  ^     result [3, 2]