You are given a 0-indexed integer array nums of length n.

nums contains a valid split at index i if the following are true:


	The sum of the first i + 1 elements is greater than or equal to the sum of the last n - i - 1 elements.
	There is at least one element to the right of i. That is, 0 &lt;= i &lt; n - 1.


Return the number of valid splits in nums.

&nbsp;
Example 1:

Input: nums = [10,4,-8,7]
Output: 2
Explanation: 
There are three ways of splitting nums into two non-empty parts:
- Split nums at index 0. Then, the first part is [10], and its sum is 10. The second part is [4,-8,7], and its sum is 3. Since 10 &gt;= 3, i = 0 is a valid split.
- Split nums at index 1. Then, the first part is [10,4], and its sum is 14. The second part is [-8,7], and its sum is -1. Since 14 &gt;= -1, i = 1 is a valid split.
- Split nums at index 2. Then, the first part is [10,4,-8], and its sum is 6. The second part is [7], and its sum is 7. Since 6 &lt; 7, i = 2 is not a valid split.
Thus, the number of valid splits in nums is 2.


Example 2:

Input: nums = [2,3,1,0]
Output: 2
Explanation: 
There are two valid splits in nums:
- Split nums at index 1. Then, the first part is [2,3], and its sum is 5. The second part is [1,0], and its sum is 1. Since 5 &gt;= 1, i = 1 is a valid split. 
- Split nums at index 2. Then, the first part is [2,3,1], and its sum is 6. The second part is [0], and its sum is 0. Since 6 &gt;= 0, i = 2 is a valid split.


&nbsp;
Constraints:


	2 &lt;= nums.length &lt;= 105
	-105 &lt;= nums[i] &lt;= 105


class Solution:
    def waysToSplitArray(self, nums: List[int]) -> int:
        prefix_sum = [nums[0]]
        n = len(nums)
        for i in range(1, n):
            prefix_sum.append(nums[i] + prefix_sum[-1]) 
        
        count = 0
        for i in range(n-1):
            if prefix_sum[i] >= prefix_sum[n-1] - prefix_sum[i]:
                count += 1
        return count
class Solution {
    public int waysToSplitArray(int[] nums) {
        long sum = 0;
        for(int i : nums){
            sum+=i;
        }
        int sol = 0;
        long localSum = 0;
        for(int i=0; i<nums.length-1;i++){
            localSum += nums[i];
            if(localSum >= sum-localSum){
                sol++;
            }
        }
        return sol;
    }
}
class Solution {
public:
    int waysToSplitArray(vector<int>& nums) {

        long long sumFromBack(0), sumFromFront(0);
        for (auto& i : nums) sumFromBack += i;

        int n(size(nums)), res(0);
        for (auto i=0; i<n-1; i++) {

            sumFromFront += nums[i]; // sum of the first i + 1 elements
            sumFromBack -= nums[i]; // sum of the last n - i - 1 elements.
            if (sumFromFront >= sumFromBack) res++;
        }
        return res;
    }
};
/**
 * @param {number[]} nums
 * @return {number}
 */
var waysToSplitArray = function(nums) {
    let result = 0;
    let letsum = 0;
    let rightsum = nums.reduce((a,b)=> a+b);
    let end = nums.length-1;
    for (let i = 0;i<end;i++) {
        letsum+=nums[i];
        rightsum-=nums[i];
        if (letsum>=rightsum) {
            result++;
        }
    }
    return result;
};
Number of Ways to Split Array