1
function numSubarrayProductLessThanK(nums: number[], k: number): number {
2
    // 边界去除（这里其实里面的逻辑也可以排除这里的边界）
3
    if (k === 0) {
4
        return 0;
5
    }
6
    let sum = 1, left = 0, ans = 0;
7
    for (let i = 0; i < nums.length; i++) {
8
        // 通过题目我们很快能推导出来，什么时候是我们子数组乘积的最大值呢？就是我们子数组里面每一个数都乘起来的值，所以可以用变长滑动窗口来维护这个边界
9
        sum *= nums[i];
10

11
        // 由题目可知，我们得到的和一定要小于k，所以一旦我们的乘积超过了我们的预期，我们这里就需要截断他。然后开始蠕动，直到我们滑动窗口内的值符合题意，然后继续更新
12
        while (sum >= k && left <= i) {
13
            sum = Math.floor(sum / nums[left]);
14
            left++;
15
        }
16
        // 这里我们采用的是答案叠加的方式，为什么可以进行叠加呢？原因是这样的，假设我们的例子现在是
17
        // [10, 2, 5, 6], k = 10
18
        // 我们很快就能发现，最后得到的答案的格式大概是这样的：
19
        // [10]、[5]、[2]、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
20
        // 按照我们的算法进行遍历，[10, 5, 2]的时候就会进入上面的循环，其余的时候是不进入的，当不存在于内循环的时候，我们这里有
21
        // [left, right] [...arr] maxValue acc
22
        // [0, 0] [10] 10 1
23
        // [0, 1] [10, 2] [2] 20 2 这里原本会有一个[10]的，但是我们不计算重复的子数组，所以[10]排除，我们会发现从[left...right]里面的值都是符合条件的，即[left + 1, right], [left + 2, right] ... [right, right]，一个有几个数组符合条件呢？恰好有right - left + 1个数组，即我们当前子数组的长度
24
        // [0, 3] [10, 5, 2] loop
25
        ans += i - left + 1;
26
    }
27
    return ans;
28
};

1
function numberOfSubstrings(s: string): number {
2
    // 这里用了一个取巧的办法，因为我们只要判断三个连在一起的a, b, c，所以让3个连号的数组存储就行了，不然可以使用哈希表噢！
3
    const arr = Array(3).fill(0);
4
    let ans = 0, left = 0;
5
    // 这里设置这个函数是因为偷懒，不想写太多的判断逻辑又能复用，主要的逻辑就是检测这三个数组有没有超过我们的规定，如果没有的话就返回true，不然就false
6
    const checkArray = () => {
7
        for (const num of arr) {
8
            if (num < 1) {
9
                return false;
10
            }
11
        }
12
        return true;
13
    }
14
    for (let i = 0; i < s.length; i++) {
15
        // 同样处理右窗口，我们把所有要进来的字符加入我们的数组当中存储起来
16
        arr[s[i].charCodeAt(0) - 'a'.charCodeAt(0)]++;
17
        // 开始判断，如果满足了题目的要求，进入循环之中
18
        while (checkArray()) {
19
            arr[s[left++].charCodeAt(0) - 'a'.charCodeAt(0)]--;
20
        }
21
        // 当循环处理完毕的时候，我们会发现处理完毕的数组应该已经不符合题目的要求了，但是这里就会存在[left, right]不符合要求而[left - 1, right]符合要求的情况，这个时候就会出现一种情况，如题所述，我们只要分别保留一个a, b, c字符就可以存入答案之中。所以会有[left - 1, right], [left - 2, right], [left - 3, right]....[0, right]，是符合题意的。而因为我们的下标是从零开始，当我们开始不符合题意的时候，当前的left值刚好就是[left - 1, right] ... [0, right] 数组的大小，即我们想要获取的答案
22
        ans += left;
23
    }
24
    return ans;
25
};

1
function numSubarraysWithSum(nums: number[], goal: number): number {
2
    // 创建一个查找的函数，目的在于每次查找>=k的值
3
    const findK = (k: number) => {
4
        let left = 0, sum = 0, ans = 0;
5
        for (let i = 0; i < nums.length; i++) {
6
            sum += nums[i];
7
            while (sum >= k && left <= i) {
8
                sum -= nums[left];
9
                left++;
10
            }
11
            ans += left;
12
        }
13
        return ans;
14
    }
15
    // 由本体我们指导，我们目前想要找到的答案需要满足goal这个条件，但是怎么样才能满足goal这个条件呢？goal是恰好等于goal的这个情况，如果根据前面的例题总结我们会发现一件事情，我们的滑动窗口应该是一次滑倒底的，即完整的一次遍历。这种情况就限制了我们很难很好的找出满足goal的这个条件。所以这里人们就发明了一个取巧的办法，我们可以先找出>=goal的值，然后我们再找到一个>=goal + 1的值，由于滑动窗口的性质决定，>=goal的值一定是>=goal + 1的值，所以我们只需要减去后面满足的情况，不就能恰好的得到满足goal的情况了吗？
16
    return findK(goal) - findK(goal + 1);
17
};