Find an element in array such that sum of left array is equal to sum of right array

<script>

// Javascript program to find an element 
// such that sum of right side element 
// is equal to sum of left side

    // Finds an element in an array such that
    // left and right side sums are equal
    function findElement(arr , n)
    {
    
        for(i = 1; i < n; i++){
          let leftSum = 0;
          for(j = i-1; j >= 0; j--){
            leftSum += arr[j];
          }
          
          let rightSum = 0;
          for(k = i+1; k < n; k++){
            rightSum += arr[k];
          }

          if(leftSum === rightSum){
            return arr[i];
          }
          
        }
        
        return -1;
    }

        // Driver code
     //Case 1
     var arr = [ 1, 4, 2, 5 ];
     var n = arr.length;
     document.write(findElement(arr, n));
     
     document.write("<br><br>")
     
     //Case 2
     var arr = [ 2, 3, 4, 1, 4, 5 ];
     var n = arr.length;
     document.write(findElement(arr, n));

// This code contributed by Bhanu Teja Kodali

</script>

<script>

// Javascript program to find an element 
// such that sum of right side element 
// is equal to sum of left side

    // Finds an element in an array such that
    // left and right side sums are equal
    function findElement(arr , n)
    {
        // Forming prefix sum array from 0
        var prefixSum = Array(n).fill(0);
        prefixSum[0] = arr[0];
        for (i = 1; i < n; i++)
            prefixSum[i] = prefixSum[i - 1] + arr[i];

        // Forming suffix sum array from n-1
        var suffixSum = Array(n).fill(0);
        suffixSum[n - 1] = arr[n - 1];
        for (i = n - 2; i >= 0; i--)
            suffixSum[i] = suffixSum[i + 1] + arr[i];

        // Find the point where prefix and suffix
        // sums are same.
        for (i = 1; i < n - 1; i++)
            if (prefixSum[i] == suffixSum[i])
                return arr[i];

        return -1;
    }

    // Driver code
    
        var arr = [ 1, 4, 2, 5 ];
        var n = arr.length;
        document.write(findElement(arr, n));

// This code contributed by umadevi9616

</script>

<script>
     // Function to compute partition
    function findElement(arr) {
        let right_sum = 0, left_sum = 0;
 
        // Computing right_sum
        for (let i = 1; i < arr.length; i++)
            right_sum += arr[i];
 
        // Checking the point of partition
        // i.e. left_Sum == right_sum
        for (let i = 0, j = 1; j < arr.length; i++, j++) {
            right_sum -= arr[j];
            left_sum += arr[i];
 
            if (left_sum === right_sum)
                return arr[i + 1];
        }
 
        return -1;
    }
 
    // Driver
    let arr = [ 2, 3, 4, 1, 4, 5 ];
    document.write(findElement(arr));
   

// This code is contributed by Surbhi Tyagi 
</script>

<script>
// javascript program to find an element 
// such that sum of right side element 
// is equal to sum of left side 

    // Function to compute partition
    function findElement(arr , size) {
        var right_sum = 0, left_sum = 0;
        // Maintains left cumulative sum
        left_sum = 0;

        // Maintains right cumulative sum
        right_sum = 0;
        var i = -1, j = -1;

        for (i = 0, j = size - 1; i < j; i++, j--) {
            left_sum += arr[i];
            right_sum += arr[j];

            // Keep moving i towards center until
            // left_sum is found lesser than right_sum
            while (left_sum < right_sum && i < j) {
                i++;
                left_sum += arr[i];
            }
            // Keep moving j towards center until
            // right_sum is found lesser than left_sum
            while (right_sum < left_sum && i < j) {
                j--;
                right_sum += arr[j];
            }
        }
        if (left_sum == right_sum && i == j)
            return arr[i];
        else
            return -1;
    }

    // Driver code
    
        var arr = [ 2, 3, 4, 1, 4, 5 ];
        var size = arr.length;
        document.write(findElement(arr, size));

// This code contributed by gauravrajput1
</script>

<script>

// Function to find equilibrium point
// a: input array
// n: size of array
function equilibriumPoint(a, n)
{
    // Here we define two pointers to the array -> start =
    // 0, end = n-1 Two variables to take care of sum ->
    // left_sum = 0, right_sum = 0
    let i = 0, start = 0, end = n - 1, left_sum = 0,
        right_sum = 0;

    for (i = 0; i < n; i++) {

        // if the equilibrium element is found our start
        // will be equal to end variable and left_sum will
        // be equal right_sum => return the equilibrium
        // element
        if (start == end && right_sum == left_sum)
            return a[start];

        // if start is equal to end variable but left_sum is
        // not equal right_sum => no equilibrium element
        // return -1
        if (start == end)
            return -1;

        // if left_sum > right_sum => add the current end
        // element to the right_sum and decrement end
        if (left_sum > right_sum) {
            right_sum += a[end];
            end--;
        }

        // if right_sum < left_sum => add the current start
        // element to the left_sum and increment start
        else if (right_sum > left_sum) {
            left_sum += a[start];
            start++;
        }
        /*
            if left_sum is equal right_sum but start is not
        equal to end => we are still in the middle of
        algorithm even though we found that left_sum is
        equal right_sum we haven't got that one required
        equilibrium element (So, in this case add the
        current end element to the right_sum and
        decrement end (or) add the current start element
        to the left_sum and increment start, to make our
        algorithm continue further)
        */

        else {
            right_sum += a[end];
            end--;
        }
    }

    // When there is only one element in array our algorithm
    // exits without entering for loop So we can check if our
    // functions enters the loop if not we can directly
    // return the value as answer
    if (!i) {
        return a[0];
    }
}

// Driver code
    let arr = [ 2, 3, 4, 1, 4, 5 ];
    let size = arr.length;
    document.write(equilibriumPoint(arr, size));




// This code is contributed by Surbhi Tyagi.
</script>