Поиск монотонной последовательности

public class Solution {
    public static List<int> SearchMonoton(List<int> nums) {
        int maxLen = 1, incLen = 1, decLen = 1;
        List<int> result = new List<int> {0, 0};

        for (int idx = 1; idx < nums.Count; idx++) {
            // последовательность возрастает
            if (nums[idx - 1] < nums[idx]) {
                incLen++;
                decLen = 1;
            }
            // последовательность убывает
            else if (nums[idx - 1] > nums[idx]) {
                decLen++;
                incLen = 1;
            } else {
                // сбрасываем последовательность
                incLen = 1;
                decLen = 1;
            }

            // обновляем максимальную длину если текущая больше
            int currLen = Math.Max(incLen, decLen);
            if (currLen > maxLen) {
                result = new List<int> {idx - currLen + 1, idx};
                maxLen = currLen;
            }
        }

        return result;
    }
}

#include <vector>

using namespace std;

vector<int> searchMonoton(vector<int>& nums) {
    int maxLen = 1, incLen = 1, decLen = 1;
    vector<int> result = {0, 0};

    for (int idx = 1; idx < nums.size(); ++idx) {
        // последовательность возрастает
        if (nums[idx - 1] < nums[idx]) {
            incLen += 1;
            decLen = 1;
        }
        // последовательность убывает
        else if (nums[idx - 1] > nums[idx]) {
            decLen += 1;
            incLen = 1;
        }
        // сбрасываем последовательность
        else {
            incLen = 1;
            decLen = 1;
        }

        // обновляем максимальную длину если текущая больше
        int currLen = max(incLen, decLen);
        if (currLen > maxLen) {
            result = {idx - currLen + 1, idx};
            maxLen = currLen;
        }
    }

    return result;
}

package main

func searchMonoton(nums []int) []int {
    maxLen, incLen, decLen := 1, 1, 1
    result := []int{0, 0}

    for idx := 1; idx < len(nums); idx++ {
        // последовательность возрастает
        if nums[idx-1] < nums[idx] {
            incLen++
            decLen = 1
        } else if nums[idx-1] > nums[idx] {
            // последовательность убывает
            decLen++
            incLen = 1
        } else {
            // сбрасываем последовательность
            incLen = 1
            decLen = 1
        }

        // обновляем максимальную длину если текущая больше
        currLen := max(incLen, decLen)
        if currLen > maxLen {
            result = []int{idx - currLen + 1, idx}
            maxLen = currLen
        }
    }

    return result
}

import java.util.*;

public class Solution {
    public static List<Integer> searchMonoton(List<Integer> nums) {
        int maxLen = 1, incLen = 1, decLen = 1;
        List<Integer> result = Arrays.asList(0, 0);

        for (int idx = 1; idx < nums.size(); idx++) {
            // последовательность возрастает
            if (nums.get(idx - 1) < nums.get(idx)) {
                incLen++;
                decLen = 1;
            }
            // последовательность убывает
            else if (nums.get(idx - 1) > nums.get(idx)) {
                decLen++;
                incLen = 1;
            } else {
                // сбрасываем последовательность
                incLen = 1;
                decLen = 1;
            }

            // обновляем максимальную длину если текущая больше
            int currLen = Math.max(incLen, decLen);
            if (currLen > maxLen) {
                result = Arrays.asList(idx - currLen + 1, idx);
                maxLen = currLen;
            }
        }

        return result;
    }
}

import java.util.*;

public class Solution {
    public static List<Integer> searchMonoton(List<Integer> nums) {
        int maxLen = 1, incLen = 1, decLen = 1;
        List<Integer> result = Arrays.asList(0, 0);

        for (int idx = 1; idx < nums.size(); idx++) {
            // последовательность возрастает
            if (nums.get(idx - 1) < nums.get(idx)) {
                incLen++;
                decLen = 1;
            }
            // последовательность убывает
            else if (nums.get(idx - 1) > nums.get(idx)) {
                decLen++;
                incLen = 1;
            } else {
                // сбрасываем последовательность
                incLen = 1;
                decLen = 1;
            }

            // обновляем максимальную длину если текущая больше
            int currLen = Math.max(incLen, decLen);
            if (currLen > maxLen) {
                result = Arrays.asList(idx - currLen + 1, idx);
                maxLen = currLen;
            }
        }

        return result;
    }
}

from typing import List

def search_monoton(nums: List[int]) -> List[int]:
    max_len = inc_len = dec_len = 1
    result = [0, 0]

    for idx in range(1, len(nums)):
        # последовательность возрастает
        if nums[idx - 1] < nums[idx]:
            inc_len += 1
            dec_len = 1
        # последовательность убывает
        elif nums[idx - 1] > nums[idx]:
            dec_len += 1
            inc_len = 1
        # сбрасываем последовательность
        else:
            inc_len = 1
            dec_len = 1

        # обновляем максимальную длину если
        # текущая длина больше предыдущей максимальной
        curr_len = max(inc_len, dec_len)
        if curr_len > max_len:
            result = [idx - curr_len + 1, idx]
            max_len = curr_len

    return result