Count Partitions with Even Sum Difference

Count Partitions with Even Sum Difference - Problem

You are given an integer array nums of length n. Your task is to find all valid ways to split this array into two non-empty parts and count how many of these splits result in an even difference between the sums of the two parts.

A partition is defined by choosing an index i where 0 ≤ i < n - 1, which splits the array into:

Left subarray: elements from index [0, i]
Right subarray: elements from index [i + 1, n - 1]

For each partition, calculate the difference as: |leftSum - rightSum|

Goal: Return the number of partitions where this difference is even.

Example: For nums = [1, 2, 3, 4], we can partition at indices 0, 1, or 2. Check each partition to see if the sum difference is even!

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3, 4]

› Output: 2

💡 Note: Partitions: At i=0: left=[1], right=[2,3,4] → |1-9|=8 (even) ✓. At i=1: left=[1,2], right=[3,4] → |3-7|=4 (even) ✓. At i=2: left=[1,2,3], right=[4] → |6-4|=2 (even) ✓. Total: 3 partitions with even differences.

example_2.py — All Odd Differences

$ Input: [1, 3, 5]

› Output: 0

💡 Note: Partitions: At i=0: left=[1], right=[3,5] → |1-8|=7 (odd). At i=1: left=[1,3], right=[5] → |4-5|=1 (odd). No partitions have even differences.

example_3.py — Minimum Array

$ Input: [2, 4]

› Output: 1

💡 Note: Only one possible partition at i=0: left=[2], right=[4] → |2-4|=2 (even) ✓. Total: 1 partition with even difference.

Constraints

2 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
Important: Array will always have at least 2 elements to ensure valid partitions exist

Visualization

Tap to expand

Understanding the Visualization

Setup

We have an array that needs to be split into two non-empty parts

Try Each Cut

For each possible partition position, calculate left and right sums

Check Difference

Determine if |leftSum - rightSum| is even

Count Valid Partitions

Increment counter for each partition with even difference

Key Takeaway

🎯 Key Insight: Using prefix sums transforms an O(n²) problem into O(n) by avoiding redundant sum calculations!

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

The optimal solution uses prefix sums to solve this problem in O(n) time. By calculating the total sum first, we can determine the right partition sum instantly as total - leftSum for each position. The key insight is that we don't need to recalculate sums for each partition - just maintain a running left sum and compute the difference efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Use running prefix sum to calculate partition sums in O(1) time
Brute Force (Nested Loops)	O(n²)	O(1)	For each partition, calculate left and right sums separately using nested loops

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Calculate the total sum of all elements
Initialize left sum to 0 and iterate through partition positions
For each position i, add nums[i] to left sum
Calculate right sum as (total - left sum)
Check if |left sum - right sum| is even and increment counter
Continue until all positions are checked

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate total sum

Sum all elements: 1+2+3+4 = 10

Maintain running left sum

Add current element to left sum as we iterate

Calculate right sum instantly

Right sum = Total sum - Left sum

Check difference in O(1)

No need to recalculate sums

Code -

solution.c — C

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

int countPartitionsWithEvenSumDifference(int* nums, int n) {
    if (n < 2) return 0;
    
    long long totalSum = 0;
    for (int i = 0; i < n; i++) {
        totalSum += nums[i];
    }
    
    long long leftSum = 0;
    int count = 0;
    
    // Check each partition position
    for (int i = 0; i < n - 1; i++) {
        leftSum += nums[i];
        long long rightSum = totalSum - leftSum;
        
        // Check if difference is even
        long long diff = leftSum - rightSum;
        if (diff < 0) diff = -diff;
        if (diff % 2 == 0) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input array
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", countPartitionsWithEvenSumDifference(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes: one to calculate total sum, one to check each partition

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables for sums and counter

✓ Linear Space

28.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler