# Equilibrium index of an array

Last Updated : 15 Feb, 2023

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

Steps to solve the problem:

1. iterate through i=1 to n:

*declare a leftsum variable to zero.

*iterate through 0 till i and add arr[i] to leftsum.

*declare a rightsum variable to zero.

*iterate through i+1 till n and add arr[i] to rightsum.

*check if leftsum is equal to rightsum than return arr[i].

2. return -1 in case of no point.

Below is the implementation of the above approach:

## C++

 `// C++ program to find equilibrium` `// index of an array` `#include ` `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 `   `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

 ``

## Javascript

 ``

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 ` `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 `   `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

 ``

## Javascript

 ``

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 ` `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` `  ``//As We Know that in prefixsum from front end the first prefixsum will be equal to first element in the array` `  ``//As well as from the back end the first prefixsum will be equal to last element in the array ` `   ``forward[0]=a[0];` ` ``rev[n-1]=a[n-1];` `    ``for` `(``int` `i = 1; i < n; i++) {` `            ``forward[i] = forward[i - 1] + a[i];` `       `  `    ``}`   `    ``// Taking the prefixsum from back end of array` `    ``for` `(``int` `i = n - 2; i >= 0; i--) {` `       `  `            ``rev[i] = rev[i + 1] + 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

 ``

Output

```First Point of equilibrium is at index 3
```

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

## Equilibrium index of an array using two pointers:

The given code is trying to find the equilibrium index of an array, where an equilibrium index is an index such that the sum of elements at lower indexes is equal to the sum of elements at higher indexes.

The code uses two pointers, left and right, to keep track of the sum of elements to the left and right of the pivot index. It starts by initializing the left pointer to 0, pivot to 0, and right pointer to the sum of all elements in the array minus the first element.

The code then enters a while loop where the pivot index is incremented until the left and right pointers are equal, or until the pivot index is the last index in the array.

In each iteration of the loop, the pivot index is incremented, and the right pointer is decremented by the value of the element at the current pivot index. The left pointer is incremented by the value of the element at the previous pivot index.

The code then checks if the left pointer is equal to the right pointer. If it is, the current pivot index is returned as the equilibrium index. If the pivot index is the last index in the array and the left pointer is still not equal to the right pointer, the function returns -1, indicating that no equilibrium index was found.

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `int` `pivotIndex(vector<``int``>& nums) {` `    ``int` `left = 0, pivot = 0, right = 0;` `    ``for` `(``int` `i = 1; i < nums.size(); i++) {` `        ``right += nums[i];` `    ``}` `    ``while` `(pivot < nums.size() - 1 && right != left) {` `        ``pivot++;` `        ``right -= nums[pivot];` `        ``left += nums[pivot - 1];` `    ``}` `    ``return` `(left == right) ? pivot : -1;` `}`   `int` `main() {` `    ``vector<``int``> nums = {1, 7, 3, 6, 5, 6};` `    ``int` `result = pivotIndex(nums);` `    ``cout <<``"First Point of equilibrium is at index "``<< result << endl;` `    ``return` `0;` `}`

## Java

 `import` `java.util.List;`   `class` `Solution {` `    ``public` `int` `pivotIndex(List nums) {` `        ``int` `left = ``0``, pivot = ``0``, right = ``0``;` `        ``for` `(``int` `i = ``1``; i < nums.size(); i++) {` `            ``right += nums.get(i);` `        ``}` `        ``while` `(pivot < nums.size() - ``1` `&& right != left) {` `            ``pivot++;` `            ``right -= nums.get(pivot);` `            ``left += nums.get(pivot - ``1``);` `        ``}` `        ``return` `(left == right) ? pivot : -``1``;` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``List nums = List.of(``1``, ``7``, ``3``, ``6``, ``5``, ``6``);` `        ``int` `result = ``new` `Solution().pivotIndex(nums);` `        ``System.out.println(result);` `    ``}` `}`

## Python3

 `from` `typing ``import` `List`   `def` `pivotIndex(nums: ``List``[``int``]) ``-``> ``int``:` `    ``left, pivot, right ``=` `0``, ``0``, ``sum``(nums)``-``nums[``0``]` `    ``while` `pivot < ``len``(nums)``-``1` `and` `right !``=` `left:` `        ``pivot ``+``=` `1` `        ``right ``-``=` `nums[pivot]` `        ``left ``+``=` `nums[pivot``-``1``]`   `    ``return` `pivot ``if` `left ``=``=` `right ``else` `-``1`   `def` `main():` `    ``# test the function with an example array` `    ``nums ``=` `[``1``, ``7``, ``3``, ``6``, ``5``, ``6``]` `    ``result ``=` `pivotIndex(nums)` `    ``print``(result)`   `if` `__name__ ``=``=` `"__main__"``:` `    ``main()`

## Javascript

 `function` `pivotIndex(nums) {` `    ``let left = 0, pivot = 0, right = nums.slice(1).reduce((a, b) => a + b, 0);` `    ``while` `(pivot < nums.length - 1 && right !== left) {` `        ``pivot++;` `        ``right -= nums[pivot];` `        ``left += nums[pivot - 1];` `    ``}` `    ``return` `(left === right) ? pivot : -1;` `}`   `console.log(pivotIndex([1, 7, 3, 6, 5, 6]));`

## C#

 `using` `System;` `using` `System.Linq;`   `class` `Solution {` `    ``public` `static` `int` `PivotIndex(``int``[] nums) {` `        ``int` `left = 0, pivot = 0, right = nums.Skip(1).Sum();` `        ``while` `(pivot < nums.Length - 1 && right != left) {` `            ``pivot++;` `            ``right -= nums[pivot];` `            ``left += nums[pivot - 1];` `        ``}` `        ``return` `(left == right) ? pivot : -1;` `    ``}`   `    ``public` `static` `void` `Main(``string``[] args) {` `        ``int``[] nums = {1, 7, 3, 6, 5, 6};` `        ``int` `result = PivotIndex(nums);` `        ``Console.WriteLine(result);` `    ``}` `}`

Output

```First Point of equilibrium is at index 3
```

Time Complexity: O(N)

Auxiliary Space: O(1)

Previous
Next