---
# System prepended metadata

title: LC 724. Find Pivot Index
tags: [easy, leedcode, python, c++]

---

# LC 724. Find Pivot Index

### [Problem link](https://leetcode.com/problems/find-pivot-index/)

###### tags: `leedcode` `python` `c++` `easy`

Given an array of integers <code>nums</code>, calculate the  **pivot index**  of this array.

The  **pivot index**  is the index where the sum of all the numbers  **strictly**  to the left of the index is equal to the sum of all the numbers  **strictly**  to the index's right.

If the index is on the left edge of the array, then the left sum is <code>0</code> because there are no elements to the left. This also applies to the right edge of the array.

Return the  **leftmost pivot index** . If no such index exists, return <code>-1</code>.

**Example 1:** 

```
Input: nums = [1,7,3,6,5,6]
Output: 3
Explanation:
The pivot index is 3.
Left sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11
Right sum = nums[4] + nums[5] = 5 + 6 = 11
```

**Example 2:** 

```
Input: nums = [1,2,3]
Output: -1
Explanation:
There is no index that satisfies the conditions in the problem statement.
```

**Example 3:** 

```
Input: nums = [2,1,-1]
Output: 0
Explanation:
The pivot index is 0.
Left sum = 0 (no elements to the left of index 0)
Right sum = nums[1] + nums[2] = 1 + -1 = 0
```

 **Constraints:** 

- <code>1 <= nums.length <= 10<sup>4</sup></code>
- <code>-1000 <= nums[i] <= 1000</code>


 **Note:**  This question is the same as1991:<a href="https://leetcode.com/problems/find-the-middle-index-in-array/" target="_blank">https://leetcode.com/problems/find-the-middle-index-in-array/</a>

## Solution 1
#### Python
```python=
class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        n = len(nums)
        left_sum, right_sum = 0, sum(nums)

        for i in range(n):
            right_sum -= nums[i]
            if left_sum == right_sum:
                return i
            left_sum += nums[i]

        return -1
```
#### C++
```cpp=
class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        int numsSum = accumulate(nums.begin(), nums.end(), 0);
        int leftSum = 0;
        for (int i = 0; i < nums.size(); i++) {
            numsSum -= nums[i];
            if (leftSum == numsSum) {
                return i;
            }
            leftSum += nums[i];
        }
        return -1;
    }
};
```

>### Complexity
>n = nums.length
>|             | Time Complexity | Space Complexity |
>| ----------- | --------------- | ---------------- |
>| Solution 1  | O(n)            | O(1)             |


## Note
x
