Ways to Make a Fair Array

Ways to Make a Fair Array - Problem

You are given an integer array nums. You can choose exactly one index (0-indexed) and remove the element. Notice that the index of the elements may change after the removal.

For example, if nums = [6,1,7,4,1]:

Choosing to remove index 1 results in nums = [6,7,4,1].
Choosing to remove index 2 results in nums = [6,1,4,1].
Choosing to remove index 4 results in nums = [6,1,7,4].

An array is fair if the sum of the odd-indexed values equals the sum of the even-indexed values.

Return the number of indices that you could choose such that after the removal, nums is fair.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,1,6,4]

› Output: 1

💡 Note: Only removing index 1 makes the array fair. After removing nums[1]=1, we get [2,6,4]. Even indices sum: 2+4=6, Odd indices sum: 6. Since 6=6, it's fair.

Example 2 — Multiple Solutions

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

› Output: 3

💡 Note: Removing any element results in [1,1]. Even sum = 1, Odd sum = 1. All three removals work.

Example 3 — No Solution

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

› Output: 0

💡 Note: No removal makes the array fair. Remove 1→[2,3] (2≠3), Remove 2→[1,3] (1≠3), Remove 3→[1,2] (1≠2).

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is that when you remove an element, all elements after it shift positions - odd indices become even and vice versa. The optimal prefix sum approach pre-calculates totals and uses math formulas to determine new sums in O(1) time per removal. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

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

For each possible removal index, create a new array without that element, then calculate the sum of even-indexed and odd-indexed elements to check if they're equal.

Prefix Sum Optimization

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

Instead of recalculating sums from scratch for each removal, we pre-compute prefix sums for even and odd positions. When removing an element, we can quickly calculate the new sums using the insight that elements after the removal shift positions.

Brute Force Simulation — Algorithm Steps

For each index i from 0 to n-1
Create new array without element at index i
Calculate sum of even indices and sum of odd indices
If sums are equal, increment count

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Remove Index 0

Remove first element and check if remaining array is fair

Try Remove Index 1

Remove second element and check if remaining array is fair

Count Valid

Count how many removals result in fair arrays

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int count = 0;
    
    for (int removeIdx = 0; removeIdx < numsSize; removeIdx++) {
        // Calculate sums of even and odd indices after removal
        int evenSum = 0;
        int oddSum = 0;
        int newIdx = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (i != removeIdx) {
                if (newIdx % 2 == 0) {
                    evenSum += nums[i];
                } else {
                    oddSum += nums[i];
                }
                newIdx++;
            }
        }
        
        if (evenSum == oddSum) {
            count++;
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop runs n times, inner sum calculation takes O(n) time

✓ Linear Growth

Space Complexity

O(n)

Creates new array of size n-1 for each removal attempt

✓ Linear Space

32.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler