Update articles (#5063)

Author: Srihari2222

articles/add-two-numbers.md

@@ -1,5 +1,43 @@
 ## 1. Recursion
 
+### Intuition
+
+We add the two linked lists exactly like adding two numbers on paper.
+
+Each node contains one digit, and since the lists are stored in **reverse order**, the head contains the ones place — making addition easy.  
+At every step:
+
+1. Take a digit from `l1` (or 0 if it’s finished)
+2. Take a digit from `l2` (or 0 if it’s finished)
+3. Add them with the incoming `carry`
+4. Create a new node for the current digit (`sum % 10`)
+5. Pass the new `carry` (`sum // 10`) forward using **recursion**
+
+The recursion naturally processes digits from left to right and stops only when:
+- both lists are fully processed **and**
+- no carry remains.
+
+---
+
+### Algorithm
+
+1. Define a recursive function `add(l1, l2, carry)`:
+   - If `l1`, `l2` are both `None` and `carry` is `0`, return `None`.
+   - Extract:
+     - `v1 = l1.val` if `l1` exists, else `0`
+     - `v2 = l2.val` if `l2` exists, else `0`
+   - Compute:
+     - `total = v1 + v2 + carry`
+     - `carry, digit = divmod(total, 10)`
+   - Recursively compute the next node using:
+     - `l1.next` if exists  
+     - `l2.next` if exists  
+     - updated `carry`
+   - Return a node with value `digit` whose `next` is the recursive result.
+
+2. In `addTwoNumbers`, call:
+    - return add(l1, l2, 0)
+
 ::tabs-start
 
 ```python
@@ -350,6 +388,48 @@ class Solution {
 
 ## 2. Iteration
 
+### Intuition
+
+We simulate normal addition the same way we do on paper — digit by digit.
+
+The linked lists store numbers in **reverse order**, so the first nodes represent the 1’s place.  
+This makes addition straightforward:
+
+- Add the two digits.
+- Add the carry from the previous step.
+- Save the resulting digit (`sum % 10`) into a new node.
+- Update the carry (`sum // 10`).
+- Move both pointers forward.
+
+We continue until **both lists are finished AND no carry remains**.  
+A dummy node helps us easily build and return the final linked list.
+
+---
+
+### Algorithm
+
+1. Create:
+   - a `dummy` node (to build the answer)
+   - a pointer `cur` pointing to `dummy`
+   - an integer `carry = 0`
+
+2. Loop while `l1` exists, `l2` exists, or `carry` is non-zero:
+   - Read the current digit of each list (`0` if that list already ended)
+   - Compute  
+     `sum = v1 + v2 + carry`
+   - Update:  
+     `carry = sum // 10`  
+     `digit = sum % 10`
+   - Append a new node containing `digit`
+   - Move the pointers `l1`, `l2`, and `cur` forward
+
+3. Return `dummy.next` (the head of the result list)
+
+This ensures correct handling of:
+- different lengths of input lists  
+- leftover carry  
+- building the result in one pass  
+
 ::tabs-start
 
 ```python

articles/balanced-binary-tree.md

@@ -1,5 +1,31 @@
 ## 1. Brute Force
 
+### Intuition
+A tree is balanced if **every node’s left and right subtree heights differ by at most 1**.
+
+The brute-force approach directly follows the definition:
+- For every node, compute the height of its left subtree.
+- Compute the height of its right subtree.
+- Check if their difference is ≤ 1.
+- Recursively repeat this check for all nodes.
+
+---
+
+### Algorithm
+1. If the current node is `null`, the subtree is balanced.
+2. Compute:
+   - `leftHeight = height(left subtree)`
+   - `rightHeight = height(right subtree)`
+3. If `abs(leftHeight - rightHeight) > 1`, return `False`.
+4. Recursively check if:
+   - left subtree is balanced
+   - right subtree is balanced
+5. If all checks pass, return `True`.
+
+Height function:
+- If node is null → return 0  
+- Otherwise → `1 + max(height(left), height(right))`
+
 ::tabs-start
 
 ```python
@@ -300,6 +326,30 @@ class Solution {
 
 ## 2. Depth First Search
 
+### Intuition
+The brute-force solution wastes time by repeatedly recomputing subtree heights.  
+We fix this by doing **one DFS that returns two things at once** for every node:
+
+1. **Is the subtree balanced?** (`True`/`False`)
+2. **What is its height?**
+
+This way, each subtree is processed only once.  
+If at any node the height difference > 1, we mark it as unbalanced and stop worrying about deeper levels.
+
+---
+
+### Algorithm
+1. Write a DFS function that:
+   - Returns `[isBalanced, height]`.
+2. For each node:
+   - Recursively get results from left and right children.
+   - A node is balanced if:
+     - Left subtree is balanced  
+     - Right subtree is balanced  
+     - Height difference ≤ 1
+3. Height of the current node = `1 + max(leftHeight, rightHeight)`
+4. Run DFS on the root and return the `isBalanced` value.
+
 ::tabs-start
 
 ```python
@@ -604,6 +654,33 @@ class Solution {
 
 ## 3. Iterative DFS
 
+### Intuition
+The recursive DFS solution computes height and balance in one postorder traversal.  
+This iterative version does **the same thing**, but simulates recursion using a stack.
+
+The idea:
+- We must visit each node **after** its children (postorder).
+- Once both children of a node are processed, we already know their heights.
+- Then we:
+  1. Check if the height difference ≤ 1  
+  2. Save the node’s height (`1 + max(left, right)`)
+
+If any node is unbalanced, return `False` immediately.
+
+---
+
+### Algorithm
+1. Use a stack to simulate postorder traversal.
+2. Use a dictionary/map (`depths`) to store the height of each visited node.
+3. For each node:
+   - Traverse left until possible.
+   - When left is done, try right.
+   - When both children are done:
+     - Get their heights from `depths`.
+     - If the difference > 1 → tree is unbalanced → return `False`.
+     - Compute current node height and store it.
+4. If the traversal completes without violations → return `True`.
+
 ::tabs-start
 
 ```python

articles/binary-search.md

@@ -1,5 +1,28 @@
 ## 1. Recursive Binary Search
 
+### Intuition
+
+Binary search works by repeatedly cutting the search space in half.  
+Instead of scanning the entire array, we check the **middle element**:
+
+- If it’s the target → return the index.
+- If the target is larger → search only in the right half.
+- If the target is smaller → search only in the left half.
+
+The recursive version simply expresses this idea as a function that keeps calling itself on the appropriate half until the target is found or the range becomes invalid.
+
+### Algorithm
+
+1. Define a recursive function that takes the current search range `[l, r]`.
+2. If `l > r`, the range is empty → return `-1`.
+3. Compute the middle index `m = (l + r) // 2`.
+4. Compare `nums[m]` with `target`:
+   - If equal → return `m`.
+   - If `nums[m] < target` → recursively search `[m + 1, r]`.
+   - If `nums[m] > target` → recursively search `[l, m - 1]`.
+5. Start the recursion with the full range `[0, n - 1]`.
+6. Return the final result.
+
 ::tabs-start
 
 ```python
@@ -173,6 +196,24 @@ class Solution {
 
 ## 2. Iterative Binary Search
 
+### Intuition
+
+Binary search checks the middle element of a sorted array and decides which half to discard.  
+Instead of using recursion, the iterative approach keeps shrinking the search range using a loop.  
+We adjust the left and right pointers until we either find the target or the pointers cross, meaning the target isn’t present.
+
+### Algorithm
+
+1. Initialize two pointers:
+   - `l = 0` (start of array)
+   - `r = len(nums) - 1` (end of array)
+2. While `l <= r`:
+   - Compute `m = l + (r - l) // 2` (safe midpoint).
+   - If `nums[m] == target`, return `m`.
+   - If `nums[m] < target`, move search to the **right half**: update `l = m + 1`.
+   - 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`.
+
 ::tabs-start
 
 ```python
@@ -352,6 +393,26 @@ class Solution {
 
 ## 3. Upper Bound
 
+### Intuition
+
+Upper bound binary search finds the **first index where a value greater than the target appears**.  
+Once we know that position, the actual target—if it exists—must be right before it.  
+So instead of directly searching for the target, we search for the boundary where values stop being ≤ target.  
+Then we simply check whether the element just before that boundary is the target.
+
+### Algorithm
+
+1. Set `l = 0` and `r = len(nums)` (right is *one past* the last index).
+2. While `l < r`:
+   - Compute midpoint `m`.
+   - If `nums[m] > target`, shrink the right side → `r = m`.
+   - Otherwise (`nums[m] <= target`), shrink the left side → `l = m + 1`.
+3. After the loop:
+   - `l` is the **upper bound**: first index where `nums[l] > target`.
+   - So the potential location of the target is `l - 1`.
+4. If `l > 0` and `nums[l - 1] == target`, return `l - 1`.
+5. Otherwise, return `-1` (target not found).
+
 ::tabs-start
 
 ```python
@@ -514,6 +575,28 @@ class Solution {
 
 ## 4. Lower Bound
 
+### Intuition
+
+Lower bound binary search finds the **first index where a value is greater than or equal to the target**.  
+This means if the target exists in the array, this lower-bound index will point exactly to its first occurrence.  
+So instead of directly searching for equality, we search for the **leftmost position** where the target *could* appear, then verify it.
+
+This approach is especially useful for sorted arrays because it avoids overshooting and naturally handles duplicates.
+
+### Algorithm
+
+1. Initialize:
+   - `l = 0`
+   - `r = len(nums)` (right is one past the last index).
+2. While `l < r`:
+   - Compute midpoint `m`.
+   - If `nums[m] >= target`, shrink the search to the **left half** → `r = m`.
+   - Otherwise (`nums[m] < target`), search in the **right half** → `l = m + 1`.
+3. After the loop:
+   - `l` is the **lower bound**: first index where value ≥ target.
+4. If `l` is within bounds *and* `nums[l] == target`, return `l`.
+5. Otherwise, return `-1` (the target is not in the array).
+
 ::tabs-start
 
 ```python