Find the equipment indices

Here is a simple program test task, it doesn't have very diffcult logic: 

A zero-indexed array A consisting of N integers is given. An equilibrium index of this array is any integer P such that 0 ≤ P < N and the sum of elements of lower indices is equal to the sum of elements of higher indices, i.e.

A[0] + A[1] + ... + A[P−1] = A[P+1] + ... + A[N−2] + A[N−1].

Sum of zero elements is assumed to be equal to 0. This can happen if P = 0 or if P = N−1.

For example, consider the following array A consisting of N = 7 elements:

A[0] = -7   A[1] =  1   A[2] = 5
A[3] =  2   A[4] = -4   A[5] = 3
A[6] =  0

P = 3 is an equilibrium index of this array, because:

• A[0] + A[1] + A[2] = A[4] + A[5] + A[6]

P = 6 is also an equilibrium index, because:

• A[0] + A[1] + A[2] + A[3] + A[4] + A[5] = 0

and there are no elements with indices greater than 6.

P = 7 is not an equilibrium index, because it does not fulfill the condition 0 ≤ P < N.

Write a function

int solution(int A[], int N);

int solution(NSMutableArray *A);

int solution(const vector<int> &A);

class Solution { int solution(int[] A); }

class Solution { public int solution(int[] A); }

object Solution { def solution(A: Array[Int]): Int }

function solution(A);

function solution(A)

function solution($A);

function solution(A: array of longint; N: longint): longint;

def solution(A)

sub solution { my (@A)=@_; ... }

def solution(a)

Private Function solution ( A As Integer() ) as Integer

that, given a zero-indexed array A consisting of N integers, returns any of its equilibrium indices. The function should return −1 if no equilibrium index exists.

Assume that:

• N is an integer within the range [0..10,000,000];
• each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

For example, given array A such that

A[0] = -7   A[1] =  1   A[2] = 5
A[3] =  2   A[4] = -4   A[5] = 3
A[6] =  0

the function may return 3 or 6, as explained above.

Complexity:

• expected worst-case time complexity is O(N);
• expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments).

Elements of input arrays can be modified.

At very beginning, I have wrotten down this:

// 62 of 100
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
class Solution {
    public int solution(int[] A) {
        if(A.Length <=1)
            return -1;
        //abc
        int sumA = 0;
        foreach(int i in A){
            sumA += i;
        }
        
        int j = 0;
        int tempSum = A[0];
        for(j = 1; j<A.Length; j++){
            
            //A[0] + A[1] + ... + A[P−1] = A[P+1] + ... + A[N−2] + A[N−1].
            //return P
            if(sumA - tempSum - A[j] == tempSum){
                break;
            }  
            tempSum += A[j];
        }
        if (j == A.Length || j == A.Length - 1)
            return -1;
        else
            return j;
    }
}

I got 62 points of 100. because it missed border check and one misunderstanding.

So I updated it to this one:

//100 of 100
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
class Solution {
    public int solution(int[] A) {
        //N is an integer within the range [0..10,000,000];
        if(A.Length <1 || A.Length >10000000)
            return -1;
        //single number
        if(A.Length == 1)
            return 0;        
        
        //each element of array A is an integer within the range [−2,147,483,648..2,147,483,647]
        Int64 sumA = 0;
        foreach(int i in A){
            sumA += i;
        }
                
        int j = 0;
        
        //each element of array A is an integer within the range [−2,147,483,648..2,147,483,647]
        Int64 tempSum = 0;
        for(; j<A.Length; j++){
            //A[0] + A[1] + ... + A[P−1] = A[P+1] + ... + A[N−2] + A[N−1].
            //return P
            if(sumA - tempSum - A[j] == tempSum){
                break;
            }  
            tempSum += A[j];
        }
        //P = 7 is not an equilibrium index, because it does not fulfill the condition 0 ≤ P < N
        if (j == A.Length)
            return -1;
        else
            return j;
    }
}

Now, I got 100 points.

This task is from a test website.