Ways to Make a Fair Array - Practice Coding Problems

Ways to Make a Fair Array - Problem

Ways to Make a Fair Array

You are given an integer array nums. Your goal is to find how many elements you can remove to make the array "fair".

Here's what happens when you remove an element:
• Choose exactly one index (0-indexed) and remove that element
• All elements after the removed index shift left by one position
• The array becomes shorter by one element

What makes an array fair?
An array is fair if the sum of elements at odd indices equals the sum of elements at even indices.

Example walkthrough:
Given nums = [6,1,7,4,1]:
• Remove index 1 → [6,7,4,1] → even sum: 6+4=10, odd sum: 7+1=8 → not fair
• Remove index 2 → [6,1,4,1] → even sum: 6+4=10, odd sum: 1+1=2 → not fair
• Remove index 4 → [6,1,7,4] → even sum: 6+7=13, odd sum: 1+4=5 → not fair

Return the count of indices whose removal would make the array fair.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Remove index 0: [1,6,4] → even_sum=1+4=5, odd_sum=6, not fair. Remove index 1: [2,6,4] → even_sum=2+4=6, odd_sum=6, fair! Remove index 2: [2,1,4] → even_sum=2+4=6, odd_sum=1, not fair. Remove index 3: [2,1,6] → even_sum=2+6=8, odd_sum=1, not fair. Only 1 way to make it fair.

example_2.py — Multiple Solutions

$ Input: [1,1,1]

› Output: 3

💡 Note: Remove index 0: [1,1] → even_sum=1, odd_sum=1, fair. Remove index 1: [1,1] → even_sum=1, odd_sum=1, fair. Remove index 2: [1,1] → even_sum=1, odd_sum=1, fair. All 3 removals make it fair since all elements are equal.

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: Remove the only element: [] → even_sum=0, odd_sum=0, fair by definition (empty sums are equal). So there's 1 way to make it fair.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Weights [6,1,7,4,1] are placed: Left pan gets 6,7,1 (even indices), Right pan gets 1,4 (odd indices)

Remove Weight

When we remove weight at position 1 (value=1), all weights after it jump to opposite pans

Recalculate Balance

New arrangement: Left pan has 6,4 (total=10), Right pan has 7,1 (total=8). Not balanced!

Try All Positions

Repeat this process for each position to find all balanced configurations

Key Takeaway

🎯 Key Insight: When you remove an element, all subsequent elements flip their index parity (even→odd, odd→even), allowing O(1) calculation using prefix sums!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we iterate through up to n-1 elements to calculate sums

⚠ Quadratic Growth

Space Complexity

O(n)

We create a new array of size n-1 for each removal simulation

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
The array contains at least one element
Index-based: Array uses 0-based indexing

Asked in

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

The optimal solution uses prefix sums to track cumulative even and odd indexed elements, then leverages the key insight that removing an element causes all subsequent elements to flip their index parity. This allows us to calculate the resulting sums in O(1) time per removal, achieving overall O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate Each Removal)	O(n²)	O(n)	For each index, simulate removing it and check if resulting array is fair
Two-Pass Prefix Sum Optimization	O(n)	O(n)	Pre-calculate prefix sums, then use them to quickly determine fairness for each removal

Brute Force (Simulate Each Removal) — Algorithm Steps

Iterate through each index i in the array
Create a new array without element at index i
Calculate sum of even-indexed elements in new array
Calculate sum of odd-indexed elements in new array
If sums are equal, increment counter
Return the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with the original array [6,1,7,4,1]

Remove Index 0

Create [1,7,4,1], check even_sum=1+4=5, odd_sum=7+1=8, not fair

Remove Index 1

Create [6,7,4,1], check even_sum=6+4=10, odd_sum=7+1=8, not fair

Remove Index 2

Create [6,1,4,1], check even_sum=6+4=10, odd_sum=1+1=2, not fair

Continue Process

Keep trying each index until we find all fair removals

Code -

solution.c — C

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

int waysToMakeFair(int* nums, int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        int evenSum = 0, oddSum = 0;
        int index = 0;
        
        for (int j = 0; j < n; j++) {
            if (j == i) continue; // Skip removed element
            
            if (index % 2 == 0) evenSum += nums[j];
            else oddSum += nums[j];
            index++;
        }
        
        if (evenSum == oddSum) count++;
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    // Simple input parsing
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", waysToMakeFair(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we iterate through up to n-1 elements to calculate sums

⚠ Quadratic Growth

Space Complexity

O(n)

We create a new array of size n-1 for each removal simulation

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
The array contains at least one element
Index-based: Array uses 0-based indexing

20.0K Views

Medium Frequency

~25 min Avg. Time

847 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 (Simulate Each Removal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler