Role-ordered prep · free
DSA prep by job role
A frontend loop and a backend loop test the same 370 problems in a different order. Pick the role you are interviewing for and the list re-sequences around it. All 30 roles below work inside the app today.
Start with your domain
Not sure of the exact title? Pick the field you are in; each groups the roles under it.
- AI & Machine LearningThe roles building models, vision and language systems — where the algorithmic core is math-, matrix- and DP-heavy.
- Data & DatabasesMoving, storing and querying data at scale — sorting, hashing, heaps and intervals do the heavy lifting.
- Web & BackendProduct engineering: the everyday interview core of arrays, strings, two pointers and sliding window.
- MobileAndroid and iOS engineering — arrays, strings and trees, with memory and lifecycle always in view.
- Systems & InfrastructureReliability, routing and low-level tooling — graphs, heaps, tries and greedy scheduling underneath it all.
- Security, Crypto & Web3Securing systems, crypto primitives and on-chain structures — bit manipulation, math, hashing and Merkle trees.
- Scientific & Quant ComputingFinance and the sciences — where DP, number-theory math, strings and sequence work carry the algorithmic load.
- Graphics & GamesRendering and game logic — matrices, geometry-flavored math and recursion carry the compute.
- Search & RetrievalRanking and lookup at scale — heaps, tries, sorting and binary search are how it's actually built.
Company-wise lists
Targeting a specific company? These lists hold only problems whose own source page names it.
College leaderboards
See who is solving the most at your campus. Only public profiles are listed; set your college on your profile to appear.
Every supported role
- SDE / Software EngineerThe broadest DSA bar: trees, graphs, and DP show up most; this is the classic generalist interview loop.Read the guide →
- Backend EngineerBackend rounds keep coming back to the same few problems: an LRU cache, a rate limiter, meeting rooms, top-K and job queues. That means hash maps with linked lists, heaps, sliding windows and intervals; hard DP and backtracking are rare.Read the guide →
- Frontend EngineerFrontend loops lean arrays, strings & two-pointers; hard DP is rare.Read the guide →
- Full-Stack DeveloperBlends frontend array/string basics with backend system-design questions; per-topic depth is shallower than a pure backend loop.Read the guide →
- Data EngineerHeavy on arrays, sorting, and math for ETL-style problems; graphs and DP show up far less than in general SDE loops.Read the guide →
- ML EngineerMath and DP-flavored optimization outweigh graph-heavy topics; interviews often mix DSA with applied stats.Read the guide →
- SDET / QA EngineerSDET rounds test core DSA + edge-case thinking; graphs are lighter.Read the guide →
- Android DeveloperArrays, strings, and recursion dominate; deep graph/DP grinding usually isn't the bar for mobile roles. The problem order is the same as iOS: the DSA bar doesn't change with the platform, only the language and SDK do.
- iOS DeveloperArrays, strings, and recursion dominate; deep graph/DP grinding usually isn't the bar for mobile roles. The problem order is the same as Android: the DSA bar doesn't change with the platform, only the language and SDK do.
- Data AnalystSQL and array/math manipulation matter far more than trees or graphs; the lightest pure-DSA bar of the nine.
- Game DeveloperVector/collision math and transform matrices dominate, with graph search and heaps for pathfinding AI; string and trie problems almost never appear.
- Graphics EngineerLinear algebra, bit-level format packing, and BVH/kd-tree traversal carry the loop; unlike gameplay roles, graph and DP questions are rare.
- Embedded / Firmware EngineerRegister bit-twiddling, fixed buffers, ring queues, and intrusive linked lists are the bar; recursion is penalized on constrained stacks, not rewarded.
- Security EngineerInput parsing, signature tries, CIDR/port interval merging, and stack-layout reasoning define these loops; heavy DP and tree problems rarely surface.
- Cryptography EngineerModular arithmetic, GF(2) bit operations, and fast exponentiation are the whole interview; graphs and tree structures are close to irrelevant here.
- Performance EngineerCache-friendly array layout, sorting, top-k heaps, and rolling-window latency math matter more than any tree or backtracking topic.
- Site Reliability EngineerDependency graphs, alert heaps, outage intervals, and rate-limit windows mirror real incident work; backtracking and DP effectively never come up.
- Cloud EngineerCIDR bitmask arithmetic, resource dependency DAGs, longest-prefix routing tries, and bin-packing greedy questions; latency-window problems are the SRE side, not this one.
- Search EngineerPrefix tries, posting-list intersection, skip-pointer binary search, and top-k heaps: the index-serving side of search, where linked lists and trees barely appear.
- Information Retrieval EngineerRanking math, term-document matrices, and edit-distance DP lead here: the relevance side rather than the index plumbing a Search Engineer is grilled on.
- Database EngineerB-tree/index search, external sorting, index tries, and DP join-order planning are the actual job; bit tricks and matrix problems rarely appear.
- Storage EngineerBitmap allocators, extent intervals, LSM merge heaps, and free-list pointer work: the layout and durability layer beneath the query planner a DB engineer owns.
- Computer Vision EngineerImages are matrices, so linear algebra, kernel windows, flood-fill graph traversal, and stereo/seam DP dominate; string and trie topics are near-zero.
- NLP EngineerTokenizer tries, Viterbi/edit-distance DP, beam-search heaps, and parse-tree recursion: string-heavy in exactly the way computer vision is not.
- Robotics EngineerMotion planning is graph search plus kinematics math and rotation matrices, with priority queues driving A*/Dijkstra; string and trie work is absent.
- Compiler / PL EngineerParsing builds and walks trees (ASTs), optimization is graph and dataflow analysis, and evaluation leans on stacks and recursion; register allocation is literally graph colouring.
- Quant DeveloperPricing and optimisation are DP, time-series work is array and sliding-window math, and combinatorics leans on number theory; strings and graphs rarely surface.
- Blockchain / Web3 EngineerMerkle trees, hash-linked structures, and GF(2)/modular bit math define the loop, with consensus modelled as graphs; DP and classic string problems are near-absent.
- Bioinformatics EngineerSequence alignment is edit-distance DP over strings, k-mer indexing is tries and hashing, and assembly is graph traversal: string- and DP-heavy in a way few other roles are.
- Networking EngineerRouting is graph shortest-path, IP lookup is longest-prefix tries, and packet scheduling is heaps, queues, and greedy interval work; trees and DP barely appear.
Guides written so far
Every other role above is selectable in the app; a written guide follows where it earns one.