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

class Solution {
    public int longestSubarray(int[] nums) {
        int len = nums.length, count = 0, max = 0, last = 0, flag = 1;

        for (int num : nums) {
            if (num == 1) {
                count++;
                continue;
            }
            flag = 0;
            max = Math.max(last + count, max);
            last = count;
            count = 0;
        }
        return Math.max(last + count, max) - flag;
    }
}

class Solution:
    def longestSubarray(self, nums: List[int]) -> int:
        res = 0;
        left = 0;
        right = 0;
        last_zero_pos = None
        while right < len(nums):
            if nums[right] == 0:
                if last_zero_pos is not None:
                    res = max(res, right - left -1)
                    left = last_zero_pos + 1
                last_zero_pos = right
            right = right + 1

        return max(res, right - left - 1)

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        start = 0
        result = 1000000
        curr_sum = 0
        for i in range(len(nums)):
            curr_sum += nums[i]
            while curr_sum >= target:
                result = min(result, i - start + 1)
                curr_sum -= nums[start]
                start += 1
        if result == 1000000:
            result = 0
        return result

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0, right = 0;
        int sum = nums[0], count = 1;
        int min = Integer.MAX_VALUE;
        int len = nums.length;
        while (right < len) {
            while (sum < target) {
                right++;
                if (right < len) {
                    sum += nums[right];
                    count++;
                } else break;
            }
            if (sum >= target) min = Math.min(count, min);
            while (sum >= target && right >= left) {
                min = Math.min(count, min);
                sum -= nums[left];
                left++;
                count--;
            }
        }
        return min == Integer.MAX_VALUE ? 0 : min;
    }
}

function minSubArrayLen(target: number, nums: number[]): number {
    let k = Number.MAX_SAFE_INTEGER;
    let left = 0;
    let sum = 0;
    for (let right = 0; right < nums.length; right++) {
        sum+= nums[right];
        while (sum >= target) {
            k = Math.min(k, right - left + 1);
            sum-= nums[left];
            left++;
        }
    }
    return k === Number.MAX_SAFE_INTEGER ? 0 : k;
};

var minSubArrayLen = function(target, nums) {
  const n = nums.length;
  let k = 0, sum = 0, ans = +Infinity;
  for (let i = 0; i < n; i++) {
    sum += nums[i];
    while (sum >= target) {
      ans = Math.min(ans, i - k + 1);
      sum -= nums[k++];
    }
  }

  return ans === Infinity ? 0 : ans;
};

var minSubArrayLen = function(target, nums) {
    if(nums.length === 1) {
        if(nums[0] >= target) return 1
        return 0
    }

    let res = Infinity;
    let p1 = 0, p2 = 0;
    let curSum = nums[p1];

    while(p2 < nums.length && p1 < nums.length ) {
        if(curSum >= target) {
            res = Math.min(res,p2 - p1 + 1)
            curSum -= nums[p1++]
        } else {
            curSum += nums[++p2]
        }
    }

    return res === Infinity ? 0 : res
};

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        i = 0
        s = 0
        ans = len(nums) + 1
        for j in range(len(nums)):
            s+=nums[j]
            while i < j and s - nums[i] >= target:
                s -= nums[i]
                i+=1
            if s >= target:
                ans = min(ans, j - i + 1)
        return 0 if ans > len(nums) else ans

function maxConsecutiveAnswers(A: string, k: number): number {
    let size = k, map = new Map(), l = 0;
    for (let i = 0; i < k; i++) {
        map.set(A[i], map.has(A[i]) ? map.get(A[i]) + 1 : 1);
    }

    for (let i = k; i < A.length; i++) {
        map.set(A[i], map.has(A[i]) ? map.get(A[i]) + 1 : 1);
        while (Math.min(map.get('T'), map.get('F')) > k){
            map.set(A[l], map.get(A[l]) - 1);
            l++
        }

        size = Math.max(size, i - l + 1);
    }
    return size;

};

class Solution:
    def maxConsecutiveAnswers(self, answer_keys: str, k: int) -> int:
        result = 0

        for change_char in "TF":
            start = 0
            num_changes = 0
            num_answers = 0
            for answer_key in answer_keys:
                num_answers += 1
                num_changes += (answer_key == change_char)

                while num_changes > k:
                    num_answers -= 1
                    num_changes -= (answer_keys[start] == change_char)
                    start += 1
                
                result = max(result, num_answers)
        
        return result

class Solution {
    public int maxConsecutiveAnswers(String answerKey, int k) {
        int len = answerKey.length();
        int left = 0, right = 0;
        int countF = 0, countT = 0;
        int ans = Integer.MIN_VALUE;
        while (right < len) {
            while ((countT <= k || countF <= k) && (right < len)) {
                if (answerKey.charAt(right) == 'T')
                    countT++;
                else countF++;
                right++;
            }

            if ((countT > k && countF > k))
                ans = Math.max(ans, countT + countF - 1);
            else ans = Math.max(ans, countT + countF);
            
            if (answerKey.charAt(left) == 'T')
                countT--;
            else countF--;
            left++;
        }
        return ans;
    }
}

var maxConsecutiveAnswers = function(answerKey, k) {
  const n = answerKey.length;
  const dd = [0];

  const countTrues = (s, e) => {
    return dd[e] - dd[s];
  };

  const countFalses = (s, e) => {
    return e - s - countTrues(s, e);
  };

  for (let i = 0; i < n; i++) {
    dd[i + 1] = dd[i] + (answerKey[i] === 'T' ? 1 : 0);
  }

  let ti = 0, fi = 0, ans = 0;
  for (let i = 0; i < n; i++) {
    while ((i + 1 - ti) - countFalses(ti, i+1) > k) {
      ti++;
    }
    while ((i + 1 - fi) - countTrues(fi, i+1) > k) {
      fi++;
    }

    ans = Math.max(ans, i + 1 - ti, i + 1 - fi);
  }

  return ans;
};