class Solution:
    def longestOnes(self, nums: List[int], k: int) -> int:
        n, right = len(nums), 0
        left = 0
        temp_k = k
        max_temp = 0

        while right < n:
            if nums[right] == 0:
                temp_k -= 1

            while temp_k < 0:
                if nums[left] == 0:
                    temp_k += 1
                left += 1

            max_temp = max(max_temp, right - left + 1)
            right += 1

        return max_temp

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int n = nums.size();
        int left = 0, right = 0;
        int temp_k = k;
        int max_temp = 0;

        while (right < n) {
            if (nums[right] == 0) {
                temp_k--;
            }

            while (temp_k < 0) {
                if (nums[left] == 0) {
                    temp_k++;
                }
                left++;
            }

            max_temp = max(max_temp, right - left + 1);
            right++;
        }

        return max_temp;
    }
};

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        n, right = len(s), len(p)

        if right > n:
            return []

        need = Counter(p)
        window = Counter(s[:right])
        start_index = []

        if need == window:
            start_index.append(0)

        for i in range(right, n):
            window[s[i]] += 1
            left_c = s[i - right]
            window[left_c] -= 1
            if window[left_c] == 0:
                del window[left_c]

            if window == need:
                start_index.append(i - right + 1)

        return start_index

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int n = s.size();
        int m = p.size();
        if (m > n) return {};

        vector<int> need(26, 0), window(26, 0);
        for (char c : p) need[c - 'a']++;

        vector<int> res;
        int left = 0, right = 0;

        while (right < n) {
            window[s[right] - 'a']++;
            right++;

            if (right - left == m) {
                if (window == need) res.push_back(left);
                window[s[left] - 'a']--;
                left++;
            }
        }
        return res;
    }
};