Codility Tape Equilibrium 在某些情况下变为零答案

【问题标题】：Codility Tape Equilibrium Getting zero on some casesCodility Tape Equilibrium 在某些情况下变为零
【发布时间】：2018-03-24 07:38:15
【问题描述】：

我刚刚做了这个样本测试，大部分情况下都是正确的，但我不知道为什么我会弄错这两个案例。

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

任何整数 P，例如 0 1, ..., A[P − 1] 和 A[P], A[P + 1], ..., A[N - 1]。

两部分的区别在于：|(A[0] + A1 + ... + A[P - 1]) - (A[P] + A[P + 1] + ... + A[N - 1])|

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

例如，考虑数组 A，这样：

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

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

类解决方案 { public int solution(int[] A); }

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

例如，给定：

A[0] = 3 A1 = 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;
 }
}

冷态结果

【问题讨论】：

第二个循环应该是i < A.length - 1，你不希望磁带的一侧什么都没有。因此，您的代码对于 [-1000, 1000] 失败，您将返回 0 但应该返回 2000。
你不能扩展失败的测试看看它们是什么吗？

标签： java algorithm

【解决方案1】：

我用 java 写的，代码写得 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;
        }

【讨论】：

【解决方案2】：

考虑这种只使用一个for循环的方法：主要思想是从左右同时累加，直到它们穿过数组的中间。那时，他们将开始共享总和中的元素，因此您需要评估 2 个案例： 1st-从左侧减去共享元素 2nd-从右侧减去共享元素

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

【讨论】：

【解决方案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;
    }

【讨论】：