Equilibrium index of an array

Equilibrium index of an array is an index such that the sum of elements at lower indexes is equal to the sum of elements at higher indexes. For example, in an array A:

Example :

Input : A[] = {-7, 1, 5, 2, -4, 3, 0}
Output : 3
3 is an equilibrium index, because:
A[0] + A[1] + A[2]  =  A[4] + A[5] + A[6]

Write a function int equilibrium(int[] arr, int n); that given a sequence arr[] of size n, returns an equilibrium index (if any) or -1 if no equilibrium indexes exist.



Method 1 (Simple but inefficient)
Use two loops. Outer loop iterates through all the element and inner loop finds out whether the current index picked by the outer loop is equilibrium index or not. Time complexity of this solution is O(n^2).

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find equilibrium
// index of an array
#include <bits/stdc++.h>
using namespace std;
  
int equilibrium(int arr[], int n)
{
    int i, j;
    int leftsum, rightsum;
  
    /* Check for indexes one by one until 
    an equilibrium index is found */
    for (i = 0; i < n; ++i) 
    {     
  
        /* get left sum */
        leftsum = 0; 
        for (j = 0; j < i; j++)
            leftsum += arr[j];
  
        /* get right sum */
        rightsum = 0; 
        for (j = i + 1; j < n; j++)
            rightsum += arr[j];
  
        /* if leftsum and rightsum  
        are same, then we are done */
        if (leftsum == rightsum)
            return i;
    }
  
    /* return -1 if no equilibrium 
    index is found */
    return -1;
}
  
// Driver code
int main()
{
    int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
    cout << equilibrium(arr, arr_size);
    return 0;
}
  
// This code is contributed 
// by Akanksha Rai(Abby_akku)

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to find equilibrium
// index of an array
  
#include <stdio.h>
  
int equilibrium(int arr[], int n)
{
    int i, j;
    int leftsum, rightsum;
  
    /* Check for indexes one by one until 
      an equilibrium index is found */
    for (i = 0; i < n; ++i) {       
  
        /* get left sum */
        leftsum = 0; 
        for (j = 0; j < i; j++)
            leftsum += arr[j];
  
        /* get right sum */
        rightsum = 0; 
        for (j = i + 1; j < n; j++)
            rightsum += arr[j];
  
        /* if leftsum and rightsum are same, 
           then we are done */
        if (leftsum == rightsum)
            return i;
    }
  
    /* return -1 if no equilibrium index is found */
    return -1;
}
  
// Driver code
int main()
{
    int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
    printf("%d", equilibrium(arr, arr_size));
  
    getchar();
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find equilibrium
// index of an array
  
class EquilibriumIndex {
    int equilibrium(int arr[], int n)
    {
        int i, j;
        int leftsum, rightsum;
  
        /* Check for indexes one by one until 
           an equilibrium index is found */
        for (i = 0; i < n; ++i) {
  
            /* get left sum */
            leftsum = 0;  
            for (j = 0; j < i; j++)
                leftsum += arr[j];
  
            /* get right sum */
            rightsum = 0;
            for (j = i + 1; j < n; j++)
                rightsum += arr[j];
  
            /* if leftsum and rightsum are same, 
               then we are done */
            if (leftsum == rightsum)
                return i;
        }
  
        /* return -1 if no equilibrium index is found */
        return -1;
    }
    // Driver code
    public static void main(String[] args)
    {
        EquilibriumIndex equi = new EquilibriumIndex();
        int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
        int arr_size = arr.length;
        System.out.println(equi.equilibrium(arr, arr_size));
    }
}
  
// This code has been contributed by Mayank Jaiswal

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find equilibrium 
# index of an array
  
# function to find the equilibrium index
def equilibrium(arr):
    leftsum = 0
    rightsum = 0
    n = len(arr)
  
    # Check for indexes one by one 
    # until an equilibrium index is found
    for i in range(n):
        leftsum = 0
        rightsum = 0
      
        # get left sum
        for j in range(i):
            leftsum += arr[j]
          
        # get right sum
        for j in range(i + 1, n):
            rightsum += arr[j]
          
        # if leftsum and rightsum are same,
        # then we are done
        if leftsum == rightsum:
            return i
      
    # return -1 if no equilibrium index is found
    return -1
              
# driver code
arr = [-7, 1, 5, 2, -4, 3, 0]
print (equilibrium(arr))
  
# This code is contributed by Abhishek Sharama

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find equilibrium
// index of an array
  
using System;
  
class GFG {
    static int equilibrium(int[] arr, int n)
    {
        int i, j;
        int leftsum, rightsum;
  
        /* Check for indexes one by 
         one until an equilibrium
        index is found */
        for (i = 0; i < n; ++i) {
  
            // initialize left sum
            // for current index i
            leftsum = 0;
  
            // initialize right sum
            // for current index i
            rightsum = 0;
  
            /* get left sum */
            for (j = 0; j < i; j++)
                leftsum += arr[j];
  
            /* get right sum */
            for (j = i + 1; j < n; j++)
                rightsum += arr[j];
  
            /* if leftsum and rightsum are
             same, then we are done */
            if (leftsum == rightsum)
                return i;
        }
  
        /* return -1 if no equilibrium 
         index is found */
        return -1;
    }
  
    // driver code
    public static void Main()
    {
        int[] arr = { -7, 1, 5, 2, -4, 3, 0 };
        int arr_size = arr.Length;
  
        Console.Write(equilibrium(arr, arr_size));
    }
}
  
// This code is contributed by Sam007

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP program to find equilibrium 
// index of an array 
  
function equilibrium($arr, $n
    $i; $j
    $leftsum;
    $rightsum
  
    /* Check for indexes one by one until 
    an equilibrium index is found */
    for ($i = 0; $i < $n; ++$i
    {     
  
        /* get left sum */
        $leftsum = 0; 
        for ($j = 0; $j < $i; $j++) 
            $leftsum += $arr[$j]; 
  
        /* get right sum */
        $rightsum = 0; 
        for ($j = $i + 1; $j < $n; $j++) 
            $rightsum += $arr[$j]; 
  
        /* if leftsum and rightsum 
        are same, then we are done */
        if ($leftsum == $rightsum
            return $i
    
  
    /* return -1 if no equilibrium
       index is found */
    return -1; 
  
// Driver code 
$arr = array( -7, 1, 5, 2, -4, 3, 0 ); 
$arr_size = sizeof($arr); 
echo equilibrium($arr, $arr_size); 
  
// This code is contributed 
// by akt_mit
?>

chevron_right




Time Complexity:
O(n^2)



Method 2 (Tricky and Efficient)
The idea is to get total sum of array first. Then Iterate through the array and keep updating the left sum which is initialized as zero. In the loop, we can get right sum by subtracting the elements one by one. Thanks to Sambasiva for suggesting this solution and providing code for this.

1) Initialize leftsum  as 0
2) Get the total sum of the array as sum
3) Iterate through the array and for each index i, do following.
    a)  Update sum to get the right sum.  
           sum = sum - arr[i] 
       // sum is now right sum
    b) If leftsum is equal to sum, then return current index. 
    c) leftsum = leftsum + arr[i] // update leftsum for next iteration.
4) return -1 // If we come out of loop without returning then
             // there is no equilibrium index

C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to find equilibrium
// index of an array
  
#include <stdio.h>
  
int equilibrium(int arr[], int n)
{
    int sum = 0; // initialize sum of whole array
    int leftsum = 0; // initialize leftsum
  
    /* Find sum of the whole array */
    for (int i = 0; i < n; ++i)
        sum += arr[i];
  
    for (int i = 0; i < n; ++i) {
        sum -= arr[i]; // sum is now right sum for index i
  
        if (leftsum == sum)
            return i;
  
        leftsum += arr[i];
    }
  
    /* If no equilibrium index found, then return 0 */
    return -1;
}
  
// Driver code
int main()
{
    int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
    printf("First equilibrium index is %d"
                 equilibrium(arr, arr_size));
  
    getchar();
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find equilibrium
// index of an array
  
class EquilibriumIndex {
    int equilibrium(int arr[], int n)
    {
        int sum = 0; // initialize sum of whole array
        int leftsum = 0; // initialize leftsum
  
        /* Find sum of the whole array */
        for (int i = 0; i < n; ++i)
            sum += arr[i];
  
        for (int i = 0; i < n; ++i) {
            sum -= arr[i]; // sum is now right sum for index i
  
            if (leftsum == sum)
                return i;
  
            leftsum += arr[i];
        }
  
        /* If no equilibrium index found, then return 0 */
        return -1;
    }
  
   // Driver code
    public static void main(String[] args)
    {
        EquilibriumIndex equi = new EquilibriumIndex();
        int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
        int arr_size = arr.length;
        System.out.println("First equilibrium index is "
                          equi.equilibrium(arr, arr_size));
    }
}
  
// This code has been contributed by Mayank Jaiswal

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find the equilibrium
# index of an array
  
# function to find the equilibrium index
def equilibrium(arr):
  
    # finding the sum of whole array
    total_sum = sum(arr)
    leftsum = 0
    for i, num in enumerate(arr):
          
        # total_sum is now right sum
        # for index i
        total_sum -= num
          
        if leftsum == total_sum:
            return i
        leftsum += num
       
      # If no equilibrium index found, 
      # then return -1
    return -1
      
# Driver code
arr = [-7, 1, 5, 2, -4, 3, 0]
print ('First equilibrium index is ',
       equilibrium(arr))
  
# This code is contributed by Abhishek Sharma

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the equilibrium
//  index of an array
  
using System;
  
class GFG {
    static int equilibrium(int[] arr, int n)
    {
        // initialize sum of whole array
        int sum = 0;
  
        // initialize leftsum
        int leftsum = 0;
  
        /* Find sum of the whole array */
        for (int i = 0; i < n; ++i)
            sum += arr[i];
  
        for (int i = 0; i < n; ++i) {
  
            // sum is now right sum
            // for index i
            sum -= arr[i];
  
            if (leftsum == sum)
                return i;
  
            leftsum += arr[i];
        }
  
        /* If no equilibrium index found, 
        then return 0 */
        return -1;
    }
  
    // Driver code
    public static void Main()
    {
        int[] arr = { -7, 1, 5, 2, -4, 3, 0 };
        int arr_size = arr.Length;
  
        Console.Write("First equilibrium index is " +
                           equilibrium(arr, arr_size));
    }
}
// This code is contributed by Sam007

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find equilibrium 
// index of an array 
  
function equilibrium($arr, $n
    $sum = 0; // initialize sum of 
              // whole array 
    $leftsum = 0; // initialize leftsum 
  
    /* Find sum of the whole array */
    for ($i = 0; $i < $n; ++$i
        $sum += $arr[$i]; 
  
    for ($i = 0; $i < $n; ++$i
    
        // sum is now right sum 
        // for index i 
        $sum -= $arr[$i]; 
  
        if ($leftsum == $sum
            return $i
  
        $leftsum += $arr[$i]; 
    
  
    /* If no equilibrium index 
    found, then return 0 */
    return -1; 
  
// Driver code
$arr = array( -7, 1, 5, 2, -4, 3, 0 ); 
$arr_size = sizeof($arr); 
echo "First equilibrium index is "
      equilibrium($arr, $arr_size); 
  
// This code is contributed by ajit
?>

chevron_right


Output:

First equilibrium index is 3

Time Complexity: O(n)

As pointed out by Sameer, we can remove the return statement and add a print statement to print all equilibrium indexes instead of returning only one.

Please write comments if you find the above codes/algorithms incorrect, or find better ways to solve the same problem.



My Personal Notes arrow_drop_up

Improved By : onlycodes, jit_t, Akanksha_Rai