Length of the longest alternating subarray

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, check if it has an alternate sign.
  • Increase the cnt by 1 if it has a 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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
?>

chevron_right


Output:

3


My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.