Practice Strategy & Tips

Knowing how to solve problems is only half the battle. This lesson covers time management, pattern recognition, a study plan, and answers to the most common questions about coding interviews for AI/ML roles.

Time Management During the Interview

Most coding interviews are 45 minutes. Here is how to allocate your time for maximum impact:

Common Patterns Cheat Sheet

Most coding problems fall into one of these patterns. Learning to recognize the pattern is the fastest way to solve new problems.

Pattern Recognition Decision Tree

# Mental decision tree for choosing the right pattern:

# 1. Is the input sorted?
#    -> Binary Search or Two Pointers

# 2. Do I need O(1) lookup?
#    -> Hash Map (dict/set)

# 3. Am I looking for a contiguous subarray?
#    -> Sliding Window (if fixed/variable size constraint)
#    -> Kadane's Algorithm (if max sum)

# 4. Am I dealing with intervals?
#    -> Sort by start or end time -> Greedy or Merge Intervals

# 5. Do I need "next greater/smaller" element?
#    -> Monotonic Stack

# 6. Am I traversing a linked list?
#    -> Two pointers (fast/slow for cycle, gap for nth from end)

# 7. Can I make locally optimal choices?
#    -> Greedy (verify greedy choice property first!)

# 8. Do I need to try all possibilities?
#    -> BFS (shortest), DFS/Backtracking (all solutions)

Python Quick Reference for Interviews

# ====== ESSENTIAL PYTHON OPERATIONS ======

# --- Strings ---
s = "hello world"
s.split()              # ['hello', 'world']
s.replace('l', 'r')    # 'herro worrd'
s[::-1]                # 'dlrow olleh' (reverse)
s.startswith('hel')    # True
s.isalnum()            # False (has space)
ord('a')               # 97
chr(97)                # 'a'

# --- Lists ---
nums = [3, 1, 4, 1, 5]
nums.sort()            # In-place: [1, 1, 3, 4, 5]
sorted(nums)           # Returns new sorted list
nums.sort(key=lambda x: -x)  # Descending
nums.append(9)         # O(1)
nums.pop()             # O(1) remove last
nums.pop(0)            # O(n) remove first - AVOID
max(nums), min(nums)   # O(n) each
sum(nums)              # O(n)

# --- Deque (for O(1) both ends) ---
from collections import deque
q = deque()
q.append(1)            # Right: O(1)
q.appendleft(0)        # Left: O(1)
q.pop()                # Right: O(1)
q.popleft()            # Left: O(1)

# --- Heap (min-heap) ---
import heapq
h = [3, 1, 4, 1, 5]
heapq.heapify(h)       # O(n) - convert to min-heap
heapq.heappush(h, 2)   # O(log n)
heapq.heappop(h)       # O(log n) - returns smallest
heapq.nlargest(3, h)   # Top 3 largest

# For max-heap: negate values
max_heap = [-x for x in nums]
heapq.heapify(max_heap)
largest = -heapq.heappop(max_heap)

# --- Infinity ---
float('inf')           # Positive infinity
float('-inf')          # Negative infinity

# --- Integer limits ---
import sys
sys.maxsize            # Largest int (platform-dependent)

# --- Useful itertools ---
from itertools import combinations, permutations, product
list(combinations([1,2,3], 2))  # [(1,2), (1,3), (2,3)]
list(permutations([1,2,3], 2))  # [(1,2), (1,3), (2,1), ...]

# --- Bisect (binary search on sorted list) ---
import bisect
arr = [1, 3, 5, 7]
bisect.bisect_left(arr, 5)    # 2 (index where 5 IS)
bisect.bisect_right(arr, 5)   # 3 (index AFTER 5)
bisect.insort(arr, 4)         # Insert maintaining sort

2-Week Study Plan for AI/ML Engineers

Frequently Asked Questions

Final Checklist Before Your Interview