Find Pivot Index - Practice Coding Problems

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

Understanding the Visualization

Input Array

Given array [1,7,3,6,5,6] with indices 0-5

Find Balance

Look for index where left sum equals right sum

Output

Return index 3 where both sides sum to 11

Key Takeaway

🎯 Key Insight: Use total sum to calculate right sum efficiently without nested loops

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

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	For each index, calculate left sum and right sum separately
Prefix Sum	O(n)	O(1)	Calculate total sum first, then use running sum to find pivot efficiently

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;
    char* token = strtok(line, "[],");
    
    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