978. Longest Turbulent Subarray

LeetCode medium original: C# #array #csharp #leetcode #math #medium

선택한 UI 언어에 맞게 문제 텍스트를 러시아어에서 번역합니다. 코드는 변경하지 않습니다.

LeetCode Static

Дан 정수 배열 arr, return длину максимального турбулентного под배열а 배열а arr.

Под배열 считается турбулентным, если знак сравнения меняется между каждой парой смежных elementов в под배열е.

Более формально, под배열 [arr[i], arr[i + 1], ..., arr[j]] 배열а arr считается турбулентным тогда и только тогда, когда:

Для всех i <= k < j:

arr[k] > arr[k + 1], когда k нечетное, и

arr[k] < arr[k + 1], когда k четное.

Или, для всех i <= k < j:

arr[k] > arr[k + 1], когда k четное, и

arr[k] < arr[k + 1], когда k нечетное.

예제:

Input: arr = [9,4,2,10,7,8,8,1,9]

Output: 5

Explanation: arr[1] > arr[2] < arr[3] > arr[4] < arr[5]

C# 해법

매칭됨/원본

public class Solution {
    public int MaxTurbulenceSize(int[] A) {
        int N = A.Length;
        int ans = 1;
        int anchor = 0;
        for (int i = 1; i < N; ++i) {
            int c = Math.Sign(A[i - 1] - A[i]);
            if (c == 0) {
                anchor = i;
            } else if (i == N - 1 || c * Math.Sign(A[i] - A[i + 1]) != -1) {
                ans = Math.Max(ans, i - anchor + 1);
                anchor = i;
            }
        }
        return ans;
    }
}

C++ 해법

자동 초안, 제출 전 검토

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int MaxTurbulenceSize(vector<int>& A) {
        int N = A.size();
        int ans = 1;
        int anchor = 0;
        for (int i = 1; i < N; ++i) {
            int c = Math.Sign(A[i - 1] - A[i]);
            if (c == 0) {
                anchor = i;
            } else if (i == N - 1 || c * Math.Sign(A[i] - A[i + 1]) != -1) {
                ans = max(ans, i - anchor + 1);
                anchor = i;
            }
        }
        return ans;
    }
}

Java 해법

매칭됨/원본

class Solution {
    public int maxTurbulenceSize(int[] A) {
        int N = A.length;
        int ans = 1;
        int anchor = 0;

        for (int i = 1; i < N; ++i) {
            int c = Integer.compare(A[i - 1], A[i]);
            if (c == 0) {
                anchor = i;
            } else if (i == N - 1 || c * Integer.compare(A[i], A[i + 1]) != -1) {
                ans = Math.max(ans, i - anchor + 1);
                anchor = i;
            }
        }

        return ans;
    }
}

JavaScript 해법

매칭됨/원본

var maxTurbulenceSize = function(A) {
    const N = A.length;
    let ans = 1;
    let anchor = 0;

    for (let i = 1; i < N; ++i) {
        const c = Math.sign(A[i - 1] - A[i]);
        if (c === 0) {
            anchor = i;
        } else if (i === N - 1 || c * Math.sign(A[i] - A[i + 1]) !== -1) {
            ans = Math.max(ans, i - anchor + 1);
            anchor = i;
        }
    }

    return ans;
};

Go 해법

매칭됨/원본

func maxTurbulenceSize(A []int) int {
    N := len(A)
    ans := 1
    anchor := 0

    for i := 1; i < N; i++ {
        c := compare(A[i-1], A[i])
        if c == 0 {
            anchor = i
        } else if i == N-1 || c*compare(A[i], A[i+1]) != -1 {
            if i-anchor+1 > ans {
                ans = i - anchor + 1
            }
            anchor = i
        }
    }

    return ans
}

func compare(a, b int) int {
    if a > b {
        return 1
    }
    if a < b {
        return -1
    }
    return 0
}

Algorithm

Сканируйте 배열 слева направо. Используйте переменные для отслеживания начала текущего блока и максимальной длины турбулентного под배열а.

Если достигли конца блока (последний element или текущий element не соответствует условию чередования), зафиксируйте длину этого блока как потенциальный ответ и установите начало нового блока на следующий element.

Повторяйте шаг 2 до конца 배열а и return максимальную длину турбулентного под배열а.

😎

Vacancies for this task

활성 채용 with overlapping task tags are 표시됨.

전체 채용

아직 활성 채용이 없습니다.