Skimmer Studykit

The Skimmer study kit is designed for you to skim through all the topics and patterns to get an idea of where you stand with each of them. We have tried to capture most of the patterns and data structures. We have skipped dynamic programming, greedy and backtracking with this study kit to focus on other topics and make it useful for everyone.
Once you enroll, you will receive an email every day. The email will have problems for that day, references to the topics related to the problem, and a solution link to the problem in case you need a reference.
There is at least one mandatory problem every day which is usually of Easy difficulty. The optional problem is of medium difficulty and is added in case you are comfortable with easy problems and want a bit of a challenge.
We suggest that you try the problem out and do not give up for at least 20-25 minutes. It will force you to come up with solutions, a skill that you will need when you actually interview.

Are you starting your interview journey? Practicing after a while? Start here. This short study kit is inspired by blind 75 and Leetcode 75 problems. It lasts for 21 days and introduces all the concepts, patterns, algorithms, and data structures. This is a perfect starter.

Today we look at arrays and one of the most common patterns/algorithms - Two Pointers. While the problem may seem trivial the constraints of using constant space make it challenging. Check out the reading links below to read more about two pointers.

Building up on yesterday's knowledge about Two pointers, we will tackle yet another string/array problem. if you think you have good knowledge of two pointers and want to challenge yourself, take a stab at 3 sum problem. We have included solutions to these problems as well for your reference.

We will be practicing today on sorting one more time. For today's problems take the properties of a sorted array, algorithm of two pointers and see if you can apply that to the first problem. If you think you want to challenge yourself a bit, try the second problem.

In today's set of problems we will be looking at a new pattern of sliding window. This pattern is a little bit tricky to understand so I would suggest going through it and really understanding it. We have included some reading references which we feel will be helpful. 

Next up is sorting. An important concept that is required to master Arrays. If you are new to sorting, I would suggest you take some time reading through it. See if you can solve today's problem without using extra space.

Building up on sliding window we learnt yesterday, we will be solving another string problems of anagrams. Similar to yesterday's problem we will be using sliding window to find if a string is present in another string.

Today is a catch up day. We sent you 6 problems so far and introduced you 3 concepts/patterns. Take time to reflect on those, re-visit some problems or take some time off.

Hope you had some breather room on the rest day. Today we will be tackling a new pattern of merge interval. 
Meeting rooms are a great example of the application of this pattern. Imagine you are given an array of time slots when there are meetings. Your task is to write code to merge the time consecutive time slots. 
The problems in this pattern are usually medium-level problems. So if you cannot solve them, do not worry. You will get there.

Today's problem is mainly to focus on heap sort. Many times we will get the question "find the Xth largest/smallest/most used/ least used etc". This is the perfect case for using heap sort.
There are two ways to approach a heap sort. You can either sort during insert (which makes retrieval constant) or you can sort on retrieval (which makes insert constant). So what do you choose? This is the question you should ask your interviewer. If the application is insert heavy, you will want to sort during retrieval or else sort during insert.
Do not let the word "stream" scare you. Just think of it as continuous flowing input. 

Over the past 9 days, we have been mainly working with arrays and strings. Today we will start with a new data structure, Linked List. While application of linked lists is limited (as dynamic lists, arrays, etc. are easy replacements), linked lists are super useful to master coding for traversals of trees and graphs. 
I view the linked list as a tree with a single child node. 
Today's problem can be solved both iteratively and recursively. I would encourage you to try both approaches and see which one you are finding challenging/easy. 

Graphs!! The data structure everyone dreads. They are complex, hard to visualize, and can be very challenging sometimes. But they are very useful and have very heavy application usage. In fact, most of the problems can actually be thought of as graph problems. 
The application of graphs can be to find connecting flights and find your 2nd and 3rd-degree connections or find similar products like the one you bought. 
Today's problem is an introduction to traversal (BFS, DFS) in the graph. Make sure to focus on coding the adjacency matrix and keeping track of the visited array.

Today is a catch-up day. We are on Day 14 and you have seen a lot of patterns/algorithms so far. Take time to reflect on those, re-visit some problems, or take some time off.

Today we will switch gears to yet another data structure: Queue. Queues are arrays that process the items in the order they were inserted. The primary difference is that you cannot access elements randomly or using indexes (like in an array, hashmap, etc.). 
So where are queues useful? The application of queues is to process items in the order. For example, imagine an e-commerce website that takes orders for items. Let's assume there are only 100 such items available. To make sure we are fair and selling items on a first come first serve basis, we can use a queue to line up orders from customers and fulfill them until we have no more items.
For interview purposes, Queue is primarily useful for BFS traversal of trees and graphs.

Building up on our LinkedList data structure, today we will learn about a new algorithm: Floyd's cycle detection or fast and slow pointer. This algorithm, as the name suggests, helps you detect a cycle. 
Similar to two pointers, we have two pointers in this algorithm. The key difference is that there is a slow pointer (moving by 1 every iteration) and there is a fast pointer (moving by 2+ every iteration). The idea is that the fast pointer keeps going around the linked list until the slow pointer reaches the end or they both meet (which indicates a cycle).

Today we will be diving deeper into graphs with one of the most dreadful but easy-to-understand algorithms: Topological sort. While today's problem can be solved using DFS or BFS, the code can get quite murky. Additionally, you might end up implementing some version of the topological sort unknowingly. Give it a shot, read a few references, and see if you can understand the algorithm.

Today we will focus on application of stack. If you remember we did a few problems on recursion. Recursion, under the hood makes use of function stack. When you call a function repeatedly, that call is added to an internal stack. Hence if you have an infinitely recursive call you will get an error of StackOverflowException. Try the problems for today to get better idea on stacks

Today we will start with one of the complex but an important topic - Trees. Trees are a key building block to understand graphs. 
A tree has a root node which can have one or more child (branches). A tree with max of two children is called binary tree. A tree with max of N children is called as N-ary tree.
Trees can be traversed using either Breadth first search (BFS) or Depth first search (DFS). Today we will be solving some problems on BFS. As the name suggests, BFS means traversing a tree level by level. 
Read some of the references to understand trees better.
Note that tree problems can take a while to master but once done, it can be very fruitful.

Today we will focus on the Depth traversals of trees. A couple of days back we learned about BFS where we traversed the tree level by level. 
Today we will learn about depth-first traversal and three different kinds of traversal orders - inorder, preorder, and postorder. 
Read the links provided to learn more.

Using our knowledge of Floyd's cycle detection and two-pointers, we will be solving two important problems to solidify our understanding. 

Selecting the right kind of traversal is the key to tree problems. Most of the time you can select either, but many times, one traversal might be better than the other. For example, the problem we solved on Day 16 clearly called for level order. Similarly, you will find today's problem will be well suited for Depth first search.

Today's problem can be solved using iterative or recursive approach. Want more challenge or practice? Try solving the problem using both approaches.

The Grind 2

The Grind study kit is designed to get into details and cover all the patterns and data structures in-depth. This study kit lasts over 6 weeks, with 1 day to catch up every week. The topics are structured based on difficulty and problems are grouped by each topic and pattern to get a consistent flow of learning. 

Once you enroll, you will receive an email every day. The email will have problems for that day, references to the topics related to the problem, and a solution link to the problem in case you need a reference.
There is at least one mandatory problem of varying difficulty. The optional problem is of medium difficulty and is added in case you are comfortable with easy problems and want a bit of a challenge.
We suggest that you try the problem out and do not give up for at least 20-25 minutes. It will force you to come up with solutions, a skill that you will need when you actually interview.

This study kit encompasses all the topics and the common patterns that you need to ace the interview practice. We have selected problems starting with strings, two pointers and covered all the topics until dynamic programming.

With today's two problems we will be focusing on the two-pointers pattern and Strings. You can solve all the problems with brute force without knowing of two pointers, but the two pointer pattern/algorithm can me it much simpler to achieve optimized results.
For the first problem, one of the key clues is that we do not actually need the substrings themselves, but only the count. This in turn makes the problem a bit easier in this case. In many problems, counting the times "X" is present can be easier than getting all the "X".
The 3-sum problem is a classic two-pointer problem. If you are new or brushing up on different patterns, stick to PODs (easy ones).

Next up is sorting. An important concept that is required to master Arrays. You will find that for many questions the time complexity can be reduced by noticing the sorting behavior as a solution. If you are new to sorting, we would suggest you take some time to read through it. See if you can solve today's problem without using extra space.

The medium problems can be solved using one of the sorting techniques. Realizing this sorting technique and applying it to this problem will give you a leap ahead. Can you recognize what technique resembles the given problem?

Today's problem is mainly to focus on heap sort. Many times we will get the question "find the Xth largest/smallest/most used/ least used etc". This is the perfect case for using heap sort.
There are two ways to approach a heap sort. You can either sort during insert (which makes retrieval constant) or you can sort on retrieval (which makes insert constant). So what do you choose? This is the question you should ask your interviewer. If the application is inserted heavy, you will want to sort during retrieval or else sort during insert.
Do not let the word "stream" scare you. Just think of it as continuous flowing input.

Today we will build up on heap sort. Today’s question might look a bit similar, except that we need to keep track of the frequency and return N elements. This might sound very similar to LRU but the opposite version of it. Note that, you can solve it using any sorting techniques, but heap sort might fit this better

Today we take the knowledge of sorting we learned in the past two days and use it on a new data structure: Linked List. To master trees and graphs, knowing and being able to code linked list traversal (iterative and recursive) is important. 

The second problem requires manipulation of the node pointers in addition to finding the next node. Finding the next node can be done with multiple loops or extra space. But can you do it in a single pass?

Today we will be covering new pattern of sliding window. Sliding windows can be quite tricky especially because of index manipulation. Read the references provided to refresh or learn this pattern.

Hopefully, you now have some idea about the sliding window pattern. Today we will tackle a problem along the same lines but slightly more tricky.

Yesterday we looked at fast and slow pointers. Today we will be solving a similar problem but at a different difficulty level. 

Linked List is great for understanding recursion before we jump on to trees. It is much easier to understand recursion with linked list. Today we will be solving two problems using recursion. 
The best way to get your head around recursion in linkedlist is to draw your function calls like stack. Since there is only one node (unlike trees or graphs), you will have a stack with single of single dimension.

Today we will start with a new data structure of stack. Stacks are vital to understanding recursion and can also be quite handy in situations where you need LIFO (Last in first out) ordering of elements. When you write recursive code, internally the function calls are mantained in a stack data structure. Hence if you write a infinite recursive function you will get an error of StackOverflowException

We will continue to practice stack today. 

LRU caches is one of the most important question that keeps repeating. Mostly because this data structure has lot of applications. For instance, LRU is used for cache eviction. While the coded can be gnarly, make sure  you can explain it well to your interviewer and focus on structure of your code.

Bit manipulation always scares many of us. It is hard to understand and not easy to grok. Human minds are best suited for decimal number system. Nevertheless, many times, bit manipulations can help with optimizations and speed up your code is smart way. However, the down sided is that they can be hard for someone to understand. Check out the hacks for bit manipulation.

Today we will be tackling a new pattern of merge interval. 
Meeting rooms are a great example of the application of this pattern. Imagine you are given an array of time slots when there are meetings. Your task is to write code to merge the time consecutive time slots. 
The problems in this pattern are usually medium-level problems. So if you cannot solve them, do not worry. You will get there.

While not recognized as a pattern, problem in today's list appear every now and then. Try to draw out the problem in multiple steps to get a better understanding.

Today we will continue with bit manipulations. In today's problem you will see how to check if a bit is set or not.

Study kits

Frequently asked questions

What is a study kit?

What is a the goal of studykits?

What is a the cost of studykits?

How do studykit work?

What does study kit contain?

Can I pause the studykit?

How many studykits can I sign up at once?

How to unenroll from studykit?

I have feedback. How can I provide one?

Want tips & tricks to ace your interviews?