LeetCode Interview Questions: Top Patterns by Company (2026)

How LeetCode Questions Map to Real Interviews

LeetCode is the closest proxy to what you'll actually see in FAANG coding interviews — but the relationship is imperfect. At Amazon and Microsoft, exact LeetCode problem appearances are common (sometimes candidates see the exact problem, more often a close variant). At Google, interviewers are trained to ask original or significantly modified problems — but the underlying patterns (graph traversal, DP, two pointers) remain the same. Meta falls between: problems are LeetCode-style with slight modifications. The implication: don't grind for memorization. Learn the patterns, practice explaining your reasoning, and use company filters to calibrate difficulty. The full breakdown of how many problems to target per company is in our dedicated guide.

Topic Breakdown Across FAANG Interviews

Based on aggregate interview reports and company-tagged problem frequency on LeetCode, here's the approximate distribution of topics across FAANG coding rounds:

• Arrays and strings (~30%): The single most common category. Subarray problems, two pointers, sliding window, prefix sums, and interval merging.
• Trees and graphs (~25%): Binary trees (DFS/BFS, path sums, LCA), BSTs, and graph problems (BFS/DFS, connected components, topological sort).
• Dynamic programming (~15%): 1D DP (climbing stairs, coin change), 2D DP (grid paths, edit distance), and DP on strings (palindromes, LCS).
• Linked lists and stacks (~10%): Reverse, merge, cycle detection. Monotonic stack for next greater element, largest rectangle.
• Binary search (~8%): Classic sorted arrays plus binary search on answer (kth smallest, capacity to ship).
• Heap / priority queue (~7%): Top-K elements, merge K sorted lists, median from data stream.
• Other (~5%): Tries (prefix matching, word search), union-find (connected components), bit manipulation.

The exact distribution shifts by company and role level — see the company-specific sections below. For a systematic study approach covering all these topics, see our DSA interview questions guide.

Google LeetCode Patterns

Google interviews have the highest algorithmic bar of any major tech company. Key characteristics:

• Graphs are over-represented (~35% vs 25% average): BFS/DFS, shortest paths (Dijkstra), topological sort, strongly connected components. Common problems: word ladder, alien dictionary, course schedule, number of islands variants.
• Dynamic programming is expected: Not just 1D DP — Google asks 2D grid DP, string DP (edit distance, regular expression matching), and occasionally DP on trees or graphs.
• Clean code and edge cases are heavily weighted: Google interviewers expect you to handle null inputs, empty arrays, and integer overflow without being asked. State assumptions explicitly.
• Hard problems are more common than at other companies: If you're targeting Google, practice hard LeetCode problems weekly — not just mediums.

See the full Google interview process guide for round structure, timeline, and what each round evaluates.

Amazon LeetCode Patterns

Amazon's technical bar is slightly lower than Google's, but the overall interview is harder because behavioral performance matters equally:

• Trees are the most common topic (~30%): Binary tree traversals, BST operations, path sums, and level-order problems appear very frequently.
• Arrays and strings are universal: Two-sum variants, sliding window, interval merging, and string manipulation.
• BFS for shortest path: Amazon often asks graph problems framed as shortest path or connectivity (word ladder, rotting oranges, 01 matrix).
• Medium difficulty dominates: Hard problems rarely appear. If you can solve mediums cleanly and explain your approach, you'll pass the coding round. The Leadership Principles round often decides the outcome.

The full Amazon interview process guide covers all rounds including the LP bar raiser format.

Meta LeetCode Patterns

Meta's coding interviews are fast-paced with two coding rounds in quick succession. The pattern profile:

• Arrays and strings dominate (~40%): Meta is known for asking array manipulation, string parsing, and in-place transformation problems. Two pointers and sliding window appear very frequently.
• Tree DFS is the most common tree pattern: Inorder, preorder, path sums, and serialization/deserialization of binary trees.
• Graph problems with a twist: Clone graph, number of islands, and friend circles — often asked to be solved with both DFS and BFS for comparison.
• Recursion-heavy problems: Meta likes problems where the elegant solution is recursive. Practice explaining your recursion base cases and call stack.
• Speed matters: Meta's two-round coding format means you'll solve 2 problems per round. Practice solving mediums in under 20 minutes.

See Meta's full interview process guide for format details.

Microsoft LeetCode Patterns

Microsoft interviews are more balanced than the other three companies, with a slightly higher emphasis on OOP design thinking alongside DSA:

• String manipulation is prominent: String parsing, reversal, pattern matching, and encoding/decoding problems appear in most loops.
• Trees and arrays have equal weight: Unlike Google (graphs-heavy) or Meta (arrays-heavy), Microsoft distributes fairly evenly.
• Medium difficulty is the norm: Microsoft rarely asks hard LeetCode problems. Consistent medium performance with clear explanations is the target.
• Design questions appear at senior levels: Mid/senior roles include a system design round. Junior roles are purely DSA + behavioral.

See Microsoft's full interview process guide for level-specific details.

The "Top 100" Myth

LeetCode's "Top 100 Liked Questions" list is community-voted based on upvotes — it doesn't reflect what companies actually ask. The upvotes correlate with problem quality and learning value, not interview frequency. More reliable sources for company-specific questions:

• LeetCode Premium company filter: Sort by frequency, filter to last 6 months. The recent interview activity is the most signal-rich data.
• Glassdoor interview reports: Search "[company] software engineer interview". Recent reports (last 3–6 months) mention specific problems or describe the format.
• Blind and Leetcode discuss forums: "[company] interview experience" threads often include the exact problem asked or a close description.

The most reliable signal: patterns repeat even when specific problems change. A Google interviewer who asked word ladder last year might ask alien dictionary this year — both are graph BFS problems. Focus on pattern mastery, not problem memorization. Read our guide on how to solve LeetCode problems for the pattern identification framework.

How to Use Company Filters on LeetCode

With LeetCode Premium, here's the most effective workflow for company-specific prep:

• Filter by your target company, sort by frequency (highest first)
• Set recency filter to "last 6 months" to surface recently asked problems
• Do the top 20–30 problems from your company's list after completing a general curated list (Blind 75 / NeetCode 150)
• Don't skip the general list in favor of company-specific problems early — without pattern foundations, company-tagged practice is less effective

Building Your Personal Question Bank

The most prepared candidates maintain a personal question bank — a spreadsheet or Notion doc tracking problems solved, patterns used, time taken, and whether they'd get it right on a second attempt. After each problem, log: the pattern (e.g. BFS), difficulty, time taken, and a 1–5 confidence rating. Problems rated 1–2 go back into rotation in 48 hours. This transforms unstructured grinding into deliberate practice. Combine this with a study plan — see our comparison of NeetCode 150 vs Striver vs Blind 75 — and you'll have a complete, trackable prep system.