Given an array a[] of N integers, the task is to find the length of the longest Alternating Even Odd subarray present in the array.
Examples:
Input: a[] = {1, 2, 3, 4, 5, 7, 9}
Output: 5
Explanation:
The subarray {1, 2, 3, 4, 5} has alternating even and odd elements.Input: a[] = {1, 3, 5}
Output: 0
Explanation:
There is no such alternating sequence possible.
Naive approach:
The idea is to consider every subarray and find the length of even and odd subarrays.
Follow the steps below to solve the problem:
- Iterate for every subarray from i = 0
- Make a nested loop, iterate from j = i + 1
- Now, check if a[j – 1] is even and a[j] is odd or a[j – 1] is odd and a[j] is even then increment count
- Maintain an answer variable which calculates max count so far
Below is the implementation of the above approach:
#include <iostream> using namespace std;
// Function to find the longest subarray int longestEvenOddSubarray( int a[], int n)
{ // Length of longest
// alternating subarray
int ans = 1;
// Iterate in the array
for ( int i = 0; i < n; i++) {
int cnt = 1;
// Iterate for every subarray
for ( int j = i + 1; j < n; j++) {
if ((a[j - 1] % 2 == 0 && a[j] % 2 != 0)
|| (a[j - 1] % 2 != 0 && a[j] % 2 == 0))
cnt++;
else
break ;
}
// store max count
ans = max(ans, cnt);
}
// Length of 'ans' can never be 1
// since even odd has to occur in pair or more
// so return 0 if ans = 1
if (ans == 1)
return 0;
return ans;
} /* Driver code*/ int main()
{ int a[] = { 1, 2, 3, 4, 5, 7, 8 };
int n = sizeof (a) / sizeof (a[0]);
cout << longestEvenOddSubarray(a, n);
return 0;
} |
// Java program for above approach import java.io.*;
import java.util.ArrayList;
import java.util.List;
// Function to check if it is possible // to make the array elements consecutive public class GfG {
// Function to find the longest subarray
static int longestEvenOddSubarray(ArrayList<Integer> a,
int n)
{
// Length of longest
// alternating subarray
int ans = 1 ;
// Iterate in the array
for ( int i = 0 ; i < n; i++) {
int cnt = 1 ;
// Iterate for every subarray
for ( int j = i + 1 ; j < n; j++) {
if ((a.get(j - 1 ) % 2 == 0
&& a.get(j) % 2 != 0 )
|| (a.get(j - 1 ) % 2 != 0
&& a.get(j) % 2 == 0 ))
cnt++;
else
break ;
}
// store max count
ans = Math.max(ans, cnt);
}
// Length of 'ans' can never be 1
// since even odd has to occur in pair or more
// so return 0 if ans = 1
if (ans == 1 )
return 0 ;
return ans;
}
// Drivers code
public static void main(String args[])
{
ArrayList<Integer> a = new ArrayList<Integer>(
List.of( 1 , 2 , 3 , 4 , 5 , 7 , 8 ));
int n = a.size();
System.out.println(longestEvenOddSubarray(a, n));
}
} // This code is contributed by shinjanpatra |
import math
# Function to find the longest subarray def longestEvenOddSubarray(a, n):
# Length of longest
# alternating subarray
ans = 1
# Iterate in the array
for i in range (n):
cnt = 1
# Iterate for every subarray
for j in range (i + 1 , n):
if ((a[j - 1 ] % 2 = = 0 and a[j] % 2 ! = 0 )
or (a[j - 1 ] % 2 ! = 0 and a[j] % 2 = = 0 )):
cnt = cnt + 1
else :
break
# store max count
ans = max (ans, cnt)
# Length of 'longest' can never be 1 since
# even odd has to occur in pair or more
# so return 0 if longest = 1
if (ans = = 1 ):
return 0
return ans
# Driver code a = [ 1 , 2 , 3 , 4 , 5 , 7 , 8 ]
n = len (a)
print (longestEvenOddSubarray(a, n))
# This code is contributed by shinjanpatra. |
// C# program for above approach using System;
using System.Collections.Generic;
// Function to check if it is possible // to make the array elements consecutive public class GfG {
// Function to find the longest subarray
static int longestEvenOddSubarray(List< int > a, int n)
{
// Length of longest
// alternating subarray
int ans = 1;
// Iterate in the array
for ( int i = 0; i < n; i++) {
int cnt = 1;
// Iterate for every subarray
for ( int j = i + 1; j < n; j++) {
if ((a[j - 1] % 2 == 0 && a[j] % 2 != 0)
|| (a[j - 1] % 2 != 0 && a[j] % 2 == 0))
cnt++;
else
break ;
}
// store max count
ans = Math.Max(ans, cnt);
}
// Length of 'ans' can never be 1
// since even odd has to occur in pair or more
// so return 0 if ans = 1
if (ans == 1)
return 0;
return ans;
}
// Drivers code
public static void Main( string [] args)
{
List< int > a = new List< int >{ 1, 2, 3, 4, 5, 7, 8 };
int n = a.Count;
Console.WriteLine(longestEvenOddSubarray(a, n));
}
} // This code is contributed by phasing17 |
<script> // Function to find the longest subarray function longestEvenOddSubarray(a, n)
{ // Length of longest
// alternating subarray
let ans = 1;
// Iterate in the array
for (let i = 0; i < n ; i++) {
let cnt = 1;
// Iterate for every subarray
for (let j = i + 1; j < n; j++) {
if ((a[j - 1] % 2 == 0 && a[j] % 2 != 0)
|| (a[j - 1] % 2 != 0 && a[j] % 2 == 0))
cnt++;
else
break ;
}
// store max count
ans = Math.max(ans, cnt);
}
// Length of 'ans' can never be 1
// since even odd has to occur in pair or more
// so return 0 if ans = 1
if (ans == 1)
return 0;
return ans;
} /* Driver code*/ let a = [ 1, 2, 3, 4, 5, 7, 8 ]; let n = a.length; document.write(longestEvenOddSubarray(a, n), "</br>" );
// This code is contributed by shinjanpatra. </script> |
5
Time Complexity: O(N2), Iterating over every subarray therefore N2 are possible
Auxiliary Space: O(1)
Length of the longest alternating even odd subarray by Checking Parity of Sum:
Observe that the Sum of two even numbers is even, the Sum of two odd numbers is even but the sum of one even and one odd number is odd.
Follow the steps below to solve the problem:
- Initially initialize cnt a counter to store the length as 1.
- Iterate among the array elements, and check if consecutive elements have an odd sum.
- Increase the cnt by 1 if it has an odd sum.
- If it does not has an odd sum, then re-initialize cnt by 1.
- The function should return at least value 1 if there are elements in the array, because there can always be a subarray with length 1 which has either odd or even element.
Below is the implementation of the above approach:
// C++ program to find the Length of the // longest alternating even odd subarray #include <bits/stdc++.h> using namespace std;
// Function to find the longest subarray int longestEvenOddSubarray( int arr[], int n)
{ // Length of longest
// alternating subarray
int count = 1;
int maxcount = 1;
for ( int i = 0; i < n - 1; i++) {
if (arr[i] % 2 == 0 && arr[i + 1] % 2 != 0) {
count++;
}
if (arr[i] % 2 != 0 && arr[i + 1] % 2 == 0) {
count++;
}
if (arr[i] % 2 == 0 && arr[i + 1] % 2 == 0) {
count = 1;
}
if (arr[i] % 2 != 0 && arr[i + 1] % 2 != 0) {
count = 1;
}
maxcount = max(maxcount, count);
}
// Length of 'maxcount' can be 1 as well because we want length of longest subarray
// which has alternate even-odd or vice-versa elements. It is not mentioned that
// they have to occur in pair.
return maxcount;
} /* Driver code*/ int main()
{ int arr[] = { 1, 2, 3, 4, 5, 7, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << longestEvenOddSubarray(arr, n);
return 0;
} |
// Java program to find the Length of the // longest alternating even odd subarray import java.util.*;
class GFG {
// Function to find the longest subarray
static int longestEvenOddSubarray( int a[], int n)
{
// Length of longest
// alternating subarray
int longest = 1 ;
int cnt = 1 ;
// Iterate in the array
for ( int i = 0 ; i < n - 1 ; i++) {
// increment count if consecutive
// elements has an odd sum
if ((a[i] + a[i + 1 ]) % 2 == 1 ) {
cnt++;
}
else {
// Store maximum count in longest
longest = Math.max(longest, cnt);
// Reinitialize cnt as 1 consecutive
// elements does not have an odd sum
cnt = 1 ;
}
}
// Length of 'longest' can never be 1
// since even odd has to occur in pair or more
// so return 0 if longest = 1
longest = Math.max(longest, cnt);
if (longest == 1 )
return 0 ;
return longest;
}
// Driver code
public static void main(String[] args)
{
int a[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 };
int n = a.length;
System.out.println(longestEvenOddSubarray(a, n));
}
} // This code is contributed by offbeat |
# Python3 program to find the length of the # longest alternating even odd subarray # Function to find the longest subarray def longestEvenOddSubarray(arr, n):
# Length of longest
# alternating subarray
longest = 1
cnt = 1
# Iterate in the array
for i in range (n - 1 ):
# Increment count if consecutive
# elements has an odd sum
if ((arr[i] + arr[i + 1 ]) % 2 = = 1 ):
cnt = cnt + 1
else :
# Store maximum count in longest
longest = max (longest, cnt)
# Reinitialize cnt as 1 consecutive
# elements does not have an odd sum
cnt = 1
# Length of 'longest' can never be 1 since
# even odd has to occur in pair or more
# so return 0 if longest = 1
if (longest = = 1 ):
return 0
return max (cnt, longest)
# Driver Code arr = [ 1 , 2 , 3 , 4 , 5 , 7 , 8 ]
n = len (arr)
print (longestEvenOddSubarray(arr, n))
# This code is contributed by skylags |
// C# program to find the Length of the // longest alternating even odd subarray using System;
class GFG {
// Function to find the longest subarray
static int longestEvenOddSubarray( int [] a, int n)
{
// Length of longest
// alternating subarray
int longest = 1;
int cnt = 1;
// Iterate in the array
for ( int i = 0; i < n - 1; i++) {
// Increment count if consecutive
// elements has an odd sum
if ((a[i] + a[i + 1]) % 2 == 1) {
cnt++;
}
else {
// Store maximum count in longest
longest = Math.Max(longest, cnt);
// Reinitialize cnt as 1 consecutive
// elements does not have an odd sum
cnt = 1;
}
}
// Length of 'longest' can never be 1
// since even odd has to occur in pair
// or more so return 0 if longest = 1
if (longest == 1)
return 0;
return Math.Max(cnt, longest);
}
// Driver code
static void Main()
{
int [] a = { 1, 2, 3, 4, 5, 7, 8 };
int n = a.Length;
Console.WriteLine(longestEvenOddSubarray(a, n));
}
} // This code is contributed by divyeshrabadiya07 |
<script> // JavaScript program to find the Length of the // longest alternating even odd subarray // Function to find the longest subarray function longestEvenOddSubarray(a, n)
{ // Length of longest
// alternating subarray
let longest = 1;
let cnt = 1;
// Iterate in the array
for (let i = 0; i < n - 1; i++) {
// increment count if consecutive
// elements has an odd sum
if ((a[i] + a[i + 1]) % 2 == 1)
{
cnt++;
}
else
{
// Store maximum count in longest
longest = Math.max(longest, cnt);
// Reinitialize cnt as 1 consecutive
// elements does not have an odd sum
cnt = 1;
}
}
// Length of 'longest' can never be 1
// since even odd has to occur in pair or more
// so return 0 if longest = 1
if (longest == 1)
return 0;
return Math.max(cnt, longest);
} /* Driver code*/ let a = [ 1, 2, 3, 4, 5, 7, 8 ];
let n = a.length;
document.write(longestEvenOddSubarray(a, n));
// This code is contributed by Surbhi Tyagi. </script> |
5
Time Complexity: O(N), Traversing over the array one time.
Auxiliary Space: O(1)
Length of the longest alternating even odd subarray by Storing the previous element
By simply storing the nature of the previous element we encounter( odd or even) and comparing it with the next element.
Follow the steps below to solve the problem:
- Initialize a variable maxLength to 0, to keep the track of maximum length of the alternating subarray obtained.
- Initialize a variable currLen to 1 considering first element as the part of alternating subarray.
- Starting with element at index 1, compare every element with it’s previous. If there nature are different, increment the currLen variable.
- Otherwise, reset the currLen to 1 again so that, this current element is considered in new alternating subarray.
- Keep storing the max length of subarray in maxLength before resetting the currLen.
- Return the found max length of subarray.
Below is the implementation of above approach:
// C++ code to find longest subarray of alternating even and // odds #include <iostream> using namespace std;
int maxEvenOdd( int arr[], int n)
{ if (n == 0)
return 0;
int maxLength = 0;
int currLen = 1;
for ( int i = 1; i < n; i++) {
// everytime we check if previous
// element has opposite even/odd
// nature or not
if (arr[i] % 2 != arr[i-1] % 2)
currLen++;
else
{
// store max in maxLength
maxLength = max(maxLength, currLen);
// reset value when pattern is broken
currLen = 1;
}
}
// since, even-odd should occur in pair
if (maxLength == 1)
return 0;
// if the pair is in last
if (currLen > 1){
maxLength = max(maxLength , currLen);
}
return maxLength;
} // Driver Code int main()
{ int arr[] = { 1, 2, 3, 4, 5, 3, 7, 2, 9, 4 };
// longest subarray should be 1 2 3 4 5 , therefore
// length = 5
int n = sizeof (arr) / sizeof ( int );
cout << "Length of longest subarray of even and odds "
"is : "
<< maxEvenOdd(arr, n);
return 0;
} // this code is contributed by Anshit Bansal and improved by Aniket Raj |
// Java code to find longest subarray // of alternating even and odds import java.util.*;
class GFG {
public static int maxEvenOdd( int [] arr, int n)
{
if (n == 0 )
return 0 ;
int maxLength = 0 ;
// storing the nature of first element, if
// remainder = 1, it is odd
int prevOdd = arr[ 0 ] % 2 ;
int curLength = 1 ;
for ( int i = 1 ; i < n; i++)
{
// everytime we check if previous
// element has opposite even/odd
// nature or not
if (arr[i] % 2 != prevOdd)
curLength++;
else
// reset value when pattern is broken
curLength = 1 ;
// changing value when new maximum
// subarray is found
if (curLength > maxLength)
maxLength = curLength;
// updating even/odd nature of prev
// number encountered everytime
prevOdd = arr[i] % 2 ;
}
return maxLength;
}
static public void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 4 , 5 , 3 , 7 , 2 , 9 , 4 };
// longest subarray should be 1 2 3 4 5 , therefore
// length = 5
int n = arr.length;
System.out.print(
"Length of longest subarray of even and odds is : " );
System.out.print(maxEvenOdd(arr, n));
}
} // This code is contributed by phasing17 |
# Python3 code to find longest subarray of alternating even and # odds def maxEvenOdd(arr, n):
if (n = = 0 ):
return 0 ;
maxLength = 0 ;
# storing the nature of first element, if
# remainder = 1, it is odd
prevOdd = arr[ 0 ] % 2 ;
curLength = 1 ;
for i in range ( 1 , n):
# everytime we check if previous
# element has opposite even/odd
# nature or not
if (arr[i] % 2 ! = prevOdd):
curLength + = 1 ;
else :
# reset value when pattern is broken
curLength = 1 ;
# changing value when new maximum
# subarray is found
if (curLength > maxLength):
maxLength = curLength;
# updating even/odd nature of prev
# number encountered everytime
prevOdd = arr[i] % 2 ;
return maxLength;
# Driver Code arr = [ 1 , 2 , 3 , 4 , 5 , 3 , 7 , 2 , 9 , 4 ];
# longest subarray should be 1 2 3 4 5 , therefore # length = 5 n = len (arr);
print ( "Length of longest subarray of even and odds is :" , maxEvenOdd(arr, n));
# This code is contributed by phasing17 |
// C# code to find longest subarray // of alternating even and odds using System;
public class GFG {
public static int maxEvenOdd( int [] arr, int n)
{
if (n == 0)
return 0;
int maxLength = 0;
// storing the nature of first element, if
// remainder = 1, it is odd
int prevOdd = arr[0] % 2;
int curLength = 1;
for ( int i = 1; i < n; i++)
{
// everytime we check if previous
// element has opposite even/odd
// nature or not
if (arr[i] % 2 != prevOdd)
curLength++;
else
// reset value when pattern is broken
curLength = 1;
// changing value when new maximum
// subarray is found
if (curLength > maxLength)
maxLength = curLength;
// updating even/odd nature of prev
// number encountered everytime
prevOdd = arr[i] % 2;
}
return maxLength;
}
static public void Main()
{
int [] arr = { 1, 2, 3, 4, 5, 3, 7, 2, 9, 4 };
// longest subarray should be 1 2 3 4 5 , therefore
// length = 5
int n = arr.Length;
Console.Write(
"Length of longest subarray of even and odds is : " );
Console.Write(maxEvenOdd(arr, n));
}
} // This code is contributed by akashish__ |
// JS code to find longest subarray of alternating even and // odds function maxEvenOdd(arr, n)
{ if (n == 0)
return 0;
let maxLength = 0;
// storing the nature of first element, if
// remainder = 1, it is odd
let prevOdd = arr[0] % 2;
let curLength = 1;
for ( var i = 1; i < n; i++) {
// everytime we check if previous
// element has opposite even/odd
// nature or not
if (arr[i] % 2 != prevOdd)
curLength++;
else
// reset value when pattern is broken
curLength = 1;
// changing value when new maximum
// subarray is found
if (curLength > maxLength)
maxLength = curLength;
// updating even/odd nature of prev
// number encountered everytime
prevOdd = arr[i] % 2;
}
return maxLength;
} // Driver Code let arr = [ 1, 2, 3, 4, 5, 3, 7, 2, 9, 4 ]; // longest subarray should be 1 2 3 4 5 , therefore // length = 5 let n = arr.length; console.log( "Length of longest subarray of even and odds is : " +
maxEvenOdd(arr, n));
// this code is contributed by phasing17 |
Length of longest subarray of even and odds is : 5
Time Complexity: O(N), Since we need to iterate over the whole array once
Auxiliary Space: O(1)