Find the Pivot Integer - Practice Coding Problems

Find the Pivot Integer - Problem

Imagine a perfect balance point where everything to the left equals everything to the right! Given a positive integer n, you need to find a special pivot integer x that creates this magical balance.

The pivot integer x must satisfy this condition: The sum of all integers from 1 to x (inclusive) equals the sum of all integers from x to n (inclusive).

🎯 Your task: Return the pivot integer if it exists, otherwise return -1. The problem guarantees at most one pivot point exists.

Example: For n = 8, the pivot is 6 because:
• Left sum: 1 + 2 + 3 + 4 + 5 + 6 = 21
• Right sum: 6 + 7 + 8 = 21

Input & Output

example_1.py — Basic Case

$ Input: n = 8

› Output: 6

💡 Note: For n=8, the pivot is 6 because: Left sum (1+2+3+4+5+6) = 21 equals Right sum (6+7+8) = 21

example_2.py — Single Element

$ Input: n = 1

› Output: 1

💡 Note: For n=1, the only number is 1, and it serves as both left and right sum, so the pivot is 1

example_3.py — No Pivot Exists

$ Input: n = 4

› Output: -1

💡 Note: For n=4, no pivot exists. Testing all positions: x=1(1≠10), x=2(3≠9), x=3(6≠7), x=4(10≠4)

Visualization

Tap to expand

Understanding the Visualization

Place the blocks

Arrange blocks numbered 1 through n on a number line

Test balance points

Try different pivot positions to find perfect balance

Calculate weights

Sum the left side (1 to x) and right side (x to n)

Find equilibrium

The pivot where left weight equals right weight is our answer

Key Takeaway

🎯 Key Insight: The pivot x satisfies the equation x² = n(n+1)/2, allowing us to solve directly with mathematics!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n possible pivots, we calculate sums that take O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store sums and the current pivot

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
The input is always a positive integer
At most one pivot integer exists for any given input

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses mathematical insight: for a pivot x to exist, x² must equal the total sum n(n+1)/2. This allows us to directly calculate and verify the answer in O(1) time, though binary search in O(log n) is also efficient and more intuitive.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Position)	O(n²)	O(1)	Try each number from 1 to n as a potential pivot and calculate both sums
Binary Search Optimization	O(log n)	O(1)	Use binary search to efficiently find the pivot point

Brute Force (Check Every Position) — Algorithm Steps

Iterate through each possible pivot x from 1 to n
For each x, calculate left_sum = 1 + 2 + ... + x
Calculate right_sum = x + (x+1) + ... + n
If left_sum equals right_sum, return x
If no pivot found after checking all positions, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Try x=1

Left: 1, Right: 1+2+3+4+5+6+7+8 = 36. Not equal.

Try x=2

Left: 1+2 = 3, Right: 2+3+4+5+6+7+8 = 35. Not equal.

Continue...

Keep testing until we find x=6 where both sums equal 21.

Code -

solution.c — C

#include <stdio.h>

int findPivotInteger(int n) {
    for (int x = 1; x <= n; x++) {
        // Calculate sum from 1 to x
        int leftSum = x * (x + 1) / 2;
        // Calculate sum from x to n
        int rightSum = (n * (n + 1) / 2) - ((x - 1) * x / 2);
        
        if (leftSum == rightSum) {
            return x;
        }
    }
    
    return -1;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", findPivotInteger(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n possible pivots, we calculate sums that take O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store sums and the current pivot

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
The input is always a positive integer
At most one pivot integer exists for any given input

23.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler