thảo luận Leetcode mỗi ngày

def bruteForce(self, nums: List[int], k: int) -> int:
        ans = 0
        for i in range(len(nums)):
            curFreq = defaultdict(int)
            maxFreq = 0
            for j in range(i, len(nums)):
                curFreq[nums[j]] += 1
                maxFreq = max(maxFreq, curFreq[nums[j]])
                if maxFreq <= k:
                    ans = max(ans, j-i+1)
        return ans

function maxSubarrayLength(nums: number[], k: number): number {
    let count = 1, start =0, end = 0, map = new Map<number, number>();
    while(end < nums.length) {
        map.set(nums[end], (map.get(nums[end]) || 0) + 1);
        while(map.get(nums[end]) > k) {
            map.set(nums[start], map.get(nums[start]) - 1);
            start++;
        }
        count = Math.max(count, end - start + 1)
        end++
    }
    return count;
};

var maxSubarrayLength = function(nums, k) {
    let l = 0;
    let counts = {};
    let res = 1;

    counts[nums[l]] = 1;

    for (let r = 1; r < nums.length; r++) {
        counts[nums[r]] = (counts[nums[r]] || 0) + 1;

        while (l <= r && counts[nums[r]] > k) {
            counts[nums[l]] -= 1;
            l++;
        }

        res = Math.max(res, r - l + 1);
    }

    return res;
};

class Solution {
public:
    int maxSubarrayLength(vector<int>& nums, int k) {
        int ret = 0;
        unordered_map<int, int> freq;
        for (int i = 0, j = 0; j < nums.size(); ++j) {
            freq[nums[j]]++;
            while(freq[nums[j]] > k) {
                freq[nums[i]]--;
                i++;
            }
            ret = max(ret, j - i + 1);
        }
        return ret;
    }
};

class Solution {
    public int maxSubarrayLength(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        int i=0, j=0, maxSubLen = -1, len = nums.length;

        while(i < len){
            int num = nums[i];
            int count = map.containsKey(num) ? map.get(num) + 1 : 1;
            map.put(num, count);
            if(count > k){
                maxSubLen = Math.max(maxSubLen, i - j);
                while(nums[j] != num && j < i){
                    map.put(nums[j], map.get(nums[j]) - 1);
                    j++;
                }
                map.put(nums[j], map.get(nums[j]) - 1);
                j++;
            }
            i++;
        }
        maxSubLen = Math.max(maxSubLen, i - j);
        return maxSubLen;
    }
}

var maxSubarrayLength = function(nums, k) {
    const n = nums.length, cnt = {};
    let ans = 0;
    for (let i = 0, j = 0; i < n; i++) {
        const x = nums[i];
        cnt[x] = (cnt[x] ?? 0) + 1;
        while (cnt[x] > k) {
            cnt[nums[j++]]--;
        }
        ans = Math.max(ans, i - j + 1);
    }
    return ans;
};

class Solution:
    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
        mp = {}
        n = len(nums)
        ans = 0
        l = 0
        for r in range(n):
            mp[nums[r]] = mp.get(nums[r] , 0) + 1
            while mp[nums[r]] > k:
                mp[nums[l]] -= 1
                l += 1
            ans = max(ans , r - l + 1)
        
        return ans

public class Solution
{
    public int MaxSubarrayLength(int[] nums, int k)
    {
        int result = 0;
        int count = 0;
        Dictionary<int, int> dict = new();
        int left = 0;
        for (int right = 0; right < nums.Length; right++)
        {
            int num = nums[right];
            if (!dict.ContainsKey(num))
            {
                dict.Add(num, 0);
            }
            dict[num]++;

            if (dict[num] <= k)
            {
                result = Math.Max(result, right - left + 1);
                continue;
            }
            while (left <= right)
            {
                int index = left;
                left++;
                dict[nums[index]]--;
                if (nums[index] == num)
                {
                    break;
                }
            }
        }

        return result;
    }
}

int maxSubarrayLength(vector<int>& nums, int k) {
    unordered_map<int, int> freq;
    int n = nums.size();
    int count = 0;
    for(int l = 0, r =0; r < n; ++r) {
        int val = nums[r];
        freq[val]++;
        while(freq[val] > k) freq[nums[l++]]--;
        count = max(count, r - l +1);
    }
    return count;
}

class Solution:
    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
        dct ={}
        l = 0
        lens=0
        for i in range(len(nums)):
            dct.update({
                nums[i]:dct.get(nums[i],0)+1
                })
            while dct[nums[i]] > k:
                dct[nums[l]] -= 1
                l+=1
            lens = max(lens, i - l +1)
        return lens

class Solution:
    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
        begin = 0
        count = {}
        maxLength = 0
        for end in range(len(nums)):
            num = nums[end]
            count[num] = count.get(num, 0) + 1
            if count[num] <= k:
                if end - begin + 1 > maxLength:
                    maxLength = end - begin + 1
            else:
                while begin <= end and count[num] > k:
                    count[nums[begin]] -= 1
                    begin += 1
        return maxLength