CoursesFeatured DecksInterview Experiences

Blind 75 Interview Flashcards + AI Practice for Behavioral & Coding Questions

Blind 75 Coding Questions Deck | Interview Flashcards - Flashcards

Master the Blind 75 Interview Questions for Coding Success

If you're preparing for technical interviews at top tech companies, mastering the Blind 75 questions is a must. These hand-picked Blind 75 coding questions have become the go-to resource for candidates looking to build a strong foundation in data structures, algorithms, and problem-solving skills. Whether you’re aiming for a role at FAANG or a fast-growing startup, these essential problems are designed to help you sharpen your approach and ace the coding round.

Why the Blind 75 Coding Questions Matter

The Blind 75 interview questions list is curated to include the most frequently asked and impactful problems in coding interviews. This isn't just a random collection—it’s a strategic set of problems covering core topics such as:

  • • Arrays and Strings
  • • Linked Lists and Trees
  • • Dynamic Programming
  • • Graphs and Backtracking
  • • Stack, Queue, and Heap
  • • Sliding Window and Two Pointers

These problems have stood the test of time and interviewers consistently return to them because they effectively evaluate a candidate’s ability to write clean, optimized code and explain their logic under pressure.

Practice the Blind 75 to Ace Your Tech Interview

On this page, you'll find categorized Blind 75 coding questions with clear explanations, solutions, and real-world tips to help you understand not just how to solve them—but why each approach works. Practicing these problems will improve your speed, accuracy, and confidence, all of which are crucial during live coding rounds.

Whether you're just starting your interview prep or revisiting the Blind 75 interview questions for a final review, our platform ensures you’re fully equipped to tackle whatever your interviewer throws at you. Dive in, code along, and level up your skills today.

Showing 75 of 75 flashcards

Difficulty: EASY

Type: Other

3Sum: Find unique triplets summing to zero.

Sort and two-pointer for each fixed index.

Difficulty: MEDIUM

Type: Other

Add Two Numbers: Sum two numbers represented by linked lists.

Simulate digit-wise addition with carry.

Difficulty: EASY

Type: Other

Best Time to Buy and Sell Stock: Maximize profit from one transaction.

Track minimum price and compute max profit in one pass.

Difficulty: EASY

Type: Other

Binary Tree Inorder Traversal: Return inorder sequence.

Recursive or iterative using stack.

Difficulty: EASY

Type: Other

Binary Tree Level Order Traversal: Return level order.

BFS with queue.

Difficulty: HARD

Type: Other

Binary Tree Maximum Path Sum: Max path sum anywhere.

DFS returning max gain.

Difficulty: EASY

Type: DP

Climbing Stairs: Count ways to climb n stairs.

DP Fibonacci relation.

Difficulty: MEDIUM

Type: Other

Clone Graph: Deep clone undirected graph.

DFS/BFS with map for visited.

Difficulty: MEDIUM

Type: DP

Coin Change II: Number of ways to make amount.

DP combinations nested loops.

Difficulty: MEDIUM

Type: DP

Coin Change: Fewest coins to make amount.

DP bottom-up over amounts.

Difficulty: MEDIUM

Type: Other

Combination Sum: All combos summing to target.

Backtracking sorting candidates.

Difficulty: HARD

Type: Other

Construct Binary Tree from Preorder and Inorder Traversal.

Recursive split on inorder index.

Difficulty: MEDIUM

Type: Other

Container With Most Water: Maximize water between two lines.

Two-pointer from ends moving smaller height.

Difficulty: EASY

Type: Other

Contains Duplicate: Check if any value appears twice in an array.

Insert into a hash set and detect repeat.

Difficulty: EASY

Type: Other

Convert Sorted Array to BST: Build height-balanced BST.

Recursively pick mid as root.

Difficulty: HARD

Type: Other

Copy List with Random Pointer: Deep copy list with random pointers.

Interleave nodes or use map.

Difficulty: MEDIUM

Type: Other

Counting Bits: Count bits for 0..n.

DP using n&(n–1) or bit DP.

Difficulty: MEDIUM

Type: Other

Course Schedule II: Return topological order of courses.

Kahn’s BFS or DFS postorder.

Difficulty: MEDIUM

Type: Other

Course Schedule: Determine if prerequisites graph has cycle.

DFS with recursion stack or Kahn’s algorithm.

Difficulty: EASY

Type: Other

Decode Ways: Number of decode ways

DP.

Difficulty: HARD

Type: Other

Design HashMap without collisions.

Array of buckets + linked list or tree per bucket.

Difficulty: EASY

Type: Other

Evaluate Reverse Polish Notation: Compute value of RPN expression.

Use stack: push numbers

Difficulty: MEDIUM

Type: Other

Find Minimum in Rotated Sorted Array: Find min in rotated sorted array without duplicates.

Binary search comparing mid to rightmost.

Difficulty: MEDIUM

Type: Other

Graph Valid Tree: Check if undirected graph is a valid tree.

Edges = n–1 and no cycles via union-find.

Difficulty: MEDIUM

Type: Other

Group Anagrams: Group strings that are anagrams together.

Use sorted string or char count as key in map.

Difficulty: MEDIUM

Type: DP

House Robber II: Circular street version.

DP twice excluding first/last.

Difficulty: MEDIUM

Type: DP

House Robber: Max sum non-adjacent in array.

DP keep include/exclude.

Difficulty: EASY

Type: Other

Implement Queue using Stacks.

Two stacks push/pop trick.

Difficulty: MEDIUM

Type: Other

Implement Stack using Queues.

Two queues simulate LIFO.

Difficulty: EASY

Type: Other

Implement Trie (Prefix Tree).

Insert/search/prefix operations

Difficulty: MEDIUM

Type: Other

Insert Interval: Insert and merge new interval into sorted list.

Find overlap range and splice.

Difficulty: MEDIUM

Type: DP

Jump Game: Can reach end?

Greedy max reach.

Difficulty: HARD

Type: Other

LRU Cache: Design cache with get/put and eviction.

Hashmap + doubly-linked list.

Difficulty: EASY

Type: Other

Linked List Cycle II: Return node where cycle begins.

After detect

Difficulty: EASY

Type: Other

Linked List Cycle: Detect cycle in linked list.

Use Floyd’s tortoise and hare.

Difficulty: HARD

Type: DP

Longest Common Subsequence: LCS length between strings.

2D DP table.

Difficulty: HARD

Type: DP

Longest Increasing Subsequence: Length of LIS.

DP + binary search tails.

Difficulty: EASY

Type: Other

Lowest Common Ancestor of BST: Find LCA using BST property.

Walk from root comparing values.

Difficulty: MEDIUM

Type: Other

Lowest Common Ancestor of Binary Tree: Find LCA in binary tree.

DFS if nodes in different subtrees.

Difficulty: HARD

Type: DP

Maximum Product Subarray: Find contiguous subarray with maximum product.

Track max/min product at each index due to negatives.

Difficulty: EASY

Type: DP

Maximum Subarray: Find contiguous subarray with largest sum.

Use Kadane’s algorithm tracking current and global max.

Difficulty: MEDIUM

Type: Other

Meeting Rooms II: Find min number of conference rooms.

Sort intervals and track end times in min-heap.

Difficulty: MEDIUM

Type: Other

Merge Intervals: Merge overlapping intervals.

Sort by start and merge end-max.

Difficulty: EASY

Type: Other

Merge Two Sorted Lists: Merge two sorted linked lists.

Iterate pointers building new list.

Difficulty: HARD

Type: Other

Merge k Sorted Lists: Merge k sorted linked lists.

Use min-heap of heads.

Difficulty: MEDIUM

Type: Other

Min Stack: Design a stack supporting getMin in O(1).

Use auxiliary stack to track current mins.

Difficulty: MEDIUM

Type: DP

Minimum Path Sum: Min sum in grid.

DP accumulate row/col.

Difficulty: EASY

Type: Other

Missing Number: Find missing from 0..n.

Sum formula or XOR.

Difficulty: HARD

Type: Other

N-Queens: Place N queens on board.

Backtracking with row/col/diag checks.

Difficulty: EASY

Type: Other

Number of 1 Bits: Count set bits.

Brian Kernighan’s trick.

Difficulty: MEDIUM

Type: Other

Number of Connected Components in Undirected Graph: Count components.

Union-Find or DFS.

Difficulty: MEDIUM

Type: Other

Number of Islands: Count islands in grid of 1s/0s.

DFS/BFS flood-fill marking visited.

Difficulty: MEDIUM

Type: Other

Number of Provinces: Count friend circles.

DFS or union-find on adjacency matrix.

Difficulty: EASY

Type: Other

Path Sum: Check root-to-leaf sum equals target.

DFS tracking current sum.

Difficulty: MEDIUM

Type: Other

Permutations: Return all permutations of array.

Backtracking swapping.

Difficulty: MEDIUM

Type: Other

Product of Array Except Self: Return product of all elements except self without division.

Compute prefix and suffix products in two passes.

Difficulty: MEDIUM

Type: Other

Remove Nth Node From End of List: Delete nth from end.

Two-pointer with gap n.

Difficulty: MEDIUM

Type: Other

Reverse Bits: Reverse bits of integer.

Bitwise loop shifting.

Difficulty: EASY

Type: Other

Reverse Linked List: Reverse a singly linked list.

Iterative pointers prev/curr or recursion.

Difficulty: MEDIUM

Type: Other

Search in Rotated Sorted Array: Search target in rotated sorted array.

Binary search with pivot logic.

Difficulty: HARD

Type: Other

Serialize and Deserialize Binary Tree: Convert tree↔string.

Preorder with null markers.

Difficulty: HARD

Type: Other

Serialize and Deserialize N-ary Tree.

DFS pre/post with child counts.

Difficulty: EASY

Type: Other

Single Number: Find num occurring once.

XOR all

Difficulty: MEDIUM

Type: Other

Subsets: Return all subsets of array.

Backtracking or bitmask.

Difficulty: MEDIUM

Type: Other

Sum Root to Leaf Numbers: Sum all root-to-leaf numbers.

DFS accumulating number.

Difficulty: EASY

Type: Other

Symmetric Tree: Check if tree is mirror of itself.

Recursive or iterative two-pointer.

Difficulty: EASY

Type: Other

Top K Frequent Elements: Return k most frequent elements.

Count frequencies and use min-heap.

Difficulty: EASY

Type: Other

Two Sum: Given an array and target

find indices of two numbers that add up to target.

Difficulty: EASY

Type: DP

Unique Paths: Number of grid paths.

DP combinatorial or DP table.

Difficulty: EASY

Type: Other

Valid Parentheses: Check if string of brackets is valid.

Use stack to match opens to closes.

Difficulty: MEDIUM

Type: Other

Valid Sudoku: Check if 9×9 board is valid.

Use row/col/box sets.

Difficulty: MEDIUM

Type: Other

Validate Binary Search Tree: Check BST property.

DFS with min/max bounds.

Difficulty: MEDIUM

Type: DP

Word Break: Check segmentation by words.

DP boolean over prefixes.

Difficulty: HARD

Type: Other

Word Ladder: Find shortest path between words.

BFS on word graph with single-letter transforms.

Difficulty: MEDIUM

Type: Other

Word Search: Check if word exists in grid via adj moves.

DFS backtracking marking visited.

We use cookies to improve your experience. By clicking “Accept” you consent to the use of cookies. Read our Privacy Policy.