Skip to content

algorithm-interview-resources.md

Latest commit

 

History

History
514 lines (401 loc) · 27.6 KB

algorithm-interview-resources.md

File metadata and controls

514 lines (401 loc) · 27.6 KB

Algorithm Interview Preparation Resources (2025-2026)

Comprehensive guide to books, platforms, courses, and references for algorithm interview prep.

1. Books

Classic / Evergreen

Book Author(s) Notes
Introduction to Algorithms (CLRS), 4th Ed. Cormen, Leiserson, Rivest, Stein The definitive algorithms textbook. 4th edition (2022) adds chapters on matchings in bipartite graphs, online algorithms, machine learning. 140 new exercises, 22 new problems. Available at most university libraries.
The Algorithm Design Manual, 3rd Ed. Steven Skiena Practical focus. "War stories" section + huge catalogue of algorithmic problems. Excellent for bridging theory to practice.
Cracking the Coding Interview, 6th Ed. Gayle Laakmann McDowell 189 programming questions and solutions. Still the gold standard for FAANG-style interview prep.
Elements of Programming Interviews (EPI) Aziz, Lee, Prakash 250+ problems with detailed analysis. Available in Python, Java, and C++ editions. More challenging than CtCI.
Programming Pearls, 2nd Ed. Jon Bentley Focus on problem-solving, algorithm design, correctness, and performance. Short, dense, excellent.

Python-Specific

Book Author(s) Notes
Grokking Algorithms, 2nd Ed. Aditya Bhargava Fully illustrated, beginner-friendly. 2nd edition updated to Python 3, adds coverage of trees (BSTs, balanced trees, B-trees). Best first book on algorithms.
Problem Solving with Algorithms and Data Structures Using Python, 3rd Ed. Miller, Ranum Free interactive version at runestone.academy. Designed as a CS2-level textbook.
Cracking the Coding Interview with Python: 2026 Edition Bruce Herbert Python-focused edition with AI-assisted prep strategies. New for 2026.
Algorithmic Thinking, 2nd Ed. Daniel Zingaro Learn algorithms by solving well-known competitive programming problems. Python examples.

For Deeper Theory

Book Notes
Algorithm Design by Kleinberg & Tardos Best for understanding algorithm design techniques (greedy, divide-and-conquer, DP, network flow).
Algorithms by Jeff Erickson Free online at jeffe.cs.illinois.edu/teaching/algorithms. Graduate-level but very readable.

2. Online Platforms

Primary Practice Platforms

Platform URL Key Features (2025-2026)
LeetCode leetcode.com 3000+ problems. Premium ($35/mo or $159/yr): company-specific questions, frequency analysis, mock interviews, editorial solutions with video. New 2025-2026 features: "Highlight to Ask" AI assistance, timer with Super Alarm, contest history in problem topics, real-time runtime/memory stats.
NeetCode neetcode.io Free: 410+ video walkthroughs, full 150-problem roadmap. Pro: structured courses (Algorithms & DS 25hr, Advanced Algorithms 25hr, System Design 10hr, Python for Coding Interviews). Created by ex-Google/Amazon engineer. 870K+ YouTube subscribers.
AlgoExpert algoexpert.io 200+ hand-picked problems with step-by-step video explanations. Includes SystemsExpert, MLExpert, FrontendExpert bundles. Good for clear explanations before pressure.
HackerRank hackerrank.com 2,500+ customers, 26M developer community. Structured challenges used by companies for screening. AI Assistant launched July 2025.
CodeSignal codesignal.com Timed coding assessments replicating real company interviews. "Cosmo" AI assistant launched May 2025. Used by many companies for actual interview screening.

Newer / Specialized Platforms

Platform URL Key Features
AlgoMonster algo.monster Pattern-based approach. Especially good for experienced devs with limited time. Pairs well with ByteByteGo for system design.
Educative educative.io Text-based interactive courses. "Grokking the Coding Interview: Patterns for Coding Questions" is a standout course. No video -- read and code in-browser.
Structy structy.net Step-by-step DSA course with visual explanations. Good for building fundamentals.
Interview Cake interviewcake.com Guided problem-solving with progressive hints. Excellent data structures reference card.
ByteByteGo bytebytego.com System design focus. Content from 7 best-selling books on OOD, ML system design, coding patterns.

Useful Chrome Extensions (2026)

  • LeetCopilot -- AI-powered progressive hints (10/20/30/100%), debugging, mock interviews, auto-generated study notes
  • Various timer and note-taking extensions for structured practice sessions

3. Courses

Free University Courses

Course Platform Notes
MIT 6.006: Introduction to Algorithms MIT OCW Full video lectures, problem sets, exams. Taught by Erik Demaine and others. Covers sorting, hashing, graph algorithms, shortest paths, DP.
MIT 6.046J: Design and Analysis of Algorithms MIT OCW Advanced follow-up to 6.006. Divide and conquer, DP, network flow, complexity theory.
Stanford Algorithms Specialization Coursera By Tim Roughgarden. 4-course specialization. Free to audit. Weekly quizzes + programming assignments in any language. Covers divide-and-conquer, graph search, greedy, DP, NP-completeness.
UC San Diego: Algorithmic Toolbox Coursera Part of the Data Structures and Algorithms specialization. Good beginner-friendly option.
Princeton Algorithms, Parts I & II Coursera By Robert Sedgewick and Kevin Wayne. Java-based but concepts transfer. Excellent animations.
Algorithms by Jeff Erickson jeffe.cs.illinois.edu Free textbook + lecture notes from UIUC.

Paid Courses

Course Platform Notes
Python Data Structures & Algorithms + LeetCode Exercises Udemy Hands-on Python-specific DSA course with LeetCode-style exercises.
Grokking the Coding Interview: Patterns Educative Pattern-based approach: sliding window, two pointers, fast/slow pointers, merge intervals, etc.
NeetCode Algorithms & Data Structures neetcode.io 25 hours. Beginner through advanced. Python-focused.
NeetCode Advanced Algorithms neetcode.io 25 hours. DP, graph theory, advanced data structures.

Free Video Courses

Course Platform Notes
freeCodeCamp DSA courses YouTube / freecodecamp.org 8+ hour deep dives. Multiple DSA courses in Python, JavaScript.
Abdul Bari's Algorithms YouTube University-professor style with hand-drawn visualizations. Covers all major topics.

4. YouTube Channels

Channel Subscribers Focus Best For
NeetCode 870K+ LeetCode problem walkthroughs, DSA concepts Primary interview prep. Clean, beginner-friendly explanations. 410+ videos.
Abdul Bari 1.5M+ Algorithm fundamentals Deep understanding of algorithms with hand-drawn visualizations.
William Fiset 200K+ Data structures and algorithms In-depth tutorials on graph algorithms, trees, DP.
Back To Back SWE 300K+ Coding interview problems Clear explanations of complex topics with whiteboard approach.
Nick White 400K+ LeetCode problem walkthroughs Quick, concise LeetCode solutions. Good for reviewing problems.
CS Dojo 1.9M+ CS fundamentals, interview prep Beginner-friendly CS and interview content.
Errichto 100K+ Competitive programming Advanced algorithm techniques and contest strategies.
freeCodeCamp 10M+ Full courses Complete 8+ hour DSA courses.
mycodeschool 250K+ Data structures fundamentals Best visualizations for basic data structures (no longer active but content holds up).
Tushar Roy 200K+ DP and graph algorithms Excellent DP walkthroughs with clear diagrams.

5. Cheat Sheets and Printable References

Big-O Complexity

Resource URL Format
Big-O Cheat Sheet bigocheatsheet.com Web + PDF download. Covers 14 data structures, 13 sorting algorithms. Also available as a poster from Redbubble.
Big-O Complexity Cheat Sheet (KDnuggets) kdnuggets.com Web article format with tables. Updated Feb 2025.
Big-O Complexity Cheat Sheet (GitHub) ReaVNaiL/Big-O-Complexity-Cheat-Sheet Markdown + visual format on GitHub.

Data Structures Reference

Resource URL Notes
Interview Cake Data Structures Reference interviewcake.com/data-structures-reference Covers arrays, linked lists, queues, stacks, hash tables, BSTs, tries, heaps, priority queues, bloom filters, LRU caches. Clean, printable.
Tech Interview Handbook Cheatsheets techinterviewhandbook.org Per-topic guides covering overview, time complexities, corner cases, useful techniques, practice questions. Topics: Array, String, Sorting, Matrix, Tree, Graph, Hash Table, Recursion, Linked List, Queue, Stack, Heap, Trie, Interval, DP, Binary, Math, Geometry.
HackerEarth Big-O Cheatsheet hackerearth.com Data structures + algorithms with complexities.

Algorithm Patterns Cheat Sheets

Resource URL Notes
LeetCode Patterns Cheat Sheet scribd.com PDF covering all major patterns.
Sliding Window & Two Pointers Cheat Sheet scribd.com Detailed cheat sheet for when to use each technique.
DSA Patterns Cheat Sheet scribd.com Covers sliding window, two pointers, DP, and more.
GitHub Technical Interview Cheat Sheet TSiege/gist Classic gist covering all major data structures and algorithms.

Common Algorithm Patterns Quick Reference

14 Patterns to Ace Coding Interviews:
 1. Sliding Window         - Subarray/substring problems, contiguous elements
 2. Two Pointers           - Sorted arrays, pair finding, partitioning
 3. Fast & Slow Pointers   - Cycle detection, linked list middle
 4. Merge Intervals        - Overlapping intervals
 5. Cyclic Sort            - Problems involving numbers in range [1, n]
 6. In-place Linked List Reversal
 7. Tree BFS               - Level-order traversal
 8. Tree DFS               - Preorder, inorder, postorder
 9. Two Heaps              - Median finding, scheduling
10. Subsets                 - Permutations, combinations
11. Modified Binary Search  - Sorted/rotated arrays
12. Bitwise XOR            - Missing/duplicate numbers
13. Top K Elements         - Heap-based selection
14. K-way Merge            - Merging sorted structures
+ Topological Sort         - Dependency ordering
+ Union Find              - Connected components, cycle detection in undirected graphs
+ Dynamic Programming      - Overlapping subproblems + optimal substructure
+ Backtracking            - Constraint satisfaction, exhaustive search
+ Monotonic Stack/Queue   - Next greater/smaller element
+ Trie                    - Prefix matching, autocomplete

6. Python-Specific Resources

Python Standard Library for Interviews

collections Module

from collections import defaultdict, Counter, deque, OrderedDict

# Counter - frequency counting
counter = Counter("abracadabra")        # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
counter.most_common(2)                   # [('a', 5), ('b', 2)]

# defaultdict - auto-initialize missing keys
graph = defaultdict(list)
graph[0].append(1)                       # No KeyError

# deque - O(1) append/pop from both ends
dq = deque([1, 2, 3])
dq.appendleft(0)                         # deque([0, 1, 2, 3])
dq.popleft()                             # 0

# OrderedDict (less needed in Python 3.7+ where dict preserves insertion order)

heapq Module (Min-Heap)

import heapq

# Basic operations
heap = [3, 1, 4, 1, 5]
heapq.heapify(heap)                      # In-place, O(n)
heapq.heappush(heap, 2)                  # O(log n)
smallest = heapq.heappop(heap)           # O(log n), returns smallest

# Top-K patterns
heapq.nlargest(3, iterable)              # 3 largest elements
heapq.nsmallest(3, iterable)             # 3 smallest elements

# Max-heap trick: negate values
heapq.heappush(heap, -val)               # Push negative
-heapq.heappop(heap)                     # Pop and negate back

# Tuple comparison for priority queue
heapq.heappush(heap, (priority, item))   # Sorts by first element

itertools Module

from itertools import combinations, permutations, product, accumulate, chain, groupby

combinations([1,2,3], 2)         # (1,2), (1,3), (2,3)
permutations([1,2,3], 2)         # (1,2), (1,3), (2,1), (2,3), (3,1), (3,2)
product([0,1], repeat=3)         # All 3-bit binary numbers
accumulate([1,2,3,4])            # 1, 3, 6, 10 (prefix sums)
chain([1,2], [3,4])              # 1, 2, 3, 4 (flatten iterables)

bisect Module (Binary Search)

import bisect

sorted_list = [1, 3, 5, 7, 9]
bisect.bisect_left(sorted_list, 5)       # 2 (index of leftmost 5)
bisect.bisect_right(sorted_list, 5)      # 3 (index after rightmost 5)
bisect.insort(sorted_list, 4)            # Insert maintaining sort order

functools Module

from functools import lru_cache, cache, reduce

@lru_cache(maxsize=None)   # Memoization decorator (Python 3.2+)
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

@cache                      # Simplified unbounded cache (Python 3.9+)
def expensive(x):
    return x ** x

Other Useful Built-ins

# Sorting
sorted(iterable, key=lambda x: x[1], reverse=True)
list.sort(key=lambda x: (-x[0], x[1]))   # Multi-key sort

# String operations
"".join(list_of_chars)
str.isalnum(), str.isdigit(), str.isalpha()
ord('a')  # 97;  chr(97)  # 'a'

# Math
float('inf'), float('-inf')
divmod(17, 5)               # (3, 2) -- quotient and remainder
abs(), min(), max(), sum()
pow(base, exp, mod)          # Modular exponentiation

# Sets
set.union(), set.intersection(), set.difference()
set.issubset(), set.issuperset()

Python Complexity Quick Reference

Operation list dict set deque
Access by index O(1) -- -- O(n)
Search O(n) O(1) avg O(1) avg O(n)
Insert/append end O(1)* O(1) avg O(1) avg O(1)
Insert/append front O(n) -- -- O(1)
Delete O(n) O(1) avg O(1) avg O(n)
Pop end O(1) -- -- O(1)
Pop front O(n) -- -- O(1)
Sort O(n log n) -- -- --

* amortized

Python Type Hints for Interviews

from typing import List, Dict, Set, Optional, Tuple

# Function signatures (clean, shows intent)
def two_sum(nums: list[int], target: int) -> list[int]: ...
def is_valid(s: str) -> bool: ...
def max_depth(root: Optional[TreeNode]) -> int: ...
def group_anagrams(strs: list[str]) -> list[list[str]]: ...

# Python 3.10+ union syntax
def find(val: int | None) -> int | None: ...

# Using type hints improves readability in live coding sessions and signals
# awareness of production-level practices.

Python Interview Cheat Sheet (GitHub)

  • python-cp-cheatsheet by peterlamar: github.com/peterlamar/python-cp-cheatsheet
    • Covers: language mechanics, collections, heapq, itertools, bisect, math, regex, sorting, hashing
    • Algorithm patterns: binary search, sliding window, DP, tree traversal, topological sort, union find, Kadane's algorithm, trie, reservoir sampling
  • python-algorithms by stefan-jansen: github.com/stefan-jansen/python-algorithms
    • Technical interview cheat sheet with Python implementations

7. Practice Problem Lists

List Comparison

List Problems Author Best For
Blind 75 75 Facebook engineer (2018) Quick prep (2-4 weeks). Covers all essential patterns in minimum problems.
NeetCode 150 150 NeetCode (ex-Google) Thorough prep (4-8 weeks). Superset of Blind 75 (+75 problems). Video solutions for all.
Grind 75 75 (customizable) Yangshun Tay (Tech Interview Handbook) Flexible prep. Customize by schedule, time, and difficulty. Updated version of Blind 75.
Grind 169 169 Yangshun Tay Extended version of Grind 75 for more thorough prep.
Sean Prashad's LeetCode Patterns 178 Sean Prashad Pattern-focused prep. Problems grouped by algorithmic pattern with heuristics for identification.
LeetCode Top Interview 150 150 LeetCode Official LeetCode curated list.
SQL 45 45 Community SQL interview prep (if needed).

Which List to Use

Time available:
  < 2 weeks  -->  Blind 75 (focus on Easy + Medium)
  2-4 weeks  -->  Grind 75 (customize to your schedule)
  4-8 weeks  -->  NeetCode 150 (with video solutions)
  8+ weeks   -->  Sean Prashad's Patterns + NeetCode 150

Strategy:
  New to DSA          -->  Grind 75 (sorted by difficulty)
  Know basics         -->  NeetCode 150 (organized by topic)
  Pattern recognition -->  Sean Prashad's LeetCode Patterns
  Targeting a company -->  LeetCode Premium company tags

Where to Find Them

List URL
Blind 75 neetcode.io/practice/practice/blind75
NeetCode 150 neetcode.io/roadmap
Grind 75 techinterviewhandbook.org/grind75
Sean Prashad's Patterns seanprashad.com/leetcode-patterns
NeetCode 150 + Blind 75 Flashcards (Anki) github.com/envico801/Neetcode-150-and-Blind-75
LeetCode Lists (all combined) leetcode.com/discuss/general-discussion/3691891

NeetCode 150 Topic Breakdown

Arrays & Hashing        (9 problems)
Two Pointers            (5 problems)
Sliding Window          (6 problems)
Stack                   (7 problems)
Binary Search           (7 problems)
Linked List             (11 problems)
Trees                   (15 problems)
Tries                   (3 problems)
Heap / Priority Queue   (7 problems)
Backtracking            (9 problems)
Graphs                  (13 problems)
Advanced Graphs         (6 problems)
1-D Dynamic Programming (12 problems)
2-D Dynamic Programming (11 problems)
Greedy                  (8 problems)
Intervals               (6 problems)
Math & Geometry         (8 problems)
Bit Manipulation        (7 problems)

Summary: Recommended Study Plan

Phase 1: Foundations (Week 1-2)

  • Read: Grokking Algorithms (2nd Ed.) for visual intuition
  • Watch: NeetCode's beginner videos on YouTube
  • Reference: Big-O Cheat Sheet, Python complexity table above

Phase 2: Core Patterns (Week 3-6)

  • Practice: NeetCode 150 or Grind 75 (2-3 problems/day)
  • Watch: NeetCode video solutions after attempting each problem
  • Reference: Tech Interview Handbook cheatsheets per topic
  • Review: Python collections, heapq, bisect, itertools patterns above

Phase 3: Depth + Speed (Week 7-10)

  • Practice: Timed sessions (25-35 min per Medium, 40-45 min per Hard)
  • Review: Sean Prashad's LeetCode Patterns for pattern recognition
  • Read: EPI or CLRS chapters on weak areas
  • Mock: LeetCode mock interviews or Pramp (free peer mock interviews)

Phase 4: Company-Specific (Week 11-12)

  • Practice: LeetCode Premium company-tagged questions
  • Review: Frequently asked problems for target companies
  • Mock: Full timed mock interviews (2-3 per week)

8. Top 5 Must-Read Books (with Chapter Guide)

  1. Introduction to Algorithms (CLRS), 4th Ed. The reference bible. Priority chapters:

    • Ch 15: Dynamic Programming (rod cutting, matrix chain, LCS, optimal BST)
    • Ch 22: Elementary Graph Algorithms (BFS, DFS, topological sort, SCC)
    • Ch 23: Minimum Spanning Trees (Kruskal, Prim)
    • Ch 24: Single-Source Shortest Paths (Bellman-Ford, Dijkstra, DAG shortest paths)
    • Ch 34: NP-Completeness (overview only -- know what NP-hard means, recognize intractable problems)
    • Skip: formal proofs unless studying for research roles. Use as a reference, not a cover-to-cover read.

  2. The Algorithm Design Manual (Skiena), 3rd Ed. Best for building intuition. Priority chapters:

    • Ch 5: Graph Traversal (BFS, DFS, applications)
    • Ch 8: Dynamic Programming (edit distance, longest increasing subsequence, partitioning)
    • All "War Stories" sections -- real-world algorithm applications
    • Part II (The Hitchhiker's Guide to Algorithms) is a lifelong catalog reference.

  3. Grokking Algorithms (Bhargava), 2nd Ed. Best visual introduction. Priority chapters:

    • Ch 6: Breadth-First Search (graph modeling, shortest path)
    • Ch 7: Dijkstra's Algorithm (weighted graphs, negative edges)
    • Ch 9: Dynamic Programming (longest common substring, knapsack)
    • Perfect for warm-up review the week before an interview.

  4. Elements of Programming Interviews in Python (Aziz, Lee, Prakash) Most interview-focused. Priority sections:

    • Arrays (Ch 5), Strings (Ch 6), Hash Tables (Ch 12), Graphs (Ch 18)
    • Do the "boot camp" problems first (marked at the start of each chapter)
    • Work 3-5 problems per section, then move on. Come back for harder ones.

  5. System Design Interview, Vol 1 & 2 (Alex Xu) Best system design prep. Priority:

    • Vol 1, Ch 1-5: fundamentals (scaling, caching, load balancing, messaging, databases)
    • Vol 1, Ch 11: Design a News Feed (real-time fan-out, similar to ASI's data distribution)
    • Vol 2: specific designs matching ASI's domain -- real-time data processing, geospatial systems, notification/alerting pipelines

9. ASI-Domain Resources

Aviation / ADS-B

Geospatial

  • H3 (Uber's hexagonal indexing): https://h3geo.org/ -- hierarchical geospatial index. Know: resolution levels, h3.latlng_to_cell(), h3.grid_ring(), h3.grid_disk().
  • PostGIS documentation: https://postgis.net/documentation/ -- spatial SQL. Know: ST_Distance, ST_Within, ST_Intersects, spatial indexes (GiST).
  • Mapbox GL JS docs: https://docs.mapbox.com/mapbox-gl-js/ -- ASI uses Mapbox for map rendering. Understand layers, sources, expressions.
  • GeoJSON specification: https://geojson.org/ -- data format for geospatial features (points, polygons, lines).

Optimization

ML / Weather

10. Concept Module Documentation Links

Key documentation for the concept modules in src/concepts/:

Topic URL Notes
Flask 3.x https://flask.palletsprojects.com/en/stable/ Async views, class-based views, nested blueprints
Pydantic v2 https://docs.pydantic.dev/latest/ Model validators, discriminated unions, serialization
Zod (TypeScript) https://zod.dev/ Runtime type validation (ASI uses TypeScript frontend)
numpy.fft https://numpy.org/doc/stable/reference/routines.fft.html FFT, IFFT, rfft, fftfreq
scipy.fft https://docs.scipy.org/doc/scipy/reference/fft.html DCT, DST, more FFT variants
Python typing https://docs.python.org/3/library/typing.html TypeVar, Protocol, ParamSpec, TypeGuard
Hypothesis https://hypothesis.readthedocs.io/en/latest/ Property-based testing strategies, composite
PEP 750 (t-strings) https://peps.python.org/pep-0750/ Template strings (Python 3.14+)

11. YouTube Playlists by Study Week

Recommended video content to supplement each week of the study plan:

Week 1: Arrays, Hashing, Two Pointers, Sliding Window

  • NeetCode "Arrays & Hashing" playlist -- all problems with visual walkthroughs
  • Abdul Bari "Sorting Algorithms" -- merge sort, quick sort, counting sort deep dives
  • NeetCode "Two Pointers" + "Sliding Window" playlists -- pattern recognition for pointer-based problems

Week 2: Trees, Graphs, Linked Lists

  • William Fiset "Graph Theory" full course (~9 hours) -- BFS, DFS, Dijkstra, topological sort, SCC, MST. Most comprehensive free graph course.
  • NeetCode "Trees" playlist -- binary tree traversals, BST operations, serialization
  • NeetCode "Graphs" playlist -- islands, course schedule, graph validity
  • Back to Back SWE "Trees" series -- whiteboard-style explanations

Week 3: DP, Backtracking, Greedy, Heaps

  • Back to Back SWE "Dynamic Programming" series -- clear state transition explanations with visual diagrams
  • NeetCode "1-D DP" + "2-D DP" playlists -- climbing stairs through edit distance
  • Tushar Roy "Dynamic Programming" -- classic DP problems with matrix visualizations
  • NeetCode "Backtracking" playlist -- subsets, permutations, N-Queens

Week 4: System Design, Domain, Mock

  • ByteByteGo "System Design" series -- visual system design walkthroughs (Alex Xu's channel)
  • Gaurav Sen system design playlist -- rate limiters, consistent hashing, message queues
  • NeetCode "System Design for Beginners" course (free intro on YouTube)