1248. Count Number of Nice Subarrays

LeetCode medium original: C# #array #csharp #leetcode #medium #sliding-window #string #two-pointers

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

LeetCode Static

Вам given две строки s1 и s2 одинаковой длины, состоящие только из букв "x" и "y". Ваша 문제 - сделать эти две строки равными друг другу. Вы можете поменять местами любые два символа, принадлежащие разным 문자열м, что означает: поменять местами s1[i] и s2[j]. return минимальное количество обменов, необходимое для того, чтобы сделать s1 и s2 равными, или return -1, если это невозможно сделать.

예제:

Input: arr = [1,2]

Output: 2

C# 해법

매칭됨/원본

public class Solution {
    public int NumberOfSubarrays(int[] nums, int k) {
        return AtMost(nums, k) - AtMost(nums, k - 1);
    }
    private int AtMost(int[] nums, int k) {
        int res = 0, left = 0, count = 0;
        for (int right = 0; right < nums.Length; right++) {
            if (nums[right] % 2 == 1) count++;
            while (count > k) {
                if (nums[left++] % 2 == 1) count--;
            }
            res += right - left + 1;
        }
        return res;
    }
}

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 NumberOfSubarrays(vector<int>& nums, int k) {
        return AtMost(nums, k) - AtMost(nums, k - 1);
    }
    private int AtMost(vector<int>& nums, int k) {
        int res = 0, left = 0, count = 0;
        for (int right = 0; right < nums.size(); right++) {
            if (nums[right] % 2 == 1) count++;
            while (count > k) {
                if (nums[left++] % 2 == 1) count--;
            }
            res += right - left + 1;
        }
        return res;
    }
}

Java 해법

매칭됨/원본

public class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        return atMost(nums, k) - atMost(nums, k - 1);
    }

    private int atMost(int[] nums, int k) {
        int res = 0, left = 0, count = 0;
        for (int right = 0; right < nums.length; right++) {
            if (nums[right] % 2 == 1) count++;
            while (count > k) {
                if (nums[left++] % 2 == 1) count--;
            }
            res += right - left + 1;
        }
        return res;
    }
}

JavaScript 해법

매칭됨/원본

var numberOfSubarrays = function(nums, k) {
    return atMost(nums, k) - atMost(nums, k - 1);
};

function atMost(nums, k) {
    let res = 0, left = 0, count = 0;
    for (let right = 0; right < nums.length; right++) {
        if (nums[right] % 2 === 1) count++;
        while (count > k) {
            if (nums[left++] % 2 === 1) count--;
        }
        res += right - left + 1;
    }
    return res;
}

Python 해법

매칭됨/원본

def numberOfSubarrays(nums, k):
    def atMost(nums, k):
        count = 0
        left = 0
        res = 0
        for right in range(len(nums)):
            if nums[right] % 2 == 1:
                count += 1
            while count > k:
                if nums[left] % 2 == 1:
                    count -= 1
                left += 1
            res += right - left + 1
        return res
    return atMost(nums, k) - atMost(nums, k - 1)

Go 해법

매칭됨/원본

func numberOfSubarrays(nums []int, k int) int {
    return atMost(nums, k) - atMost(nums, k-1)
}

func atMost(nums []int, k int) int {
    res, left, count := 0, 0, 0
    for right := 0; right < len(nums); right++ {
        if nums[right] % 2 == 1 {
            count++
        }
        for count > k {
            if nums[left] % 2 == 1 {
                count--
            }
            left++
        }
        res += right - left + 1
    }
    return res
}

Algorithm

Преобразуйте 배열 чисел nums, заменив все чётные числа на 0, а все нечётные числа на 1.

Используя технику скользящего окна (или двух указателей), find все под배열ы, содержащие ровно k единиц.

Подсчитайте количество таких под배열ов и return этот результат.

😎

Vacancies for this task

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

전체 채용

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