Find The Longest Turbulent Subarray In C++

Delving into the world of obstacles, the journey to discover the subsequence introduces a captivating enigma. A tumultuous subsequence is recognized by adjacent elements that switch between ascending and descending sequences. Conquering this challenge effectively demands comprehension of array handling and recognizing patterns. This piece explores the notion of subsequences in C++, elaborating on the problem definition and a feasible coding approach.

Describing the Problem:

In this particular challenge, the primary objective is to pinpoint the segment within a provided array that adheres to the turbulence condition. A segment is defined as turbulent when its components alternate between rising and strictly declining values.

To specify a subarray, we look at elements arr[i] through arr[j] inclusive, where;

For any index i in the array, arr[k+1] remains true when k is an odd number.

The goal is to determine the length of the subarray within the given array.

Example;

Given array arr = [1, 5, 3, 7, 4, 6, 9, 2, 8]

Within this array, the alternating pattern consists of '[1, 5, 3, 7, 4, 6, 9]', totaling 7 elements.

Let us make sure this sequence follows the alternating pattern rule;

• ✅ '1 is than 5' (going up at index 0)
• ✅ '5 is than 3' (going down at index 1)
• ✅ '3 is than 7' (going up at index 2)
• ✅ '7 is than 4' (going down at index 3)
• ✅ '4 is than 6' (going up at index 4)
• ✅ '6 is than 9' (going up at index 5)

At this juncture, the pattern shifts due to the fact that the subsequent numeral, '2', is lesser than '9'. Furthermore, the position '6' represents a numerical value. Consequently, the most extended turbulent subarray comprises '[1, 5, 3, 7 4 6 9]' and spans a total of 7 elements.

Let's now explore a different example to illustrate a situation.

For instance;

If an array 'arr = [3, 2, 1, 4, 5, 6, 7, 8, 7]' is provided, the longest turbulent subarray in this case is '[3, 2, 1, 4, 5, 6, 7, 8]' which has a length of eight.

Here's how we can confirm that this subarray meets the turbulence condition;

• ✅ '3 >2' (decreasing; even index at position zero)
• ✅ '2 >1' (decreasing; odd index at position one)
• ✅ '1 <4' (increasing; even index at position two)
• ✅ '4 <5'(increasing; index at position three)
• ✅ '5<6'(increasing; even index, at position four)

At this juncture, we are evaluating the expression '6 < 7', indicating a rising pattern at position 5.

1. Following that, we observe '7 < 8' demonstrating growth at index 6.

In this case, the numeral 7 fails to meet the turbulence requirement as it falls short of 8. The placement of the digit 7 is duly acknowledged. As a result, the lengthiest turbulent sequence is [3, 2, 1, 4, 5, 6, 7, 8], encompassing a grand total of eight elements.

These instances demonstrate that a turbulent series can start and end at any point within the given array and can include elements as long as they meet the turbulence criteria.

Approach:

Let's examine three strategies for solving the challenge of detecting the subarray. Below are three techniques we can investigate:

1. Brute Force Approach

When implementing the brute force approach, each subarray within the provided array undergoes scrutiny to determine if it qualifies as a turbulent subarray. This involves evaluating each subarray against specific turbulence criteria. The time complexity associated with this technique is O(n^3), where n represents the dimension of the input array. Consequently, this approach may prove inadequate for effectively managing arrays due to its inefficiency.

2. Two Pointer Technique

The strategy that involves utilizing two pointers, specifically labeled as 'start' and 'end', for monitoring the subarray is known as the two-pointer technique. Initially, these pointers are positioned at the same index within the array. Subsequently, the 'end' pointer is advanced until it no longer meets the specified turbulence condition. Whenever this condition is breached, the 'start' pointer is readjusted to the exact location of the violation, enabling the 'end' pointer to continue its progression. Throughout this iterative process, the subarrays that meet the criteria are documented. This methodology showcases a time complexity of O(n), with 'n' denoting the array's length, highlighting its superior efficiency compared to alternative approaches.

3. Dynamic Programming

Dynamic programming consists of dividing a complex issue into smaller segments and retaining the solutions to these segments in a cache or data structure.

A state known as 'dpi' is employed to represent the size of the subarray ending at index 'j' with a specific state (either increasing or decreasing) at index 'i'. The values stored in 'dpi 1' are leveraged to compute the value of 'dpi'. Subsequently, the relationship between 'arr[i 1]' and 'arr[j]' is taken into account. The 'dp' table captures the lengths of the subarrays, leading us to the final outcome.

This method functions with a time complexity of O(n2), where n denotes the size of the input array, and a space complexity of O(n2) for the 'dp' matrix.

The two-pointer approach is often considered the optimal method for addressing this issue. It is efficient in terms of time complexity and does not require additional space.

The brute force technique proves to be less effective when handling input arrays because of its cubic time complexity. Conversely, the dynamic programming method could be suitable in certain situations but requires extra memory for the 'dp' table.

It's crucial to take into account that the choice of approach can be influenced by the specific needs of the problem, like the necessity to display the subarray or solely its size, in addition to any other restrictions or enhancements that might be necessary.

Example:

Let's consider a scenario to demonstrate the process of identifying the Longest Turbulent Subarray in C++.

#include <iostream>
#include <vector>

using namespace std;

int maxTurbulenceSize(vector<int>& arr) {
    int n = arr.size();
    if (n < 2) {
        return n;  // Empty or single-element array is considered a turbulent subarray
    }

    int maxLen = 1;  // Initialize the maximum length to 1
    int start = 0;   // Starcpp tutorialer of the current turbulent subarray
    int end = 1;     // End pointer of the current turbulent subarray

    while (end < n) {
        if (arr[end] == arr[end - 1]) {
            // If the current element is equal to the previous element,
            // reset the starcpp tutorialer to the current end pointer
            start = end;
        } else if ((end - start >= 2) &&
                   (arr[end] < arr[end - 1]) == (arr[end - 1] < arr[end - 2])) {
            // If the current element violates the turbulence condition,
            // update the starcpp tutorialer to the index where the violation occurred
            start = end - 1;
        }

        maxLen = max(maxLen, end - start + 1);  // Update the maximum length
        end++;  // Move the end pointer forward
    }

    return maxLen;
}

int main() {
    vector<int> arr1 = {9, 4, 2, 10, 7, 8, 8, 1, 9};
    vector<int> arr2 = {4, 8, 12, 16};
    vector<int> arr3 = {1, 5, 3, 7, 4, 6, 9, 2, 8};
    vector<int> arr4 = {3, 2, 1, 4, 5, 6, 7, 8, 7};

    cout << "Length of the longest turbulent subarray in arr1: " << maxTurbulenceSize(arr1) << endl;
    cout << "Length of the longest turbulent subarray in arr2: " << maxTurbulenceSize(arr2) << endl;
    cout << "Length of the longest turbulent subarray in arr3: " << maxTurbulenceSize(arr3) << endl;
    cout << "Length of the longest turbulent subarray in arr4: " << maxTurbulenceSize(arr4) << endl;

    return 0;
}

Output:

Length of the longest turbulent subarray in arr1: 5
Length of the longest turbulent subarray in arr2: 2
Length of the longest turbulent subarray in arr3: 6
Length of the longest turbulent subarray in arr4: 3

Explanation:

Here is a breakdown of the code step-by-step;

• ✅ First, determine the size of the input array, and then save it in a variable called 'n'.
• ✅ If 'n' is greater than 2, return 'n', as a single-element array is seen as a turbulent subarray.
• ✅ Next, set up a variable named 'maxLen' to 1 to keep track of the subarray found so far.
• ✅ After that, initialize two pointers 'start' and 'end' at 0 and 1, indicating the beginning and end indices of the turbulent subarray.
• ✅ Create a loop that runs until the 'end' pointer reaches the end of the array.
• ✅ Within the loop, consider these scenarios; If the current element ('arr[end]') matches with the element ('arr[end. 1]'), reset the 'start' pointer to match with the position indicated by 'end'. If the current segment goes against the expected pattern of turbulence, there are at least two segments between the starting and ending points. Adjust the starting point to where this mismatch occurs (at 'end. 1'). If neither of the situations applies, no further action is necessary.
• ✅ Update the 'variable to reflect whichever value is greater; its value or the length of the current turbulent segment ('end. Start + 1').
• ✅ Move the 'end' pointer forward by incrementing it.
• ✅ After the loop terminates, return the 'maxLen' variable, which represents the length of the longest turbulent subarray found in the input array.
• ✅ If the current element ('arr[end]') matches with the element ('arr[end. 1]'), reset the 'start' pointer to match with the position indicated by 'end'.
• ✅ If the current segment goes against the expected pattern of turbulence, there are at least two segments between the starting and ending points. Adjust the starting point to where this mismatch occurs (at 'end. 1').
• ✅ If neither of the situations applies, no further action is necessary.

These instructions detail the two-pointer technique employed to effectively determine the size of the longest turbulent subarray, boasting a time complexity of O(n) and a fixed space complexity of O(1).