Open In App

# Print indices of array elements whose removal makes the sum of odd and even-indexed elements equal

Given an array arr[] of size N, the task is to find indices of array elements whose removal makes the sum of odd and even indexed elements equal. If no such element exists, then print -1.

Examples:

Input: arr[] = {4, 1, 6, 2}
Output:
Explanation:
Removing arr[1] modifies arr[] to {4, 6, 2}
Sum of even-indexed array elements = arr[0] + arr[2] = 4 + 2 = 6
Sum of odd-indexed array elements = arr[1] = 6
Therefore, the required output is 1.

Input:arr = {3, 2, 1}
Output: -1

Naive Approach: The simplest approach to solve this problem to traverse the array and remove the ith element from the array and check if the sum of odd-indexed array elements equal to the sum of even-indexed array elements or not. If found to be true then print the index.

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

Efficient Approach: The above approach can be optimized using the Prefix Sum technique. The idea is to use the fact that If an array element removed from the index, then after that index, the even-indexed array elements become the odd-indexed and vice-versa. Follow the steps below to solve the problem:

• Initialize two arrays, say odd[] and even[], to store the prefix sum of odd and even-indexed array elements and prefix sum of even-indexed array elements respectively.
• Traverse the array arr[] and compute prefix sum of odd and even-indexed array elements.
• Initialize two variables, say P = 0 and Q = 0, to store the sum of even and odd-indexed array elements respectively after removal of an array element.
• Traverse the array and remove array elements one by one and update prefix sums accordingly. Check if the sum of even-indexed array elements, P, is equal to the sum of odd-indexed array elements, Q or not. If found to be true, then print the current index.
• Otherwise, print -1.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find indices of array elements``// whose removal makes the sum of odd and``// even indexed array elements equal``void` `removeIndicesToMakeSumEqual(vector<``int``>& arr)``{``    ``// Stores size of array``    ``int` `N = arr.size();` `    ``// Store prefix sum of odd``    ``// index array elements``    ``vector<``int``> odd(N, 0);` `    ``// Store prefix sum of even``    ``// index array elements``    ``vector<``int``> even(N, 0);` `    ``// Update even[0]``    ``even[0] = arr[0];` `    ``// Traverse the given array``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// Update odd[i]``        ``odd[i] = odd[i - 1];` `        ``// Update even[i]``        ``even[i] = even[i - 1];` `        ``// If the current index``        ``// is an even number``        ``if` `(i % 2 == 0) {` `            ``// Update even[i]``            ``even[i] += arr[i];``        ``}` `        ``// If the current index``        ``// is an odd number``        ``else` `{` `            ``// Update odd[i]``            ``odd[i] += arr[i];``        ``}``    ``}` `    ``// Check if at least one``    ``// index found or not that``    ``// satisfies the condition``    ``bool` `find = 0;` `    ``// Store odd indices sum by``    ``// removing 0-th index``    ``int` `p = odd[N - 1];` `    ``// Store even indices sum by``    ``// removing 0-th index``    ``int` `q = even[N - 1] - arr[0];` `    ``// If p and q are equal``    ``if` `(p == q) {``        ``cout << ``"0 "``;``        ``find = 1;``    ``}` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// If i is an even number``        ``if` `(i % 2 == 0) {` `            ``// Update p by removing``            ``// the i-th element``            ``p = even[N - 1] - even[i - 1]``                ``- arr[i] + odd[i - 1];` `            ``// Update q by removing``            ``// the i-th element``            ``q = odd[N - 1] - odd[i - 1]``                ``+ even[i - 1];``        ``}``        ``else` `{` `            ``// Update q by removing``            ``// the i-th element``            ``q = odd[N - 1] - odd[i - 1]``                ``- arr[i] + even[i - 1];` `            ``// Update p by removing``            ``// the i-th element``            ``p = even[N - 1] - even[i - 1]``                ``+ odd[i - 1];``        ``}` `        ``// If odd index values sum is equal``        ``// to even index values sum``        ``if` `(p == q) {` `            ``// Set the find variable``            ``find = 1;` `            ``// Print the current index``            ``cout << i << ``" "``;``        ``}``    ``}` `    ``// If no index found``    ``if` `(!find) {` `        ``// Print not possible``        ``cout << -1;``    ``}``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 4, 1, 6, 2 };``    ``removeIndicesToMakeSumEqual(arr);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find indices of array elements``// whose removal makes the sum of odd and``// even indexed array elements equal``static` `void` `removeIndicesToMakeSumEqual(``int` `[]arr)``{``    ` `    ``// Stores size of array``    ``int` `N = arr.length;` `    ``// Store prefix sum of odd``    ``// index array elements``    ``int` `[]odd = ``new` `int``[N];` `    ``// Store prefix sum of even``    ``// index array elements``    ``int` `[]even = ``new` `int``[N];` `    ``// Update even[0]``    ``even[``0``] = arr[``0``];` `    ``// Traverse the given array``    ``for``(``int` `i = ``1``; i < N; i++)``    ``{``        ` `        ``// Update odd[i]``        ``odd[i] = odd[i - ``1``];` `        ``// Update even[i]``        ``even[i] = even[i - ``1``];` `        ``// If the current index``        ``// is an even number``        ``if` `(i % ``2` `== ``0``)``        ``{``            ` `            ``// Update even[i]``            ``even[i] += arr[i];``        ``}` `        ``// If the current index``        ``// is an odd number``        ``else``        ``{``            ` `            ``// Update odd[i]``            ``odd[i] += arr[i];``        ``}``    ``}` `    ``// Check if at least one``    ``// index found or not that``    ``// satisfies the condition``    ``boolean` `find = ``false``;` `    ``// Store odd indices sum by``    ``// removing 0-th index``    ``int` `p = odd[N - ``1``];` `    ``// Store even indices sum by``    ``// removing 0-th index``    ``int` `q = even[N - ``1``] - arr[``0``];` `    ``// If p and q are equal``    ``if` `(p == q)``    ``{``        ``System.out.print(``"0 "``);``        ``find = ``true``;``    ``}` `    ``// Traverse the array arr[]``    ``for``(``int` `i = ``1``; i < N; i++)``    ``{``        ` `        ``// If i is an even number``        ``if` `(i % ``2` `== ``0``)``        ``{``            ` `            ``// Update p by removing``            ``// the i-th element``            ``p = even[N - ``1``] - even[i - ``1``] -``                     ``arr[i] + odd[i - ``1``];` `            ``// Update q by removing``            ``// the i-th element``            ``q = odd[N - ``1``] - odd[i - ``1``] +``               ``even[i - ``1``];``        ``}``        ``else``        ``{``            ` `            ``// Update q by removing``            ``// the i-th element``            ``q = odd[N - ``1``] - odd[i - ``1``] -``                    ``arr[i] + even[i - ``1``];` `            ``// Update p by removing``            ``// the i-th element``            ``p = even[N - ``1``] - even[i - ``1``] +``                 ``odd[i - ``1``];``        ``}` `        ``// If odd index values sum is equal``        ``// to even index values sum``        ``if` `(p == q)``        ``{` `            ``// Set the find variable``            ``find = ``true``;` `            ``// Print the current index``            ``System.out.print(i + ``" "``);``        ``}``    ``}` `    ``// If no index found``    ``if` `(!find)``    ``{``        ` `        ``// Print not possible``        ``System.out.print(-``1``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr = { ``4``, ``1``, ``6``, ``2` `};``    ` `    ``removeIndicesToMakeSumEqual(arr);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python program to implement``# the above approach` `# Function to find indices of array elements``# whose removal makes the sum of odd and``# even indexed array elements equal``def` `removeIndicesToMakeSumEqual(arr):``  ` `    ``# Stores size of array``    ``N ``=` `len``(arr);` `    ``# Store prefix sum of odd``    ``# index array elements``    ``odd ``=` `[``0``] ``*` `N;` `    ``# Store prefix sum of even``    ``# index array elements``    ``even ``=` `[``0``] ``*` `N;` `    ``# Update even[0]``    ``even[``0``] ``=` `arr[``0``];` `    ``# Traverse the given array``    ``for` `i ``in` `range``(``1``, N):` `        ``# Update odd[i]``        ``odd[i] ``=` `odd[i ``-` `1``];` `        ``# Update even[i]``        ``even[i] ``=` `even[i ``-` `1``];` `        ``# If the current index``        ``# is an even number``        ``if` `(i ``%` `2` `=``=` `0``):` `            ``# Update even[i]``            ``even[i] ``+``=` `arr[i];` `        ``# If the current index``        ``# is an odd number``        ``else``:` `            ``# Update odd[i]``            ``odd[i] ``+``=` `arr[i];` `    ``# Check if at least one``    ``# index found or not that``    ``# satisfies the condition``    ``find ``=` `False``;` `    ``# Store odd indices sum by``    ``# removing 0-th index``    ``p ``=` `odd[N ``-` `1``];` `    ``# Store even indices sum by``    ``# removing 0-th index``    ``q ``=` `even[N ``-` `1``] ``-` `arr[``0``];` `    ``# If p and q are equal``    ``if` `(p ``=``=` `q):``        ``print``(``"0 "``);``        ``find ``=` `True``;` `    ``# Traverse the array arr``    ``for` `i ``in` `range``(``1``, N):` `        ``# If i is an even number``        ``if` `(i ``%` `2` `=``=` `0``):` `            ``# Update p by removing``            ``# the i-th element``            ``p ``=` `even[N ``-` `1``] ``-` `even[i ``-` `1``] ``-` `arr[i] ``+` `odd[i ``-` `1``];` `            ``# Update q by removing``            ``# the i-th element``            ``q ``=` `odd[N ``-` `1``] ``-` `odd[i ``-` `1``] ``+` `even[i ``-` `1``];``        ``else``:` `            ``# Update q by removing``            ``# the i-th element``            ``q ``=` `odd[N ``-` `1``] ``-` `odd[i ``-` `1``] ``-` `arr[i] ``+` `even[i ``-` `1``];` `            ``# Update p by removing``            ``# the i-th element``            ``p ``=` `even[N ``-` `1``] ``-` `even[i ``-` `1``] ``+` `odd[i ``-` `1``];` `        ``# If odd index values sum is equal``        ``# to even index values sum``        ``if` `(p ``=``=` `q):``          ` `            ``# Set the find variable``            ``find ``=` `True``;` `            ``# Print the current index``            ``print``(i, end ``=` `"");` `    ``# If no index found``    ``if` `(find ``=``=` `False``):``      ` `        ``# Print not possible``        ``print``(``-``1``);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``4``, ``1``, ``6``, ``2``];` `    ``removeIndicesToMakeSumEqual(arr);` `    ``# This code is contributed by shikhasingrajput`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to find indices of array elements``// whose removal makes the sum of odd and``// even indexed array elements equal``static` `void` `removeIndicesToMakeSumEqual(``int` `[]arr)``{``    ` `    ``// Stores size of array``    ``int` `N = arr.Length;` `    ``// Store prefix sum of odd``    ``// index array elements``    ``int` `[]odd = ``new` `int``[N];` `    ``// Store prefix sum of even``    ``// index array elements``    ``int` `[]even = ``new` `int``[N];` `    ``// Update even[0]``    ``even[0] = arr[0];` `    ``// Traverse the given array``    ``for``(``int` `i = 1; i < N; i++)``    ``{``        ` `        ``// Update odd[i]``        ``odd[i] = odd[i - 1];` `        ``// Update even[i]``        ``even[i] = even[i - 1];` `        ``// If the current index``        ``// is an even number``        ``if` `(i % 2 == 0)``        ``{``            ` `            ``// Update even[i]``            ``even[i] += arr[i];``        ``}` `        ``// If the current index``        ``// is an odd number``        ``else``        ``{``            ` `            ``// Update odd[i]``            ``odd[i] += arr[i];``        ``}``    ``}` `    ``// Check if at least one``    ``// index found or not that``    ``// satisfies the condition``    ``bool` `find = ``false``;` `    ``// Store odd indices sum by``    ``// removing 0-th index``    ``int` `p = odd[N - 1];` `    ``// Store even indices sum by``    ``// removing 0-th index``    ``int` `q = even[N - 1] - arr[0];` `    ``// If p and q are equal``    ``if` `(p == q)``    ``{``        ``Console.Write(``"0 "``);``        ``find = ``true``;``    ``}` `    ``// Traverse the array arr[]``    ``for``(``int` `i = 1; i < N; i++)``    ``{``        ` `        ``// If i is an even number``        ``if` `(i % 2 == 0)``        ``{``            ` `            ``// Update p by removing``            ``// the i-th element``            ``p = even[N - 1] - even[i - 1] -``                     ``arr[i] + odd[i - 1];` `            ``// Update q by removing``            ``// the i-th element``            ``q = odd[N - 1] - odd[i - 1] +``               ``even[i - 1];``        ``}``        ``else``        ``{``            ` `            ``// Update q by removing``            ``// the i-th element``            ``q = odd[N - 1] - odd[i - 1] -``                    ``arr[i] + even[i - 1];` `            ``// Update p by removing``            ``// the i-th element``            ``p = even[N - 1] - even[i - 1] +``                 ``odd[i - 1];``        ``}` `        ``// If odd index values sum is equal``        ``// to even index values sum``        ``if` `(p == q)``        ``{` `            ``// Set the find variable``            ``find = ``true``;` `            ``// Print the current index``            ``Console.Write(i + ``" "``);``        ``}``    ``}` `    ``// If no index found``    ``if` `(!find)``    ``{``        ` `        ``// Print not possible``        ``Console.Write(-1);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int``[] arr = { 4, 1, 6, 2 };``    ` `    ``removeIndicesToMakeSumEqual(arr);``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`1`

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