docs: add sliding window intuition guide for pattern recognition

Create intuition.md as a complementary document to templates.md that
focuses on building pattern-level understanding before code:
- Introduce Explorer/Gatekeeper mental model for window boundaries
- Frame invariants as "promises" the window must keep
- Describe maximize/minimize modes with vivid metaphors
- Add pattern recognition flowchart and problem mapping table
- Defer code until after conceptual understanding is established

Author: lufftw

docs/patterns/sliding_window/intuition.md

@@ -0,0 +1,287 @@
+# Sliding Window: Pattern Intuition Guide
+
+> *"The window is a moving lens of attention — it forgets the past to focus on what matters now."*
+
+---
+
+## The Situation That Calls for a Window
+
+Imagine you're walking through a long corridor, and you can only see through a rectangular frame you carry with you. As you move forward, new things enter your view on the right, and old things disappear on the left.
+
+**This is the essence of Sliding Window.**
+
+You encounter this pattern whenever:
+- You're scanning through a sequence (string, array, stream)
+- You care about a **contiguous portion** of that sequence
+- The answer depends on properties of that portion
+- Those properties can be **updated incrementally** as the portion shifts
+
+The key insight: *You don't need to remember everything — only what's currently in view.*
+
+---
+
+## The Two Forces at Play
+
+Every sliding window algorithm is a dance between two opposing forces:
+
+### The Explorer (Right Boundary)
+- Always moves forward, never backward
+- Discovers new territory
+- Adds new elements to consideration
+- Asks: *"What happens if I include this?"*
+
+### The Gatekeeper (Left Boundary)  
+- Follows behind, cleaning up
+- Removes elements that no longer serve the goal
+- Enforces the rules of what's allowed
+- Asks: *"Must I let go of something to stay valid?"*
+
+The Explorer is eager and expansive. The Gatekeeper is disciplined and selective. Together, they maintain a **window of validity** that slides through the sequence.
+
+---
+
+## The Invariant: The Window's Promise
+
+At every moment, the window makes a promise — an **invariant** that must always be true:
+
+| Problem Type | The Promise |
+|--------------|-------------|
+| Longest unique substring | *"Every character in my view appears exactly once"* |
+| At most K distinct | *"I contain no more than K different characters"* |
+| Minimum covering substring | *"I contain everything required"* |
+| Sum at least target | *"My total meets or exceeds the goal"* |
+
+**This promise is sacred.** The moment it's broken, the Gatekeeper must act — shrinking the window until the promise is restored.
+
+---
+
+## The Irreversible Truth
+
+Here's what makes sliding window work: **the Explorer never retreats.**
+
+Once the right boundary passes an element, that element has been "seen." We may include it or exclude it from our current window, but we never go back to re-examine it as a potential starting point... unless the Gatekeeper releases it.
+
+This one-directional march is what gives us O(n) time complexity. Each element enters the window at most once and exits at most once. No element is visited more than twice across the entire algorithm.
+
+The irreversibility creates efficiency: *past decisions don't haunt us.*
+
+---
+
+## The Two Modes of Seeking
+
+Depending on what you're optimizing, the dance changes:
+
+### Mode 1: Maximize the Window
+*"How large can my view become while staying valid?"*
+
+```
+Process:
+1. Explorer advances, adding new element
+2. If promise breaks → Gatekeeper advances until promise restored
+3. Record the current window size (this is a candidate answer)
+4. Repeat
+
+The window EXPANDS freely, CONTRACTS only when forced.
+```
+
+**Mental image**: Stretching a rubber band until it's about to snap, then easing off just enough.
+
+### Mode 2: Minimize the Window
+*"How small can my view become while still being valid?"*
+
+```
+Process:
+1. Explorer advances until promise becomes TRUE
+2. While promise holds → Gatekeeper advances, shrinking window
+3. Record the window size just before promise breaks
+4. Repeat
+
+The window EXPANDS until valid, then CONTRACTS aggressively.
+```
+
+**Mental image**: Tightening a noose around the minimal solution.
+
+---
+
+## Pattern Recognition: "Is This a Sliding Window Problem?"
+
+Ask yourself these questions:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  1. Am I looking for a CONTIGUOUS subarray or substring?   │
+│     └── No? → Not sliding window                           │
+│                                                             │
+│  2. Can I describe a PROPERTY that makes a window valid?   │
+│     └── No? → Probably not sliding window                  │
+│                                                             │
+│  3. Can I UPDATE that property in O(1) when I add/remove   │
+│     a single element?                                       │
+│     └── No? → Sliding window won't give O(n)               │
+│                                                             │
+│  4. Is the answer about OPTIMIZING that window             │
+│     (longest, shortest, exists)?                            │
+│     └── Yes to all? → SLIDING WINDOW.                      │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## The Three Window Shapes
+
+### Shape 1: Variable Window, Maximize
+**Story**: *"I want the biggest room that still follows the rules."*
+
+- Invariant: Some constraint must not be violated
+- Strategy: Grow greedily, shrink reluctantly
+- Answer: Largest valid window seen
+
+**Classic problems**: Longest substring without repeating characters, longest with at most K distinct
+
+### Shape 2: Variable Window, Minimize  
+**Story**: *"I want the smallest container that still holds everything I need."*
+
+- Invariant: Some requirement must be satisfied
+- Strategy: Grow until valid, shrink aggressively
+- Answer: Smallest valid window seen
+
+**Classic problems**: Minimum window substring, minimum size subarray sum
+
+### Shape 3: Fixed Window
+**Story**: *"I'm looking through a frame of exact size — does it ever show what I'm looking for?"*
+
+- Invariant: Window size exactly K
+- Strategy: Add one, remove one, check condition
+- Answer: Whether/where condition is met
+
+**Classic problems**: Find all anagrams, check permutation inclusion
+
+---
+
+## The State: What the Window Remembers
+
+The window isn't just boundaries — it carries **state** about its contents:
+
+| What You're Tracking | State Structure | Update Cost |
+|---------------------|-----------------|-------------|
+| Character uniqueness | Last-seen index map | O(1) |
+| Character frequencies | Count map | O(1) |
+| Distinct count | Map + size | O(1) |
+| Running sum | Single integer | O(1) |
+| Requirement satisfaction | "Have" vs "Need" counters | O(1) |
+
+The magic of sliding window is that these states are **incrementally maintainable**. Adding an element updates the state. Removing an element reverses that update. No full recomputation needed.
+
+---
+
+## Visualizing the Dance
+
+```
+Sequence:  [ a  b  c  a  b  c  b  b ]
+            ↑
+           Both start here
+
+Step 1:    [ a ]                    Explorer sees 'a'
+            L  R
+
+Step 2:    [ a  b ]                 Explorer sees 'b'  
+            L     R
+
+Step 3:    [ a  b  c ]              Explorer sees 'c'
+            L        R
+
+Step 4:    [ a  b  c  a ]           Explorer sees 'a' — duplicate!
+            L           R
+           
+           Gatekeeper must act:     Move L past the first 'a'
+           
+               [ b  c  a ]          Promise restored
+                  L     R
+
+Step 5:        [ b  c  a  b ]       Explorer sees 'b' — duplicate!
+                  L        R
+               
+           Gatekeeper moves:
+               
+                  [ c  a  b ]       Promise restored
+                     L     R
+```
+
+Notice: The Explorer always advances. The Gatekeeper only moves when the promise breaks. Together, they visit each element at most twice.
+
+---
+
+## The Moment of Recognition
+
+You're reading a problem. You see phrases like:
+- *"contiguous subarray"*
+- *"substring"*  
+- *"longest/shortest"*
+- *"at most K"*
+- *"containing all of"*
+
+And you feel it: *This is about maintaining something over a moving portion.*
+
+That's your cue. The Explorer and Gatekeeper are ready. The window wants to slide.
+
+---
+
+## From Intuition to Implementation
+
+Only now — after the dance is clear — does code become useful.
+
+The template is always the same skeleton:
+
+```python
+def sliding_window(sequence):
+    state = initial_state()
+    left = 0
+    answer = initial_answer()
+    
+    for right, element in enumerate(sequence):
+        # Explorer: include new element
+        update_state_add(state, element)
+        
+        # Gatekeeper: enforce the promise
+        while promise_is_broken(state):
+            update_state_remove(state, sequence[left])
+            left += 1
+        
+        # Record: this window is valid
+        answer = consider(answer, left, right)
+    
+    return answer
+```
+
+The variations come from:
+1. **What is the promise?** (determines the while condition)
+2. **What state do we track?** (determines the data structure)
+3. **What are we optimizing?** (determines how we update the answer)
+
+---
+
+## Quick Reference: Problem → Pattern Mapping
+
+| When You See... | Think... | Window Type |
+|----------------|----------|-------------|
+| "Longest substring with unique chars" | Uniqueness promise | Maximize |
+| "Longest with at most K distinct" | Count limit promise | Maximize |
+| "Minimum window containing all of T" | Coverage promise | Minimize |
+| "Subarray sum ≥ target" | Threshold promise | Minimize |
+| "Contains permutation" | Exact match promise | Fixed |
+| "Find all anagrams" | Exact match, collect all | Fixed |
+
+---
+
+## The Pattern in One Sentence
+
+> *Sliding Window is the art of maintaining a valid contiguous view by advancing eagerly and retreating only when necessary.*
+
+When you see a problem about optimizing over contiguous sequences with incrementally checkable properties — you've found your window.
+
+Let it slide.
+
+---
+
+*For detailed implementations and code examples, see [templates.md](./templates.md).*
+