Week 01 - Arrays, Strings & Hash Maps

Reference extracted from the detailed guide.

Day 1-2: Arrays & Two Pointers

Watch First (Essential):

• NeetCode: "Two Pointers" pattern → https://www.youtube.com/watch?v=cQ1Oz4ckceM
• NeetCode: "Sliding Window" pattern → https://www.youtube.com/watch?v=p-ss2JNynmw

Problems in Order:

How to solve each:

LC #1 (Two Sum):
1. Brute force: O(n²) - two nested loops
2. Optimal: O(n) - use hash map to store {value: index}
3. One pass: check if (target - num) exists in map

LC #121 (Best Time to Buy/Sell):
1. Track minimum price seen so far
2. At each price, calculate profit = current - min
3. Track maximum profit

LC #11 (Container With Most Water):
1. Two pointers at start and end
2. Calculate area = min(height[l], height[r]) * (r - l)
3. Move the pointer with smaller height inward

Day 3-4: Hash Maps Deep Dive

Watch First:

• NeetCode: Hash Map patterns → https://www.youtube.com/watch?v=P6RZZMu_maU

Problems in Order:

Key Templates:

# Template: Frequency Count
from collections import Counter
freq = Counter(nums)  # or Counter(s) for strings

# Template: Two Sum Pattern (find pair)
seen = {}
for i, num in enumerate(nums):
    complement = target - num
    if complement in seen:
        return [seen[complement], i]
    seen[num] = i

# Template: Group by Key
from collections import defaultdict
groups = defaultdict(list)
for item in items:
    key = get_key(item)  # e.g., tuple(sorted(item))
    groups[key].append(item)

Day 5-7: Linked Lists

Watch First:

• NeetCode: Linked List playlist → https://www.youtube.com/watch?v=G0_I-ZF0S38

Problems in Order:

Key Templates:

# Template: Reverse Linked List
def reverse(head):
    prev, curr = None, head
    while curr:
        nxt = curr.next
        curr.next = prev
        prev = curr
        curr = nxt
    return prev

# Template: Fast/Slow Pointer (find middle)
def find_middle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow

# Template: Dummy Node (for edge cases)
dummy = ListNode(0)
dummy.next = head
# ... operations
return dummy.next

---