Three-Question Quick Reference for the Four Problems#

About the code Each problem provides implementations in C / C++ / JavaScript. The three versions are logically equivalent; switch tabs to view them. The window is always written as left-closed, right-open [left, right), so the length is always right - left, nums[right] is the element that just entered the window, and nums[left] is the element about to leave the window.

Problem Description#

Given an array nums of n positive integers and a positive integer target, find the minimum length of a subarray whose sum is greater than or equal to target, and return its length. If no such subarray exists, return 0.

Example:

1
Input: target = 7, nums = [2,3,1,2,4,3]
2
Output: 2
3
Explanation: The subarray [4,3] is the minimum-length subarray under this condition.
4

5
Input: target = 4, nums = [1,4,4]          Output: 1
6
Input: target = 11, nums = [1,1,1,1,1,1,1,1]  Output: 0

Constraints: 1 <= target <= 10^9, 1 <= nums.length <= 10^5, 1 <= nums[i] <= 10^4.

Approach: Shrink Once the Sum Is Enough, Record Before Shrinking#

The window state is just a single sum. Because the array is all positive numbers, sum increases monotonically when expanding right and sum decreases monotonically when shrinking left. This gives two properties:

1. As soon as sum >= target, you should shrink immediately — continuing to expand only makes the window longer, never better. This is the classic “shrink when satisfied” pattern (Style A).
2. Shrinking will definitely break the “already enough” state, so the answer must be recorded before removing left — that is, “record first, then break.”

Fill in the four blanks following the template: ② when adding, sum += nums[right]; ③ the shrink condition is sum >= target; ④ record right - left on the first line of the shrink loop; ⑤ when removing, sum -= nums[left].

Walkthrough#

Using target = 7, nums = [2,3,1,2,4,3] as an example:

1
Subscript   0  1  2  3  4  5
2
nums   2  3  1  2  4  3

1
Expand to right=1, window [0,1)=[2], sum=2   → not enough, do not shrink
2
Expand to right=2, window [0,2)=[2,3], sum=5 → not enough, do not shrink
3
Expand to right=3, window [0,3)=[2,3,1], sum=6 → not enough, do not shrink
4
Expand to right=4, window [0,4)=[2,3,1,2], sum=10 ≥ 7 ← enter shrink loop
5
  ├ First record: [0,4) length 4 → best = 4
6
  ├ Remove 2 → sum=8, window [1,4) length 3 → best = 3
7
  ├ Remove 3 → sum=5, stop shrinking, window [2,4)=[1,2]
8
Expand to right=5, window [2,5)=[1,2,4], sum=9 ≥ 7 ← enter shrink loop again
9
  ├ First record: [2,5) length 3, not better than 3
10
  ├ Remove 1 → sum=8, window [3,5) length 2 → best = 2
11
  ├ Remove 2 → sum=6, stop shrinking, window [4,5)=[4]
12
Expand to right=6, window [4,6)=[4,3], sum=9 ≥ 7
13
  ├ First record: [4,6) length 2, not better than 2
14
  └ Remove 4 → sum=5, stop shrinking
15

16
Answer 2 ✔ (subarray [4,3])

Note two things: left will never exceed right (the window is always valid); and each round of shrinking must record first, then remove — reversing the order will record a window whose “sum is already less than target,” giving a length that is too small and actually invalid. On this problem, the length obtained for this reason happens to be the same, so it’s easy to get away with it; a different dataset will expose the bug (see pitfall 4 below).

Code Implementation#

1
int minSubArrayLen(int target, int *nums, int numsSize) {
2
    long long sum = 0;                 /* Sum of elements in the window, long long to prevent overflow */
3
    int left = 0, right = 0;
4
    int best = numsSize + 1;           /* Larger than any valid length, means "not found yet" */
5

6
    while (right < numsSize) {
7
        sum += nums[right];            /* ① Right boundary element enters the window */
8
        right++;                       /*    Window becomes [left, right) */
9

10
        while (sum >= target) {        /* ③ Sum is enough, start shrinking */
11
            if (right - left < best)   /* ④ Record the answer first, then move left out */
12
                best = right - left;
13
            sum -= nums[left];         /* ⑤ Left boundary element exits the window */
14
            left++;
15
        }
16
    }
17
    return best == numsSize + 1 ? 0 : best;
18
}

1
#include <vector>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int minSubArrayLen(int target, vector<int>& nums) {
7
        long long sum = 0;
8
        int left = 0, right = 0;
9
        int best = (int)nums.size() + 1;      // Larger than any valid length
10

11
        while (right < (int)nums.size()) {
12
            sum += nums[right];               // ① Right boundary element enters the window
13
            right++;
14

15
            while (sum >= target) {           // ③ Sum is enough, start shrinking
16
                if (right - left < best)      // ④ Record the answer first
17
                    best = right - left;
18
                sum -= nums[left];            // ⑤ Left boundary element exits the window
19
                left++;
20
            }
21
        }
22
        return best == (int)nums.size() + 1 ? 0 : best;
23
    }
24
};

1
function minSubArrayLen(target, nums) {
2
  let sum = 0;
3
  let left = 0, right = 0;
4
  let best = nums.length + 1;      // Larger than any valid length
5

6
  while (right < nums.length) {
7
    sum += nums[right];            // ① Right boundary element enters the window
8
    right++;
9

10
    while (sum >= target) {        // ③ Sum is enough, start shrinking
11
      if (right - left < best)     // ④ Record the answer first
12
        best = right - left;
13
      sum -= nums[left];           // ⑤ Left boundary element exits the window
14
      left++;
15
    }
16
  }
17
  return best === nums.length + 1 ? 0 : best;
18
}

Complexity#

Pitfalls#

1. Using long long for sum is safer. The upper bound of the window sum is the sum of the entire array n × nums[i] = 10^5 × 10^4 = 10^9, and int just barely fits it (upper limit around 2.1 × 10^9); but target in the problem itself is given as 10^9, so if the data scale goes up one more notch it will overflow. Writing long long costs nothing.
2. Return 0 when no answer is found, not the initial value of best. So the initial value should be a sentinel like n + 1 that can never equal any valid length, and a final check is needed.
3. The shrink condition uses >=, not >. The problem asks for “greater than or equal to target”; writing > will miss windows whose sum is exactly target.
4. The inner loop must be while, not if. In some problems the shrink is “at most one step per round,” but not here: when sum >= target, you may need to shrink several steps in a row to bring sum down. Counterexample: target = 10, nums = [1,1,1,10], the correct answer is 1 (subarray [10]). Using while will shrink all the way to [10]; switching to if shrinks only one step, left stops at 1, and the answer will be wrongly reported as 4.

Extension: This problem also has an O(n log n) solution — prefix sum + binary search on the answer (fix a length L, check whether there exists a window of length L with sum ≥ target; the check function is monotonic in L). Because the array is all positive, the sliding window is already optimal, but this “binary search + prefix sum” technique is very useful for problems where “the window state is hard to maintain.”

Problem Description#

Given an integer array nums and an integer k, return the number of contiguous subarrays where the product of all elements in the subarray is strictly less than k.

Example:

1
Input: nums = [10,5,2,6], k = 100
2
Output: 8
3
Explanation: The 8 subarrays whose product is less than 100 are:
4
      [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6].
5
      Note that the product of [10,5,2] is 100, which is not less than 100, so it does not count.
6

7
Input: nums = [1,2,3], k = 0   Output: 0

Constraints: 1 <= nums.length <= 3 * 10^4, 1 <= nums[i] <= 1000, 0 <= k <= 10^6.

Approach: Each Right Endpoint Contributes right - left Subarrays#

The window state is prod. This problem has the same flavor as the previous one—all positive numbers, prod increases monotonically as the window expands and decreases monotonically as it shrinks—but the shape of the answer is different:

• The previous problem asked for “the shortest window that satisfies the condition,” which is a window itself;
• This problem asks for the number of subarrays, so you need to know how to count.

The counting method is: fix the right endpoint right - 1 and ask “how many valid subarrays end at this position.” Since the array is all positive numbers, the product only increases as the window grows, so the valid subarrays ending at right - 1 have starting points that form exactly the contiguous range left, left+1, …, right-1, giving right - left in total. Summing up the contribution of each right endpoint gives the answer.

So the four blanks: ② prod *= nums[right]; ③ the shrink condition is prod >= k (shrink when violated, style B—the smaller prod is, the more valid); ④ only after shrinking is there a right - left to count, so accumulate after the shrink loop; ⑤ prod /= nums[left].

Walkthrough#

Taking nums = [10,5,2,6], k = 100 as an example:

1
Subscript   0   1  2  3
2
nums   10  5  2  6

1
Add 10 → prod=10   < 100, window [0,1)
2
          valid subarrays ending at nums[0]: 1 - 0 = 1 → [10]          cumulative 1
3
Add 5  → prod=50   < 100, window [0,2)
4
          ending at nums[1]: 2 - 0 = 2 → [5], [10,5]                cumulative 3
5
Add 2  → prod=100  ≥ 100 ← violation, shrink
6
          remove 10 → prod=10, window [1,3), 1 < 2
7
          ending at nums[2]: 3 - 1 = 2 → [2], [5,2]                 cumulative 5
8
Add 6  → prod=60   < 100, window [1,4)
9
          ending at nums[3]: 4 - 1 = 3 → [6], [2,6], [5,2,6]        cumulative 8
10

11
Answer 8 ✔

Note the round with prod = 100: the problem requires strictly less than k, so prod >= k must shrink; after shrinking to prod = 10, the window is [5,2], and the monotonic decrease of prod guarantees that “shrinking further only makes it smaller,” so no solutions are missed.

Code Implementation#

1
int numSubarrayProductLessThanK(int *nums, int numsSize, int k) {
2
    long long prod = 1;                 /* Product of elements in the window */
3
    int left = 0, right = 0, count = 0;
4

5
    while (right < numsSize) {
6
        prod *= nums[right];            /* ① Right boundary element enters the window */
7
        right++;
8

9
        while (left < right && prod >= k) {   /* ③ Product exceeds limit, shrink; left < right to avoid empty window division by zero */
10
            prod /= nums[left];               /* ⑤ Left boundary element exits the window */
11
            left++;
12
        }
13
        count += right - left;          /* ④ Subarrays ending at right-1 with starting point inside the window */
14
    }
15
    return count;
16
}

1
#include <vector>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
7
        long long prod = 1;
8
        int left = 0, right = 0, count = 0;
9

10
        while (right < (int)nums.size()) {
11
            prod *= nums[right];              // ① Right boundary element enters the window
12
            right++;
13

14
            while (left < right && prod >= k) {   // ③ Product exceeds limit, shrink
15
                prod /= nums[left];               // ⑤ Left boundary element exits the window
16
                left++;
17
            }
18
            count += right - left;            // ④ Number of valid subarrays ending at right-1
19
        }
20
        return count;
21
    }
22
};

1
function numSubarrayProductLessThanK(nums, k) {
2
  let prod = 1;
3
  let left = 0, right = 0, count = 0;
4

5
  while (right < nums.length) {
6
    prod *= nums[right];                    // ① Right boundary element enters the window
7
    right++;
8

9
    while (left < right && prod >= k) {     // ③ Product exceeds limit, shrink
10
      prod /= nums[left];                   // ⑤ Left boundary element exits the window
11
      left++;
12
    }
13
    count += right - left;                  // ④ Number of valid subarrays ending at right-1
14
  }
15
  return count;
16
}

Complexity#

Common Pitfalls#

1. The shrink loop must include the condition left < right. When k <= 1 (nums[i] >= 1, the product of any non-empty subarray is ≥ 1), prod >= k will always hold, and the loop will push left to right. At this point, if you still try to prod /= nums[left], you will read elements outside the window or even divide by 0. With left < right added, it automatically stops when the window is empty, and count += right - left contributes exactly 0.
2. count += right - left goes outside the shrink loop. Putting it inside will double-count multiple windows in the same round.
3. count can be very large. When n = 3 × 10^4 and all elements are 1 and k is very large, the answer is n(n+1)/2 = 4.5 × 10^8, which is still within the int range; but if you apply the same template to larger data, remember to switch to 64-bit.
4. prod needs headroom in C / C++. Shrinking is “shrink when exceeded,” so the peak of prod is k × nums[right] ≈ 10^6 × 1000 = 10^9; int is barely enough, but writing long long is safer.

Problem Description#

Given a binary array nums and an integer k, assuming at most k 0 can be flipped, return the maximum number of consecutive 1 in the array after performing the operation.

Example:

1
Input: nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
2
Output: 6
3
Explanation: Flip the two 0s at indices 3 and 4 to 1, yielding [1,1,1,1,1,1,0,1,1,1,1,0], where the first 6 positions are consecutive 1s;
4
      flipping the two 0s at indices 5 and 10 instead makes the last 6 positions consecutive 1s.
5

6
Input: nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
7
Output: 10

Constraints: 1 <= nums.length <= 10^5, nums[i] is either 0 or 1, 0 <= k <= nums.length.

Approach: Treat “how many 0s are in the window” as the violation count#

“Flip at most k 0s” is equivalent to: find the longest window where the number of 0s in the window does not exceed k. Because after all the 0 in the window are flipped to 1, the window becomes one continuous stretch of 1; and the 0 outside the window don’t matter.

So the window state is zeros (the number of 0s in the window):

• ② When adding nums[right], if it is 0 then zeros++;
• ③ The shrink condition is zeros > k, which is “shrink on violation” (style B);
• ④ The window is only valid after shrinking, and only then do we record right - left;
• ⑤ When removing nums[left], if it is 0 then zeros--.

This problem is the cleanest example of “shrink on violation”: the violation metric corresponds one-to-one with the window contents, with no tricks at all. What is truly worth noting is the position of ④ — it must be written after the shrink loop.

Walkthrough Diagram#

Taking nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2 as an example:

1
Index  0  1  2  3  4  5  6  7  8  9  10
2
nums  1  1  1  0  0  0  1  1  1  1  0

1
right=3: window [0,4)=1110, zeros=1 ≤ 2 → best = 4
2
right=4: window [0,5)=11100, zeros=2 ≤ 2 → best = 5
3
right=5: window [0,6)=111000, zeros=3 > 2 ← violation, shrink
4
  ├ remove 1 (index 0) → zeros still 3
5
  ├ remove 1 (index 1) → still 3
6
  ├ remove 1 (index 2) → still 3
7
  ├ remove 0 (index 3) → zeros=2, stop shrinking, window [4,6)=00, length 2
8
  └ record only after shrinking: length 2, do not update best (best is still 5)
9
right=6: window [4,7)=001, zeros=2 → length 3
10
right=7: length 4      right=8: length 5      right=9: length 6 → best = 6
11
right=10: window [4,11)=0011110, zeros=3 > 2 ← violation, shrink
12
  ├ remove 0 (index 4) → zeros=2, stop shrinking, window [5,11)
13
  └ length 5, do not update best
14

15
answer 6 ✔

Look clearly at the relationship between ③ and ④: a violating window can never contribute to the score. The purpose of the shrink loop is to repair the window back to zeros <= k, and only after it is repaired do we measure its length.

Code Implementation#

1
int longestOnes(int *nums, int numsSize, int k) {
2
    int left = 0, right = 0;
3
    int zeros = 0;                      /* How many 0s are in the window */
4
    int best = 0;
5

6
    while (right < numsSize) {
7
        if (nums[right] == 0) zeros++;  /* ① Right boundary enters window, count 0s along the way */
8
        right++;
9

10
        while (zeros > k) {             /* ③ Too many 0s, shrink to just enough */
11
            if (nums[left] == 0) zeros--;
12
            left++;
13
        }
14
        if (right - left > best)        /* ④ After shrinking, the window is definitely valid, only then record */
15
            best = right - left;
16
    }
17
    return best;
18
}

1
#include <vector>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int longestOnes(vector<int>& nums, int k) {
7
        int left = 0, right = 0;
8
        int zeros = 0;                      // How many 0s are in the window
9
        int best = 0;
10

11
        while (right < (int)nums.size()) {
12
            if (nums[right] == 0) zeros++;  // ① Right boundary enters window, count 0s along the way
13
            right++;
14

15
            while (zeros > k) {             // ③ Too many 0s, shrink to just enough
16
                if (nums[left] == 0) zeros--;
17
                left++;
18
            }
19
            if (right - left > best)        // ④ After shrinking the window is necessarily valid, only then record
20
                best = right - left;
21
        }
22
        return best;
23
    }
24
};

1
function longestOnes(nums, k) {
2
  let left = 0, right = 0;
3
  let zeros = 0;                      // How many 0s are in the window
4
  let best = 0;
5

6
  while (right < nums.length) {
7
    if (nums[right] === 0) zeros++;   // ① Right boundary enters window, count 0s along the way
8
    right++;
9

10
    while (zeros > k) {               // ③ Too many 0s, shrink to just enough
11
      if (nums[left] === 0) zeros--;
12
      left++;
13
    }
14
    if (right - left > best)          // ④ After shrinking the window is necessarily valid, only then record
15
      best = right - left;
16
  }
17
  return best;
18
}

Complexity#

Common Pitfalls#

1. k = 0 is a valid input. In this case the window cannot contain a single 0, and the answer may be 0 (for example, nums = [0,0]), so initializing best to 0 is correct; do not use -1 or n + 1.
2. Record the answer after the shrink loop. Putting it inside will record a zeros > k window, making the answer too large.
3. Do not actually write the “flips” onto the array. This problem only asks for the count; the 0s in the window can simply be treated as flippable, and there is no need to actually modify nums — once nums is modified, all subsequent window statistics will be thrown off.
4. zeros > k, not zeros >= k. At most k can be flipped, so zeros == k is valid.

Problem Description#

You are given a string s and an integer k. You can choose any character in the string and change it to any other uppercase English letter, and this operation can be performed at most k times. Return the length of the longest substring containing the same letter after performing the above operations.

Example:

1
Input: s = "ABAB", k = 2     Output: 4
2
Input: s = "AABABBA", k = 1  Output: 4
3
Explanation: Replace the middle 'A' with 'B' to get "AABBBBA", in which the substring "BBBB" has the longest repeating letter, with length 4.

Constraints: 1 <= s.length <= 10^5, s consists only of uppercase English letters, 0 <= k <= s.length.

Approach: Window length − count of the most frequent character in the window ≤ k#

This problem and the previous one are the same problem in different clothing:

The reasoning is: to make an entire window into the same letter, the cheapest modification is to “keep the letter that appears most often in the window and change all the rest,” so the number of characters to replace is window length - count of the most frequent character. If it does not exceed k, the window is feasible.

The state we maintain is cnt[26] and maxCnt (how many times the most frequent character in the window appears). The ③ shrink condition is right - left - maxCnt > k.

There is a key detail here: maxCnt is only updated when a character is added, and never decreases when a character is removed. In other words, it records “the maximum frequency ever seen in history,” not “the maximum frequency in the current window.” Writing it this way has two benefits: the window length becomes monotonically non-decreasing, and shrinking degrades from while to if (at most one step per round); at the same time, the true answer will not be miscalculated. For why this works, see the pitfalls below.

Walkthrough#

Taking s = "AABABBA", k = 1 as an example:

1
Subscript  0  1  2  3  4  5  6
2
s     A  A  B  A  B  B  A

1
Add A at index 0: [0,1)=A, cnt[A]=1, maxCnt=1
2
  length 1 - 1 = 0 ≤ 1 → no replacement needed → window length 1
3
Add A at index 1: [0,2)=AA, cnt[A]=2, maxCnt=2
4
  2 - 2 = 0 ≤ 1 → length 2
5
Add B at index 2: [0,3)=AAB, cnt[B]=1, maxCnt still 2
6
  3 - 2 = 1 ≤ 1 → length 3 (change B to A)
7
Add A at index 3: [0,4)=AABA, cnt[A]=3, maxCnt=3
8
  4 - 3 = 1 ≤ 1 → length 4 (change B to A)      best = 4
9
Add B at index 4: [0,5)=AABAB, cnt[B]=2, maxCnt still 3
10
  5 - 3 = 2 > 1 ← violation, shrink by one: cnt[A]-- → cnt[A]=2, window [1,5)=ABAB, length 4
11
  4 - 3 = 1 ≤ 1 → length 4, do not update best
12
Add B at index 5: [1,6)=ABABB, cnt[B]=3, maxCnt still 3
13
  5 - 3 = 2 > 1 ← violation, shrink by one: cnt[A]-- → cnt[A]=1, window [2,6)=BABB, length 4
14
  4 - 3 = 1 ≤ 1 → length 4, do not update best
15
Add A at index 6: [2,7)=BABBA, cnt[A]=2, maxCnt still 3
16
  5 - 3 = 2 > 1 ← violation, shrink by one: cnt[B]-- → cnt[B]=2, window [3,7)=ABBA, length 4
17
  4 - 3 = 1 ≤ 1 → length 4, do not update best
18

19
Answer 4 ✔

Note that in the last three rounds, maxCnt = 3 is already no longer the true maximum frequency of the current window (in [3,7), A and B each appear 2 times), but the window length is held steady at 4, and best also stops at 4—and 4 is indeed the correct answer.

Code Implementation#

1
#include <string.h>
2

3
int characterReplacement(char *s, int k) {
4
    int cnt[26] = {0};
5
    int n = (int)strlen(s);
6
    int left = 0, right = 0;
7
    int maxCnt = 0;                 /* Maximum frequency ever seen in history, only increases, never decreases */
8
    int best = 0;
9

10
    while (right < n) {
11
        int c = s[right] - 'A';
12
        cnt[c]++;                   /* ① Right boundary enters window */
13
        if (cnt[c] > maxCnt) maxCnt = cnt[c];
14
        right++;
15

16
        if (right - left - maxCnt > k) {   /* ③ Characters needing replacement exceed k */
17
            cnt[s[left] - 'A']--;          /* ⑤ Left boundary exits window */
18
            left++;
19
        }
20
        if (right - left > best) best = right - left;   /* ④ Record after shrinking */
21
    }
22
    return best;
23
}

1
#include <string>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int characterReplacement(string s, int k) {
7
        int cnt[26] = {0};
8
        int left = 0, right = 0;
9
        int maxCnt = 0;                 // Maximum frequency ever seen in history, only increases, never decreases
10
        int best = 0;
11

12
        while (right < (int)s.size()) {
13
            int c = s[right] - 'A';
14
            cnt[c]++;                   // ① Right boundary enters window
15
            if (cnt[c] > maxCnt) maxCnt = cnt[c];
16
            right++;
17

18
            if (right - left - maxCnt > k) {   // ③ Characters needing replacement exceed k
19
                cnt[s[left] - 'A']--;          // ⑤ Left boundary exits window
20
                left++;
21
            }
22
            if (right - left > best) best = right - left;   // ④ Record after shrinking
23
        }
24
        return best;
25
    }
26
};

1
function characterReplacement(s, k) {
2
  const cnt = new Array(26).fill(0);
3
  let left = 0, right = 0;
4
  let maxCnt = 0;                 // Maximum frequency ever seen in history, only increases, never decreases
5
  let best = 0;
6

7
  while (right < s.length) {
8
    const c = s.charCodeAt(right) - 65;
9
    cnt[c]++;                     // ① Right boundary enters window
10
    if (cnt[c] > maxCnt) maxCnt = cnt[c];
11
    right++;
12

13
    if (right - left - maxCnt > k) {        // ③ Characters needing replacement exceed k
14
      cnt[s.charCodeAt(left) - 65]--;       // ⑤ Left boundary exits window
15
      left++;
16
    }
17
    if (right - left > best) best = right - left;   // ④ Record after shrinking
18
  }
19
  return best;
20
}

Complexity#

Pitfalls#

1. maxCnt is not “the maximum frequency of the current window,” but “the historical maximum frequency.” It only increases and never decreases, so length - maxCnt <= k can only be used to control the window length and cannot be understood as “the current window is definitely valid.” Pairing it with if (at most one shrink per round, window length monotonically non-decreasing) is the mainstream formulation; if you change it to while, you must recompute the true maximum frequency within the window when shrinking, otherwise the judgment condition is no longer equivalent to “the window is valid.” (By the way: the claim circulating online that “while + a maxCnt that only increases and never decreases is definitely wrong” is something I could not verify—I ran both versions on 640,000 exhaustive test cases (118,092 three-letter strings of length ≤ 9 + 524,280 two-letter strings of length ≤ 16), and the results were completely identical. To be safe, still use the if version.)
2. The index for cnt must subtract 'A' (65); do not directly use the character as an index. In C / C++, cnt[c] will go out of bounds; in JS, cnt[c] will become undefined, and after ++ comes NaN, silently producing wrong results all the way.
3. Shrinking must be written before updating the answer. As with 1004, an invalid window must not participate in scoring.
4. Only keep the “lowest-cost” letter in the window as the retained character. That is, the one with the highest occurrence count—do not enumerate “which letter to keep”; maxCnt has already chosen it for you.