Find Pivot Index - Practice Coding Problems

Find Pivot Index - Problem

Imagine you have an array of integers, and you need to find the perfect balance point - an index where the sum of all elements to its left equals the sum of all elements to its right.

Given an array nums, find the pivot index where:

The sum of elements strictly to the left equals the sum of elements strictly to the right
If the index is at the leftmost position, consider the left sum as 0
If the index is at the rightmost position, consider the right sum as 0

Goal: Return the leftmost pivot index, or -1 if no such index exists.

Example: For array [1, 7, 3, 6, 5, 6], index 3 is the pivot because left sum = 1+7+3 = 11 and right sum = 5+6 = 11.

Input & Output

example_1.py — Basic Pivot

$ Input: [1, 7, 3, 6, 5, 6]

› Output: 3

💡 Note: At index 3, left sum = 1+7+3 = 11 and right sum = 5+6 = 11. Both sides are equal.

example_2.py — No Pivot

$ Input: [1, 2, 3]

› Output: -1

💡 Note: No index exists where left and right sums are equal. Index 0: left=0, right=5. Index 1: left=1, right=3. Index 2: left=3, right=0.

example_3.py — Edge Case

$ Input: [2, 1, -1]

› Output: 0

💡 Note: At index 0, left sum = 0 (no elements to left) and right sum = 1 + (-1) = 0. Both sides equal 0.

Constraints

1 ≤ nums.length ≤ 10⁴
-1000 ≤ nums[i] ≤ 1000
Note: Array can contain negative numbers and zeros

Visualization

Tap to expand

Understanding the Visualization

Calculate Total Weight

First, we need to know the total weight of all elements: 1+7+3+6+5+6 = 28

Find Balance Point

We check each position to see if it can be our fulcrum. At each position, we know: Left Weight + Right Weight + Current Element = Total Weight

Apply Balance Formula

For balance: Left Weight = Right Weight. So: Left Weight × 2 + Current Element = Total Weight

Success!

At index 3: Left Weight (11) × 2 + Current (6) = 28 ✓. Perfect balance achieved!

Key Takeaway

🎯 Key Insight: Instead of recalculating sums repeatedly, we use the mathematical relationship that at the pivot point: `leftSum × 2 + currentElement = totalSum`. This allows us to find the balance point in just one pass!

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses prefix sum technique to solve this in O(n) time. First calculate the total sum, then iterate once using the mathematical relationship: leftSum × 2 + nums[i] = totalSum to identify the pivot index efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each index, calculate left and right sums separately
One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Calculate total sum first, then use running left sum to find pivot in one pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each index as potential pivot
For current index, calculate sum of all elements to the left
Calculate sum of all elements to the right
Compare left and right sums
Return first index where sums are equal, or -1 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Index 0

Left sum = 0, Right sum = 7+3+6+5+6 = 27

Check Index 1

Left sum = 1, Right sum = 3+6+5+6 = 20

Check Index 3

Left sum = 1+7+3 = 11, Right sum = 5+6 = 11 ✓

Code -

solution.c — C

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

int pivotIndex(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() {
    int nums[1000];
    int size = 0;
    char c;
    while (scanf("%d%c", &nums[size], &c)) {
        size++;
        if (c == ']') break;
    }
    printf("%d\n", pivotIndex(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n indices, we calculate left and right sums which takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store sums

✓ Linear Space

48.9K Views

High Frequency

~15 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler