Longest Strictly Increasing or Strictly Decreasing Subarray

class Solution {
public:
    int longestMonotoneSubarray(vector<int>& array) {
        int increase = 1, decrease = 1;
        int maxLen = 1;

        for (int i = 0; i < array.size() - 1; i++) {
            if (array[i + 1] > array[i]) {
                increase++;
                decrease = 1;
            } else if (array[i + 1] < array[i]) {
                decrease++;
                increase = 1;
            } else {
                increase = 1;
                decrease = 1;
            }
            maxLen = max(maxLen, max(increase, decrease));
        }
        return maxLen;
    }
};

This C++ code defines a solution to find the length of the longest strictly increasing or strictly decreasing subarray within a given array of integers.

• The class Solution includes the function longestMonotoneSubarray which takes a vector<int>& representing the array.

• Two main variables, increase and decrease, track the lengths of the current increasing and decreasing subarrays, respectively.

• Another variable, maxLen, keeps record of the maximum length found during the traversal of the array.

• Iterate through the array using a for loop. For each pair of adjacent elements:

  • If the next element is greater than the current element, increment the increase counter and reset the decrease counter.

  • If the next element is less than the current element, increment the decrease counter and reset the increase counter.

  • If elements are equal or if it's the first pair of elements being compared, reset both increase and decrease to 1.

  • Update maxLen by taking the maximum value among maxLen, increase, and decrease.

• At the end of the array traversal, return maxLen which will be the length of the longest subarray that is either strictly increasing or strictly decreasing.

This approach ensures efficiency by only requiring a single pass through the input array, with a time complexity of O(n), where n is the number of elements in the array. The additional space complexity is O(1), using only a few auxiliary variables for tracking purposes.

class Solution {

    public int findLongestMonotoneSequence(int[] data) {
        int increasingSeqLength = 1, decreasingSeqLength = 1;
        int maxSeqLength = 1;

        for (int i = 0; i < data.length - 1; i++) {
            if (data[i + 1] > data[i]) {
                increasingSeqLength++;
                decreasingSeqLength = 1; 
            } else if (data[i + 1] < data[i]) {
                decreasingSeqLength++;
                increasingSeqLength = 1;
            } else {
                increasingSeqLength = 1;
                decreasingSeqLength = 1;
            }

            maxSeqLength = Math.max(maxSeqLength, Math.max(increasingSeqLength, decreasingSeqLength));
        }
        return maxSeqLength;
    }
}

This Java solution aims to find the length of the longest strictly increasing or strictly decreasing subarray within a given array. The approach involves tracking the length of the current increasing and decreasing sequences simultaneously, and updating the maximum length found accordingly.

• Start by initializing increasingSeqLength and decreasingSeqLength to 1, assuming the smallest possible subarray has a length of 1.
• Initialize maxSeqLength to 1, which will store the length of the longest monotone subarray found.
• Traverse the input array from the first to the penultimate element, using a for loop. Comparisons between consecutive elements determine if the current sequence is increasing or decreasing.
• If an element is greater than the previous one, increment the increasingSeqLength and reset decreasingSeqLength to 1 to start counting a new decreasing sequence.
• If an element is less than the previous one, increment the decreasingSeqLength and reset increasingSeqLength to 1 for a new increasing sequence.
• If elements are equal, reset both increasingSeqLength and decreasingSeqLength to 1.
• At each iteration, compute the maximum sequence length by comparing maxSeqLength with both increasingSeqLength and decreasingSeqLength.
• Finally, return maxSeqLength as the result, which represents the length of the longest monotone subarray found in the input array.

This method ensures efficient calculation with a time complexity of O(n), where n is the number of elements in the data array, as it requires just a single pass through the array.

class Solution:
    def longestContinuousSegment(self, array: list[int]) -> int:
        increase_run = decrease_run = longest_run = 1

        for index in range(1, len(array)):
            if array[index] > array[index - 1]:
                increase_run += 1
                decrease_run = 1
            elif array[index] < array[index - 1]:
                decrease_run += 1
                increase_run = 1
            else:
                increase_run = decrease_run = 1

            longest_run = max(longest_run, increase_run, decrease_run)

        return longest_run

In this Python solution, you determine the length of the longest strictly increasing or strictly decreasing subarray within a list of integers. This problem can effectively highlight trends within sequences, useful in data analysis contexts.

The logic operates as follows:

• Initiate counters for increasing (increase_run) and decreasing sequences (decrease_run), and also for the longest sequence found so far (longest_run), each set to 1.

• Iterate over each element in the array starting from the second element.

  • Compare the current element to the previous one.

    • If the current element is greater, it indicates an increasing sequence; increment increase_run and reset decrease_run.

    • If it's lesser, it indicates a decreasing sequence; increment decrease_run and reset increase_run.

    • If neither, reset both runs as the sequence has neither strictly increased nor decreased at this point.

  • Update longest_run to hold the maximum value among itself, increase_run, and decrease_run.

• Return the value of longest_run as the length of the longest continual segment of either strictly increasing or decreasing numbers.

This approach effectively tracks trends with a time complexity of O(n) due to a single pass through the array, making it optimal for larger datasets. The implementation leverages direct comparisons and simple arithmetic to maintain and update runs, resulting in an elegant and efficient solution for trend detection.