如果有一个地方可以拆分数组，使一侧的数字之和等于另一侧的数字总和，则返回true

Question

给定一个数字数组，如果有一个地方可以拆分数组，使一侧的数字之和等于另一侧的数字总和，则返回true。

这是我所能到达的。请帮助：

function splitSum(arr) {
    if(arr.length % 2 === 0) {
        if ()
    }
}

Answer 1

这可以用一种非常简单的方式解决：
只需迭代所有可能的位置即可拆分数组，从一个空的左数组开始，右数组等于输入数组，并计算两个块的总和。现在，只需将数组中的第一个元素从右侧块移动到左侧块即可。总和以一种非常简单的方式变化：假设我们从右块中移除n，简单地从右块减去n，并将其添加到左块的和。

int equilibrium(int[] i)
    int splitBefore = 0;
    int left = 0;
    int right = sumof(i);
    for(; splitBefore < length(i) ; splitBefore++)        
        if(left == right)
            return true;
        left += i[splitBefore];
        right -= i[splitBefore];
    return left == right;

Answer 2

public boolean canBalance(int[] nums) {
  int left = 0;
  int right=0;
  for(int k=0;k<nums.length; k++) {
   right+=nums[k];
  }
  for(int i=0; i<nums.length-1; i++) {
    if(left!=right) {
      left+=nums[i];
      right-=nums[i];
    }
  }
  return left==right;
}

Answer 3

下面是有评论的答案，希望它能解释一切：(

public boolean canBalance(int[] nums) {
  int p1 = 0; // a pointer to start of array
  int p2 = nums.length-1; // a pointer to end of array
  int sum1=0;// sum1 for left side elements sum taken care by p1
  int sum2=0;// sum2 for right side elements sum taken care by p2
  for(int i=0;i<nums.length;i++){
    //run upto the length of array
    sum1+=nums[p1]; // summing left side elements
    sum2+=nums[p2];//adding right side elements
    if(sum1==sum2 && Math.abs(p1-p2) == 1){
      //if two sums become equal and the pointers differ by only one position
      //then we got the answer
      return true;
    }
    if(sum1 == sum2){
        //two sums are equal means elements are equal on both sides
        //hence move both pointers
            p1++;
            p2--;
            }
            else if(sum1 > sum2){
              // sum1 is greater then need to make sum2 bigger hence move p2
              p2--;
              sum1-= nums[p1];//removing repeated addition when p2 is changed
            }
            else{
              // sum2 is greater then need to make sum1 bigger hence move p1
              p1++;
              sum2-=nums[p2];//removing repeated addition when p1 is changed
            }
  }
  return false;

}

Answer 4

public boolean canBalance(int[] nums) {
  int leftSum = 0;
  int rightSum = 0;
  for (int i = 0; i < nums.length; i++){
        leftSum += nums[i];
        for (int j = i+1; j < nums.length; j++){
          rightSum += nums[j];
        }
        if (leftSum == rightSum)
          return true;
        rightSum = 0;
  }
  return false;
}

Answer 5

我用不同的方法解决了这个问题。如果我们想将数组拆分为等号，则数组必须可被2整除。当你开始从左边添加列表时，你会到达一个点，左边将等于总数的一半。

public boolean canBalance(int[] nums) {
  int total = 0, half = 0; 
  for(int i = 0; i < nums.length; i++)
  {
    total = nums[i] + total;
  }
  if(total % 2 == 1)
  {
    return false;
  }
  for(int i = 0; i < nums.length; i++)
  {
    half = nums[i] + half;
    if(half == total / 2)
    {
      return true;
    }
  }
  return false;
}

Answer 6

Python中的解决方案：

a = [2,1,1,2,1]
for i in range(len(a)):
    a1 = a[:i+1]
    a2 = a[i+1:]
    if sum(a1) == sum(a2):
        print(a1)
        print(a2)