Finding index with Superior Even-to-Odd Average

Given an array a[] of size N which consists of both positive and negative integers, the task is to find the index of the array for which the average of all the even elements on its LHS is Greater than the average of all the odd elements on its RHS (Follow 0-based Indexing).

Note:

• The First Index and Last Index Cannot be valid answers because the first index will not have any elements on its LHS as well as last index will not have any elements on its RHS.
• If there are multiple indices satisfying the above condition then return the smallest valid index as an answer.
• Else if there is no such index in the given array then return -1.

Examples:

Input: a[] = {4, 6, 1, 6, 5, 3}
Output: 1
Explanation: The average of even numbers in the array before index 1 is 4 (elements = {4}) and the average of odd numbers in array a[] after index 1 (elements = { 1, 3, 5} ) is 3. Here Floor Value Is Considered While calculating the average hence smallest valid index is 1.

Input: a[] = { 1,5,3,4,6}
Output: -1
Explanation: In the given array there is no such index that satisfies the above condition because

• LHS Even average for every index in the given array is {0, 0, 0, 0, 4}
• RHS Odd average for every index in the given array is {2, 3, 0, 0, 0}
• There is no such index that satisfies the given condition.
• Hence - 1 is the answer.

Approach: To solve the problem follow the below steps:

• Create an Prefix Even Average array and Suffix Odd Average array of length N.
• Iterate array a[] over loop from 0 to N-1 and use average variable to track the average of even numbers and assign PrefixEvenAverage[i]=average .
• If current number is even then add and update the average , do it for all indices of array a[]
• In a Similar Way iterate array a[] over loop from N-1 to 0 for calculating Suffix Odd Average array values.
• Initialize a answer variable with -1 for storing the answer.
• Then Check For Every index from 1 to N and if the index is satisfying the condition mentioned in question then store the index in answer variable and break the loop.
• Return The Answer.

Below is the code to implement the above approach:

// C++ code for the above approach:
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int findValidIndex(int a[], int n)
{

    // Initializing arrays for storing averages
    vector<int> prefixEvenAverage(n), suffixOddAverage(n);

    // Initializing all required variables
    int evenSum = 0, evenAverage = 0, evenLength = 0,
        oddSum = 0, oddAverage = 0, oddLength = 0,
        answer = -1;

    // Calculating prefix Even Averages for
    // every index i in array a[]
    for (int i = 0; i < n; i++) {
        prefixEvenAverage[i] = evenAverage;
        if (a[i] % 2 == 0) {
            evenSum = evenSum + a[i];
            evenLength++;
            evenAverage = evenSum / evenLength;
        }
    }

    // Calculating suffix Odd Averages for every
    // index i in array a[]
    for (int i = n - 1; i >= 0; i--) {
        suffixOddAverage[i] = oddAverage;
        if (a[i] % 2 != 0) {
            oddSum = oddSum + a[i];
            oddLength++;
            oddAverage = oddSum / oddLength;
        }
    }

    // Finding whether there is an valid
    // index or not
    for (int i = 1; i < n - 1; i++) {
        if (prefixEvenAverage[i] > suffixOddAverage[i]) {

            // If we found an valid index then
            // storing it on answer variable
            // and breaking the loop
            answer = i;
            break;
        }
    }

    // Returning the final answer
    return answer;
}

// Drivers code
int main()
{

    int a[] = { 4, 6, 1, 6, 5, 3 };
    int n = sizeof(a) / sizeof(a[0]);

    // Printing the answer
    cout << findValidIndex(a, n);
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;

class GFG {

    public static int findValidIndex(int[] a, int n)
    {

        // initializing arrays for storing averages

        List<Integer> prefixEvenAverage
            = new ArrayList<>(n);
        List<Integer> suffixOddAverage = new ArrayList<>(n);
        // initializing all required variables

        int evenSum = 0, evenAverage = 0, evenLength = 0,
            oddSum = 0, oddAverage = 0, oddLength = 0,
            answer = -1;

        // calculating prefix Even Averages for every index
        // i in array a[]

        for (int i = 0; i < n; i++) {
            prefixEvenAverage.add(evenAverage);
            if (a[i] % 2 == 0) {
                evenSum += a[i];
                evenLength++;
                evenAverage = evenSum / evenLength;
            }
        }
        // calculating suffix Odd Averages for every index i
        // in array a[]

        for (int i = n - 1; i >= 0; i--) {
            suffixOddAverage.add(oddAverage);
            if (a[i] % 2 != 0) {
                oddSum += a[i];
                oddLength++;
                oddAverage = oddSum / oddLength;
            }
        }
        // finding whether there is an valid index or not

        for (int i = 1; i < n - 1; i++) {
            // if we found an valid index then storing it on
            // answer variable and breaking the loop

            if (prefixEvenAverage.get(i)
                > suffixOddAverage.get(i)) {
                answer = i;
                break;
            }
        }
        // returning the final answer

        return answer;
    }

    public static void main(String[] args)
    {
        int[] a = { 4, 6, 1, 6, 5, 3 };
        int n = a.length;
        System.out.println(findValidIndex(a, n));
    }
}

def findValidIndex(arr):
    n = len(arr)

    # Initializing arrays for storing averages
    prefix_even_average = [0] * n
    suffix_odd_average = [0] * n

    # Initializing all required variables
    even_sum = 0
    even_average = 0
    even_length = 0
    odd_sum = 0
    odd_average = 0
    odd_length = 0
    answer = -1

    # Calculating prefix Even Averages for every index i in array arr
    for i in range(n):
        prefix_even_average[i] = even_average
        if arr[i] % 2 == 0:
            even_sum += arr[i]
            even_length += 1
            even_average = even_sum / even_length

    # Calculating suffix Odd Averages for every index i in array arr
    for i in range(n - 1, -1, -1):
        suffix_odd_average[i] = odd_average
        if arr[i] % 2 != 0:
            odd_sum += arr[i]
            odd_length += 1
            odd_average = odd_sum / odd_length

    # Finding whether there is a valid index or not
    for i in range(1, n - 1):
        if prefix_even_average[i] > suffix_odd_average[i]:
            # If we found a valid index then store it in the answer variable and break the loop
            answer = i
            break

    # Returning the final answer
    return answer

# Driver code
if __name__ == "__main__":
    arr = [4, 6, 1, 6, 5, 3]

    # Printing the answer
    print(findValidIndex(arr))

using System;
using System.Collections.Generic;

class GFG
{
    static int FindValidIndex(int[] a, int n)
    {
        // Initializing arrays for storing averages
        List<int> prefixEvenAverage = new List<int>(n);
        List<int> suffixOddAverage = new List<int>(n);

        // Initializing all required variables
        int evenSum = 0, evenAverage = 0, evenLength = 0,
            oddSum = 0, oddAverage = 0, oddLength = 0,
            answer = -1;

        // Calculating prefix Even Averages for every index i in array a[]
        for (int i = 0; i < n; i++)
        {
            prefixEvenAverage.Add(evenAverage);
            if (a[i] % 2 == 0)
            {
                evenSum += a[i];
                evenLength++;
                evenAverage = evenSum / evenLength;
            }
        }

        // Calculating suffix Odd Averages for every index i in array a[]
        for (int i = n - 1; i >= 0; i--)
        {
            suffixOddAverage.Insert(0, oddAverage); // Insert at the beginning to reverse the order
            if (a[i] % 2 != 0)
            {
                oddSum += a[i];
                oddLength++;
                oddAverage = oddSum / oddLength;
            }
        }

        // Finding whether there is a valid index or not
        for (int i = 1; i < n - 1; i++)
        {
            if (prefixEvenAverage[i] > suffixOddAverage[i])
            {
                // If we found a valid index, store it in the answer variable and break the loop
                answer = i;
                break;
            }
        }

        // Returning the final answer
        return answer;
    }

    static void Main()
    {
        int[] a = { 4, 6, 1, 6, 5, 3 };
        int n = a.Length;

        // Printing the answer
        Console.WriteLine(FindValidIndex(a, n));
    }
}
//Contributed by Aditi Tyagi

function findValidIndex(arr) {
    // Initializing arrays for storing averages
    const prefixEvenAverage = new Array(arr.length);
    const suffixOddAverage = new Array(arr.length);

    // Initializing all required variables
    let evenSum = 0;
    let evenAverage = 0;
    let evenLength = 0;
    let oddSum = 0;
    let oddAverage = 0;
    let oddLength = 0;
    let answer = -1;

    // Calculating prefix Even Averages for every index in the array
    for (let i = 0; i < arr.length; i++) {
        prefixEvenAverage[i] = evenAverage;
        if (arr[i] % 2 === 0) {
            evenSum += arr[i];
            evenLength++;
            evenAverage = evenSum / evenLength;
        }
    }

    // Calculating suffix Odd Averages for every index in the array
    for (let i = arr.length - 1; i >= 0; i--) {
        suffixOddAverage[i] = oddAverage;
        if (arr[i] % 2 !== 0) {
            oddSum += arr[i];
            oddLength++;
            oddAverage = oddSum / oddLength;
        }
    }

    // Finding whether there is a valid index or not
    for (let i = 1; i < arr.length - 1; i++) {
        if (prefixEvenAverage[i] > suffixOddAverage[i]) {
            // If we found a valid index, store it in the answer variable and break the loop
            answer = i;
            break;
        }
    }

    // Returning the final answer
    return answer;
}

// Driver code
const a = [4, 6, 1, 6, 5, 3];
console.log(findValidIndex(a));

// This code is contributed by Taranpreet Singh.

1

Time Complexity: O(N), where N is the length of the array.
Auxiliary Space: O(N), where N is the length of the array.