使用 Arrays Java - 任何更好的选择

Question

Any better options available in java 8 for the below problem.

There are two arrays, one integral array and one incremental array.Apply each of the increment values to the elements in integral array and get the sum of absolute values of the elements of incremental after adding each increment.

import java.util.Arrays;

public class ArrayChallenge {

    public static void main(String[] args) {
        long[] nA = {-3, -2, 4, 5};
        long[] iA = {2, 4, -6};
        long[] sumArr = findAbsValueSum(nA, iA);
        System.out.println(Arrays.toString(sumArr));

    }

    public static long[] findAbsValueSum(long[] numArr, long[] incrArr) {
        long[] sumArr = new long[incrArr.length];

        for (int i = 0; i < incrArr.length; i++) {
            long sum = 0;
            for (int j = 0; j < numArr.length; j++) {
                sum = sum + Math.abs(numArr[j] + incrArr[i]);
                numArr[j] = numArr[j] + incrArr[i];
            }
            sumArr[i] = sum;
        }
        return sumArr;
    }
}


Result:
[14, 28, 14]

Is there any better options (Performance wise) to do the same in java 8?

Answer 1

The code you pasted is obviously as efficient as it is going to get. Computers aren't magic; if you find some other language or library that has a sumAll function, it'd just be doing this under the hood.

If you want it to be more efficient, you need to setup rules. Restrict the input or widen the things one is allowed to do, then you can get this to be more efficient.

For example, if you tell me that numArr is known well in advance and therefore any work done to transform numArr into different, more efficient (for this specific task) data types is 'free', because the only thing that is relevant is to return the answer as fast as possible once an incrArr is available, then:

1. Sort numArr in place. (free - can be done without knowing incrArr).
2. Build an incremental sum array. This array is the sum of the absolute value of all numbers at this index + all previous indices; {-3, -2, 4, 5} turns into {0, 3, 5, 9, 14} . (free - can be done without knowing incrArr)

To calculate the sumAbs for a positive increment

For this example, let's say your increment ( I ) is 2 .

1. First, do a binary search for the index at which -I occurs; we shall call this IDX(-I) . Here, IDX(-2) = 1 (because numArr[1] is -2 ). If -I isn't in the list, the nearest smaller number (Had -2 not been in your list, find -3 instead). (cost: O(logn)).
2. For this number, and all numbers in numArr below this index, the answer is trivial: It is the sum of the absolute value of all those numbers, minus X*I. This is O(1) : it is simply sumArr[IDX(-I)] - (IDX(-I) * I) .
3. Next find the index of 0 (cost: O(logn)). For all numbers 0 and up, the answer is again trivial. We need the sum of all positive numbers first, which is sumArr[sumArr.length - 1] - sumArr[idx(0)] , then add X*I to this for each number in it, analogous to how we handled the negative numbers.
4. This leaves the interesting ones in between, such as -1 - which contributes only 1 to the sum total (-1 + 2 = +1). There is no speedy way out, so for only this slice of the input, we must iterate through it(so from IDX(-I) to IDX(0) exclusive, doing the math. This is technically O(n), except n is heavily limited; it can never be more than I unless there are duplicates in your list (and if there are, there are ways to handle those in bulk as well by making a weight array in the free precalculation phase), and is usually much less; it is the overlap: All values in the input which are between 0 and -I.

the increment is negative

The exact same algorithm applies, but reversed: For an increment such as -6 , all numbers at 0 or below are trivial, as are all numbers at 6 or higher. The loop needs to only cover all numbers between 1 and 5, inclusive.

This results in an algorithm that is O(logn) +O(restricted-n) instead of the O(n) algorithm you have. In purely mathematical terms, it's still O(n), but in almost all scenarios it's orders of magnitude fewer operations.

Building the sum tables is itself O(n), so if the preptime is not 'free', there is no point to any of this, and what you described is as fast as it is going to get.

Answer 2

The "stream" version may look like this:

public static long[] findAbsValueSumStream(long[] numArr, long[] incrArr) {
    
    return Arrays.stream(incrArr)
                 .map(inc -> IntStream.range(0, numArr.length)
                                      .mapToLong(i -> Math.abs(numArr[i] += inc))
                                      .sum()
                 )
                 .toArray();
}

Update
Shorter form can be used:
a lambda (i -> {long abs = Math.abs(numArr[i] + inc); numArr[i] += inc; return abs;})
may be replaced with equivalent (i -> Math.abs(numArr[i] += inc))

It provides the same output for the given test data:

long[] nA = {-3, -2, 4, 5};
long[] iA = {2, 4, -6};
long[] sumArr = findAbsValueSum(nA, iA);
System.out.println("loop: " + Arrays.toString(sumArr));

long[] sumArrStream = findAbsValueSumStream(nA, iA);
System.out.println("stream: " + Arrays.toString(sumArrStream));

Output:

loop: [14, 28, 14]
stream: [14, 28, 14]

However, the stream solution does not look as more performant because it uses similar nested loop.

Moreover, stream should not be used here at all because one of the input arrays numArr is modified while processing the stream, so it has side effects and cannot be run in parallel to increase performance because the results would be incorrect.

Answer 3

instead of _{(original code segment)}

sum = sum + Math.abs(numArr[j] + incrArr[i]);
numArr[j] = numArr[j] + incrArr[i];

first micro-optimization ( switched the 2 lines to remove the sum from second one):

numArr[j] = numArr[j] + incrArr[i];
sum = sum + Math.abs(numArr[j]);

and more micro-optimization (using compound assignment)

numArr[j] += incrArr[i];
sum = sum + Math.abs(numArr[j]);

and even more micro-optimization (using variable instead of array access)

var n = numArr[j] += incrArr[i];
sum = sum + Math.abs(n);

but eventually the JIT-compiler is already doing that (for bigger arrays).

^{unable to know if that really helps or if the difference is sensitive at all since this is micro-optimization and no testing/timing was done}

Answer 4

Please find the efficient way to find answer to the above problem

import java.util.Arrays;

public class BenchMarkedSolution {

public static long[] findAbsValueSum(long[] numArr, long[] incrArr) {
        int n = numArr.length;
        Arrays.sort(numArr);
        long[] res = new long[incrArr.length];
        long[] cumArr = new long[n];
        long sum = 0, cumIncr = 0;
        for (int i = 0; i < n; ++i) {
            sum += numArr[i];
            cumArr[i] = sum;
        }
        for (int i = 0; i < incrArr.length; ++i) {
            cumIncr += incrArr[i];
            int p = Arrays.binarySearch(numArr, -cumIncr);
            p = p < 0 ? Math.max(-p - 2, 0) : p;
            res[i] = Math.abs(cumArr[p] + cumIncr * (p + 1)) + Math.abs((cumArr[n - 1] - cumArr[p]) + cumIncr * (n - p - 1));
        }
        return res;
    }

    public static void main(String[] args) {
        long[] numArr;
        long[] incArr;
        long[] sumArr;
        numArr = new long[]{-3, -2, 4, 5};
        incArr = new long[]{2, 4, -6};
        sumArr = findAbsValueSum(numArr, incArr);
        System.out.println(Arrays.toString(sumArr));
    }
}