Skip to content
Related Articles

Related Articles

Improve Article

Length of longest Subarray with equal number of odd and even elements

  • Last Updated : 27 May, 2021

Given an integer array arr[], the task is to find the length of the longest subarray with an equal number of odd and even elements.

Examples:

Input: arr[] = {1, 2, 1, 2}
Output: 4 
Explanation: 
Subarrays in the given array are – 
{{1}, {1, 2}, {1, 2, 1}, {1, 2, 1, 2}, {2}, {2, 1}, {2, 1, 2}, {1}, {1, 2}, {2}} 
where the length of the longest subarray with an equal number of even and odd elements is 4 – {1, 2, 1, 2}

Input: arr[] = {12, 4, 7, 8, 9, 2, 11, 0, 2, 13} 
Output: 8  

Naive Approach: Simple solution is to consider all subarrays one by one and check the count of even and odd elements in the subarray and find the maximum out of those subarrays. 
Time Complexity: O(N2) 
 



Efficient Approach: The idea is to consider the odd elements as 1 and even elements as -1 and return the length of the longest sub-array with the sum equal to 0. The subarray with a given sum can be found using this method. 
Time Complexity: O(N) 
Below is the implementation of the above approach: 

C++




// C++ program to find the length
// of the longest sub-array with an
// equal number of odd and even elements
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns the length of
// the longest sub-array with an equal
// number of odd and even elements
int maxSubarrayLength(int* A, int N)
{
    // Initialize variable to store result
    int maxLen = 0;
 
    // Initialize variable to store sum
    int curr_sum = 0;
 
    // Create an empty map to store
    // index of the sum
    unordered_map<int, int> hash;
 
    // Loop through the array
    for (int i = 0; i < N; i++) {
        if (A[i] % 2 == 0)
            curr_sum -= 1;
        else
            curr_sum += 1;
 
        // Check if number of even and
        // odd elements are equal
        if (curr_sum == 0)
            maxLen = max(maxLen, i + 1);
 
        // If curr_sum already exists in map
        // we have a subarray with 0 sum, i.e,
        // equal number of odd and even number
        if (hash.find(curr_sum) != hash.end())
            maxLen = max(maxLen,
                        i - hash[curr_sum]);
 
        // Store the index of the sum
        else
            hash[curr_sum] = i;
    }
    return maxLen;
}
 
// Driver Code
int main()
{
    int arr[] = { 12, 4, 7, 8, 9, 2,
                        11, 0, 2, 13 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << maxSubarrayLength(arr, n);
 
    return 0;
}
Java



// Java program to find the length
// of the longest sub-array with an
// equal number of odd and even elements
import java.util.*;
 
class GFG
{
 
// Function that returns the length of
// the longest sub-array with an equal
// number of odd and even elements
static int maxSubarrayLength(int []A, int N)
{
    // Initialize variable to store result
    int maxLen = 0;
 
    // Initialize variable to store sum
    int curr_sum = 0;
 
    // Create an empty map to store
    // index of the sum
    HashMap<Integer,Integer> hash = new HashMap<Integer,Integer>();
 
    // Loop through the array
    for (int i = 0; i < N; i++)
    {
        if (A[i] % 2 == 0)
            curr_sum -= 1;
        else
            curr_sum += 1;
 
        // Check if number of even and
        // odd elements are equal
        if (curr_sum == 0)
            maxLen = Math.max(maxLen, i + 1);
 
        // If curr_sum already exists in map
        // we have a subarray with 0 sum, i.e,
        // equal number of odd and even number
        if (hash.containsKey(curr_sum))
            maxLen = Math.max(maxLen,
                        i - hash.get(curr_sum));
 
        // Store the index of the sum
        else {
            hash.put(curr_sum, i);
        }
    }
    return maxLen;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 12, 4, 7, 8, 9, 2,
                        11, 0, 2, 13 };
    int n = arr.length;
 
    System.out.print(maxSubarrayLength(arr, n));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 program to find the length
# of the longest sub-array with an
# equal number of odd and even elements
 
# Function that returns the length of
# the longest sub-array with an equal
# number of odd and even elements
def maxSubarrayLength(A, N) :
 
    # Initialize variable to store result
    maxLen = 0;
 
    # Initialize variable to store sum
    curr_sum = 0;
 
    # Create an empty map to store
    # index of the sum
    hash = {};
 
    # Loop through the array
    for i in range(N) :
        if (A[i] % 2 == 0) :
            curr_sum -= 1;
        else :
            curr_sum += 1;
 
        # Check if number of even and
        # odd elements are equal
        if (curr_sum == 0) :
            maxLen = max(maxLen, i + 1);
 
        # If curr_sum already exists in map
        # we have a subarray with 0 sum, i.e,
        # equal number of odd and even number
        if curr_sum in hash :
            maxLen = max(maxLen, i - hash[curr_sum]);
 
        # Store the index of the sum
        else :
            hash[curr_sum] = i;
     
    return maxLen;
 
# Driver Code
if __name__ == "__main__" :
 
    arr = [ 12, 4, 7, 8, 9, 2, 11, 0, 2, 13 ];
    n = len(arr);
 
    print(maxSubarrayLength(arr, n));
 
# This code is contributed by AnkitRai01
C#



// C# program to find the length
// of the longest sub-array with an
// equal number of odd and even elements
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function that returns the length of
// the longest sub-array with an equal
// number of odd and even elements
static int maxSubarrayLength(int []A, int N)
{
    // Initialize variable to store result
    int maxLen = 0;
 
    // Initialize variable to store sum
    int curr_sum = 0;
 
    // Create an empty map to store
    // index of the sum
    Dictionary<int, int> hash = new Dictionary<int, int>();
 
    // Loop through the array
    for (int i = 0; i < N; i++)
    {
        if (A[i] % 2 == 0)
            curr_sum -= 1;
        else
            curr_sum += 1;
 
        // Check if number of even and
        // odd elements are equal
        if (curr_sum == 0)
            maxLen = Math.Max(maxLen, i + 1);
 
        // If curr_sum already exists in map
        // we have a subarray with 0 sum, i.e,
        // equal number of odd and even number
        if (hash.ContainsKey(curr_sum))
            maxLen = Math.Max(maxLen,
                        i - hash[curr_sum]);
 
        // Store the index of the sum
        else {
            hash.Add(curr_sum, i);
        }
    }
    return maxLen;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 12, 4, 7, 8, 9, 2,
                        11, 0, 2, 13 };
    int n = arr.Length;
    Console.Write(maxSubarrayLength(arr, n));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// Javascript program to find the length
// of the longest sub-array with an
// equal number of odd and even elements
 
// Function that returns the length of
// the longest sub-array with an equal
// number of odd and even elements
function maxSubarrayLength(A, N)
{
    // Initialize variable to store result
    var maxLen = 0;
 
    // Initialize variable to store sum
    var curr_sum = 0;
 
    // Create an empty map to store
    // index of the sum
    var hash = new Map();
 
    // Loop through the array
    for (var i = 0; i < N; i++) {
        if (A[i] % 2 == 0)
            curr_sum -= 1;
        else
            curr_sum += 1;
 
        // Check if number of even and
        // odd elements are equal
        if (curr_sum == 0)
            maxLen = Math.max(maxLen, i + 1);
 
        // If curr_sum already exists in map
        // we have a subarray with 0 sum, i.e,
        // equal number of odd and even number
        if (hash.has(curr_sum))
            maxLen = Math.max(maxLen,
                        i - hash.get(curr_sum));
 
        // Store the index of the sum
        else
            hash.set(curr_sum, i);
    }
    return maxLen;
}
 
// Driver Code
var arr = [12, 4, 7, 8, 9, 2,
                    11, 0, 2, 13 ];
var n = arr.length;
document.write( maxSubarrayLength(arr, n));
 
</script>
Output: 
8
 



My Personal Notes
arrow_drop_up
Previous
R-CNN | Region Based CNNs
Next

7 Best Coding Challenge Websites in 2020
Recommended Articles
Page :
Length of the longest alternating even odd subarray
21, May 20
Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays
16, Dec 20
Count of integers in a range which have even number of odd digits and odd number of even digits
21, Aug 19
Longest subarray with all even or all odd elements
30, Jul 21
Length of the longest Subarray with only Even Elements
22, Oct 18
Even numbers at even index and odd numbers at odd index
28, Oct 17
Maximum length of subarray such that all elements are equal in the subarray
20, Jun 20
Largest element in the longest Subarray consisting of only Even or only Odd numbers
09, Dec 20
Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal
02, Dec 20
Maximum length of subarray such that sum of the subarray is even
25, Apr 19
Print indices of array elements whose removal makes the sum of odd and even-indexed elements equal
11, Dec 20
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Count of odd and even parity elements in subarray using MO's algorithm
04, May 20
Query to count odd and even parity elements in subarray after XOR with K
22, May 20
Count number of even and odd length elements in an Array
05, Apr 20
Length of longest subarray of length at least 2 with maximum GCD
07, May 20
Number of permutations such that sum of elements at odd index and even index are equal
02, Jul 18
Construct an Array of size N in which sum of odd elements is equal to sum of even elements
22, Apr 20
Length of longest subarray having frequency of every element equal to K
11, Nov 20
Length of longest subarray with product greater than or equal to 0
01, Apr 20
Length of longest subarray with product equal to a power of 2
19, Oct 20
Length of longest Palindromic Subsequence of even length with no two adjacent characters same
04, Feb 20
Maximum partitions possible of given Array with cost at most K and equal count of odd and even elements
21, Jun 21
Maximum sum of even indexed elements obtained by right shift on an even sized subarray
30, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rupesh_rao
@rupesh_rao
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox