How to identify which algorithm to use

Two engineers sit down with the same unfamiliar problem. One stares at the description, mentally cycling through every technique, trying each until something sticks. The other reads three lines, notices the input is a directed graph with dependencies, and knows topological sort applies within 30 seconds. Both have solved roughly the same number of problems. Both have been preparing for months. One has trained how to identify which algorithm to use. The other is still guessing.

The gap isn't talent or problem count. It's a skill that almost nobody trains directly.

The phase every platform skips

Every DSA learning resource teaches two things. How an algorithm works (the mechanism) and how to apply it (the problems). What almost none of them teach is the step in between, where you look at an unfamiliar problem and determine which algorithm actually applies.

Algorithm identification means reading a problem and systematically determining which pattern fits before you write any code. You analyze four diagnostic signals: the input, the output, the required transformation, and the algorithmic invariant that enables it.

This is what separates engineers who solve novel problems from engineers who can only solve ones they've seen before. Most platforms assume identification develops passively through volume. For some engineers, it does develop that way. Someone who solves 500+ problems across diverse categories will start recognizing patterns by feel. But that's an expensive way to build the skill, like learning to read by staring at enough words until the alphabet clicks. It works for a fraction of learners and takes way too long for most.

The identification gap shows up during interviews in a specific, painful way. You've studied topological sort in depth. You understand how it works. You can implement it when someone tells you to use it. But the problem description doesn't say "use topological sort." It says "determine if all courses can be completed given their prerequisites." The bridge between those two sentences is identification, and most engineers haven't practiced crossing it deliberately.

Four questions to identify which algorithm to use

The process is four questions, asked in order. Each one narrows the search space until the right pattern becomes clear.

Question 1: Ask what kind of input are you given? Is it a sorted array, an unsorted array with a contiguous-element constraint, a tree, a directed graph, or a string? The input type eliminates entire algorithm families immediately. Directed acyclic graphs point toward topological sort or DP on DAGs. Sorted arrays with a target point toward binary search. Strings with a "contiguous range" constraint point toward sliding window.

Question 2: Ask what does the expected output look like? Is the output a single value like a count or minimum, a boolean, a sequence, a subset, or a transformation of the input? Output type tells you what kind of computation you need. "Find the minimum number of X" usually signals DP or BFS. "Determine if X is possible" often signals DFS, backtracking, or DP. "Return all valid X" signals backtracking.

Question 3: ask what transformation connects input to output? What operation turns the input into the desired output? Are you searching, sorting, partitioning, traversing, optimizing, or enumerating? This narrows the search from algorithm families to specific patterns.

Question 4: Ask what algorithmic invariant enables that transformation? The invariant is the why behind the pattern. For two pointers on a sorted array, the invariant is that moving one pointer eliminates a provably suboptimal portion of the search space. For BFS on an unweighted graph, the invariant is that the first time BFS reaches a node, it's found the shortest path. The invariant isn't academic theory. It's how you confirm you've identified correctly.

Identifying which algorithm to use: Five problems

Five problems across five different algorithm families, with all four questions applied each time.

Take Course Schedule, which asks whether you can finish all courses given their prerequisites. Your input is a directed graph where courses are nodes and prerequisites are edges. You need a boolean output, whether everything can be completed. The transformation requires determining whether a valid ordering of all nodes exists. And the invariant confirms the identification: a valid ordering exists if and only if the graph contains no cycle. Topological sort on a DAG produces exactly such an ordering.

Once you've identified the pattern, the implementation follows directly from the invariant:

You don't need to have seen Course Schedule before. You need to recognize "directed dependencies + valid ordering = topological sort."

Now consider Longest Substring Without Repeating Characters. Your input is a string with characters as elements, and you need a single integer representing maximum length. Finding the longest contiguous range satisfying a uniqueness constraint is the transformation. The invariant confirms it: the variable sliding window maintains a window where all characters are unique, expanding when the constraint holds and contracting when it breaks.

The trigger words are "contiguous range" and "optimize length." Those two together point to sliding window before you've finished reading the problem description. Three more problems diagnosed the same way:

One diagnostic process produced five different outputs depending on the problem. The questions stayed constant while the answers changed every time.

Why most engineers misidentify problems

Misidentification happens for specific, predictable reasons.

These traps get worse under time pressure. It's tempting to skip the diagnostic step and jump straight to the first pattern that feels right during an interview. That instinct is completely understandable, but it's also the most common source of wrong starts under a clock.

Learning to identify which algorithm to use

Identification doesn't have to develop passively over years of problem-solving. You can train it directly, the same way you train the algorithms themselves.

The key insight from learning science is interleaving: mixing practice across different pattern types so you're forced to practice identification on every problem. Blocked practice (solving 20 sliding window problems in a row) trains application. Interleaved practice (mixing sliding window, two pointers, DP, and graph problems) trains identification. Studies on interleaved math and motor skill practice show the same result: worse performance during training, but significantly better transfer to novel problems.

This is the gap most platforms don't address. LeetCode's default practice mode lets you filter by topic, which is blocked practice. You already know it's a sliding window problem before you read the description. The identification muscle never fires.

Codeintuition is the only platform that teaches identification as a separate phase. Every pattern module includes a dedicated identification lesson before any problems begin. You don't learn what the variable sliding window is and then jump to problems. You first learn the recognition triggers that indicate when a variable sliding window applies, such as "contiguous range" + "dynamic constraint" + "optimize length or count." Then you practice applying the pattern to problems where you've already been trained to recognize it.

The learning path sequences 75+ patterns this way across 16 courses. Premium covers the full path at $79.99/year, but even the free Arrays course gives you identification training across 8 patterns covering two pointers, simultaneous traversal, fixed sliding window, variable sliding window, interval merging, and maximum overlap. After completing it, you'll recognize triggers on unfamiliar problems before reaching for the hints.

Six months ago, you would've stared at Course Schedule and tried BFS, then DFS, then maybe DP, burning 25 minutes before arriving at topological sort by elimination. Now you read "directed dependencies" and "valid ordering" and the pattern is clear before you've finished the description. You didn't get smarter. You trained the one skill that every other platform assumed you'd figure out on your own.