How to Prepare for Coding Interviews

Most developers really hate coding interviews.

A big reason why is because most developers think they have to solve hundreds of problems to be prepared. They don’t know where to begin, so they normally solve problems randomly, without any sort of plan.

A month later, they remember nothing. They attempt a problem they have already solved before. Guess what? They can’t solve it.

Here are some suggestions:

1. Focus on learning patterns rather than solving a ton of questions.

2. Learn new topics & patterns in an intuitive order.

3. Repetition - Review and re-solve problems.

None of this is complicated is it? But for some reason, few people do it. If you make it a habit to read this newsletter every week you will be far ahead of the competition.

Learning the Patterns

Fortunately, the vast majority of interview questions are based on a couple dozen underlying patterns, for example:

• Prefix Sums

• Recursive Backtracking

• Breadth-First Search

If you can master these patterns and understand where to apply them, then you can pass nearly any coding interview.

A few years ago, I created a free roadmap to make this easier.

It’s been used by over a million people, so I think you will find it useful. It includes:

• Practice problems grouped by pattern.

• Free video solutions if you get stuck.

• Code solutions in several languages.

And most importantly, it gives you an intuitive order that you can solve questions in.

Study Plan for Coding Interviews

Step 1

Be familiar with how to benchmark algorithms using Big O time and space complexity. You should know what these represent:

• Constant - O(1)

• Logarithmic - O(log n)

• Linear - O(n)

• Log-Linear - O(n log n)

• Polynomial - O(n^k ) where k is a constant

• Exponential - O(kⁿ ) where k is a constant

• Factorial - O(n!)

We created a free video covering all of these here.

You should also have an intuition for how time complexities compare with each other. For some problems, the best we can do is an exponential solution. For others, we can optimize them to polynomial time.

Step 2

The next step is to learn the fundamental data structures and algorithms.

Some of the topics you should cover are

If you’re a NeetCode Pro subscriber, then you can go through the Data Structures for Beginners and Advanced Algorithms courses to see these explained visually.

Step 3

After you’re familiar with the fundamentals, you’ll want to tackle the patterns that appear the most frequently in coding interviews.

Here’s a (non-exhaustive) list of some patterns you can check out.

To practice, you can solve problems in the NeetCode 150 list. For even more problems, check out the NeetCode All list on the same page.

Every single problem in both lists has a free detailed video solution.

Problem - Maximum Subarray Sum

Given an array of integers, find the subarray with the largest sum and return the sum.

Here’s a link to the question if you wanna try it before reading the solution.

1. Brute Force Solution

The brute force solution uses nested loops to iterate through all the possible subarrays.

1. For each subarray, you compute the sum.

2. Maintain a variable that stores the largest sum so far.

3. Return the largest sum.

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        maxSubarraySum = nums[0]

        for subArrayStart in range(len(nums)):
            curSubarraySum = 0

            for j in range(subArrayStart, len(nums)):
                curSubarraySum += nums[j]
                maxSubarraySum = max(curSubarraySum, maxSubarraySum)
        
        return maxSubarraySum

Time: O(n² )

Space: O(1)

Unfortunately, this solution is not optimal and would probably not result in a passing interview round.

2. Optimal Solution

The key to this question is Kadane’s Algorithm, which is a famous greedy algorithm.

1. Iterate through the array.

2. If the current subarray sum is negative, set it to the current element i.

3. If the current subarray sum is not negative, add the current element i to the current subarray sum.

4. At each step, recompute the max subarray sum.

At the end, you’ll have the maximum possible sum from a contiguous subarray of the input array.

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        maxSubarraySum = nums[0]
        curSubarraySum = 0

        for i in nums:
            curSubarraySum = max(i, curSubarraySum + i)
            maxSubarraySum = max(maxSubarraySum, curSubarraySum)
        
        return maxSubarraySum

Time: O(n)

Space: O(1)

This is the most optimal solution for this problem. If you prefer a full video explanation, check out this free video.