If you are looking to switch jobs and preparing for coding interviews, you will definitely know LeetCode. It is probably the biggest online repository for coding interview questions and also contains a vibrant community to discuss algorithms with other fellow engineers. Whenever I’m free, I love spending time on LeetCode, trying to solve a new coding question, or learning from other smart solutions that people have developed.

One of the biggest challenges with LeetCode is that it lacks organization; it has a huge set of coding problems, and one feels lost on where to start or what to focus on. What is an ample amount of questions one should go through before considering themselves prepared for their coding interview? I would love to see a streamlined process that can guide me and teach me enough algorithmic techniques to feel confident for the interview. Being a lazy person myself, I wouldn’t say I like to go through 500+ questions.

One technique that people often follow is to solve questions related to the same data structure; for example, focusing on questions related to Arrays, then LinkedList, HashMap, Heap, Tree, or Trie, etc. Although this does provide some organization, it still lacks coherence. For example, many questions can be solved using HashMaps but still require different algorithmic techniques. I would love to see question sets that follow not only the same data structure but also similar algorithmic techniques. The best thing I came across was the problem-solving patterns like

**Sliding Window**,

**Fast and Slow Pointers**, or

**Topological Sort**, etc. Following these patterns helped me nurture my ability to map a new problem to an already known problem. This not only made this whole coding-interview-preparation process fun but also a lot more organized.

I have gathered around 25 of these coding problem patterns, which I believe can help anyone learn these beautiful algorithmic techniques and make a real difference in the coding interviews. The idea behind these patterns is, once you’re familiar with a pattern, you’ll be able to solve dozens of problems with it. For a detailed discussion of these patterns and related problems with solutions, take a look at

**Grokking the Coding Interview**.

So, without further ado, let me list all these patterns:

**Sliding Window****Two Pointers****Fast & Slow Pointers****Merge Intervals****Cyclic Sort****In-place Reversal of a LinkedList****Tree Breadth-First Search****Tree Depth First Search****Two Heaps****Subsets****Modified Binary Search****Bitwise XOR****Top ‘K’ Elements****K-way Merge****0/1 Knapsack****Unbounded Knapsack****Fibonacci Numbers****Palindromic Subsequence****Longest Common Substring****Topological Sort****Trie Traversal****Number of Island****Trial & Error****Union Find****Unique Paths**

Following is a small intro of each of these patterns with sample problems:

**Usage**: This algorithmic technique is used when we need to handle the input data in specific window size.

**Usage:** In this technique, we use two pointers to iterate the input data. Generally, both pointers move in the opposite direction at a constant interval.

**Usage:** Also known as Hare & Tortoise algorithm. In this technique, we use two pointers that traverse the input data at a different speed.

**Usage:** This technique is used to deal with overlapping intervals. Given two intervals (‘a’ and ‘b’), there will be six different ways the two intervals can relate to each other:

**Usage:** Use this technique to solve array problems where the input data lies within a fixed range.

**Sample Problems:**

**Usage:** This technique describes an efficient way to reverse the links between a set of nodes of a LinkedList. Often, the constraint is that we need to do this in-place, i.e., using the existing node objects and without using extra memory.

**Usage:** As the name suggests, this technique is used to solve problems involving traversing trees in a breadth-first search manner.

**Usage:** As the name suggests, this technique is used to solve problems involving traversing trees in depth-first search manner.

Sample Problems:

- Path With Given Sequence
- Count Paths for a Sum

**Usage:** In many problems, where we are given a set of elements such that we can divide them into two parts. We are interested in knowing the smallest element in one part and the biggest element in the other part. As the name suggests, this technique uses a Min-Heap to find the smallest element and a Max-Heap to find the biggest element.

Sample Problems:

- Find the Median of a Number Stream
- Next Interval

**Usage:** Use this technique when the problem asks to deal with permutations or combinations of a set of elements.

Sample Problems:

- String Permutations by changing case
- Unique Generalized Abbreviations

**Usage:** Use this technique to search a sorted set of elements efficiently.

Sample Problems:

- Ceiling of a Number
- Bitonic Array Maximum

**Usage:** This technique uses the XOR operator to manipulate bits to solve problems.

Sample Problems:

- Two Single Numbers
- Flip and Invert an Image

**Usage:** This technique is used to find top/smallest/frequently occurring ‘K’ elements in a set.

Sample Problems:

- ‘K’ Closest Points to the Origin
- Maximum Distinct Elements

**Usage:** This technique helps us solve problems that involve a list of sorted arrays.

Sample Problems:

- Kth Smallest Number in M Sorted Lists
- Kth Smallest Number in a Sorted Matrix

**Usage:** This technique is used to solve optimization problems. Use this technique to select elements that give maximum profit from a given set with a limitation on capacity and that each element can only be picked once.

Sample Problems:

- Equal Subset Sum Partition
- Minimum Subset Sum Difference

**Usage:** Use this technique to select elements that give maximum profit from a given set with a limitation on capacity and that each element can be picked multiple times.

**Sample Problems:**

**Usage: **Use this technique to solve problems that follow the Fibonacci numbers sequence, i.e., every subsequent number is calculated from the last few numbers.

**Sample Problems:**

**Usage:** This technique is used to solve optimization problems related to palindromic sequences or strings.

**Sample Problems:**

- Longest Palindromic Subsequence
- Minimum Deletions in a String to make it a Palindrome

**Usage:** Use this technique to find the optimal part of a string/sequence or set of strings/sequences.

**Sample Problems:**

- Maximum Sum Increasing Subsequence
- Edit Distance

**Usage:** Use this technique to find a linear ordering of elements that have dependencies on each other.

**Sample Problems:**

- Tasks Scheduling
- Alien Dictionary

**Usage:** Use this technique that involves creating or traversing of Trie data structure.

**Sample Problems:**

- Longest Word in Dictionary
- Palindrome Pairs

**Usage:** Use this technique to traverse a two-dimensional array and find a set of connected elements.

Sample Problems:

- Number of Distinct Islands
- Maximum Area of Island

**Usage:** Use this technique to traverse an array to find a required optimal element. The traversal process runs in a trial & error manner.

Sample Problems:- Find Kth Smallest Pair Distance
- Minimize Max Distance to Gas Station

**Usage:** Use this technique to solve problems that require maintaining a given set of elements partitioned into multiple non-overlapping subsets.

**Sample Problems:**

- Number of Provinces
- Bipartite Graph

**Usage:** Use this technique to find different/optimal ways to traverse a multi-dimensional array.

**Sample Problems:**

- Find Unique Paths
- Dungeon Game

Like it or not, LeetCode-type questions are a part of almost every programming interview, so every software developer should practice them before an interview. Their only option is to prepare smartly and learn problem-solving by focusing on the underlying problem patterns. Learn more about these patterns and sample problems in

**Grokking the Coding Interview **and

**Grokking Dynamic Programming for Coding Interviews**.