maxdoubleslicesum one of codility tasks Java + codesays community solution in Python

MaxDoubleSliceSum

// my solution is based on iterating all the list comparing all possible sums and find the max sum.
class Solution {
    public static int solution(int[] A) {
        int length = A.length;
        int max = 0;
        int sum = 0;
        for (int x = 0; x < length - 4; x++) {
            for (int y = x + 2; y < length - 2; y++) {
                for (int z = y + 2; z < length; z++) {
                    for (int l = x + 1; l <= (y - 1); l++) {
                        sum += A[l];
                    }
                    for (int m = y + 1; m <= (z - 1); m++) {
                        sum += A[m];
                    }
                    if (sum > max) {
                        max = sum;
                    }
                    sum = 0;
                }
            }
        }
        return max;
    }
    
// for comparison there is https://codesays.com/2014/solution-to-max-double-slice-sum-by-codility/ 
// solution, using very clever but very rare algorithm, written in python

def solution(A):
    A_len = len(A)    # The length of array A
 
    # Get the sum of maximum subarray, which ends this position
    # Method: http://en.wikipedia.org/wiki/Maximum_subarray_problem
    max_ending_here = [0] * A_len
    max_ending_here_temp = 0
    for index in xrange(1, A_len-2):
        max_ending_here_temp = max(0, A[index]+max_ending_here_temp)
        max_ending_here[index] = max_ending_here_temp
 
    # Get the sum of maximum subarray, which begins this position
    # The same method. But we travel from the tail to the head
    max_beginning_here = [0] * A_len
    max_beginning_here_temp = 0
    for index in xrange(A_len-2, 1, -1):
        max_beginning_here_temp = max(0, A[index]+max_beginning_here_temp)
        max_beginning_here[index] = max_beginning_here_temp
 
    # Connect two subarray for a double_slice. If the first subarray
    # ends at position i, the second subarray starts at position i+2.
    # Then we compare each double slice to get the one with the
    # greatest sum.
    max_double_slice = 0
    for index in xrange(0, A_len-2):
        max_double_slice = max(max_double_slice,
                 max_ending_here[index] + max_beginning_here[index+2] )
 
    return max_double_slice