Skip to content
Related Articles

Related Articles

Equilibrium index of an array

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 30 Sep, 2022
Improve Article
Save Article

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

The 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. 

Examples: 

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]

Input: A[] = {1, 2, 3} 
Output: -1 

Recommended Practice

Naive approach: To solve the problem follow the below idea:

Use two loops. The 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

Below is the implementation of the above approach:

C++




// 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]);
 
    // Function call
    cout << equilibrium(arr, arr_size);
    return 0;
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)


C




// 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]);
 
    // Function call
    printf("%d", equilibrium(arr, arr_size));
 
    getchar();
    return 0;
}


Java




// 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;
 
        // Function call
        System.out.println(equi.equilibrium(arr, arr_size));
    }
}
 
// This code has been contributed by Mayank Jaiswal


Python3




# Python3 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
if __name__ == "__main__":
    arr = [-7, 1, 5, 2, -4, 3, 0]
 
    # Function call
    print(equilibrium(arr))
 
# This code is contributed by Abhishek Sharama


C#




// 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;
 
        // Function call
        Console.Write(equilibrium(arr, arr_size));
    }
}
 
// This code is contributed by Sam007


PHP




<?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);
 
// Function call
echo equilibrium($arr, $arr_size);
 
// This code is contributed
// by akt_mit
?>


Javascript




<script>
// JavaScript Program to find equilibrium
// index of an array
function equilibrium(arr, n)
{
         var i, j;
         var 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(let j = 0; j < i; j++)
              leftsum += arr[j];
               
              /*get right sum*/
              rightsum = 0;
              for(let 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
      
     var arr = new Array(-7,1,5,2,-4,3,0);
     n = arr.length;
      document.write(equilibrium(arr,n));
       
// This code is contributed by simranarora5sos 
</script>


Output

3

Time Complexity: O(N2)
Auxiliary Space: O(1)

Equilibrium index of an Array using Array-Sum:

To solve the problem follow the below idea:

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

Follow the given steps to solve the problem:

  • Initialize leftsum  as 0
  • Get the total sum of the array as sum
  • Iterate through the array and for each index i, do the following:
    • Update the sum to get the right sum.  
    • sum = sum – arr[i] 
    • The sum is now the right sum
    • If leftsum is equal to the sum, then return the current index. 
    • update left sum for the next iteration.
    • leftsum = leftsum + arr[i]
  • Return -1 
  • If we come out of the loop without returning then there is no equilibrium index

The image below shows the dry run of the above approach: 

Below is the implementation of the above approach: 

C++




// C++ program to find equilibrium
// index of an array
#include <bits/stdc++.h>
using namespace std;
 
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]);
 
    // Function call
    cout << "First equilibrium index is "
         << equilibrium(arr, arr_size);
    return 0;
}
 
// This is code is contributed by rathbhupendra


C




// 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]);
 
    // Function call
    printf("First equilibrium index is %d",
           equilibrium(arr, arr_size));
 
    getchar();
    return 0;
}


Java




// 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;
 
        // Function call
        System.out.println(
            "First equilibrium index is "
            + equi.equilibrium(arr, arr_size));
    }
}
 
// This code has been contributed by Mayank Jaiswal


Python3




# 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
if __name__ == "__main__":
    arr = [-7, 1, 5, 2, -4, 3, 0]
 
    # Function call
    print('First equilibrium index is ',
          equilibrium(arr))
 
# This code is contributed by Abhishek Sharma


C#




// 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;
 
        // Function call
        Console.Write("First equilibrium index is "
                      + equilibrium(arr, arr_size));
    }
}
// This code is contributed by Sam007


PHP




<?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);
 
// Function call
echo "First equilibrium index is ",
      equilibrium($arr, $arr_size);
 
// This code is contributed by ajit
?>


Javascript




<script>
// 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 (let i = 0; i < n; ++i)
        sum += arr[i];
  
    for (let 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
 
arr =new Array(-7, 1, 5, 2, -4, 3, 0);
n=arr.length;
document.write("First equilibrium index is " + equilibrium(arr, n));
 
// This code is contributed by simranarora5sos
</script>


Output

First equilibrium index is 3

 Time Complexity: O(N)
Auxiliary Space: O(1)

Equilibrium index of an array using Prefix-Sum:

To solve the problem follow the below idea:

This is a quite simple and straightforward method. The idea is to take the prefix sum of the array twice. Once from the front end of the array and another from the back end of the array. After taking both prefix sums run a loop and check for some i if both the prefix sum from one array is equal to prefix sum from the second array then that point can be considered as the Equilibrium point

Follow the given steps to solve the problem:

  • Declare two arrays to store the prefix sum of the array from the front and the back
  • Run a loop from 1 to N and check if at any point prefix sum of the array from the front is equal to the prefix sum of the array from the back
  • If any such index is found then return that index
  • Else return -1

Below is the implementation of the above approach:

C++




// C++ program to find equilibrium index of an array
#include <bits/stdc++.h>
using namespace std;
 
int equilibrium(int a[], int n)
{
    if (n == 1)
        return (0);
    int forward[n] = { 0 };
    int rev[n] = { 0 };
 
    // Taking the prefixsum from front end array
    for (int i = 0; i < n; i++) {
        if (i) {
            forward[i] = forward[i - 1] + a[i];
        }
        else {
            forward[i] = a[i];
        }
    }
 
    // Taking the prefixsum from back end of array
    for (int i = n - 1; i > 0; i--) {
        if (i <= n - 2) {
            rev[i] = rev[i + 1] + a[i];
        }
        else {
            rev[i] = a[i];
        }
    }
 
    // Checking if forward prefix sum
    // is equal to rev prefix
    // sum
    for (int i = 0; i < n; i++) {
        if (forward[i] == rev[i]) {
            return i;
        }
    }
    return -1;
 
    // If You want all the points
    // of equilibrium create
    // vector and push all equilibrium
    // points in it and
    // return the vector
}
 
// Driver code
int main()
{
    int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    cout << "First Point of equilibrium is at index "
         << equilibrium(arr, n) << "\n";
    return 0;
}


Java




// Java program to find equilibrium
// index of an array
import java.io.*;
 
class GFG {
 
    static int equilibrium(int a[], int n)
    {
        if (n == 1)
            return (0);
 
        int[] front = new int[n];
        int[] back = new int[n];
 
        // Taking the prefixsum from front end array
        for (int i = 0; i < n; i++) {
            if (i != 0) {
                front[i] = front[i - 1] + a[i];
            }
            else {
                front[i] = a[i];
            }
        }
 
        // Taking the prefixsum from back end of array
        for (int i = n - 1; i > 0; i--) {
            if (i <= n - 2) {
                back[i] = back[i + 1] + a[i];
            }
            else {
                back[i] = a[i];
            }
        }
 
        // Checking for equilibrium index by
        // comparing front and back sums
        for (int i = 0; i < n; i++) {
            if (front[i] == back[i]) {
                return i;
            }
        }
 
        // If no equilibrium index found,then return -1
        return -1;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { -7, 1, 5, 2, -4, 3, 0 };
        int arr_size = arr.length;
 
        // Function call
        System.out.println("First Point of equilibrium "
                           + "is at index "
                           + equilibrium(arr, arr_size));
    }
}
 
// This code is contributed by Lovish Aggarwal


Python3




# Python3 program to find the equilibrium
# index of an array
 
# Function to find the equilibrium index
 
 
def equilibrium(arr):
    left_sum = []
    right_sum = []
 
    # Iterate from 0 to len(arr)
    for i in range(len(arr)):
 
        # If i is not 0
        if(i):
            left_sum.append(left_sum[i-1]+arr[i])
            right_sum.append(right_sum[i-1]+arr[len(arr)-1-i])
        else:
            left_sum.append(arr[i])
            right_sum.append(arr[len(arr)-1])
 
    # Iterate from 0 to len(arr)
    for i in range(len(arr)):
        if(left_sum[i] == right_sum[len(arr) - 1 - i]):
            return(i)
 
    # If no equilibrium index found,then return -1
    return -1
 
 
# Driver code
if __name__ == "__main__":
    arr = [-7, 1, 5, 2, -4, 3, 0]
 
    # Function call
    print('First equilibrium index is ',
          equilibrium(arr))
 
# This code is contributed by Lokesh Sharma


C#




// C# program to find equilibrium
// index of an array
using System;
 
class GFG {
 
    static int equilibrium(int[] a, int n)
    {
        if (n == 1)
            return (0);
 
        int[] front = new int[n];
        int[] back = new int[n];
 
        // Taking the prefixsum from front end array
        for (int i = 0; i < n; i++) {
            if (i != 0) {
                front[i] = front[i - 1] + a[i];
            }
            else {
                front[i] = a[i];
            }
        }
 
        // Taking the prefixsum from back end of array
        for (int i = n - 1; i > 0; i--) {
            if (i <= n - 2) {
                back[i] = back[i + 1] + a[i];
            }
            else {
                back[i] = a[i];
            }
        }
 
        // Checking for equilibrium index by
        // comparing front and back sums
        for (int i = 0; i < n; i++) {
            if (front[i] == back[i]) {
                return i;
            }
        }
 
        // If no equilibrium index found,then return -1
        return -1;
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        int[] arr = { -7, 1, 5, 2, -4, 3, 0 };
        int arr_size = arr.Length;
 
        // Function call
        Console.WriteLine("First Point of equilibrium "
                          + "is at index "
                          + equilibrium(arr, arr_size));
    }
}
 
// This code is contributed by ukasp


Javascript




<script>
// Program to find equilibrium index of an array
 function equilibrium(a, n)
{
    if (n == 1)
        return (0);
    var forward = new Array(0);
    var rev = new Array(0);
  
    // Taking the prefixsum from front end array
    for (let i = 0; i < n; i++) {
        if (i) {
            forward[i] = forward[i - 1] + a[i];
        }
        else {
            forward[i] = a[i];
        }
    }
  
    // Taking the prefixsum from back end of array
    for (let i = n - 1; i > 0; i--) {
        if (i <= n - 2) {
            rev[i] = rev[i + 1] + a[i];
        }
        else {
            rev[i] = a[i];
        }
    }
  
    // Checking if forward prefix sum
    // is equal to rev prefix
    // sum
    for (let i = 0; i < n; i++) {
        if (forward[i] == rev[i]) {
            return i;
        }
    }
    return -1;
  
    // If You want all the points
    // of equilibrium create
    // vector and push all equilibrium
    // points in it and
    // return the vector
}
  
// Driver code
    arr = new Array(-7, 1, 5, 2, -4, 3, 0);
    n = arr.length;
    document.write("First Point of equilibrium is at index "
         + equilibrium(arr, n) + "\n");
          
// This code is contributed by simranarora5sos
</script>


Output

First Point of equilibrium is at index 3

Time Complexity: O(N)
Auxiliary Space: O(N)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!