Given an array of N including positive and negative numbers only. The task is to find the length of the longest alternating (means negative-positive-negative or positive-negative-positive) subarray present in the array.
Examples:
Input: a[] = {-5, -1, -1, 2, -2, -3} Output: 3 The subarray {-1, 2, -2} Input: a[] = {1, -5, 1, -5} Output: 4
Approach: The following steps are followed to solve the problem:
- Initially initialize cnt as 1.
- Iterate among the array elements, and check if it has an alternate sign.
- Increase the cnt by 1 if it has an alternate sign.
- If it does not has an alternate sign, then re-initialize cnt by 1.
Below is the implementation of the above approach:
C++
// C++ program to find the longest alternating // subarray in an array of N number #include <bits/stdc++.h> using namespace std;
// Function to find the longest subarray int longestAlternatingSubarray( int a[], int n)
{ // Length of longest alternating
int longest = 1;
int cnt = 1;
// Iterate in the array
for ( int i = 1; i < n; i++) {
// Check for alternate
if (a[i] * a[i - 1] < 0) {
cnt++;
longest = max(longest, cnt);
}
else
cnt = 1;
}
return longest;
} /* Driver program to test above functions*/ int main()
{ int a[] = { -5, -1, -1, 2, -2, -3 };
int n = sizeof (a) / sizeof (a[0]);
// Function to find the longest subarray
cout << longestAlternatingSubarray(a, n);
return 0;
} |
Java
// Java program to find the longest alternating // subarray in an array of N number class GFG
{ // Function to find the longest subarray
static int longestAlternatingSubarray( int a[], int n)
{
// Length of longest alternating
int longest = 1 ;
int cnt = 1 ;
// Iterate in the array
for ( int i = 1 ; i < n; i++)
{
// Check for alternate
if (a[i] * a[i - 1 ] < 0 )
{
cnt++;
longest = Math.max(longest, cnt);
}
else
cnt = 1 ;
}
return longest;
}
/* Driver program to test above functions*/
public static void main (String[] args)
{
int a[] = { - 5 , - 1 , - 1 , 2 , - 2 , - 3 };
int n = a.length ;
// Function to find the longest subarray
System.out.println(longestAlternatingSubarray(a, n));
}
} // This code is contributed by Ryuga |
Python 3
# Python3 program to find the longest alternating # subarray in an array of N number # Function to find the longest subarray def longestAlternatingSubarray(a, n):
# Length of longest alternating
longest = 1
cnt = 1
# Iterate in the array
i = 1
while i < n:
# Check for alternate
if (a[i] * a[i - 1 ] < 0 ):
cnt = cnt + 1
longest = max (longest, cnt)
else :
cnt = 1
i = i + 1
return longest
# Driver Code a = [ - 5 , - 1 , - 1 , 2 , - 2 , - 3 ]
n = len (a)
# Function to find the longest subarray print (longestAlternatingSubarray(a, n))
# This code is contributed # by shashank_sharma |
C#
// C# program to find the longest alternating // subarray in an array of N number using System;
class GFG
{ // Function to find the longest subarray static int longestAlternatingSubarray( int []a,
int n)
{ // Length of longest alternating
int longest = 1;
int cnt = 1;
// Iterate in the array
for ( int i = 1; i < n; i++)
{
// Check for alternate
if (a[i] * a[i - 1] < 0)
{
cnt++;
longest = Math.Max(longest, cnt);
}
else
cnt = 1;
}
return longest;
} // Driver Code public static void Main()
{ int []a = { -5, -1, -1, 2, -2, -3 };
int n = a.Length;
// Function to find the longest subarray
Console.Write(longestAlternatingSubarray(a, n));
} } // This code is contributed // by Akanksha Rai |
PHP
<?php // PHP program to find the longest alternating // subarray in an array of N number // Function to find the longest subarray function longestAlternatingSubarray( $a , $n )
{ // Length of longest alternating
$longest = 1;
$cnt = 1;
// Iterate in the array
for ( $i = 1; $i < $n ; $i ++)
{
// Check for alternate
if ( $a [ $i ] * $a [ $i - 1] < 0)
{
$cnt ++;
$longest = max( $longest , $cnt );
}
else
$cnt = 1;
}
return $longest ;
} // Driver Code $a = array (-5, -1, -1, 2, -2, -3 );
$n = sizeof( $a );
// Function to find the longest subarray echo longestAlternatingSubarray( $a , $n );
// This code is contributed by akt_mit ?> |
Javascript
<script> // JavaScript program to find the longest alternating // subarray in an array of N number // Function to find the longest subarray function longestAlternatingSubarray(a, n)
{ // Length of longest alternating
let longest = 1;
let cnt = 1;
// Iterate in the array
for (let i = 1; i < n; i++) {
// Check for alternate
if (a[i] * a[i - 1] < 0) {
cnt++;
longest = Math.max(longest, cnt);
}
else
cnt = 1;
}
return longest;
} /* Driver program to test above functions*/ let a = [ -5, -1, -1, 2, -2, -3 ];
let n = a.length;
// Function to find the longest subarray
document.write(longestAlternatingSubarray(a, n));
// This code is contributed by Surbhi Tyagi. </script> |
Output
3
Complexity Analysis:
- Time Complexity: O(N), as we are using a loop to traverse N times. Where N is the number of elements in the array.
- Auxiliary Space: O(1), as we are not using any extra space.