Question

我刚接受了这个样本测试，大部分都是正确的，但我不确定为什么我会把这两个案例弄错。

给出了由N个整数组成的非空零索引数组A.   数组A表示磁带上的数字。

任何整数P，使得0 <0。 P＆lt; N，将此磁带分成两部分   非空部分：A [0]，A 1，...，A [P-1]和A [P]，A [P + 1]，...，   A [N - 1]。

两部分之间的差异是：|（A [0] + A 1 +   ...... + A [P - 1]） - （A [P] + A [P + 1] + ... + A [N - 1]）|

换句话说，它是总和之间的绝对差值   第一部分和第二部分的总和。

例如，考虑数组A：

A [0] = 3 A 1 = 1 A [2] = 2 A [3] = 4 A [4] = 3我们可以拆分   这个磁带有四个地方：

P = 1，差异= | 3 - 10 | = 7 P = 2，差异= | 4 - 9 | = 5 P =   3，差异= | 6 - 7 | = 1 P = 4，差值= | 10 - 3 | = 7写一个   功能：

class Solution {public int solution（int [] A）; }

给定N个整数的非空零索引数组A，返回   可以达到的最小差异。

例如，给定：

A [0] = 3 A 1 = 1 A [2] = 2 A [3] = 4 A [4] = 3函数   应该返回1，如上所述。

假设：

N是[2..100,000]范围内的整数;数组A的每个元素   是[-1,000..1,000]范围内的整数。复杂度：

预期的最坏情况时间复杂度为O（N）;预期的最坏情况空间   复杂度是O（N），超出了输入存储（不包括存储   输入参数需要。）

class Solution {
 public int solution(int[] A) {
  int sum = 0;
  int subtracted = 0;
  int minDiff = 100000;

  for (int i = 0; i < A.length; i++) {
   sum += A[i];
  }

  for (int i = 0; i < A.length; i++) {
   sum -= A[i];
   subtracted += A[i];

   int diff = (Math.abs(sum - subtracted));
   if (minDiff > diff) {
    minDiff = diff;
   }

  }

  return minDiff;
 }
}

寒冷结果

Answer 1

我用Java编写，在Codility方面达到了100％

public static int solution(int[] A) {
        int sum=0,leftsum=0,rightsum=0,newmin=0,min=0;
        for(int i=0;i<A.length;i++){
            sum=sum+A[i];
        }
        for(int i=1;i<A.length;i++){
            leftsum=leftsum+A[i-1];
            rightsum=sum-leftsum;
            //System.out.println(leftsum-rightsum);
            if(i==1)
                min=newmin=Math.abs(leftsum-rightsum);
            else
                newmin=Math.abs(leftsum-rightsum);
            min=Math.min(min,newmin);
        }
        return min;
        }

Answer 2

仅使用一个for循环来考虑这种方法：主要思想是同时从左和右累积，直到它们越过数组的中间为止。届时，他们将开始共享总和中的元素，因此您需要评估2种情况： 1-从左侧减去共享元素第二，从右侧减去共享元素

public int solution(int[] A) {
    // write your code in C# 6.0 with .NET 4.5 (Mono)
    int l=A.Length;
    int mid= l%2>0 ? (l/2) : (l/2)-1;

    long ls=0;
    long rs=0;
    long res=long.MaxValue;
    long shared=0;

    for(int i=0, j=l-1; i<l; i++, j--){
        ls=ls+A[i];
        rs=rs+A[j];

        if(i>=mid && i<l-1){

            if(i==j) shared=A[i];
            else if(i>j) shared=shared+A[i]+A[j];

            rs=rs-shared;
            res= res < Math.Abs(ls-rs) ? res : Math.Abs(ls-rs);

            rs=rs+shared;
            ls=ls-shared;
            res= res < Math.Abs(ls-rs) ? res : Math.Abs(ls-rs);

            ls=ls+shared;
        }
    }

    return (int)res;
}

Answer 3

解决了。不要使用int sum = Arrays.stream(A).sum();，它不能通过性能测试。我得到了所有正确的测试用例，除了带有int sum = Arrays.stream(A).sum();的测试用例之外，但在最大的测试用例上却超时。所以我将其更改为for循环总和，并以100％通过。

    public int solution(int[] A) {
        int result = Integer.MAX_VALUE;
        int total = 0;
        int sum = 0;

        for (int i = 0; i < A.length; i++) {
            sum += A[i];
        }

        for (int i = 0; i < A.length - 1; i++) {
            total += A[i];
            int toEndSum = sum - total;
            int diff = Math.abs(total - toEndSum);
            if (diff < result)
                result = diff;

        }
        return result != Integer.MAX_VALUE ? result : 0;
    }

Codility Tape Equilibrium在某些情况下获得零

我刚接受了这个样本测试，大部分都是正确的，但我不确定为什么我会把这两个案例弄错。

3 个答案: