To LeetCode or not to LeetCode?

What if you don't want to practice 100s of coding questions before your next coding interview?

There is a part of me that dislikes coding interviews, primarily because it requires me to spend a lot of time preparing for coding questions. Moreover, during an interview, I have to present a reasonable (if not optimal) solution to someone who is evaluating me, something I don't have to deal with in my everyday life as a software engineer.

Having said that, I do love algorithms and solving coding problems. It is a fun activity for me, it gives me good mental exercise, and I love to spend time on it. In this post, I would like to share some of my learnings and the techniques that I've developed over time which makes preparing for coding interviews an exciting and fun activity.

A little about me; my software engineering career spans around 20 years, in which I've switched jobs five times. I've given around 30 interview loops containing 120+ interviews. I have some experience sitting on the other side of the table too. I've taken 300+ coding interviews and 200+ system design interviews.

Background

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.

Problems with LeetCode

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.

The Solution

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:

1. Sliding Window
2. Two Pointers
3. Fast & Slow Pointers
4. Merge Intervals
5. Cyclic Sort
6. In-place Reversal of a LinkedList
7. Tree Breadth-First Search
8. Tree Depth First Search
9. Two Heaps
10. Subsets
11. Modified Binary Search
12. Bitwise XOR
13. Top 'K' Elements
14. K-way Merge
15. 0/1 Knapsack
16. Unbounded Knapsack
17. Fibonacci Numbers
18. Palindromic Subsequence
19. Longest Common Substring
20. Topological Sort
21. Trie Traversal
22. Number of Island
23. Trial & Error
24. Union Find
25. Unique Paths

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

1. Sliding Window

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

Sample Problems:

• Longest Substring with K Distinct Characters
• Fruits into Baskets
• Permutation in a String

2. Two Pointers

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.

Sample Problems:

• Squaring a Sorted Array
• Dutch National Flag Problem
• Minimum Window Sort

3. Fast & Slow Pointers

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

Sample Problems:

• Middle of the LinkedList
• Happy Number
• Cycle in a Circular Array

4. Merge Intervals

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:

Sample Problems:

• Intervals Intersection
• Conflicting Appointments
• Minimum Meeting Rooms

5. Cyclic Sort

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

Sample Problems:

• Find all Missing Numbers
• Find all Duplicate Numbers
• Find the First K Missing Positive Numbers

6. In-place Reversal of a LinkedList

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.

Sample Problems:

• Reverse every K-element Sub-list
• Rotate a LinkedList

7. Tree Breadth-First Search

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

Sample Problems:

• Binary Tree Level Order Traversal
• Minimum Depth of a Binary Tree
• Connect Level Order Siblings

8. Tree Depth First Search

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

9. Two Heaps

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

10. Subsets

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

11. Modified Binary Search

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

Sample Problems:

• Ceiling of a Number
• Bitonic Array Maximum

12. Bitwise XOR

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

Sample Problems:

• Two Single Numbers
• Flip and Invert an Image

13. Top 'K' Elements

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

14. K-way Merge

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

15. 0/1 Knapsack

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

16. Unbounded Knapsack

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:

• Rod Cutting
• Coin Change

17. Fibonacci Numbers

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:

• Staircase
• House Thief

18. Palindromic Subsequence

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

19. Longest Common Substring

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

20. Topological Sort

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

Sample Problems:

• Tasks Scheduling
• Alien Dictionary

21. Trie Traversal

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

Sample Problems:

• Longest Word in Dictionary
• Palindrome Pairs

22. Number of Island

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

23. Trial & Error

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

24. Union Find

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

25. Unique Paths

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

Sample Problems:

• Find Unique Paths
• Dungeon Game

Conclusion

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.

Check Design Gurus for some interesting courses on Coding and System Design interviews.

First Published here