Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Length of the longest alternating increasing decreasing subarray

  • Difficulty Level : Medium
  • Last Updated : 12 Dec, 2021

Given an array arr[], the task is to find the length of the longest alternating subarray. 

A subarray {x1, x2, .. xn} is an alternating increasing decreasing sequence if its elements satisfy one of the following relations : 

x1 < x2 > x3 < x4 > x5 < …. xn or 
x1 > x2 < x3 > x4 < x5 > …. xn

Example:

Input: arr = {1, 2, 3, 2, 5, 6}
Output: 4
Explanation: The first elements form index 1 to 4 inclusive are alternating subarray – {2, 3, 2, 5}

Input: arr = {5, 2, 1}
Output: 2

 

Naive Approach: The naive approach is to check for each subarray if the subarrays starting at every index are alternating. The idea is to use two nested for-loops.

Below is the implementation of the above approach

C++14




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
int maxAlternatingSubarray(int n, int* arr)
{
 
    // Initialize mx to store maximum
    // length alternating subarrays
    int i, j, max = 1, count = 1, a, b;
 
    // Initialize a variable to check is the
    // subarray starts with greater
    // or smaller value
    bool check;
 
    // If length of the array is 1
    // then return 1
    if (n == 1)
        return 1;
 
    // Traverse for every element
    for (i = 0; i < n; i++) {
 
        // Reintialize count to 1 as
        // at least one element is counted
        count = 1;
 
        // Subarray starting at every element
        for (j = i; j < n - 1; j++) {
 
            // Initialize a and b for storing
            // adjacent positions
            a = j;
            b = j + 1;
 
            // Check if the alternating subarray
            // starts with greater
            // or smaller element
            if (j == i) {
 
                // Smaller element starts first
                if (arr[a] < arr[b])
                    check = 1;
 
                // Greater element starts first
                else if (arr[a] > arr[b])
                    check = 0;
            }
 
            // If check is 1 then the next
            // element should be greater
            if (check && arr[a] < arr[b]) {
 
                // Increment count
                count++;
            }
 
            // If check is 0 then the next
            // element should be greater
            else if (!check && arr[a] > arr[b]) {
 
                // Increment count
                count++;
            }
            else
                break;
 
            // Update the value of check
            check = !check;
        }
 
        // Update the maximum value of count
        if (max < count)
            max = count;
    }
 
    // Return the maximum length
    return max;
}
 
// Driver code
int main()
{
 
    // Initialize the array
    int arr[] = { 1, 2, 3, 2, 5, 7 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Call thefunction and print the answer
    cout << maxAlternatingSubarray(n, arr);
}

Java




// Java code for the above approach
import java.io.*;
 
class GFG {
  static int maxAlternatingSubarray(int n, int[] arr)
  {
 
    // Initialize mx to store maximum
    // length alternating subarrays
    int i, j, max = 1, count = 1, a, b;
 
    // Initialize a variable to check is the
    // subarray starts with greater
    // or smaller value
    boolean check=false;
 
    // If length of the array is 1
    // then return 1
    if (n == 1)
      return 1;
 
    // Traverse for every element
    for (i = 0; i < n; i++) {
 
      // Reintialize count to 1 as
      // at least one element is counted
      count = 1;
 
      // Subarray starting at every element
      for (j = i; j < n - 1; j++) {
 
        // Initialize a and b for storing
        // adjacent positions
        a = j;
        b = j + 1;
 
        // Check if the alternating subarray
        // starts with greater
        // or smaller element
        if (j == i) {
 
          // Smaller element starts first
          if (arr[a] < arr[b])
            check = true;
 
          // Greater element starts first
          else if (arr[a] > arr[b])
            check = false;
        }
 
        // If check is 1 then the next
        // element should be greater
        if (check==true && arr[a] < arr[b]) {
 
          // Increment count
          count++;
        }
 
        // If check is 0 then the next
        // element should be greater
        else if (check==false && arr[a] > arr[b]) {
 
          // Increment count
          count++;
        }
        else
          break;
 
        // Update the value of check
        check = !check;
      }
 
      // Update the maximum value of count
      if (max < count)
        max = count;
    }
 
    // Return the maximum length
    return max;
  }
 
  // Driver code
  public static void main (String[] args)
  {
 
    // Initialize the array
    int arr[] = { 1, 2, 3, 2, 5, 7 };
 
    int n = arr.length;
 
    // Call thefunction and print the answer
 
    System.out.println( maxAlternatingSubarray(n, arr));
  }
}
 
// This code is contributed by Potta Lokesh

Python3




# Python implementation of the above approach
def maxAlternatingSubarray(n, arr):
 
    # Initialize mx to store maximum
    # length alternating subarrays
    max = 1
    count = 1
    a = 0
    b = 0
 
    # Initialize a variable to check is the
    # subarray starts with greater
    # or smaller value
    check = 0
 
    # If length of the array is 1
    # then return 1
    if (n == 1):
        return 1;
 
    # Traverse for every element
    for i in range(n):
 
        # Reintialize count to 1 as
        # at least one element is counted
        count = 1;
 
        # Subarray starting at every element
        for j in range(i, n - 1):
 
            # Initialize a and b for storing
            # adjacent positions
            a = j;
            b = j + 1;
 
            # Check if the alternating subarray
            # starts with greater
            # or smaller element
            if (j == i):
 
                # Smaller element starts first
                if (arr[a] < arr[b]):
                    check = 1;
 
                # Greater element starts first
                elif (arr[a] > arr[b]):
                    check = 0;
             
 
            # If check is 1 then the next
            # element should be greater
            if (check and arr[a] < arr[b]):
 
                # Increment count
                count += 1
             
 
            # If check is 0 then the next
            # element should be greater
            elif (not check and arr[a] > arr[b]):
 
                # Increment count
                count += 1
             
            else:
                break;
 
            # Update the value of check
            check = not check;
         
 
        # Update the maximum value of count
        if (max < count):
            max = count;
     
    # Return the maximum length
    return max;
 
# Driver code
 
# Initialize the array
arr = [ 1, 2, 3, 2, 5, 7 ];
 
n = len(arr);
 
# Call thefunction and print the answer
print(maxAlternatingSubarray(n, arr));
 
# This code is contributed by gfgking.

C#




// C# code for the above approach
using System;
 
class GFG {
  static int maxAlternatingSubarray(int n, int []arr)
  {
 
    // Initialize mx to store maximum
    // length alternating subarrays
    int i, j, max = 1, count = 1, a, b;
 
    // Initialize a variable to check is the
    // subarray starts with greater
    // or smaller value
    bool check=false;
 
    // If length of the array is 1
    // then return 1
    if (n == 1)
      return 1;
 
    // Traverse for every element
    for (i = 0; i < n; i++) {
 
      // Reintialize count to 1 as
      // at least one element is counted
      count = 1;
 
      // Subarray starting at every element
      for (j = i; j < n - 1; j++) {
 
        // Initialize a and b for storing
        // adjacent positions
        a = j;
        b = j + 1;
 
        // Check if the alternating subarray
        // starts with greater
        // or smaller element
        if (j == i) {
 
          // Smaller element starts first
          if (arr[a] < arr[b])
            check = true;
 
          // Greater element starts first
          else if (arr[a] > arr[b])
            check = false;
        }
 
        // If check is 1 then the next
        // element should be greater
        if (check==true && arr[a] < arr[b]) {
 
          // Increment count
          count++;
        }
 
        // If check is 0 then the next
        // element should be greater
        else if (check==false && arr[a] > arr[b]) {
 
          // Increment count
          count++;
        }
        else
          break;
 
        // Update the value of check
        check = !check;
      }
 
      // Update the maximum value of count
      if (max < count)
        max = count;
    }
 
    // Return the maximum length
    return max;
  }
 
  // Driver code
  public static void Main ()
  {
 
    // Initialize the array
    int []arr = { 1, 2, 3, 2, 5, 7 };
 
    int n = arr.Length;
 
    // Call thefunction and print the answer
    Console.Write(maxAlternatingSubarray(n, arr));
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript




<script>
// Javascript implementation of the above approach
 
function maxAlternatingSubarray(n, arr)
{
 
    // Initialize mx to store maximum
    // length alternating subarrays
    let i, j, max = 1, count = 1, a, b;
 
    // Initialize a variable to check is the
    // subarray starts with greater
    // or smaller value
    let check;
 
    // If length of the array is 1
    // then return 1
    if (n == 1)
        return 1;
 
    // Traverse for every element
    for (i = 0; i < n; i++) {
 
        // Reintialize count to 1 as
        // at least one element is counted
        count = 1;
 
        // Subarray starting at every element
        for (j = i; j < n - 1; j++) {
 
            // Initialize a and b for storing
            // adjacent positions
            a = j;
            b = j + 1;
 
            // Check if the alternating subarray
            // starts with greater
            // or smaller element
            if (j == i) {
 
                // Smaller element starts first
                if (arr[a] < arr[b])
                    check = 1;
 
                // Greater element starts first
                else if (arr[a] > arr[b])
                    check = 0;
            }
 
            // If check is 1 then the next
            // element should be greater
            if (check && arr[a] < arr[b]) {
 
                // Increment count
                count++;
            }
 
            // If check is 0 then the next
            // element should be greater
            else if (!check && arr[a] > arr[b]) {
 
                // Increment count
                count++;
            }
            else
                break;
 
            // Update the value of check
            check = !check;
        }
 
        // Update the maximum value of count
        if (max < count)
            max = count;
    }
 
    // Return the maximum length
    return max;
}
 
// Driver code
 
// Initialize the array
let arr = [ 1, 2, 3, 2, 5, 7 ];
 
let n = arr.length;
 
// Call thefunction and print the answer
document.write(maxAlternatingSubarray(n, arr));
 
// This code is contributed by Samim Hossain Mondal.
</script>
Output: 
4

 

Time Complexity: O(N^2)
Auxiliary Space: O(1)

Approach: The given problem can be optimized by iterating the array and precomputing the difference between consecutive elements. Follow the steps below to solve the problem:

  • Iterate the array from index 1 till the end and at every iteration:
    • If the current element is greater than the previous element then increment currGreater by 1 and reset currSmaller to 0
    • Else if the current element is smaller than the previous element then increment currSmaller by 1 and reset currGreater to 0
    • Else if current and previous elements are equal then reset both currGreater and currSmaller to 0
    • Swap the values of currGreater and currSmaller
    • Update the value of maximum length by comparing it to currGreater and currSmaller
  • Return the value of maximum length calculated

C++14




// C++ implementation for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate maximum length
// of alternating subarray
int longestAltSubarray(int N, int* arr)
{
 
    // If length of the array is 1
    // then return 1
    if (N == 1)
        return 1;
 
    int maxLen = 0;
    int currGreater = 0, currSmaller = 0;
 
    // Traverse the temp array
    for (int i = 1; i < N; i++) {
 
        // If current element is greater
        // than the previous element
        if (arr[i] > arr[i - 1]) {
 
            // Increment currGreater by 1
            currGreater++;
 
            // Reset currSmaller to 0
            currSmaller = 0;
        }
 
        // If current element is smaller
        // than the previous element
        else if (arr[i] < arr[i - 1]) {
 
            // Increment currSmaller by 1
            currSmaller++;
 
            // Reset currGreater to 0
            currGreater = 0;
        }
        // If current element is equal
        // to previous element
        else {
 
            // Reset both to 0
            currGreater = 0;
            currSmaller = 0;
        }
 
        // Swap currGreater and currSmaller
        // for the next iteration
        int temp = currGreater;
        currGreater = currSmaller;
        currSmaller = temp;
 
        // Update maxLen
        maxLen = max(maxLen,
                     max(currGreater, currSmaller));
    }
 
    // Return the maximum length
    return maxLen + 1;
}
 
// Drivers code
int main()
{
 
    // Initialize the array
    int arr[] = { 1, 2, 3, 2, 5, 7 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Call the function and print the answer
    cout << longestAltSubarray(n, arr);
}

Java




// Java implementation for the above approach
import java.util.*;
public class GFG
{
   
// Function to calculate maximum length
// of alternating subarray
static int longestAltSubarray(int N, int []arr)
{
 
    // If length of the array is 1
    // then return 1
    if (N == 1)
        return 1;
 
    int maxLen = 0;
    int currGreater = 0, currSmaller = 0;
 
    // Traverse the temp array
    for (int i = 1; i < N; i++) {
 
        // If current element is greater
        // than the previous element
        if (arr[i] > arr[i - 1]) {
 
            // Increment currGreater by 1
            currGreater++;
 
            // Reset currSmaller to 0
            currSmaller = 0;
        }
 
        // If current element is smaller
        // than the previous element
        else if (arr[i] < arr[i - 1]) {
 
            // Increment currSmaller by 1
            currSmaller++;
 
            // Reset currGreater to 0
            currGreater = 0;
        }
       
        // If current element is equal
        // to previous element
        else {
 
            // Reset both to 0
            currGreater = 0;
            currSmaller = 0;
        }
 
        // Swap currGreater and currSmaller
        // for the next iteration
        int temp = currGreater;
        currGreater = currSmaller;
        currSmaller = temp;
 
        // Update maxLen
        maxLen = Math.max(maxLen,
                     Math.max(currGreater, currSmaller));
    }
 
    // Return the maximum length
    return maxLen + 1;
}
 
// Drivers code
public static void main(String args[])
{
 
    // Initialize the array
    int []arr = { 1, 2, 3, 2, 5, 7 };
 
    int n = arr.length;
 
    // Call the function and print the answer
    System.out.println(longestAltSubarray(n, arr));
}
}
 
// This code is contributed by Samim Hossain Mondal.

Python3




# Python3 implementation for the above approach
from builtins import range
 
# Function to calculate maximum length
# of alternating subarray
def longestAltSubarray(N, arr):
     
    # If length of the array is 1
    # then return 1
    if (N == 1):
        return 1
         
    maxLen = 0
    currGreater = 0
    currSmaller = 0
     
    # Traverse the temp array
    for i in range(1, N, 1):
         
        # If current element is greater
        # than the previous element
        if (arr[i] > arr[i - 1]):
 
            # Increment currGreater by 1
            currGreater += 1
 
            # Reset currSmaller to 0
            currSmaller = 0
             
        # If current element is smaller
        # than the previous element
        elif (arr[i] < arr[i - 1]):
 
            # Increment currSmaller by 1
            currSmaller += 1
 
            # Reset currGreater to 0
            currGreater = 0
             
        # If current element is equal
        # to previous element
        else:
 
            # Reset both to 0
            currGreater = 0
            currSmaller = 0
 
        # Swap currGreater and currSmaller
        # for the next iteration
        temp = currGreater
        currGreater = currSmaller
        currSmaller = temp
 
        # Update maxLen
        maxLen = max(maxLen, max(currGreater,
                                 currSmaller))
 
    # Return the maximum length
    return maxLen + 1
 
# Driver code
if __name__ == '__main__':
     
    # Initialize the array
    arr = [ 1, 2, 3, 2, 5, 7 ]
 
    n = len(arr)
 
    # Call the function and print the answer
    print(longestAltSubarray(n, arr))
 
# This code is contributed by shikhasingrajput

C#




// C# implementation for the above approach
using System;
class GFG
{
   
// Function to calculate maximum length
// of alternating subarray
static int longestAltSubarray(int N, int []arr)
{
 
    // If length of the array is 1
    // then return 1
    if (N == 1)
        return 1;
 
    int maxLen = 0;
    int currGreater = 0, currSmaller = 0;
 
    // Traverse the temp array
    for (int i = 1; i < N; i++) {
 
        // If current element is greater
        // than the previous element
        if (arr[i] > arr[i - 1]) {
 
            // Increment currGreater by 1
            currGreater++;
 
            // Reset currSmaller to 0
            currSmaller = 0;
        }
 
        // If current element is smaller
        // than the previous element
        else if (arr[i] < arr[i - 1]) {
 
            // Increment currSmaller by 1
            currSmaller++;
 
            // Reset currGreater to 0
            currGreater = 0;
        }
       
        // If current element is equal
        // to previous element
        else {
 
            // Reset both to 0
            currGreater = 0;
            currSmaller = 0;
        }
 
        // Swap currGreater and currSmaller
        // for the next iteration
        int temp = currGreater;
        currGreater = currSmaller;
        currSmaller = temp;
 
        // Update maxLen
        maxLen = Math.Max(maxLen,
                     Math.Max(currGreater, currSmaller));
    }
 
    // Return the maximum length
    return maxLen + 1;
}
 
// Drivers code
public static void Main()
{
 
    // Initialize the array
    int []arr = { 1, 2, 3, 2, 5, 7 };
 
    int n = arr.Length;
 
    // Call the function and print the answer
    Console.Write(longestAltSubarray(n, arr));
}
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript




<script>
// Javascript implementation for the above approach
 
// Function to calculate maximum length
// of alternating subarray
function longestAltSubarray(N, arr) {
 
  // If length of the array is 1
  // then return 1
  if (N == 1)
    return 1;
 
  let maxLen = 0;
  let currGreater = 0, currSmaller = 0;
 
  // Traverse the temp array
  for (let i = 1; i < N; i++) {
 
    // If current element is greater
    // than the previous element
    if (arr[i] > arr[i - 1]) {
 
      // Increment currGreater by 1
      currGreater++;
 
      // Reset currSmaller to 0
      currSmaller = 0;
    }
 
    // If current element is smaller
    // than the previous element
    else if (arr[i] < arr[i - 1]) {
 
      // Increment currSmaller by 1
      currSmaller++;
 
      // Reset currGreater to 0
      currGreater = 0;
    }
    // If current element is equal
    // to previous element
    else {
 
      // Reset both to 0
      currGreater = 0;
      currSmaller = 0;
    }
 
    // Swap currGreater and currSmaller
    // for the next iteration
    let temp = currGreater;
    currGreater = currSmaller;
    currSmaller = temp;
 
    // Update maxLen
    maxLen = Math.max(maxLen,
      Math.max(currGreater, currSmaller));
  }
 
  // Return the maximum length
  return maxLen + 1;
}
 
// Drivers code
 
// Initialize the array
let arr = [1, 2, 3, 2, 5, 7];
 
let n = arr.length
 
// Call the function and let the answer
document.write(longestAltSubarray(n, arr))
 
// This code is contributed by gfgking.
</script>
Output: 
4

 

Time Complexity: O(N)
Auxiliary Space: O(N)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!