docs: add incredibly detailed deep dives for Sliding Window and Two Pointers

Author: Wasim

Algorithms/DeepDives/01_Sliding_Window.md

@@ -0,0 +1,57 @@
+# Understanding the Sliding Window Concept
+
+Think of a Sliding Window like looking through a camera's zoom lens as you pan across a landscape. The full landscape is your data (a long list of numbers or characters), but at any single moment, you can only see a small portion—this portion is your "Window."
+
+Instead of starting a new search from scratch every single time you move, you use the information already inside the window and just update what enters and what leaves. This saves huge amounts of time.
+
+There are two primary types:
+1. **Fixed-Size Window** (The size is always constant).
+2. **Variable-Size Window** (The size grows or shrinks based on a condition).
+
+## Type 1: Fixed-Size Sliding Window
+In this type, the window size (let's call it k) is fixed from the start. You might need to find the maximum sum of any k consecutive numbers, or the average of k elements. We slide the window one step at a time, keeping its size constant.
+
+### The Process Step-by-Step
+**Goal:** Slide a window of exactly 3 elements across the data [A, B, C, D, E, F].
+
+```plaintext
+Data:  A   B   C   D   E   F
+       -----------------------
+Step 1: [A   B   C]               (Initial window, calculate sum/average)
+Step 2:      [B   C   D]          (Slide right by 1: Drop A, Add D)
+Step 3:          [C   D   E]      (Slide right by 1: Drop B, Add E)
+Step 4:              [D   E   F]  (Slide right by 1: Drop C, Add F - End) 
+```
+
+## Type 2: Variable-Size Sliding Window
+A variable window does not have a fixed size. Instead, it expands or contracts based on a defined constraint. We maintain two pointers: a 'Right' pointer (the window's leading edge) and a 'Left' pointer (the window's trailing edge).
+
+- **Expand**: We move the Right pointer to include new elements as long as the constraint is satisfied.
+- **Shrink**: If the constraint is violated, we move the Left pointer to remove elements from the window until the constraint is met again.
+
+### The Process Step-by-Step
+**Goal:** Find segments where the sum of numbers is strictly less than 5 in the data [1, 2, 1, 3, 1, 4].
+
+```plaintext
+Data:  1   2   1   3   1   4
+       -----------------------
+Step 1: [1]                           (Sum = 1. Valid < 5, EXPAND right)
+Step 2: [1   2]                       (Sum = 3. Valid < 5, EXPAND right)
+Step 3: [1   2   1]                   (Sum = 4. Valid < 5, EXPAND right)
+Step 4: [1   2   1   3]               (Sum = 7. INVALID! > 5, must SHRINK left)
+Step 5:  1  [2   1   3]               (Sum = 6. INVALID! > 5, must SHRINK left)
+Step 6:  1   2  [1   3]               (Sum = 4. Valid < 5, EXPAND right)
+Step 7:  1   2  [1   3   1]           (Sum = 5. INVALID! Not < 5, SHRINK left)
+Step 8:  1   2   1  [3   1]           (Sum = 4. Valid < 5, EXPAND right)
+Step 9:  1   2   1  [3   1   4]       (Sum = 8. INVALID! > 5, SHRINK left)
+Step 10: 1   2   1   3  [1   4]       (Sum = 5. INVALID! Not < 5, SHRINK left)
+Step 11: 1   2   1   3   1  [4]       (Sum = 4. Valid < 5. Reached End)
+```
+
+### Comparison Summary
+| Feature | Fixed-Size Window | Variable-Size Window |
+|---------|-------------------|----------------------|
+| **Size (k)** | Constant (Set at the beginning) | Dynamic (Grows or shrinks) |
+| **Pointers** | One pointer (usually tracking the window's start) | Two pointers (one Left, one Right) |
+| **Primary Action** | The window slides (shifted by one). | The window expands (R++) or shrinks (L++). |
+| **Used For...** | Analyzing a set amount of consecutive data. | Finding the best segment that meets a dynamic rule. |

Algorithms/DeepDives/02_Two_Pointers.md

@@ -0,0 +1,73 @@
+# Understanding the Two Pointers Concept
+
+Think of the Two Pointers technique like two people searching for a specific book on a long bookshelf. Instead of one person starting at the left and checking every single combination of books (which takes forever), one person starts at the far left, and the other starts at the far right. They look at the books they are holding, communicate, and take steps toward each other until they find exactly what they are looking for.
+
+Instead of an O(N^2) double-loop comparing every single pair, we use two pointers to scan the array simultaneously, completing the search in just O(N) time.
+
+There are two primary types:
+1. **Opposite Ends (Collision)** (Pointers start at opposite ends and move toward the center).
+2. **Same Direction (Trailing)** (Pointers start at the same end but move at different speeds or intervals).
+
+## Type 1: Opposite Ends (Collision)
+In this type, the array must usually be **sorted**. We place a `Left` pointer at index 0 and a `Right` pointer at the last index. Because the array is sorted, we know exactly which pointer to move based on our current calculation.
+
+- If the current sum is **too small**, we need a bigger number, so we move the `Left` pointer to the right.
+- If the current sum is **too big**, we need a smaller number, so we move the `Right` pointer to the left.
+
+### The Process Step-by-Step
+**Goal:** Find a pair of numbers that add up to the Target Sum of `8` in the sorted data: `[1, 2, 3, 4, 6]`.
+
+```plaintext
+Data:   1     2     3     4     6
+        ^                       ^
+       Left                   Right
+       ---------------------------------
+Step 1: [1]   2     3     4    [6]    (1+6 = 7. 7 < 8. Too small! Move Left ->)
+Step 2:  1   [2]    3     4    [6]    (2+6 = 8. TARGET FOUND! Stop.)
+```
+
+Let's try a slightly longer one with a Target Sum of `10` in `[2, 3, 5, 8, 9, 11]`.
+
+```plaintext
+Data:   2     3     5     8     9     11
+        ----------------------------------
+Step 1: [2]   3     5     8     9    [11]   (2+11 = 13. 13 > 10. Too big! Move <- Right)
+Step 2: [2]   3     5     8    [9]    11    (2+9 = 11. 11 > 10. Too big! Move <- Right)
+Step 3: [2]   3     5    [8]    9     11    (2+8 = 10. TARGET FOUND! Stop.)
+```
+
+## Type 2: Same Direction (Trailing/Slow & Fast)
+Here, both pointers start at the beginning (index 0). One pointer is the "explorer" (Fast), and the other is the "marker" (Slow). This is extremely common when you need to process an array in-place, like removing duplicates.
+
+- **Fast Pointer**: Scans the array looking for new/unique elements.
+- **Slow Pointer**: Keeps track of where the next unique element should be placed.
+
+### The Process Step-by-Step
+**Goal:** Remove duplicates from the sorted array `[1, 1, 2, 3, 3]` in-place.
+
+```plaintext
+Data:   1     1     2     3     3
+        -------------------------
+Step 1: [1]  [1]    2     3     3    (Slow=0, Fast=1. Values match! Fast moves right.)
+         ^S   ^F
+
+Step 2: [1]   1    [2]    3     3    (Fast found a '2'. It's unique!)
+         ^S         ^F               (Action: Move Slow right, copy Fast's value to Slow)
+
+Step 3:  1   [2]    2    [3]    3    (Array is now [1, 2, 2, 3, 3])
+              ^S          ^F         (Fast found a '3'. It's unique!)
+                                     (Action: Move Slow right, copy Fast's value to Slow)
+
+Step 4:  1    2    [3]    3    [3]   (Array is now [1, 2, 3, 3, 3])
+                   ^S           ^F   (Values match. Fast moves right, hits end.)
+
+Result: The unique elements are everything from index 0 up to the Slow pointer: [1, 2, 3].
+```
+
+### Comparison Summary
+| Feature | Opposite Ends (Collision) | Same Direction (Trailing) |
+|---------|---------------------------|---------------------------|
+| **Setup** | `Left` at start, `Right` at end. | `Slow` at start, `Fast` at start. |
+| **Requirement** | Array MUST usually be sorted. | Array doesn't always need to be sorted (depends on problem). |
+| **Primary Action** | Pointers step toward each other. | Fast pointer pulls ahead of the slow pointer. |
+| **Used For...** | Target sums, valid palindromes, reversing strings. | Removing duplicates in-place, filtering elements. |