remove ddry runs from articles, visuals replaced them

Author: neetcode-gh

articles/best-time-to-buy-and-sell-stock-ii.md

@@ -34,55 +34,6 @@ The recursive version simply expresses this idea as a function that keeps callin
 5. Start the recursion with the full range `[0, n - 1]`.
 6. Return the final result.
 
-<details>
-<summary>Example - Dry Run</summary>
-
-Input: nums = [-1, 0, 3, 5, 9, 12], target = 9
-
-**Initial Array:**
-
-```markdown
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-```
-
-**Call 1:** binary_search(l=0, r=5)
-
-```markdown
-L M R
-↓ ↓ ↓
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-l = 0, r = 5, m = 2
-nums[M] = nums[2] = 3
-3 < 9 (target)
-→ Search right half: binary_search(3, 5)
-```
-
-**Call 2:** binary_search(l=3, r=5)
-
-```markdown
-                  L    M    R
-                  ↓    ↓    ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-l = 3, r = 5, m = 4
-nums[M] = nums[4] = 9
-9 == 9 (target) ✓ Found!
-```
-
-**Result: index 4**
-
-</details>
 
 <br>
 
@@ -300,53 +251,6 @@ We adjust the left and right pointers until we either find the target or the poi
     - If `nums[m] > target`, move search to the left half: update `r = m - 1`.
 3. If the loop ends without finding the target, return `-1`.
 
-<details>
-<summary>Example - Dry Run</summary>
-
-Input: nums = [-1, 0, 3, 5, 9, 12], target = 9
-
-**Initial Array:**
-
-```markdown
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-```
-
-**Step 1:** L = 0, R = 5, M = 2
-
-```markdown
-L M R
-↓ ↓ ↓
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[2] = 3
-3 < 9 (target)
-→ Search right half: L = M + 1 = 3
-```
-
-**Step 2:** L = 3, R = 5, M = 4
-
-```markdown
-                  L    M    R
-                  ↓    ↓    ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[4] = 9
-9 == 9 (target) ✓ Found!
-```
-
-**Result: index 4**
-
-</details>
 
 <br>
 
@@ -569,84 +473,6 @@ Then we simply check whether the element just before that boundary is the target
 4. If `l > 0` and `nums[l - 1] == target`, return `l - 1`.
 5. Otherwise, return `-1` (target not found).
 
-<details>
-<summary>Example - Dry Run</summary>
-
-Input: nums = [-1, 0, 3, 5, 9, 12], target = 9
-
-The upper bound approach finds the first index where value > target, then checks index - 1.
-
-**Initial Array:**
-
-```markdown
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-Note: R starts at index 6 (past end of array)
-```
-
-**Step 1:** L = 0, R = 6, M = 3
-
-```markdown
-L M R
-↓ ↓ ↓
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │ (6)
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[3] = 5
-5 <= 9 (target)
-→ Move left pointer: L = M + 1 = 4
-```
-
-**Step 2:** L = 4, R = 6, M = 5
-
-```markdown
-                       L    M        R
-                       ↓    ↓        ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │ (6)
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[5] = 12
-12 > 9 (target)
-→ Move right pointer: R = M = 5
-```
-
-**Step 3:** L = 4, R = 5, M = 4
-
-```markdown
-                      L,M   R
-                       ↓    ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[4] = 9
-9 <= 9 (target)
-→ Move left pointer: L = M + 1 = 5
-```
-
-**Final Check:**
-
-```markdown
-L = 5 (upper bound: first index where value > target)
-L - 1 = 4
-nums[4] = 9 == 9 (target) ✓
-
-Return L - 1 = 4
-```
-
-**Result: index 4**
-
-</details>
 
 <br>
 
@@ -856,84 +682,6 @@ This approach is especially useful for sorted arrays because it avoids overshoot
 4. If `l` is within bounds and `nums[l] == target`, return `l`.
 5. Otherwise, return `-1` (the target is not in the array).
 
-<details>
-<summary>Example - Dry Run</summary>
-
-Input: nums = [-1, 0, 3, 5, 9, 12], target = 9
-
-The lower bound approach finds the first index where value >= target.
-
-**Initial Array:**
-
-```markdown
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-Note: R starts at index 6 (past end of array)
-```
-
-**Step 1:** L = 0, R = 6, M = 3
-
-```markdown
-L M R
-↓ ↓ ↓
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │ (6)
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[3] = 5
-5 < 9 (target)
-→ Move left pointer: L = M + 1 = 4
-```
-
-**Step 2:** L = 4, R = 6, M = 5
-
-```markdown
-                       L    M        R
-                       ↓    ↓        ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │ (6)
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[5] = 12
-12 >= 9 (target)
-→ Move right pointer: R = M = 5
-```
-
-**Step 3:** L = 4, R = 5, M = 4
-
-```markdown
-                      L,M   R
-                       ↓    ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-
-nums[M] = nums[4] = 9
-9 >= 9 (target)
-→ Move right pointer: R = M = 4
-```
-
-**Final Check:**
-
-```markdown
-L = 4, R = 4 → Loop ends (L == R)
-L = 4 is within bounds (< 6)
-nums[4] = 9 == 9 (target) ✓
-
-Return L = 4
-```
-
-**Result: index 4**
-
-</details>
 
 <br>
 
@@ -1121,91 +869,6 @@ impl Solution {
 
 ## 5. Built-In Function
 
-<details>
-<summary>Example - Dry Run</summary>
-
-Input: nums = [-1, 0, 3, 5, 9, 12], target = 9
-
-Built-in functions abstract the binary search logic. Here is how they work internally:
-
-**Initial Array:**
-
-```markdown
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-```
-
-**Using Python's `bisect_left` (or similar):**
-
-The function finds the leftmost position where target can be inserted to maintain sorted order.
-
-```markdown
-                        ↓
-                   bisect_left
-                    returns 4
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-```
-
-**Internal Binary Search (what the built-in does):**
-
-Step 1: L = 0, R = 6, M = 3
-
-```markdown
-L M R
-↓ ↓ ↓
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │ (6)
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-nums[3] = 5 < 9 → L = 4
-```
-
-Step 2: L = 4, R = 6, M = 5
-
-```markdown
-                       L    M        R
-                       ↓    ↓        ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │ (6)
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-nums[5] = 12 >= 9 → R = 5
-```
-
-Step 3: L = 4, R = 5, M = 4
-
-```markdown
-                      L,M   R
-                       ↓    ↓
-
-┌────┬────┬────┬────┬────┬────┐
-│ -1 │ 0 │ 3 │ 5 │ 9 │ 12 │
-└────┴────┴────┴────┴────┴────┘
-0 1 2 3 4 5
-nums[4] = 9 >= 9 → R = 4
-```
-
-Loop ends: L = 4
-
-**Verification:**
-
-```markdown
-index = 4
-nums[4] = 9 == 9 (target) ✓
-
-Return 4
-```
-
-**Result: index 4**
-
-</details>
 
 <br>