Решение: Последующая последующая мощность

Это является частью серии объяснений решения LeetCode ( index ). Если вам понравилось это решение или нашли его полезным, Пожалуйста, нравится Этот пост и/или upvote Мое решение по сообщению на форумах LeetCode Анкет

Проблема LeetCode #376 (средняя): Последующая последующая мощность

Описание:

( прыгнуть в : Идея решения Код : JavaScript | Python | Java | C ++

Учитывая целочисленное массив Nums , вернуть длину самых длинных Последовательность покачивания Анкет

A Последовательность покачивания это последовательность, в которой различия между последовательными числами строго чередуются между положительным и отрицательным. Первое различие (если кто -то существует) может быть либо положительным, либо отрицательным. Последовательность с менее чем двумя элементами – это тривиально последовательность.

• Например, [1, 7, 4, 9, 2, 5] это Последовательность покачивания Потому что различия (6, -3, 5, -7, 3) альтернативно положительные и отрицательные.
• Напротив, [1, 4, 7, 2, 5] и [1, 7, 4, 5, 5] не являются последовательностями, первыми, потому что его первые два различия положительны, а второе, потому что его последнее различие – нулевой.

A Последующая последовательность получается путем удаления некоторых элементов (в конечном итоге, также нулевого) из исходной последовательности, оставляя оставшиеся элементы в их первоначальном порядке.

Примеры:

Ограничения:

• 1. длиной
• 0 [i]

Идея:

( Прыгните к : Описание задачи Код : JavaScript | Python | Java | C ++

Ключевая реализация здесь заключается в том, что любое число, которое лежит в середине участка одного и того же направления, является посторонним, потому что чем более экстремальные числа являются лучшим выбором, поскольку они позволяют с большей вероятностью, что последующее число будет направленным сдача.

Таким образом, простой ответ здесь состоит в том, чтобы подсчитать точки перегиба в нашем входном массиве ( n ), где изменяется направление. Есть несколько способов сделать это, но в этом решении мы можем сохранить направленный флаг ( up ), чтобы отслеживать текущее направление, а затем увеличить наш ответ ( ans ) и инвертировать вверх Когда изменение найдено.

Одна сложная вещь заключается в установке начального направления. Согласно инструкциям, первый номер может представлять любое направление, поэтому нам придется подождать, пока мы не увидим другой номер, чтобы установить наше направление. Мы можем проверить это с помощью простого В то время как петля перед главной петлей.

Как только мы закончим, мы можем вернуть ANS Анкет

Реализация:

Все, кроме JavaScript, потребует дополнительной проверки перед основным циклом, чтобы учесть массив ввода со всем одинаковым номером.

Код JavaScript:

( Прыгните к : Описание задачи Идея решения

var wiggleMaxLength = function(N) {
    let len = N.length, i = 1
    while (N[i] === N[i-1]) i++
    let up = N[i-1] > N[i], ans = 1
    for (; i < len; i++)
        if ((up && N[i] < N[i-1]) || (!up && N[i] > N[i-1]))
            up = !up, ans++
    return ans
};

Код Python:

( Прыгните к : Описание задачи Идея решения

class Solution:
    def wiggleMaxLength(self, N: List[int]) -> int:
        lenN, i = len(N), 1
        while i < lenN and N[i] == N[i-1]: i += 1
        if i == lenN: return 1
        up, ans = N[i-1] > N[i], 1
        while i < lenN:
            if (up and N[i] < N[i-1]) or (not up and N[i] > N[i-1]):
                up = not up
                ans += 1
            i += 1
        return ans

Код Java:

( Прыгните к : Описание задачи Идея решения

class Solution {
    public int wiggleMaxLength(int[] N) {
        int len = N.length, i = 1, ans = 1;
        while (i < len && N[i] == N[i-1]) i++;
        if (i == len) return 1;
        boolean up = N[i-1] > N[i];
        for (; i < len; i++)
            if ((up && N[i] < N[i-1]) || (!up && N[i] > N[i-1])) {
                up = !up;
                ans++;
            }
        return ans;
    }
}

C ++ Код:

( Прыгните к : Описание задачи Идея решения

class Solution {
public:
    int wiggleMaxLength(vector& N) {
        int len = N.size(), i = 1, ans = 1;
        while (i < len && N[i] == N[i-1]) i++;
        if (i == len) return 1;
        bool up = N[i-1] > N[i];
        for (; i < len; i++)
            if ((up && N[i] < N[i-1]) || (!up && N[i] > N[i-1]))
                up = !up, ans++;
        return ans;
    }
};

Оригинал: “https://dev.to/seanpgallivan/solution-wiggle-subsequence-3e65”