Complete documentation system with 81 comprehensive notes and updated README index

Author: Carlos Gutierrez

.gitignore

@@ -1,7 +1,7 @@
 # Created by https://www.toptal.com/developers/gitignore/api/node,java,python,c++
 # Edit at https://www.toptal.com/developers/gitignore?templates=node,java,python,c++
 .cursor*
-*src/notes*
+# *src/notes*
 *backup/
 ./src/notes/
 *sync_leetcode.sh

README.md

@@ -0,0 +1,113 @@
+# Two Sum
+
+[![Problem 1](https://img.shields.io/badge/Problem-1-blue?style=for-the-badge&logo=leetcode)](https://leetcode.com/problems/two-sum/)
+[![Difficulty](https://img.shields.io/badge/Difficulty-Easy-green?style=for-the-badge)](https://leetcode.com/problemset/?difficulty=EASY)
+[![LeetCode](https://img.shields.io/badge/LeetCode-View%20Problem-orange?style=for-the-badge&logo=leetcode)](https://leetcode.com/problems/two-sum/)
+
+**Problem Number:** [1](https://leetcode.com/problems/two-sum/)
+**Difficulty:** [Easy](https://leetcode.com/problemset/?difficulty=EASY)
+**Category:** Array, Hash Table
+**LeetCode Link:** [https://leetcode.com/problems/two-sum/](https://leetcode.com/problems/two-sum/)
+
+## Problem Description
+
+Given an array of integers `nums` and an integer `target`, return indices of the two numbers such that they add up to `target`.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+```
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+```
+
+**Example 2:**
+```
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+```
+
+**Example 3:**
+```
+Input: nums = [3,3], target = 6
+Output: [0,1]
+```
+
+**Constraints:**
+- `2 <= nums.length <= 10^4`
+- `-10^9 <= nums[i] <= 10^9`
+- `-10^9 <= target <= 10^9`
+- Only one valid answer exists.
+
+## My Approach
+
+I used a **Hash Table (Dictionary)** approach to solve this problem efficiently. The key insight is to use a hash map to store previously seen numbers and their indices, allowing us to find the complement in O(1) time.
+
+**Algorithm:**
+1. Create an empty hash map to store numbers and their indices
+2. Iterate through the array once
+3. For each number, calculate its complement (target - current_number)
+4. Check if the complement exists in the hash map
+5. If found, return the current index and the complement's index
+6. If not found, add the current number and its index to the hash map
+
+## Solution
+
+The solution uses a hash table approach to achieve O(n) time complexity. See the implementation in the [solution file](../exercises/1.two-sum.py).
+
+**Key Points:**
+- Uses a hash map for O(1) lookup time
+- Only requires a single pass through the array
+- Handles edge cases appropriately
+- Returns indices in the order [current_index, complement_index]
+
+## Time & Space Complexity
+
+**Time Complexity:** O(n)
+- We iterate through the array once: O(n)
+- Hash map operations (insertion and lookup) are O(1) on average
+- Total: O(n)
+
+**Space Complexity:** O(n)
+- In the worst case, we might need to store all n elements in the hash map
+- This occurs when the solution is found at the end of the array
+
+## Key Insights
+
+1. **Hash Table Efficiency:** Using a hash table allows us to achieve O(n) time complexity instead of the O(n²) that would result from a brute force approach with nested loops.
+
+2. **Single Pass Solution:** We can find the solution in just one iteration through the array by storing previously seen numbers and checking for complements.
+
+3. **Complement Strategy:** Instead of looking for two numbers that sum to target, we look for one number and its complement (target - number).
+
+4. **Edge Case Handling:** The solution includes proper handling of edge cases like empty arrays and arrays with fewer than 2 elements.
+
+5. **No Duplicate Usage:** The algorithm naturally avoids using the same element twice because we check for the complement before adding the current element to the hash map.
+
+## Mistakes Made
+
+1. **Initial Edge Case Over-engineering:** The solution includes edge cases for arrays with 0, 1, or 2 elements, which might be unnecessary given the problem constraints (array length ≥ 2).
+
+2. **Return Order:** The solution returns [current_index, complement_index], but the problem allows returning the answer in any order.
+
+## Related Problems
+
+- **Two Sum II - Input Array Is Sorted** (Problem 167): Similar problem but with a sorted array, allowing for a two-pointer approach
+- **Two Sum BST** (Problem 653): Finding two nodes in a BST that sum to target
+- **Three Sum** (Problem 15): Extension to finding three numbers that sum to zero
+- **Four Sum** (Problem 18): Further extension to finding four numbers that sum to target
+
+## Alternative Approaches
+
+1. **Brute Force:** O(n²) time complexity with nested loops
+2. **Two Pointers:** Only works for sorted arrays, O(n log n) due to sorting
+3. **Binary Search:** Only applicable for sorted arrays
+
+---
+
+[![Back to Index](../../README.md#-problem-index)](../../README.md#-problem-index) | [![View Solution](../exercises/1.two-sum.py)](../exercises/1.two-sum.py)
+
+*Note: This is a fundamental problem that introduces the hash table optimization pattern, commonly used in array and string problems.*

src/notes/001_two_sum.md

@@ -0,0 +1,128 @@
+# Add Two Numbers
+
+[![Problem 2](https://img.shields.io/badge/Problem-2-blue?style=for-the-badge&logo=leetcode)](https://leetcode.com/problems/add-two-numbers/)
+[![Difficulty](https://img.shields.io/badge/Difficulty-Medium-orange?style=for-the-badge)](https://leetcode.com/problemset/?difficulty=MEDIUM)
+[![LeetCode](https://img.shields.io/badge/LeetCode-View%20Problem-orange?style=for-the-badge&logo=leetcode)](https://leetcode.com/problems/add-two-numbers/)
+
+**Problem Number:** [2](https://leetcode.com/problems/add-two-numbers/)
+**Difficulty:** [Medium](https://leetcode.com/problemset/?difficulty=MEDIUM)
+**Category:** Linked List, Math, Recursion
+**LeetCode Link:** [https://leetcode.com/problems/add-two-numbers/](https://leetcode.com/problems/add-two-numbers/)
+
+## Problem Description
+
+You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+```
+Input: l1 = [2,4,3], l2 = [5,6,4]
+Output: [7,0,8]
+Explanation: 342 + 465 = 807
+```
+
+**Example 2:**
+```
+Input: l1 = [0], l2 = [0]
+Output: [0]
+```
+
+**Example 3:**
+```
+Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+Output: [8,9,9,9,0,0,0,1]
+```
+
+**Constraints:**
+- The number of nodes in each linked list is in the range [1, 100]
+- 0 <= Node.val <= 9
+- It is guaranteed that the list represents a number that does not have leading zeros
+
+## My Approach
+
+I used an **iterative approach** to simulate the manual addition process we learned in elementary school. The key insight is to process both linked lists digit by digit, maintaining a carry value, and building the result linked list as we go.
+
+**Algorithm:**
+1. Initialize a carry variable to 0
+2. Create a dummy head node for the result linked list
+3. Iterate through both linked lists simultaneously:
+   - Extract the current digit from each list (0 if list is exhausted)
+   - Add the digits along with the carry
+   - Calculate the new carry and the digit to store
+   - Create a new node with the calculated digit
+   - Append it to the result list
+4. If there's still a carry after processing all digits, create a final node
+5. Return the head of the result linked list
+
+## Solution
+
+The solution uses an iterative approach to add two numbers represented as linked lists. See the implementation in the [solution file](../exercises/2.add-two-numbers.py).
+
+**Key Points:**
+- Processes both lists simultaneously, handling different lengths
+- Maintains a carry value throughout the addition process
+- Builds the result linked list incrementally
+- Handles the final carry if it exists
+- Returns the result in reverse order (least significant digit first)
+
+## Time & Space Complexity
+
+**Time Complexity:** O(max(M, N))
+- We iterate through both linked lists once
+- M and N are the lengths of the input linked lists
+- Each iteration performs constant time operations
+
+**Space Complexity:** O(max(M, N))
+- We create a new linked list to store the result
+- The result can be at most max(M, N) + 1 digits long (due to carry)
+- We use a constant amount of extra space for variables
+
+## Key Insights
+
+1. **Reverse Order Advantage:** The fact that digits are stored in reverse order makes the addition process straightforward - we can process from left to right, just like manual addition.
+
+2. **Carry Management:** The carry must be tracked and added to the next position, similar to how we learned addition in school.
+
+3. **Different Lengths:** The solution handles cases where the input lists have different lengths by treating missing digits as 0.
+
+4. **Final Carry:** After processing all digits, if there's still a carry, it becomes the most significant digit in the result.
+
+5. **Linked List Construction:** Building the result linked list incrementally is more efficient than converting to integers and back.
+
+6. **No Leading Zeros:** The problem guarantees no leading zeros in input, but we need to handle the case where the result might have a leading zero (like 0 + 0 = 0).
+
+## Mistakes Made
+
+1. **Carry Calculation:** The initial approach of converting the sum to a string to extract carry and digit is inefficient. A more efficient approach would be to use integer division and modulo operations.
+
+2. **Variable Naming:** The variable names could be more descriptive to improve code readability.
+
+3. **Edge Case Handling:** Need to ensure proper handling when one list is longer than the other.
+
+## Related Problems
+
+- **Add Two Numbers II** (Problem 445): Similar problem but digits are stored in forward order
+- **Multiply Strings** (Problem 43): Multiplying two numbers represented as strings
+- **Plus One** (Problem 66): Adding one to a number represented as an array
+- **Add Binary** (Problem 67): Adding two binary strings
+- **Add Strings** (Problem 415): Adding two numbers represented as strings
+
+## Alternative Approaches
+
+1. **Recursive Solution:** Can be solved recursively by processing one digit at a time
+2. **Convert to Integer:** Convert linked lists to integers, add them, then convert back (not recommended due to potential overflow)
+3. **Stack-based:** Use stacks to reverse the order and then add (useful for forward order problems)
+
+## Common Pitfalls
+
+1. **Forgetting Final Carry:** Always check if there's a carry after processing all digits
+2. **Null Pointer Exceptions:** Ensure proper null checks when accessing list nodes
+3. **Memory Management:** Be careful not to lose references when building the result list
+4. **Overflow:** While the problem constraints prevent integer overflow, it's good practice to consider it
+
+---
+
+[![Back to Index](../../README.md#-problem-index)](../../README.md#-problem-index) | [![View Solution](../exercises/2.add-two-numbers.py)](../exercises/2.add-two-numbers.py)
+
+*Note: This is a fundamental linked list problem that teaches the importance of careful iteration and carry management in mathematical operations.*

src/notes/002_add_two_numbers.md

@@ -0,0 +1,123 @@
+# Longest Substring Without Repeating Characters
+
+[![Problem 3](https://img.shields.io/badge/Problem-3-blue?style=for-the-badge&logo=leetcode)](https://leetcode.com/problems/longest-substring-without-repeating-characters/)
+[![Difficulty](https://img.shields.io/badge/Difficulty-Medium-orange?style=for-the-badge)](https://leetcode.com/problemset/?difficulty=MEDIUM)
+[![LeetCode](https://img.shields.io/badge/LeetCode-View%20Problem-orange?style=for-the-badge&logo=leetcode)](https://leetcode.com/problems/longest-substring-without-repeating-characters/)
+
+**Problem Number:** [3](https://leetcode.com/problems/longest-substring-without-repeating-characters/)
+**Difficulty:** [Medium](https://leetcode.com/problemset/?difficulty=MEDIUM)
+**Category:** Hash Table, String, Sliding Window
+**LeetCode Link:** [https://leetcode.com/problems/longest-substring-without-repeating-characters/](https://leetcode.com/problems/longest-substring-without-repeating-characters/)
+
+## Problem Description
+
+Given a string `s`, find the length of the longest substring without repeating characters.
+
+**Example 1:**
+```
+Input: s = "abcabcbb"
+Output: 3
+Explanation: The answer is "abc", with the length of 3.
+```
+
+**Example 2:**
+```
+Input: s = "bbbbb"
+Output: 1
+Explanation: The answer is "b", with the length of 1.
+```
+
+**Example 3:**
+```
+Input: s = "pwwkew"
+Output: 3
+Explanation: The answer is "wke", with the length of 3.
+Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.
+```
+
+**Constraints:**
+- `0 <= s.length <= 5 * 10^4`
+- `s` consists of English letters, digits, symbols and spaces
+
+## My Approach
+
+I used a **Sliding Window** approach with a hash table to track characters in the current window. The key insight is to maintain a window of unique characters and expand/shrink it as needed.
+
+**Algorithm:**
+1. Initialize two pointers (i, j) at the beginning of the string
+2. Use a hash table to track characters in the current window
+3. Expand the window by moving the right pointer (j) when we encounter a new character
+4. Shrink the window by moving the left pointer (i) when we encounter a duplicate
+5. Keep track of the maximum window size seen so far
+6. Return the maximum length found
+
+## Solution
+
+The solution uses a sliding window approach with hash table optimization. See the implementation in the [solution file](../exercises/3.longest-substring-without-repeating-characters.py).
+
+**Key Points:**
+- Uses two pointers to maintain a sliding window
+- Hash table tracks characters in the current window
+- Expands window when encountering new characters
+- Shrinks window when encountering duplicates
+- Tracks maximum window size throughout the process
+
+## Time & Space Complexity
+
+**Time Complexity:** O(n)
+- We traverse the string once with two pointers
+- Hash table operations are O(1) on average
+- Each character is visited at most twice (once by each pointer)
+
+**Space Complexity:** O(min(m, n))
+- Hash table stores at most min(m, n) characters
+- m is the size of the character set (ASCII: 128, Unicode: much larger)
+- n is the length of the string
+
+## Key Insights
+
+1. **Sliding Window Pattern:** This is a classic sliding window problem where we maintain a window of unique characters.
+
+2. **Two Pointer Technique:** Using two pointers allows us to efficiently expand and shrink the window without recalculating from scratch.
+
+3. **Hash Table for Tracking:** A hash table provides O(1) lookup to check if a character is already in the current window.
+
+4. **Optimal Window Management:** When we encounter a duplicate, we shrink the window from the left until the duplicate is removed.
+
+5. **Character Frequency vs. Presence:** We only need to track character presence (not frequency) since we want unique characters.
+
+6. **Maximum Tracking:** We need to continuously update the maximum length as we process the string.
+
+## Mistakes Made
+
+1. **Inefficient Window Shrinking:** The current implementation removes characters one by one, which could be optimized.
+
+2. **Character Tracking:** Using a simple dictionary instead of a set might be more appropriate for this use case.
+
+3. **Edge Case Handling:** Need to ensure proper handling of empty strings and single characters.
+
+## Related Problems
+
+- **Longest Substring with At Most Two Distinct Characters** (Problem 159): Similar sliding window with character count limit
+- **Longest Substring with At Most K Distinct Characters** (Problem 340): Generalization of the above
+- **Minimum Window Substring** (Problem 76): Finding minimum window containing all characters from another string
+- **Substring with Concatenation of All Words** (Problem 30): More complex sliding window with word matching
+
+## Alternative Approaches
+
+1. **Brute Force:** Check all possible substrings - O(n³) time complexity
+2. **Optimized Brute Force:** Use hash set for each substring - O(n²) time complexity
+3. **Character Position Tracking:** Store last position of each character for O(1) window shrinking
+
+## Common Pitfalls
+
+1. **Confusing Substring vs Subsequence:** The problem asks for substring (consecutive characters), not subsequence.
+2. **Inefficient Duplicate Removal:** Removing characters one by one can be optimized.
+3. **Missing Edge Cases:** Empty string, single character, all same characters.
+4. **Character Set Size:** Consider the size of the character set for space complexity.
+
+---
+
+[![Back to Index](../../README.md#-problem-index)](../../README.md#-problem-index) | [![View Solution](../exercises/3.longest-substring-without-repeating-characters.py)](../exercises/3.longest-substring-without-repeating-characters.py)
+
+*Note: This is a fundamental sliding window problem that introduces the concept of maintaining a dynamic window of unique elements.*