Find Pivot Index

Find Pivot Index - Problem

Given an array of integers nums, 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 right of the index.

If the index is on the left edge of the array, then the left sum is 0 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 -1.

Input & Output

Example 1 — Basic Pivot Found

$ 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 pivot index is 3.

Example 2 — No Pivot Exists

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

› Output: -1

💡 Note: No index where left sum equals right sum. Index 0: left=0, right=5. Index 1: left=1, right=3. Index 2: left=3, right=0.

Example 3 — Pivot at Edge

$ Input: nums = [2,1,-1]

› Output: 0

💡 Note: At index 0: left sum = 0 (no elements), right sum = 1+(-1) = 0. Both are equal, so pivot is at index 0.

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 35 a Amazon 28 M Microsoft 22

The key insight is using the total sum to calculate right sums efficiently. Instead of recalculating sums repeatedly, we compute the total once and use the formula: right_sum = total - left_sum - current_element. Best approach is Prefix Sum with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

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

Check every possible pivot index by computing the sum of elements to the left and right of that index. Compare these sums to find where they're equal.

Prefix Sum

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

First calculate the total sum of all elements. Then iterate through the array maintaining a running left sum. For each position, the right sum can be calculated as total - left sum - current element.

Brute Force — Algorithm Steps

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

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Index 0

Left sum = 0, Right sum = 7+11+15 = 33

Check Index 1

Left sum = 2, Right sum = 11+15 = 26

Found Pivot

At some index, left sum equals right sum

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        int leftSum = 0;
        int rightSum = 0;
        
        // Calculate left sum
        for (int j = 0; j < i; j++) {
            leftSum += nums[j];
        }
        
        // Calculate right sum
        for (int j = i + 1; j < numsSize; j++) {
            rightSum += nums[j];
        }
        
        if (leftSum == rightSum) {
            return i;
        }
    }
    
    return -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int count = 0;
    
    // Remove brackets and parse numbers
    char* start = strchr(line, '[');
    if (start) {
        start++; // Skip '['
        char* end = strchr(start, ']');
        if (end) {
            *end = '\0'; // Null terminate before ']'
        }
        
        char* token = strtok(start, ",");
        while (token != NULL) {
            nums[count++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    int result = solution(nums, count);
    printf("%d\n", 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

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for sum calculations

✓ Linear Space

85.0K Views

Medium Frequency

~15 min Avg. Time

2.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler