Java 协调任务'；磁带平衡'；演出

我已经解决了Codibility（磁带平衡）中的第一个任务

我已经设法得到了50%的分数（100%的正确性，0%的性能）

你能给我一些如何提高性能的建议吗

链接到我的结果和问题描述

代码如下：

import java.util.*;

class Solution {
    public int solution(int[] A) {
        List<Integer> splittedTape = new ArrayList<Integer>();
        for (int i = 1; i < A.length; i++){
            splittedTape.add(calculateDifference(i, A));
        }
        Collections.sort(splittedTape);
        return splittedTape.get(0);
    }

    private int calculateDifference(int position, int[] array){
        int sumA = 0;
        int sumB = 0;

        for (int i = 0; i < array.length; i++){
            if (i < position){
                sumA += array[i];
            } else {
                sumB += array[i];
            }
        }
        return Math.abs(sumA - sumB);
    }
}

import java.util.*；
类解决方案{
公共int解决方案（int[]A）{
List splittedTape=new ArrayList（）；
for（int i=1；i

---

提前感谢。

我还没有完全测试拐角案例，因此这可能不会产生预期的结果，但这是一个O（N）解决方案，可以实现问题的要求

class Solution {
public int solution(int[] A) {
    // write your code in Java SE 8
    int totalSum = 0;
    int firstSum = A[0];
    for(int i=1;i<A.length;i++)
     totalSum += A[i]; 

    int min = Math.abs(firstSum-totalSum);

    for(int i=1;i<A.length-1;i++) {
        firstSum+=A[i];
        totalSum-=A[i];
        if(Math.abs(firstSum-totalSum)<min) 
            min = Math.abs(firstSum-totalSum);

    }
    return min;
}
}

类解决方案{
公共int解决方案（int[]A）{
//用JavaSE8编写代码
整数总和=0；
int firstSum=A[0]；
对于（inti=1；i，下面的java解决方案给出了100%的O（n）复杂度

public static int solution(int[] A) {
    int accumulator = 0;
    int originalArrayLength = A.length;
    int[] accumulatedArray = new int[originalArrayLength];

    for (int i = 0; i < originalArrayLength; i++) {
        accumulator += A[i];
        accumulatedArray[i] = accumulator;
    }

    int max = accumulatedArray[originalArrayLength - 1];
    int minAbsoluteDiff = Integer.MAX_VALUE;
    for (int i = 0; i < accumulatedArray.length - 1; i++) {
        int firstSum = accumulatedArray[i];
        int secondSum = max - firstSum;
        int absoluteDiff = Math.abs(firstSum - secondSum);

        if (absoluteDiff < minAbsoluteDiff) {
            minAbsoluteDiff = absoluteDiff;
        }
    }

公共静态int解决方案（int[]A）{
int累加器=0；
int originalArrayLength=A.长度；
int[]累计阵列=新的int[原始阵列长度]；
对于（int i=0；i
代码更容易理解：

class Solution {
public int solution(int[] numbersOnATape) {

    int minimalDifference = Integer.MAX_VALUE;
    int sumOfFirstPart = 0;
    int sumOfSecondPart = sumOfValuesInsideOfTheTap(numbersOnATape);

    for (int count = 0; count < numbersOnATape.length - 1; count++) {
        int currentNumber = numbersOnATape[count];
        int nextNumber = numbersOnATape[count + 1];
        sumOfFirstPart += currentNumber;

        int difference = Math.abs(sumOfFirstPart - sumOfSecondPart);
        if (minimalDifference > difference) {
            minimalDifference = difference;
        }
        sumOfSecondPart -= nextNumber;
    }

    return minimalDifference;
}

private int sumOfValuesInsideOfTheTap(int[] numbersOnATape) {

    int sumOfValuesInsideOfTheTap = 0;

    for (int count = 1; count < numbersOnATape.length; count++) {
        sumOfValuesInsideOfTheTap += numbersOnATape[count];
    }

    return sumOfValuesInsideOfTheTap;
}

类解决方案{
公共int解决方案（int[]numbersOnATape）{
int最小差值=整数最大值；
int sumOfFirstPart=0；
int sumOfSecondPart=Tap（numbersOnATape）边上的值之和；
for（int count=0；count差异）{
最小差异=差异；
}
sumOfSecondPart-=下一个编号；
}
返回差；
}
Tap（int[]numbersOnATape）边上的私有int Sumof值{
int SUMOOFVALUESINSINDEOFTAP=0；
for（int count=1；count

}

得分100%
以下Swift解决方案的复杂性为84%O（n）

func minimalDifference( A: [Int]) -> Int {

    var sum = 0;
    let originalArrayLength = A.count-1
    var sumArray = [Int]()

    for  i in 0...originalArrayLength {

        sum += A[i];
        sumArray.append(sum)
    }

    let totalSum = sumArray[originalArrayLength]
    var minDiff = Int.max

    for i in 0..<sumArray.count {

        let firstSum = sumArray[i];
        let secondSum = totalSum - firstSum
        let diff = abs(firstSum - secondSum)

        if (diff < minDiff) {

            minDiff = diff
        }
    }

    return minDiff

}

func（A:[Int]）->Int{
var总和=0；
让originalArrayLength=A.count-1
变量sumArray=[Int]（）
对于0…原始长度中的i{
总和+=A[i]；
sumArray.append（总和）
}
设totalSum=sumArray[原始阵列长度]
var minDiff=Int.max
对于0中的i..对于那些熟悉可编性的注释，您能提供一些上下文吗？这里的目标是什么？可能更适合，因为他们更关注工作代码..请注意，您在这里发布此内容违反了可编性。@Marcin Marczyk…您不应该在这里发布问题描述。最好提供问题的urltementok，谢谢你的提示