"""
    Tape Equilibrium
    ~~~~~~~~~~~~~~~~

    A non-empty array **A** consisting of **N** integers is given. Array A
    represents numbers on a tape.

    Any integer **P**, such that 0 < P < N, splits this tape into two non-empty
    parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., 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])|

    In other words, it is the absolute difference between the sum of the first
    part and the sum of the second part.

    For example, consider array A such that:

        A[0] = 3
        A[1] = 1
        A[2] = 2
        A[3] = 4
        A[4] = 3

    We can split this tape in four places:

    * P = 1, difference = |3 − 10| = 7 
    * P = 2, difference = |4 − 9| = 5 
    * P = 3, difference = |6 − 7| = 1 
    * P = 4, difference = |10 − 3| = 7 
    
    Write a function::
    
        def solution(A)

    that, given a non-empty array A of N integers, returns the minimal
    difference that can be achieved.

    For example, given:

        A[0] = 3
        A[1] = 1
        A[2] = 2
        A[3] = 4
        A[4] = 3

    the function should return 1, as explained above.

    Write an efficient algorithm for the following assumptions:

    N is an integer within the range [2..100,000];
    each element of array A is an integer within the range [−1,000..1,000].
"""

def solution(A):
    """Detected time complexity: O(N)"""

    N = len(A)
    L = [A[0]]  # Left group
    R = [A[-1]] # Right group
    
    for P in range(1, N - 1):
        # Sum the current A item to the previous Left part value
        L.append(L[P - 1] + A[P])
        R.append(A[-(P + 1)] + R[P - 1])

    S = abs(L[0] - R[-1])  # Smaller absolute difference

    for i in range(1, len(L)):
        C = abs(L[i] - R[-(i + 1)])

        if C < S:
            S = C

    return S

1bdd3b949706dad707ee9541738398a989fbdd84
<mask token>

<mask token>


def solution(A):
    """Detected time complexity: O(N)"""
    N = len(A)
    L = [A[0]]
    R = [A[-1]]
    for P in range(1, N - 1):
        L.append(L[P - 1] + A[P])
        R.append(A[-(P + 1)] + R[P - 1])
    S = abs(L[0] - R[-1])
    for i in range(1, len(L)):
        C = abs(L[i] - R[-(i + 1)])
        if C < S:
            S = C
    return S

"""
    Tape Equilibrium
    ~~~~~~~~~~~~~~~~

    A non-empty array **A** consisting of **N** integers is given. Array A
    represents numbers on a tape.

    Any integer **P**, such that 0 < P < N, splits this tape into two non-empty
    parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., 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])|

    In other words, it is the absolute difference between the sum of the first
    part and the sum of the second part.

    For example, consider array A such that:

        A[0] = 3
        A[1] = 1
        A[2] = 2
        A[3] = 4
        A[4] = 3

    We can split this tape in four places:

    * P = 1, difference = |3 − 10| = 7 
    * P = 2, difference = |4 − 9| = 5 
    * P = 3, difference = |6 − 7| = 1 
    * P = 4, difference = |10 − 3| = 7 
    
    Write a function::
    
        def solution(A)

    that, given a non-empty array A of N integers, returns the minimal
    difference that can be achieved.

    For example, given:

        A[0] = 3
        A[1] = 1
        A[2] = 2
        A[3] = 4
        A[4] = 3

    the function should return 1, as explained above.

    Write an efficient algorithm for the following assumptions:

    N is an integer within the range [2..100,000];
    each element of array A is an integer within the range [−1,000..1,000].
"""

def solution(A):
    """Detected time complexity: O(N)"""

    N = len(A)
    L = [A[0]]  # Left group
    R = [A[-1]] # Right group
    
    for P in range(1, N - 1):
        # Sum the current A item to the previous Left part value
        L.append(L[P - 1] + A[P])
        R.append(A[-(P + 1)] + R[P - 1])

    S = abs(L[0] - R[-1])  # Smaller absolute difference

    for i in range(1, len(L)):
        C = abs(L[i] - R[-(i + 1)])

        if C < S:
            S = C

    return S
