前言

重新开始, 康复训练, 苦练go, 加油💪

他*个*的go什么**语法, 受不鸟了

定长子串中元音的最大数目

class Solution:
    def maxVowels(self, s: str, k: int) -> int:
        ans = cnt = 0
        
        for r, v in enumerate(s):
            l = r - k + 1
            if v in 'aeiou':
                cnt += 1
                ans = max(ans, cnt)
            if l < 0:
                continue
            if s[l] in 'aeiou':
                cnt -= 1
        
        return ans
# 剪枝优化
class Solution:
    def maxVowels(self, s: str, k: int) -> int:
        ans = cnt = 0

        for r, v in enumerate(s):
            l = r - k + 1

            if v in 'aeiou':
                cnt += 1
                ans = max(ans, cnt)
                if ans == k:
                    return k

            if l < 0:
                continue
                
            if s[l] in 'aeiou':
                cnt -= 1
        
        return ans

func maxVowels(s string, k int) int {
    cur, ans := 0, 0
    // 入
    for r, v := range s{
        if v == 'a' || v == 'e' || v == 'i' || v == 'o' || v == 'u'{
            cur ++
        }
        l := r - k + 1 // 初始化左指针
        // 不满足窗口大小继续扩容
        if l < 0{
            continue
        }
        // 更新ans
        ans = max(ans, cur)
        vL := s[l]
        // 出
        if vL == 'a' || vL == 'e' || vL == 'i' || vL == 'o' || vL == 'u' {
            cur --
        }
    }
    return ans
}

子数组最大平均数

class Solution:
    def findMaxAverage(self, nums: List[int], k: int) -> float:
        ans = -1000000
        cur = 0
        for r, v in enumerate(nums):
            l = r - k + 1
            cur += v
            if l < 0:
                continue
            ans = max(cur, ans)
            cur -= nums[l]
        
        return ans/k

func findMaxAverage(nums []int, k int) float64 {
    ans, cur := -1000000, 0

    for r, v := range(nums) {
        cur += v
        l := r - k + 1

        if l < 0 {
            continue
        }

        ans = max(cur, ans)
        cur -= nums[l]
    }
    return float64(ans) / float64(k)
}

大小为 K 且平均值大于等于阈值的子数组数目

class Solution:
    def numOfSubarrays(self, arr: List[int], k: int, threshold: int) -> int:
        n, tar = len(arr), k * threshold
        cur = ans= 0

        for r, v in enumerate(arr):
            l = r - k + 1
            cur += v
            if l < 0:
                continue
            ans += int(cur >= tar)
            cur -= arr[l]
        
        return ans

# 模板写腻了
class Solution:
    def numOfSubarrays(self, arr: List[int], k: int, threshold: int) -> int:
        n, tar = len(arr), k * threshold
        
        cur = sum(arr[:k])
        ans = int(cur >= tar)

        for r in range(k, n):
            l = r - k
            cur += arr[r] - arr[l]
            ans += int(cur >= tar)
        
        return ans
            

func numOfSubarrays(arr []int, k int, threshold int) int {
    ans, cur, tar := 0, 0, threshold * k

    for r, v := range(arr) {
        cur += v
        l := r - k + 1

        if l < 0 {
            continue
        }

        if cur >= tar {
            ans ++
        }

        cur -= arr[l]
    }
    return ans
}

半径为k的子数组平均值

class Solution:
    def getAverages(self, nums: List[int], k: int) -> List[int]:
        cur, x, n = 0, k * 2 + 1, len(nums)
        ans = [-1] * n
        for i, v in enumerate(nums):
            cur += v
            l = i - k * 2
            if l < 0 :
                continue
            ans[i - k] = cur // x
            cur -= nums[l]
        
        return ans

func getAverages(nums []int, k int) []int {
    if k == 0 {
        return nums
    }
    
    ans := make([]int, len(nums))
    cur := 0
    for i, _  := range ans {
        ans[i] = -1
    }

    for r, v := range nums {
        l, m := r - k * 2, r - k
        cur += v
        fmt.Println(cur)
        if l < 0 {
            continue
        }
        
        ans[m] = cur / (k * 2 + 1)
        cur -= nums[l]
    }
    return ans
}

得到k个黑块的最少涂色次数

func minimumRecolors(blocks string, k int) int {
    ans, cur := 10000000, 0
    for r, v := range blocks {
        l := r - k + 1
        if v == 'W' {
            cur ++
        }
        if l < 0 {
            continue
        }

        ans = min(cur, ans)
        if blocks[l] == 'W' {
            cur --
        }
    }

    return ans
}

2841. 几乎唯一子数组的最大和

func maxSum(nums []int, m int, k int) int64 {
    cnt := make(map[int]int)
    var ans, cur int64 = 0, 0
    for r, v := range nums {
        cnt[v]++
        cur += int64(v)
        l := r - k + 1
        if l < 0 {
            continue
        }
        if len(cnt) >= m {
            ans = max(ans, cur)
        }

        cnt[nums[l]] --
        if cnt[nums[l]] == 0 {
            delete(cnt, nums[l])
        }
        cur -= int64(nums[l])
    }
    return ans
}

1423. 可获得的最大点数

func maxScore(cardPoints []int, k int) int {
    k = len(cardPoints) - k
    cur, s := 0, 0
    for _, v := range cardPoints {
        s += v
    }

    ans := s
    if k == 0 {
        return ans
    }

    for r, v := range cardPoints {
        cur += v
        l := r - k + 1
        if l < 0 {
            continue
        }

        ans = min(ans, cur)
        cur -= cardPoints[l]
    }

    return s - ans
}

3679. 使库存平衡的最少丢弃次数

func minArrivalsToDiscard(arrivals []int, w int, m int) int {
    ans, cnt := 0, make(map[int]int)
    for r, v := range arrivals {
        l := r - w + 1
        cnt[v] ++
        if cnt[v] > m {
            ans ++
            cnt[v] --
            arrivals[r] = 0
        }
        if l < 0 {
            continue
        }

        cnt[arrivals[l]] --
    }

    return ans
}