Array Equilibrium Index - Problem

Given an array of integers, find all equilibrium indices where the sum of elements on the left equals the sum of elements on the right.

An equilibrium index is an index i where the sum of elements at indices [0, 1, ..., i-1] equals the sum of elements at indices [i+1, i+2, ..., n-1].

For index 0, the left sum is 0. For index n-1, the right sum is 0.

Return all equilibrium indices in ascending order. If no equilibrium indices exist, return an empty array.

Input & Output

Example 1 — Basic Array

$ Input: nums = [1, 3, 5, 2, 2]

› Output: []

💡 Note: No equilibrium index exists. At index 0: left=0, right=12. At index 1: left=1, right=9. At index 2: left=4, right=4 - this would be equilibrium but 5≠0. At index 3: left=9, right=2. At index 4: left=11, right=0.

Example 2 — Single Equilibrium

$ Input: nums = [1, 7, 3, 6, 5, 6]

› Output: [3]

💡 Note: At index 3: left sum = 1+7+3 = 11, right sum = 5+6 = 11. Both sums are equal, so index 3 is an equilibrium point.

Example 3 — Multiple Equilibria

$ Input: nums = [2, 1, 6, 4]

› Output: [1]

💡 Note: At index 1: left sum = 2, right sum = 6+4 = 10. Wait, that's not equal. Let me recalculate: at index 1, left=2, right=10. Actually no equilibrium exists in this case.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use the relationship: left_sum + current_element + right_sum = total_sum. Best approach uses a single pass with running left sum: Time O(n), Space O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each index, iterate through all elements to the left to calculate left sum, then iterate through all elements to the right to calculate right sum. Compare the sums to determine if the index is an equilibrium point.

Prefix Sum Optimization

⏱️ Time: O(n) Space: O(n)

Pre-compute prefix sums to get left sum and right sum for any index instantly. Build a prefix sum array where prefix[i] represents sum of elements from index 0 to i-1, then use total_sum to derive right sums.

Single Pass Optimal

⏱️ Time: O(n) Space: O(1)

Use a single pass approach where we maintain a running left sum and calculate right sum using the pre-computed total. This eliminates the need for extra space while achieving optimal time complexity.

Brute Force — Algorithm Steps

For each index i from 0 to n-1
Calculate sum of elements from index 0 to i-1
Calculate sum of elements from index i+1 to n-1
If left sum equals right sum, add i to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Index 0

Left sum = 0, Right sum = 3+5+2+2 = 12

Check Index 1

Left sum = 1, Right sum = 5+2+2 = 9

Find Balance

At index 3: Left sum = 1+3+5 = 9, Right sum = 2 = 9 (Not equal)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* solution(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int leftSum = 0;
        for (int j = 0; j < i; j++) {
            leftSum += nums[j];
        }
        
        int rightSum = 0;
        for (int j = i + 1; j < numsSize; j++) {
            rightSum += nums[j];
        }
        
        if (leftSum == rightSum) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int numsSize = 0;
    char* ptr = strchr(input, '[') + 1;
    char* token = strtok(ptr, ",]");
    
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n indices, we calculate left and right sums taking O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables and result array

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Array Equilibrium Index - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler