Longest alternating (positive and negative) subarray starting at every index

A subarray is called alternating if any two consecutive numbers in it have opposite signs (i.e. one of them should be negative, whereas the other should be positive).

Given an array of n integers. For each index i, we need to find the length if the longest alternating subarray starting at i.

Examples:

Input : a[] = {1, -5, 1, -5}
Output : For index 0, {1, -5, 1, -5} = 4
             index 1, {-5, 1, -5} = 3
             index 2, {1, -5} = 2
             index 3, {-5} = 1.
      
Input :a[] = {-5, -1, -1, 2, -2, -3}
Output : index 0 = 1,
         index 1 = 1,
         index 2 = 3,
         index 3 = 2,
         index 4 = 1,
         index 5 = 1,

A Naive approach is to use two loops in which we traverse the whole array starting from every index i (0 to n-1) and calculate the length of the alternating subarray.
Time Complexity: O(n2).

Efficient Approach:
Observe that when a[i] and a[i+1] have opposite signs, count[i] will be 1 more than count[i+1]. Otherwise when they have same sign count[i] will be 1.

We use Dynamic Programming here.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find longest alternating
// subarray starting from every index.
#include <bits/stdc++.h>
using namespace std;
  
void longestAlternating(int arr[], int n)
{
    int count[n];
  
    // Fill count[] from end. 
    count[n - 1] = 1;
    for (int i = n - 2; i >= 0; i--) {
        if (arr[i] * arr[i + 1] < 0)
            count[i] = count[i + 1] + 1;
        else
            count[i] = 1;
    }
  
    // Print result
    for (int i = 0; i < n; i++)
        cout << count[i] << " ";
}
  
// Driver code
int main()
{
    int a[] = { -5, -1, -1, 2, -2, -3 };
    int n = sizeof(a) / sizeof(a[0]);
    longestAlternating(a, n);
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java program to find longest alternating 


// subarray starting from every index. 


import java.util.*; 


  


class Longest{ 


      


    public static void longestAlternating(int arr[],  


                                             int n) 


    { 


        int[] count = new int[n]; 


  


        // Fill count[] from end.  


        count[n - 1] = 1; 


        for (int i = n - 2; i >= 0; i--) { 


            if (arr[i] * arr[i + 1] < 0) 


                count[i] = count[i + 1] + 1; 


            else


                count[i] = 1; 


        } 


  


        // Print result 


        for (int i = 0; i < n; i++) 


            System.out.print(count[i] + " "); 


    } 


      


    // driver program 


    public static void main(String[] args) 


    { 


        int a[] = { -5, -1, -1, 2, -2, -3 }; 


        int n = 6; 


        longestAlternating(a, n); 


    } 


} 


  


// This code is contributed by rishabh_jain 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 program to find longest alternating 


# subarray starting from every index. 


  


def longestAlternating(arr, n) : 


    count = [None] * n 


  


    # Fill count[] from end.  


    count[n - 1] = 1


    i = n - 2


      


    while i >= 0 : 


        if (arr[i] * arr[i + 1] < 0) : 


            count[i] = count[i + 1] + 1


        else : 


            count[i] = 1; 


        i = i - 1


  


    i = 0


      


    # Print result 


    while i < n : 


        print (count[i], end = " ") 


        i = i + 1


  


# Driver Code 


a = [ -5, -1, -1, 2, -2, -3 ] 


n = len(a) 


longestAlternating(a, n); 


  


  


# This code is contributed by rishabh_jain  



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















//C# program to find longest alternating 


// subarray starting from every index. 


using System; 


  


class Longest 


{ 


      


    public static void longestAlternating(int []arr,  


                                            int n) 


    { 


        int[] count = new int[n]; 


  


        // Fill count[] from end.  


        count[n - 1] = 1; 


        for (int i = n - 2; i >= 0; i--)  


        { 


            if (arr[i] * arr[i + 1] < 0) 


                count[i] = count[i + 1] + 1; 


            else


                count[i] = 1; 


        } 


  


        // Print result 


        for (int i = 0; i < n; i++) 


            Console.Write(count[i] + " "); 


    } 


      


    // Driver program 


    public static void Main() 


    { 


        int []a = { -5, -1, -1, 2, -2, -3 }; 


        int n = 6; 


        longestAlternating(a, n); 


    } 


} 


  


// This code is contributed by vt_m 



















                        chevron_right







                        filter_none









PHP














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















<?php 


// PHP program to find longest alternating 


// subarray starting from every index. 


  


function longestAlternating( $arr, $n) 


{ 


    $count = array(); 


  


    // Fill count[] from end.  


    $count[$n - 1] = 1; 


    for ( $i = $n - 2; $i >= 0; $i--)  


    { 


        if ($arr[$i] * $arr[$i + 1] < 0) 


            $count[$i] = $count[$i + 1] + 1; 


        else


            $count[$i] = 1; 


    } 


  


    // Print result 


    for ( $i = 0; $i < $n; $i++) 


        echo $count[$i] , " "; 


} 


  


    // Driver code 


    $a = array( -5, -1, -1, 2, -2, -3 ); 


    $n =count($a); 


    longestAlternating($a, $n); 


  


// This code is contributed by anuj_67. 


?> 



















                        chevron_right







                        filter_none










Output:


1 1 3 2 1 1




          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
Harsha_Mogali
Check out this Author's contributed articles.
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.


Improved By :  vt_m