Codility Java 中的 TapeEquilibrium 问题

Question

I am trying to code through one of the challenges from codility but the value returned is wrong. Please help me through it to understand it. Given an integer array, the objective is to split it at a given index into 2 smaller arrays, sum each arrays and find the smallest absolute difference possible between the 2 arrays.

Example:

I have an array A[] = {3, 1, 2, 4, 3}.

If I split at index 1, left array is {3} and right array is {1, 2, 4, 3}. The absolute difference is |(3) - (1 + 2 + 4 + 3)| = 7.

The smallest possible split is with index 3, where left array is {3, 1, 2} and right array is {4, 3} and the absolute difference is |(3 + 1 + 2) - (4 + 3)| = 1.

Here is my code:

import java.lang.*;

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
        int difference  = 0;
        int leftSum = 0;
        int rightSum = 0;
        int minValue = 0;
        for (int i = 1; i < A.length; i++) {
            int c = i - 1;
            while(c >= 0) {
                leftSum = A[c] + leftSum;
                c--;
            }
            int a = i;
            while(a < A.length) {
                rightSum = A[a] + rightSum;
                a++;
            }
            difference = Math.abs(leftSum - rightSum);
            int temp = difference;
            minValue = temp;

            if (difference < minValue) {
                minValue = difference;
            }
        }

        return minValue;
    }
}

Answer 1

You probably need to give more information about the task, so we could try to figure your misstep. But, looking at the code I see

minValue = 0;
difference = Math.abs(leftSum - rightSum);
int temp = difference;
minValue = temp;
if (difference < minValue) {
    minValue = difference;
}

From this, difference will always be equal to minValue ; difference < minValue fails.

Answer 2

Minimize the value |(A[0] + ... + A[P-1]) - (A[P] + ... + A[N-1])|. The difference between the two parts is the value of: |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])|.

public int solution(int[] A) {
 int N = A.length;
 int leftsum = 0;
 int difference;
 int rightSum;
 int min = Integer.MAX_VALUE;
 int sum = 0;
 for (int i = 0; i < N; i++) {
  sum = sum + A[i];
 }
 for (int i = 0; i < N - 1; i++) {
  leftsum = leftsum + A[i];
  rightSum = sum - leftsum;
  difference = Math.abs(rightSum - leftsum);
  min = Math.min(min, difference);
 }
 return min;
}

Answer 3

This Kotlin sample passed codility with 100% score

    private fun tapeEquilibrium03(inputList: ArrayList<Int>): Int {
    var output = 0
    var leftSum = 0
    val sum = inputList.sum()
    for (i in 0 until inputList.size - 1) {
        leftSum += inputList[i]
        val resultPart = abs((sum - leftSum) - leftSum)
        if (i == 0) output = resultPart
        else if (resultPart < output) output = resultPart
    }
    return output
}