Patterns

Companies don't pick AI coding problems at random. The reason you see the same kinds of problems over and over is deliberate: they're challenging enough to allow for multiple paths and non-obvious solutions, but not so complicated that they can't fit in a 45-minute interview. You're less likely to encounter problems focused on simple leetcode easy/medium, in part because AI squashes them immediately and there's nothing interesting to cover.

That constraint shapes everything. The problems that survive the AI filter tend to cluster around a handful of algorithmic patterns, things like dependency resolution, constraint satisfaction, and graph traversal. These problems require you to think about which approach to use before you prompt. AI can implement topological sort just fine, but it can't look at a vague feature request and decide that topological sort is what's needed. That's your job.

In a traditional interview, knowing patterns saved you time. In an AI-enabled interview, knowing patterns changes the quality of your output entirely.

Here's the thing most candidates get wrong: they treat the AI like a search engine. They paste in the problem and hope for the best. But LLMs are extremely sensitive to how you frame the request. "Build a task scheduler" gets you generic code. "Implement a task scheduler using topological sort with Kahn's algorithm, tracking in-degrees in a hash map" gets you something you can actually ship.

The difference between candidates who ace these interviews and those who struggle isn't raw coding ability. It's how quickly they can map a problem to a known approach and communicate that approach to the AI with enough specificity that the output is useful on the first try.

Here's a quick tour:

Graph Search & Pathfinding shows up whenever the problem involves navigating networks, finding shortest paths, or exploring connected structures. BFS, DFS, Dijkstra's, and A* are the workhorses.

Topological Sort appears in any problem with dependencies: build systems, course prerequisites, task scheduling. If things need to happen in a specific order, you're probably looking at a DAG.

Backtracking is the go-to for constraint satisfaction problems. Configuration generators, puzzle solvers, scheduling with complex rules. You try options, check constraints, and undo when you hit a dead end.

Greedy & Bin Packing covers problems where local optimization leads to good-enough global solutions. Resource allocation, interval scheduling, packing items into containers.

Dynamic Programming handles problems with overlapping subproblems. Edit distance, resource allocation with constraints, path counting. The classic "have I solved a smaller version of this before?" pattern.

Data Structure Design tests whether you can compose primitives (maps, heaps, queues) into custom structures that satisfy specific performance constraints. LRU caches, time-based key-value stores, that sort of thing.

String Matching & Parsing covers pattern matching, text processing, and building simple parsers. Regex-style matching, expression evaluation, template engines.

Each pattern page goes deep on the specific approach: what problems it solves, how to recognize it, what to tell the AI, and how to verify the output. You don't need to read them all before your interview. Pick the two or three you're least comfortable with and focus there.

If you're short on time, at minimum understand graph search, topological sort, and backtracking. Those three cover the majority of problems you'll see.