Question

我昨晚看了Codility的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;
    }
}

对于那些不熟悉该任务的人，可以在http://blog.codility.com/2011/03/solutions-for-task-equi.html

找到

我想知道是否有人可以帮助指出我的解决方案落在何处？

非常感谢！

Answer 1

您的解决方案的最大问题是嵌套循环。

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

你只需要遍历数组两次：一次得到元素的总和，一次找到平衡。在第二个循环开始时，左边的总和== 0，右边的总和==总和。迭代你需要更新总和的元素：正确的总和=总和 - 左总和 - 当前指数的值，然后你比较如果正确==左，如果不是 - 左边的总和增长当前指数的值。

我为这个获得了100分：

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;
}

Answer 2

您的解决方案失败主要是因为它始终只能检测到处于平衡状态的第一个指标。

例如，如果序列3和6都存在均衡序列，但如果我们将解决方案应用于此序列，那么它将始终仅返回3并且永远不会提供6作为答案。

这是因为你没有存储已经发现处于均衡状态并且超越它们的指数的任何地方。您需要使用递归或为已经发现具有均衡的索引维护一些存储，并相应地修改您的解决方案以捕获所有这些索引而不仅仅是第一个索引。

此外，定义的变量很少但从未在你的答案中使用，例如sum变量，导致不必要的开销。

Answer 3

首先，您的函数始终返回0（如果n> 0）。这是因为你将if (sumLeft == sumRight)置于内部for循环中。
如果你解决这个问题，你仍然有问题，因为变量sumLeft和sumRight没有在内部for循环之前初始化。如果您解决了这些问题，该功能至少是正确的，它得分为75分。但是，您的算法显然是二次的。要解决这个问题，你必须问自己，当你将i增加一个时，左右总和是如何变化的。是否有必要从头开始重新计算？

Answer 4

我用这个解决方案得分100％，它是用C ++编写的，但你会看到算法。我做的第一件事是创建一个数组运行总和的向量，然后我用它来检查边缘情况，然后循环整个数组的第一个equi索引。然后，复杂性将始终为O（n）。

#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;
}

Answer 5

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;
}

}

Answer 6

我的JavaScript解决方案......

 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;
}

Answer 7

我的回答是这个：

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;}

此解决方案满足O（n）要求

Answer 8

略有不同（100pts）：

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;
}

Answer 9

\\ 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;
}

Answer 10

JS解决方案分数 - 100% 并且表现相当快

function solution(A) {
   const values = new Set(A) // dedupe array
   let i = 0
   while(++i) { // iterate from 1, the first possible positive integer greater than 0 
       if(!values.has(i)) { // check if set has value and break loop if it does not
           break
       }
   }
   return i
}

JavaScript Codility演示解决方案

10 个答案: