When the window size is fixed, the trick is to compute the first window's sum once and then slide it by adding the new element and removing the old one (sum += arr[i] - arr[i - k]). This O(n) update replaces the O(n*k) recomputation a naive solution would do. The same skeleton handles fixed-size averages, max-of-k, and any aggregate that supports incremental update. The early-return when the array is shorter than k is the easy edge case to forget.

When the window size depends on the data (longest valid substring, smallest window covering a target), use two pointers and a hash structure. The right pointer extends while the window stays valid, and the left pointer jumps past the offending position when validity breaks. Storing the last index where each character appeared lets the left pointer leap rather than slide one-by-one, keeping the whole pass O(n). This is LeetCode's longest-substring-without-repeat in 10 lines.

Counting subarrays with 'exactly K distinct' values is hard, but counting 'at most K' is straightforward with sliding window. The trick: exactly(K) === atMost(K) - atMost(K - 1). The at-most function counts subarrays ending at each position by accumulating hi - lo + 1, which works because every shorter window starting in [lo, hi] is also valid. This decomposition turns several otherwise tricky problems (subarrays-with-K-different-integers, count-vowel-strings) into two calls of the same templated function.