Count ways to make sum of odd and even indexed elements equal by removing an array element

Given an array, arr[] of size N, the task is to find the count of array indices such that removing an element from these indices makes the sum of even-indexed and odd-indexed array elements equal.

Examples:

Input: arr[] = { 2, 1, 6, 4 } 
Output:
Explanation: 
Removing arr[1] from the array modifies arr[] to { 2, 6, 4 } such that, arr[0] + arr[2] = arr[1]. 
Therefore, the required output is 1. 

Input: arr[] = { 1, 1, 1 } 
Output:
Explanation: 
Removing arr[0] from the given array modifies arr[] to { 1, 1 } such that arr[0] = arr[1] 
Removing arr[1] from the given array modifies arr[] to { 1, 1 } such that arr[0] = arr[1] 
Removing arr[2] from the given array modifies arr[] to { 1, 1 } such that arr[0] = arr[1] 
Therefore, the required output is 3.

Naive Approach: The simplest approach to solve this problem is to traverse the array and for each array element, check if removing the element from the array makes the sum of even-indexed and odd-indexed array elements equal or not. If found to be true, then increment the count. Finally, print the count.



Time Complexity: O(N2) 
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized based on the observation that removing any element from the given array makes even indices of succeeding elements as odd and odd indices of the succeeding elements as even. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count array indices
// whose removal makes sum of odd and
// even indexed elements equal
int cntIndexesToMakeBalance(int arr[], int n)
{
 
    // If size of the array is 1
    if (n == 1) {
        return 1;
    }
 
    // If size of the array is 2
    if (n == 2)
        return 0;
 
    // Stores sum of even-indexed
    // elements of the given array
    int sumEven = 0;
 
    // Stores sum of odd-indexed
    // elements of the given array
    int sumOdd = 0;
 
    // Traverse the array
    for (int i = 0; i < n; i++) {
 
        // If i is an even number
        if (i % 2 == 0) {
 
            // Update sumEven
            sumEven += arr[i];
        }
 
        // If i is an odd number
        else {
 
            // Update sumOdd
            sumOdd += arr[i];
        }
    }
 
    // Stores sum of even-indexed
    // array elements till i-th index
    int currOdd = 0;
 
    // Stores sum of odd-indexed
    // array elements till i-th index
    int currEven = arr[0];
 
    // Stores count of indices whose
    // removal makes sum of odd and
    // even indexed elements equal
    int res = 0;
 
    // Stores sum of even-indexed elements
    // after removing the i-th element
    int newEvenSum = 0;
 
    // Stores sum of odd-indexed elements
    // after removing the i-th element
    int newOddSum = 0;
 
    // Traverse the array
    for (int i = 1; i < n - 1; i++) {
 
        // If i is an odd number
        if (i % 2) {
 
            // Update currOdd
            currOdd += arr[i];
 
            // Update newEvenSum
            newEvenSum = currEven + sumOdd
                         - currOdd;
 
            // Update newOddSum
            newOddSum = currOdd + sumEven
                        - currEven - arr[i];
        }
 
        // If i is an even number
        else {
 
            // Update currEven
            currEven += arr[i];
 
            // Update newOddSum
            newOddSum = currOdd + sumEven
                        - currEven;
 
            // Update newEvenSum
            newEvenSum = currEven + sumOdd
                         - currOdd - arr[i];
        }
 
        // If newEvenSum is equal to newOddSum
        if (newEvenSum == newOddSum) {
 
            // Increase the count
            res++;
        }
    }
 
    // If sum of even-indexed and odd-indexed
    // elements is equal by removing the last element
    if (sumOdd == sumEven - arr[0]) {
 
        // Increase the count
        res++;
    }
 
    // If length of the array
    // is an odd number
    if (n % 2 == 1) {
 
        // If sum of even-indexed and odd-indexed
        // elements is equal by removing the last element
        if (sumOdd == sumEven - arr[n - 1]) {
 
            // Increase the count
            res++;
        }
    }
 
    // If length of the array
    // is an even number
    else {
 
        // If sum of even-indexed and odd-indexed
        // elements is equal by removing the last element
        if (sumEven == sumOdd - arr[n - 1]) {
 
            // Increase the count
            res++;
        }
    }
 
    return res;
}
 
// Driver Code
int main()
{
 
    int arr[] = { 1, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << cntIndexesToMakeBalance(arr, n);
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
class GFG {
     
    // Function to count array indices
    // whose removal makes sum of odd and
    // even indexed elements equal
    static int cntIndexesToMakeBalance(int arr[], int n)
    {
     
        // If size of the array is 1
        if (n == 1)
        {
            return 1;
        }
     
        // If size of the array is 2
        if (n == 2)
            return 0;
     
        // Stores sum of even-indexed
        // elements of the given array
        int sumEven = 0;
     
        // Stores sum of odd-indexed
        // elements of the given array
        int sumOdd = 0;
     
        // Traverse the array
        for (int i = 0; i < n; i++)
        {
     
            // If i is an even number
            if (i % 2 == 0)
            {
     
                // Update sumEven
                sumEven += arr[i];
            }
     
            // If i is an odd number
            else
            {
     
                // Update sumOdd
                sumOdd += arr[i];
            }
        }
     
        // Stores sum of even-indexed
        // array elements till i-th index
        int currOdd = 0;
     
        // Stores sum of odd-indexed
        // array elements till i-th index
        int currEven = arr[0];
     
        // Stores count of indices whose
        // removal makes sum of odd and
        // even indexed elements equal
        int res = 0;
     
        // Stores sum of even-indexed elements
        // after removing the i-th element
        int newEvenSum = 0;
     
        // Stores sum of odd-indexed elements
        // after removing the i-th element
        int newOddSum = 0;
     
        // Traverse the array
        for (int i = 1; i < n - 1; i++)
        {
     
            // If i is an odd number
            if (i % 2 != 0)
            {
     
                // Update currOdd
                currOdd += arr[i];
     
                // Update newEvenSum
                newEvenSum = currEven + sumOdd
                             - currOdd;
     
                // Update newOddSum
                newOddSum = currOdd + sumEven
                            - currEven - arr[i];
            }
     
            // If i is an even number
            else
            {
     
                // Update currEven
                currEven += arr[i];
     
                // Update newOddSum
                newOddSum = currOdd + sumEven
                            - currEven;
     
                // Update newEvenSum
                newEvenSum = currEven + sumOdd
                             - currOdd - arr[i];
            }
     
            // If newEvenSum is equal to newOddSum
            if (newEvenSum == newOddSum)
            {
     
                // Increase the count
                res++;
            }
        }
     
        // If sum of even-indexed and odd-indexed
        // elements is equal by removing the last element
        if (sumOdd == sumEven - arr[0])
        {
     
            // Increase the count
            res++;
        }
     
        // If length of the array
        // is an odd number
        if (n % 2 == 1)
        {
     
            // If sum of even-indexed and odd-indexed
            // elements is equal by removing the last element
            if (sumOdd == sumEven - arr[n - 1])
            {
     
                // Increase the count
                res++;
            }
        }
     
        // If length of the array
        // is an even number
        else
        {
     
            // If sum of even-indexed and odd-indexed
            // elements is equal by removing the last element
            if (sumEven == sumOdd - arr[n - 1])
            {
     
                // Increase the count
                res++;
            }
        }
     
        return res;
    }
     
    // Driver Code
   public static void main (String[] args)
    {  
        int arr[] = { 1, 1, 1 };
        int n = arr.length;
        System.out.println(cntIndexesToMakeBalance(arr, n));
    }
}
 
// This code is contributed by AnkitRai01
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
# Function to count array indices
# whose removal makes sum of odd and
# even indexed elements equal
def cntIndexesToMakeBalance(arr, n):
 
    # If size of the array is 1
    if (n == 1):
        return 1
 
    # If size of the array is 2
    if (n == 2):
        return 0
 
    # Stores sum of even-indexed
    # elements of the given array
    sumEven = 0
 
    # Stores sum of odd-indexed
    # elements of the given array
    sumOdd = 0
 
    # Traverse the array
    for i in range(n):
 
        # If i is an even number
        if (i % 2 == 0):
 
            # Update sumEven
            sumEven += arr[i]
 
        # If i is an odd number
        else:
 
            # Update sumOdd
            sumOdd += arr[i]
 
    # Stores sum of even-indexed
    # array elements till i-th index
    currOdd = 0
 
    # Stores sum of odd-indexed
    # array elements till i-th index
    currEven = arr[0]
 
    # Stores count of indices whose
    # removal makes sum of odd and
    # even indexed elements equal
    res = 0
     
    # Stores sum of even-indexed elements
    # after removing the i-th element
    newEvenSum = 0
 
    # Stores sum of odd-indexed elements
    # after removing the i-th element
    newOddSum = 0
 
    # Traverse the array
    for i in range(1, n - 1):
 
        # If i is an odd number
        if (i % 2):
             
            # Update currOdd
            currOdd += arr[i]
 
            # Update newEvenSum
            newEvenSum = (currEven + sumOdd -
                          currOdd)
 
            # Update newOddSum
            newOddSum = (currOdd + sumEven -
                        currEven - arr[i])
 
        # If i is an even number
        else:
 
            # Update currEven
            currEven += arr[i]
 
            # Update newOddSum
            newOddSum = (currOdd + sumEven -
                         currEven)
 
            # Update newEvenSum
            newEvenSum = (currEven + sumOdd -
                           currOdd - arr[i])
         
        # If newEvenSum is equal to newOddSum
        if (newEvenSum == newOddSum):
 
            # Increase the count
            res += 1
 
    # If sum of even-indexed and odd-indexed
    # elements is equal by removing the last
    # element
    if (sumOdd == sumEven - arr[0]):
 
        # Increase the count
        res += 1
 
    # If length of the array
    # is an odd number
    if (n % 2 == 1):
 
        # If sum of even-indexed and odd-indexed
        # elements is equal by removing the last
        # element
        if (sumOdd == sumEven - arr[n - 1]):
 
            # Increase the count
            res += 1
 
    # If length of the array
    # is an even number
    else:
 
        # If sum of even-indexed and odd-indexed
        # elements is equal by removing the last
        # element
        if (sumEven == sumOdd - arr[n - 1]):
 
            # Increase the count
            res += 1
 
    return res
 
# Driver Code
if __name__ == "__main__" :
 
    arr = [ 1, 1, 1 ]
    n = len(arr)
     
    print(cntIndexesToMakeBalance(arr, n))
     
# This code is contributed by AnkitRai01
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach 
using System;
 
class GFG {
      
    // Function to count array indices
    // whose removal makes sum of odd and
    // even indexed elements equal
    static int cntIndexesToMakeBalance(int[] arr, int n)
    {
      
        // If size of the array is 1
        if (n == 1)
        {
            return 1;
        }
      
        // If size of the array is 2
        if (n == 2)
            return 0;
      
        // Stores sum of even-indexed
        // elements of the given array
        int sumEven = 0;
      
        // Stores sum of odd-indexed
        // elements of the given array
        int sumOdd = 0;
      
        // Traverse the array
        for (int i = 0; i < n; i++)
        {
      
            // If i is an even number
            if (i % 2 == 0)
            {
      
                // Update sumEven
                sumEven += arr[i];
            }
      
            // If i is an odd number
            else
            {
      
                // Update sumOdd
                sumOdd += arr[i];
            }
        }
      
        // Stores sum of even-indexed
        // array elements till i-th index
        int currOdd = 0;
      
        // Stores sum of odd-indexed
        // array elements till i-th index
        int currEven = arr[0];
      
        // Stores count of indices whose
        // removal makes sum of odd and
        // even indexed elements equal
        int res = 0;
      
        // Stores sum of even-indexed elements
        // after removing the i-th element
        int newEvenSum = 0;
      
        // Stores sum of odd-indexed elements
        // after removing the i-th element
        int newOddSum = 0;
      
        // Traverse the array
        for (int i = 1; i < n - 1; i++)
        {
      
            // If i is an odd number
            if (i % 2 != 0)
            {
      
                // Update currOdd
                currOdd += arr[i];
      
                // Update newEvenSum
                newEvenSum = currEven + sumOdd
                             - currOdd;
      
                // Update newOddSum
                newOddSum = currOdd + sumEven
                            - currEven - arr[i];
            }
      
            // If i is an even number
            else
            {
      
                // Update currEven
                currEven += arr[i];
      
                // Update newOddSum
                newOddSum = currOdd + sumEven
                            - currEven;
      
                // Update newEvenSum
                newEvenSum = currEven + sumOdd
                             - currOdd - arr[i];
            }
      
            // If newEvenSum is equal to newOddSum
            if (newEvenSum == newOddSum)
            {
      
                // Increase the count
                res++;
            }
        }
      
        // If sum of even-indexed and odd-indexed
        // elements is equal by removing the last element
        if (sumOdd == sumEven - arr[0])
        {
      
            // Increase the count
            res++;
        }
      
        // If length of the array
        // is an odd number
        if (n % 2 == 1)
        {
      
            // If sum of even-indexed and odd-indexed
            // elements is equal by removing the last element
            if (sumOdd == sumEven - arr[n - 1])
            {
      
                // Increase the count
                res++;
            }
        }
      
        // If length of the array
        // is an even number
        else
        {
      
            // If sum of even-indexed and odd-indexed
            // elements is equal by removing the last element
            if (sumEven == sumOdd - arr[n - 1])
            {
      
                // Increase the count
                res++;
            }
        }
      
        return res;
    }
      
    // Drivers Code
    public static void Main ()
    {
        int[] arr = { 1, 1, 1 };
        int n = arr.Length;
        Console.WriteLine(cntIndexesToMakeBalance(arr, n));   
    }
  
}
 
// This code is contributed by susmitakundugoaldanga
chevron_right

Output: 
3

 

Time Complexity: O(N) 
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




Article Tags :
Practice Tags :