Возрастающая подпоследовательность

public class Solution
{
    public static int FindLength(List<int> nums)
    {
        int maxLength = 1; // максимальная длина возрастающей последовательности
        int currLength = 1; // текущая длина возрастающей последовательности

        for (int i = 1; i < nums.Count; i++)
        {
            int prev = nums[i - 1];

            // т.к. последовательность по условию непрерывная,
            // то мы на каждой итерации или увеличиваем ответ - если
            // приходит число больше чем предыдущее, или делаем ответ 1,
            // т.к. непрерывная возрастающая последовательности кончилась
            // и мы начинаем новую возрастающую последовательность
            if (prev < nums[i])
            {
                currLength += 1;
            }
            else
            {
                currLength = 1;
            }

            // на каждой итерации обновляем ответ
            maxLength = Math.Max(maxLength, currLength);
        }

        return maxLength;
    }
}

#include <vector>

using namespace std;

int findLength(const vector<int>& nums) {
    int maxLength = 1; // максимальная длина возрастающей последовательности
    int currLength = 1; // текущая длина возрастающей последовательности
    for (int i = 1; i < nums.size(); i++) {
        int prev = nums[i - 1];
        // т.к. последовательность по условию непрерывная,
        // то мы на каждой итерации или увеличиваем ответ - если
        // приходит число больше чем предыдущее, или делаем ответ 1,
        // т.к. непрерывная возрастающая последовательности кончилась
        // и мы начинаем новую возрастающую последовательность
        if (prev < nums[i]) {
            currLength += 1;
        } else {
            currLength = 1;
        }
        // на каждой итерации обновляем ответ
        maxLength = max(maxLength, currLength);
    }
    return maxLength;
}

package main

func findLength(nums []int) int {
    maxLength := 1 // максимальная длина возрастающей последовательности
    currLength := 1 // текущая длина возрастающей последовательности
    for i := 1; i < len(nums); i++ {
        prev := nums[i - 1]
        // т.к. последовательность по условию непрерывная,
        // то мы на каждой итерации или увеличиваем ответ - если
        // приходит число больше чем предыдущее, или делаем ответ 1,
        // т.к. непрерывная возрастающая последовательности кончилась
        // и мы начинаем новую возрастающую последовательность
        if prev < nums[i] {
            currLength += 1
        } else {
            currLength = 1
        }
        if currLength > maxLength {
            // на каждой итерации обновляем ответ
            maxLength = currLength
        }
    }
    return maxLength
}

import java.util.List;

public class Solution {
    public int findLength(List<Integer> nums) {
        int maxLength = 1; // максимальная длина возрастающей последовательности
        int currLength = 1; // текущая длина возрастающей последовательности
        for (int i = 1; i < nums.size(); i++) {
            int prev = nums.get(i - 1);
            // т.к. последовательность по условию непрерывная,
            // то мы на каждой итерации или увеличиваем ответ - если
            // приходит число больше чем предыдущее, или делаем ответ 1,
            // т.к. непрерывная возрастающая последовательности кончилась
            // и мы начинаем новую возрастающую последовательность
            if (prev < nums.get(i)) {
                currLength += 1;
            } else {
                currLength = 1;
            }
            // на каждой итерации обновляем ответ
            maxLength = Math.max(maxLength, currLength);
        }
        return maxLength;
    }
}

from typing import *

def find_length(nums: List[int]) -> int:
    max_length = 1 # максимальная длина возрастающей последовательности
    curr_length = 1 # текущая длина возрастающей последовательности
    for i in range(1, len(nums)):
        prev = nums[i - 1]
        # т.к. последовательность по условию непрерывная,
        # то мы на каждой итерации или увеличиваем ответ - если
        # приходит число больше чем предыдущее, или делаем ответ 1,
        # т.к. непрерывная возрастающая последовательности кончилась
        # и мы начинаем новую возрастающую последовательность
        if prev < nums[i]:
            curr_length += 1
        else:
            curr_length = 1
        # на каждой итерации обновляем ответ
        max_length = max(max_length, curr_length)
    return max_length

export function findLength(nums) {
    let maxLength = 1; // максимальная длина возрастающей последовательности
    let currLength = 1; // текущая длина возрастающей последовательности

    for (let i = 1; i < nums.length; i++) {
        const prev = nums[i - 1];
        // т.к. последовательность по условию непрерывная,
        // то мы на каждой итерации или увеличиваем ответ - если
        // приходит число больше чем предыдущее, или делаем ответ 1,
        // т.к. непрерывная возрастающая последовательности кончилась
        // и мы начинаем новую возрастающую последовательность
        if (prev < nums[i]) {
            currLength += 1;
        } else {
            currLength = 1;
        }
        // на каждой итерации обновляем ответ
        maxLength = Math.max(maxLength, currLength);
    }
    return maxLength;
}