JavaScript Program for Maximum equilibrium sum in an array

The equilibrium sum of an array is found at an index where the sum of elements from the start to that index (inclusive) equals the sum of elements after that index. When multiple equilibrium points exist, we need to find the maximum sum among them.

Problem Statement

Given an array, find the maximum equilibrium sum where:

• Left sum includes elements from index 0 to current index (inclusive)
• Right sum includes elements after the current index (exclusive)
• Left sum equals right sum at the equilibrium point

Example

Array: [2, 3, -1, 0, -1, 2, 3]

At index 2: Left sum = 2+3+(-1) = 4, Right sum = 0+(-1)+2+3 = 4
At index 3: Left sum = 2+3+(-1)+0 = 4, Right sum = (-1)+2+3 = 4

Maximum equilibrium sum = 4

Approach 1: Brute Force

Calculate left and right sums for each index using nested loops:

function maxEquilibriumSum(arr) {
    let n = arr.length;
    let maxSum = 0;
    
    for (let i = 0; i < n; i++) {
        // Calculate left sum (including current element)
        let leftSum = 0;
        for (let j = 0; j <= i; j++) {
            leftSum += arr[j];
        }
        
        // Calculate right sum (excluding current element)
        let rightSum = 0;
        for (let j = i + 1; j < n; j++) {
            rightSum += arr[j];
        }
        
        // Check equilibrium condition
        if (leftSum === rightSum && leftSum > maxSum) {
            maxSum = leftSum;
        }
    }
    
    return maxSum;
}

// Test the function
let arr = [2, 3, -1, 0, -1, 2, 3];
console.log("Maximum equilibrium sum:", maxEquilibriumSum(arr));

Maximum equilibrium sum: 4

Time Complexity: O(N²) - nested loops for each element
Space Complexity: O(1) - constant extra space

Approach 2: Prefix and Suffix Arrays

Pre-compute prefix and suffix sums to avoid recalculating sums:

function maxEquilibriumSumOptimized(arr) {
    let n = arr.length;
    let maxSum = 0;
    
    // Build prefix sum array
    let prefixSum = new Array(n);
    prefixSum[0] = arr[0];
    for (let i = 1; i < n; i++) {
        prefixSum[i] = prefixSum[i - 1] + arr[i];
    }
    
    // Build suffix sum array
    let suffixSum = new Array(n);
    suffixSum[n - 1] = arr[n - 1];
    for (let i = n - 2; i >= 0; i--) {
        suffixSum[i] = suffixSum[i + 1] + arr[i];
    }
    
    // Check equilibrium points
    for (let i = 0; i < n - 1; i++) {
        let leftSum = prefixSum[i];
        let rightSum = suffixSum[i + 1];
        
        if (leftSum === rightSum && leftSum > maxSum) {
            maxSum = leftSum;
        }
    }
    
    return maxSum;
}

// Test the function
let arr2 = [2, 3, -1, 0, -1, 2, 3];
console.log("Maximum equilibrium sum:", maxEquilibriumSumOptimized(arr2));

Maximum equilibrium sum: 4

Time Complexity: O(N) - three linear passes
Space Complexity: O(N) - prefix and suffix arrays

Approach 3: Two Pointers (Most Efficient)

Use running sum technique with two variables:

function maxEquilibriumSumEfficient(arr) {
    let n = arr.length;
    let maxSum = 0;
    
    // Calculate total sum
    let totalSum = arr.reduce((sum, num) => sum + num, 0);
    
    let leftSum = 0;
    
    // Check each potential equilibrium point
    for (let i = 0; i < n - 1; i++) {
        leftSum += arr[i];
        let rightSum = totalSum - leftSum;
        
        if (leftSum === rightSum && leftSum > maxSum) {
            maxSum = leftSum;
        }
    }
    
    return maxSum;
}

// Test with different arrays
let testArrays = [
    [2, 3, -1, 0, -1, 2, 3],
    [1, 2, 3, 4, 5],
    [-1, 0, 1],
    [10]
];

testArrays.forEach((arr, index) => {
    console.log(`Array ${index + 1}: [${arr.join(', ')}]`);
    console.log(`Maximum equilibrium sum: ${maxEquilibriumSumEfficient(arr)}`);
    console.log('---');
});

Array 1: [2, 3, -1, 0, -1, 2, 3]
Maximum equilibrium sum: 4
---
Array 2: [1, 2, 3, 4, 5]
Maximum equilibrium sum: 0
---
Array 3: [-1, 0, 1]
Maximum equilibrium sum: 0
---
Array 4: [10]
Maximum equilibrium sum: 0
---

Time Complexity: O(N) - two linear passes
Space Complexity: O(1) - constant extra space

Complexity Comparison

Conclusion

The two-pointer approach provides the most efficient solution with O(N) time and O(1) space complexity. It uses the mathematical relationship that left sum + right sum = total sum to avoid storing additional arrays while maintaining optimal performance.