JavaScript代码演示解决方案

我昨晚看了关于Codibility的演示Equi任务，在以下功能中得了12/100分：

function solution(A) {
    var n = A.length;
    var p = 0;
    var sum = 0;
    var sumLeft = 0;
    var sumRight = 0;
    var equilExists = 0;

    if (n == 0) {
        return -1;
    }

    for (i=0; i<=n; i++) {
        sum = A[i];
        for (j=0; j<=n; j++) {
        if (j < i) {
            sumLeft += A[j];
        } else if (j > i) {
            sumRight += A[j];
        }
        if (sumLeft == sumRight) {
            equilExists = 1;
            p = i;
            return p;
                }
        }
    }

    if (equilExists == 0) {
        return -1;
    }
}

函数解决方案（A）{
var n=A.长度；
var p=0；
var总和=0；
var Sumlet=0；
var sumRight=0；
var equilExists=0；
如果（n==0）{
返回-1；
}
对于（i=0；i，您的解决方案失败的主要原因是它始终只能检测到处于平衡状态的第一个指标

例如，如果有一个序列在索引3和索引6处都有平衡，但是如果我们将你的解应用于这个序列，那么它将始终只返回3，并且永远不会提供6作为答案

这是因为您没有将已发现处于平衡状态的索引存储在任何位置，也没有在其前面移动。您需要使用递归或为已发现处于平衡状态的索引保留一些存储，并相应地修改您的解决方案以捕获所有此类索引，而不仅仅是第一个索引

此外，在您的答案中定义但从未使用过的变量很少，例如sum变量，这会导致不必要的开销。
您的解决方案失败的主要原因是它始终只能检测到处于平衡状态的第一个索引

例如，如果有一个序列在索引3和索引6处都有平衡，但是如果我们将你的解应用于这个序列，那么它将始终只返回3，并且永远不会提供6作为答案

这是因为您没有将已发现处于平衡状态的索引存储在任何位置，也没有在其前面移动。您需要使用递归或为已发现处于平衡状态的索引保留一些存储，并相应地修改您的解决方案以捕获所有此类索引，而不仅仅是第一个索引

此外，在您的答案中定义但从未使用过的变量很少，例如sum变量，这会导致不必要的开销。
首先，您的函数总是返回0（如果n>0）。这是因为您将
if（sumlift==sumlright）
放在内部for循环中。

如果您解决了这个问题，您仍然会遇到问题，因为变量
sumlefit
和
sumlright
在内部for循环之前没有初始化。
如果您解决了这些问题，该函数至少是正确的，并且得到75分。
但是，您的算法显然是二次的。要纠正这一点，您必须问问自己，当您将
i
增加1时，左右和是如何变化的。是否有必要从头开始重新计算这两个值？
首先，您的函数总是返回0（如果n>0）。这是因为您将
if（sumlift==sumlright）放在
内部for循环。

如果您解决了这个问题，您仍然会遇到问题，因为变量
sumlefit
和
sumlright
在内部for循环之前没有初始化。
如果您解决了这些问题，该函数至少是正确的，并且得到75分。
但是，你的算法显然是二次的。为了解决这个问题，你必须问自己，当你增加<代码> i>代码>一个时，左右的总和是如何变化的。是否需要从头算一遍？< /p> < p>这个解决方案我得到了100%，它是C++，但是你会看到算法。
我要做的第一件事是创建一个数组的运行和向量，然后使用它首先检查边缘情况，然后循环整个数组以获得第一个相等索引。然后复杂性将始终为O（n）

#包括
使用名称空间std；
长和（向量：：常量迭代器开始，向量：：常量迭代器结束，向量和和）
{
长和=0；
for（vector:：const_迭代器it=begin；it！=end；it++）
{
总和+=（长）（*它）；
sum.向后推（sum）；
}
回报金额；
}
整数解（向量&A）
{
向量和；
long-long-allSum=Sum（A.begin（），A.end（），sums）；
int N=sums.size（）；
如果（N==0）
返回-1；
如果（N==1&&allSum==0）
返回0；
如果（N>1）
{
如果（和[N-2]==0）
返回N-1；
}
如果（（所有总和-总和[0]）==0）
返回0；
长前缀=0；
对于（int i=1；i<>代码>我用这个解决方案得到100%，它是C++，但是你会看到算法。
我要做的第一件事是创建一个数组的运行和向量，然后使用它首先检查边缘情况，然后循环整个数组以获得第一个相等索引。然后复杂性将始终为O（n）

#包括
使用名称空间std；
长和（向量：：常量迭代器开始，向量：：常量迭代器结束，向量和和）
{
长和=0；
for（vector:：const_迭代器it=begin；it！=end；it++）
{
总和+=（长）（*它）；
sum.向后推（sum）；
}
回报金额；
}
整数解（向量&A）
{
向量和；
long-long-allSum=Sum（A.begin（），A.end（），sums）；
int N=sums.size（）；
如果（N==0）
返回-1；
如果（N==1&&allSum==0）
返回0；
如果（N>1）
{
如果（和[N-2]==0）
返回N-1；
}
如果（（所有总和-总和[0]）==0）
返回0；
长前缀=0；
对于（int i=1；i
解决方案的最大问题是嵌套循环

您在每个索引处迭代整个数组，以计算当前索引处左右部分的总和。它们的要求之一是O（n）复杂度，而您的要求是O（n^2）（我认为）

您只需要在数组上循环两次：一次获得元素之和，一次找到平衡点。在第二次循环开始时，左边的和==0
#include <vector>

using namespace std;

long long Sum(vector<int>::const_iterator begin, vector<int>::const_iterator end, vector<long long>& sums)
{
    long long sum = 0;
    for(vector<int>::const_iterator it = begin; it != end; it++)
    {
        sum += (long long) (*it);
        sums.push_back(sum);
    }
    return sum;
}

int solution(vector<int> &A)
{
    vector<long long> sums;

    long long allSum = Sum(A.begin(), A.end(), sums);

    int N = sums.size();

    if(N==0)
        return -1;

    if(N==1 && allSum == 0)
        return 0;

    if(N > 1)
    {
        if(sums[N-2] == 0)
            return N-1;
    }

    if((allSum- sums[0]) == 0)
        return 0;

    long long prefixSum = 0;
    for(int i = 1; i < N; ++i)
    {
        prefixSum = sums[i-1];

        if(prefixSum == 0 && i == N-1)
            return i;

        if(prefixSum == (allSum - sums[i]))
            return i;
    }

    return -1;
}

function solution(A) {
  var total = (function(a){ var l = a.length, s = 0; while(--l>-1){ s+=a[l] } return s; }(A)), 
  eq = -1, 
  l = A.length, 
  Lsum = 0, 
  Rsum = 0; 
  A.forEach(function(n,i){ 
    Rsum = total - Lsum - n; 
    if(Rsum == Lsum){ eq = i; /* in fact no need to continue, should terminate here. */ } 
    Lsum += n; 
  }); 
  return eq;
}

class Solution {
public int solution(int[] A) {
    if(A.length < 1) {
        return -1;
    }
    double leftSum = 0, sum = 0;
    for(int i=0; i<A.length; i++) {
        sum += A[i];
    }
    for(int i=0; i<A.length; i++) {
        if(leftSum == sum - leftSum - A[i]) {
            return i;   
        }
        leftSum += A[i];
    }
    return -1;
}

 function solution(A) {

    var length = A.length;

    // special case to void total calculation
    if(!length) return -1;

    var lSum = 0;
    var rSum = 0;
    var i    = 0;

    // get total
    for(; i < length; rSum += A[i++]);

    // reset iterator
    i = 0;

    for(; i < length; i++) {
        rSum -= A[i];
        if(rSum === lSum) return i;
        lSum += A[i];        
    }

    return -1;
}

function balance(arr){

var N = arr.length;
if (N == 0){ return -1};

var suma = 0;
for (var i=0; i<N; i++){
    suma += arr[i];
}

var suma_iz = 0;
for(i=0; i<N; i++){
    var suma_de = suma - suma_iz - arr[i];
    if (suma_iz == suma_de){
        return i};
    suma_iz += arr[i];
}

  return -1;}

function solution(list) {
  var length = list.length,
      sumRight,
      sumLeft = 0,
      equi_index = -1;

  if (length === 0) {
    return equi_index;
  } else if (length === 1) {
    return 0;
  }

  var total = (function(){
    var sum = 0;
    while (length--) {
      sum += list[length];
    }
    return sum;
  })();

  list.some(function(each, index){
    sumRight = total - sumLeft - each;
    if (sumLeft === sumRight) {
      equi_index = index;
      return true; // stop iteration
    }

    sumLeft += each;
  });

  return equi_index;
}

\\ Javascript solution
function solution(A) {
    const sortAry = A.sort((a, b) => a - b);
    var initVal = 1;
    for (let i = 0; i < sortAry.length; i++) {
        if (sortAry[i] <= 0) continue;
        if (sortAry[i] < initVal) continue;
        if (sortAry[i] === initVal) {
            initVal += 1;
        } else {
            return initVal;
        }
    }
    return initVal;
}