When accessing via the browser you get a

Page Not Found
We could not find what you were looking for.

Looks like a status 404 error.

Has RSS feeds been phased out on the website ?

https://techinterviewhandbook.org/blog/rss.xml
https://techinterviewhandbook.org/blog/atom.xml

Tried a couple of different RSS feed readers, as well as without success. Just thought I'd bring this to your attention. Would love to see this fixed!

Can I contribute a .cpp file explaining kadane's algorithm implementation and required comments for the maximum contiguous subarray sum problem. I saw the maximum contiguous subarray sum problem on the site . So people can see it's solution on the repo.

Here it probably should be Placing <script>s just before </body>.

Elynn Lee has written great content about it here. Unfortunately it is not for reproduction and some rephrasing + more research will have to be done.

Umbrella issue to house plans for adding more content to the handbook which would be useful to job seekers.

Off the top of my head, I have the following ideas in mind:

• #222
• #223

Feel free to contribute ideas!

I think using a checklist to display all the weekly problems would be more helpful. The user can mark the problems which he/she already knows.

mergeSort method doesn't handle null case, it should handle the case where arr is null

Hello,

This repository is great! Thanks for sharing this. I had created a github repo that lists all the various websites where people can practice algorithmic questions typically asked in interviews. It was initially for myself and then I decided to open-source it. I would like to add a reference to this repository here so, it could be helpful to the community as well. I feel it is aptly suited under the preparing section in your repository.

Let me know if this sounds good, I will raise a PR for this change!

Thanks,
Harshita Kasera

You are given an n x n 2D matrix representing an image. Rotate the image by 90 degrees (clockwise or anti-clockwise).

This is an issue to start collecting ideas on a page on team selection.

Goal

Help candidates to evaluate teams in their new company and what factors they need to take into account.

Resources

TODO

In the cheatsheet,

Under Before Interview:
Prepare answers to the frequently-asked behaioral questions in an interview.

Hi Yangshun,
I'd like to download template file in this https://techinterviewhandbook.org/resume-case-study/. Could you please help?

Great guide!
I think I might have found an error there: string.md
E.g. "abba" and "redblueredblue" should return true
It should either be: "return false" or "redbluebluered" according to the given pattern.

would be nice to have checkmark cell in the best practice questions tables, but not sure how you would work localStorage with MDX?

Instead of paying a subscription for "Grokking the System Design Interview by Educative", people can also pay for lifetime access for the same course from Design Gurus (along with others). This might be an option people want to consider when paying for a course.

This is an awesome resource for people looking to polish their skills for when they go into interviews.

Are there any plans to add some resources for the interviewers? IE, the brand new tech lead who needs to hire a junior but has no idea what kinds of questions to ask, or the manager who doesn't know a ton but needs to find just the right dev for their open position.

https://github.com/yangshun/tech-interview-handbook/blob/master/contents/algorithms/sorting-searching.md

Sort a list of numbers in which each number is at a distance K from its actual position.

is same as

Sort a list where each element is no more than k positions away from its sorted position.

Would it be fine if I add Arcesium(DE Shaw & Co.) Interview Formats to https://techinterviewhandbook.org/interview-formats/? Shall I raise a PR for it?

Really great resource, thanks for sharing!

A few of us like to read and remember better with codex style Superbook [1] format. I can convert and publish it for you using a script in a weekend if you want.

[1] https://bubblin.io/docs/format

I would be very pleased if I can contribute to this project by translating it into Chinese version.

In, URL: https://yangshun.github.io/tech-interview-handbook/algorithms/sorting-searching
File: tech-interview-handbook/contents/algorithms/sorting-searching.md

• Sort a list of numbers in which each number is at a distance K from its actual position.
• Sort a list where each element is no more than k positions away from its sorted position.

Are they the same questions?

Hey Yangshun,
Thanks for the great list of guides!

I found the explanation for Snake game bit difficult to follow and I came across this interesting and better explanantion here https://www.youtube.com/watch?v=AaGK-fj-BAM

Problem: https://leetcode.com/problems/sum-root-to-leaf-numbers/

Solution Explanation Blog Post: https://medium.com/leetcode-solutions/summing-root-to-leaf-numbers-in-a-binary-tree-353f33c8565e

Solution Explanation Text:

Summing Root to Leaf Numbers in a Binary Tree

Sum Root to Leaf Numbers is an interesting problem from Leetcode. The problem is of medium difficulty and is about binary trees. This post presents and explains the solution along with the thought process.

I assume that you’re familiar with Python and the concept of binary trees. If you’re not, you can read this article to get started.

The Problem

Given a binary tree whose nodes contain values 0-9, we have to find the sum of all numbers formed by root-to-leaf paths. A leaf is a node that doesn’t have any child nodes. In a binary tree, a root-to-leaf path is always unique. Here below is the expected behavior of the solution required:

In the tree on the left, the output is 25. 25 is the sum of 12 and 13, which are the two numbers formed when starting from 1 and visiting every leaf. In the tree on the right, the output is 1026 as it is sum of the three numbers 495, 491 and 40.

The Observations and Insights

• We notice that we traverse the tree from the root to the leaf, visiting some leaves before many of the direct children of the root itself. This suggests that a depth-first search might be more useful here, and especially the one which starts visits the root first.

• We notice that the building of numbers is incremental and similar of sorts: the only difference between 495 and 491 is the last digit. If we remove the 5 and insert a 1 in its place, we have the next number. A number is essentially made of up all digits in its ancestor nodes and thus shares many digits with siblings and nodes within the same sub-tree.

• Finally, we notice that this problem involves a tree so a recursive solution is possible and natural.

The Solution

We can do a pre-order traversal of the tree where we incrementally build up a number and exploit the fact that numbers formed by nodes in the same sub-tree have common digits for common ancestors. When we’re done forming numbers in a sub-tree, we can back-track and go to another sub-tree.

Let’s create a Solution class to encompass our solution. We can have an array attribute to store all the root-to-leaf numbers formed and an array attribute to store the current list of digits as we traverse the tree.

class Solution: 
    curr = [] # stores digits in the current path 
    numbers = [] # stores numbers formed by root-to-leaf paths
    def sum_numbers(self, root: TreeNode) -> int:

The method signature given to us in the problem has one argument: root , which is of the type TreeNode . A TreeNode class is as follows (from Leetcode):

class TreeNode:
     def __init__(self, val=0, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right

As highlighted earlier, we need to build a number for each root-to-leaf path so that we can compute the sum of all numbers. To keep our code modular, let’s define another method to do this (instead of doing it within the sum_numbers method). This method will be responsible for filling our numbers array with all the root-to-leaf numbers. Let’s call it get_root_to_leaf_nums. It should take an argument of type TreeNode as well and return nothing (since it is modifying state by filling up the numbers array.

Our Solution class looks like:

class Solution: 
    curr = []
    numbers = []
    def sum_numbers(self, root: TreeNode) -> int:
    def get_root_to_leaf_nums(self, root: TreeNode): 

We can think of the get_root_to_leaf_nums method recursively and process each node differently based on whether it is a leaf or a not a leaf.

• If it is a leaf, we want to add the value to our curr array, create a number based on the digits in the curr array and add the number to the numbers array. Since the node is a leaf, we will backtrack from here to the previous node and therefore want to delete the current node’s value from the curr array.

• If it is not a leaf, we want to add the value to our curr array, and then continue traversing the left and right sub-trees. When done, we want to remove the current node’s value from the curr array as we backtrack.

Thus, our get_root_to_leaf_nums method will be as follows:

def get_root_to_leaf_nums(self, root: TreeNode): 
        if root: 
            self.curr.append(str(root.val))
            if not root.left and not root.right:
                self.numbers.append(self.convert_to_num(self.curr))
                self.curr.pop()
            else: 
                self.get_root_to_leaf_nums(root.left)
                self.get_root_to_leaf_nums(root.right)
                self.curr.pop()

We check if the root is not a None and simply do nothing if it is None as we are not concerned with empty sub-trees. We need a convert_to_num method that can convert the curr array representing digits of the number to an integer:

def convert_to_num(self, arr) -> int:
        cum = int("".join([str(x) for x in arr]))
        return int(cum)

We basically convert each int in the curr array to a string, concatenate the string and then typecast the result back to an int.

Now, in our main method, we first want to fill the numbers array and then simply return its sum. We need to clear the numbers array at the end because Leetcode will typically run this through a lot of testcases and subsequent testcases will fail if the numbers array contains solutions numbers from a previous testcase.

Finally, this is how our solution looks:

class Solution: 
    curr = []
    numbers = []
    def sum_numbers(self, root: TreeNode) -> int:
        #get all numbers from root to leaf paths
        self.pre_order(root)
        # sum all numbers
        ans = sum(self.numbers)
        self.numbers.clear()
        return ansdef get_root_to_leaf_nums(self, root: TreeNode): 
        if root: 
            self.curr.append(str(root.val))
            if not root.left and not root.right:
                self.numbers.append(self.convert_to_num(self.curr))
                self.curr.pop()
            else: 
                self.get_root_to_leaf_nums(root.left)
                self.get_root_to_leaf_nums(root.right)
                self.curr.pop()def convert_to_num(self, arr) -> int:
        cum = int("".join([str(x) for x in arr]))
        return int(cum)

The Algorithmic Complexity

When solving a problem, it is important to analyze its algorithmic complexity not only to estimate its performance but also to identify areas for improvement and reflect on our problem solving skills.

Time:

Our solution is a modification of the depth-first-search pre-order traversal where we visit all nodes exactly once. Thus, our runtime is simply O(N) where N represents the number of nodes in the given tree. I can’t think of a solution that will be better than O(N) because to construct a number from digits, I need to know all the digits.

We also incur a small cost to sum the numbers in the numbers list and to convert the curr array to an integer, but these costs are insignificant when compared to the cost of visiting each node (the number of numbers formed will be less than total number of nodes).

Space:

In terms of storage, we store the numbers formed and the current list of digits, which is not that significant. However, what is significant is the recursion call stack that builds up as our get_root_to_leaf_nums calls itself. These calls “build-up” as one waits for another to finish.

Generally, the maximum call stack will be dependent upon the height of the binary tree (since we start backtracking after we visit a leaf), giving a complexity of O(H) where H is the height of the binary tree. In the worst case, the binary tree is skewed in either direction and thus H = N. Therefore, the worst case space complexity is O(H).

You can read this article to know more about recursion call stacks.

The Conclusion

I hope this post helped! Please do let me know if you have any feedback, comments or suggestions by responding to this post.

On the tech interview handbook website, under the algorithms>Dynamic Programming>Recommended Leetcode questions, the 0/1 Knapsack Problem does not link to a page. Request to assign this issue to me so I can fix it.

Is there a reason why a few files were deleted in this commit a6918b2 ?

I found the old Questions to Ask a lot more useful than the current Final Question as it broke down all questions to ask depending on who you are being interviewed by (Culture, Product, Management, Leadership, HR, etc.) and not just SWE.

This is an issue to start collecting ideas on a page on engineering levels.

Goal

Help candidates know what is expected of levels at various companies to better determine the engineering level they should be at and making sure they're getting a fair offer

Resources

• Dropbox Levels
• Wise

You speak about shirt and tie. Now of course there's nothing stopping a woman from wearing that, but wouldn't you agree that this makes it sound like you're only addressing a male audience?

If I want to enroll in the Facebook internship programme as a Front End Engineer do I need to be an expert at algorithms?

I'm confused by the new Study and Practice Plan format.

The recommended questions from weeks 1-4 are also found in the later weeks.
So should we not solve those recommended problems in those initial 4 weeks, and just read through the concepts?

A collapse all/expand all buttons will really improve UX because on first load, every weekly problem group on Grind75 page is expanded, which makes it a little bit cumbersome to scroll down to Week 6+, and there are no easy ways to collapse all either.

Therefore, I believe having collapse all/expand all buttons along with starting in Collapsed mode would be better

I will be happy to contribute PRs to code (I want to contribute to OSS too) if someone can point me to right file and folder.

Great guide, just a little nitpick.

https://pugjs.org

Any plans on being able to clone the repo and building a PDF out of it?

Christina has kindly agreed to let us replicate the content of her whole post .

Feel free to contribute success stories/testimonials to the website! If this repository has helped you with your job hunt and you would like to put in a good word for the repo and be featured on the front page of the website, please comment down below! If there are too many submissions, I'll create a separate page to include them.

If interested, please submit the following:

• Display Name
• URL to profile picture (GitHub profile pic preferred e.g. https://github.com/yangshun.png)
• Testimonial/Recommendations (< 200 words)

Submit them here

Webpage : https://techinterviewhandbook.org/algorithms/introduction/#references

Under this section, the 3rd URL is broken : https://quip.com/q41AA3OmoZbC
Moreover, the URL redirects to https://quip.com/cVcAAAJJ9qq for me.

Screenshot :

This is my first issue in github, BTW.

public class Ferry
{
private Vehicle[] ferry;
private int numVehicle;
private int maxVehicle;
private int maxAxel;
private int maxPassenger;
private double weightLimit;
private double weight = 0;
private int numAxel = 0;
private int numPassenger = 0;

public Ferry(int maxVehicle, int maxAxel, int maxPassenger, double weightLimit)
{
	
	ferry = new Vehicle[maxVehicle];
	numVehicle = 0;
	

}



public boolean addVehicle(Vehicle v)
{
	boolean added = false;
	if(numVehicle < ferry.length)
	{
		boolean found = false;
		for(int i=0;i<numVehicle && !found;i++)
		{
			if(v.getIdNum() == ferry[i].getIdNum()){
			found = true;
			}
		}
		return found;
		
	
		if(!found)
		{
			if(weight<weightLimit) 
			{
				if(numAxel<maxAxel)
				{
					if(numPassenger<maxPassenger)
					{
						ferry[numVehicle] = v;
						numVehicle++;
						numAxel += v.getNumAxel();
						numPassenger += v.getNumPassenger();
						weight += v.getWeight();
						added = true;

					}
					
				}
			}

		}
	
	}
	return added;
}



//removing vehicle

public boolean removeVehicle(Vehicle v){
	boolean removed = false; 
	for (int i = 0; i<numVehicle && !removed; i++) 
	{
		if (v.getIdNum() == ferry[i].getIdNum()) 
		{
			ferry[i] = ferry[numVehicle - 1];
			numVehicle--;
			numAxel -= v.getNumAxel();
			numPassenger -= v.getNumPassenger();
			weight -= v.getWeight();
			removed = true;
		}
	}
	
	return removed;


}


public boolean changeNumPass(Vehicle v,int  newNumPassenger)
{
	boolean changed = false;
	if(numVehicle < ferry.length)
	{
		
		for(int i=0;i<numVehicle && !found;i++)
		{
			if(v.getIdNum() == ferry[i].getIdNum())
			{
				if((numPassenger-v.getNumPassenger()+newNumPassenger) < maxPassenger)
				{
					v.setNumPassenger(newNumPassenger);
					numPassenger = numPassenger - v.getNumPassenger()+newNumPassenger;
					changed = true;

				}

			}
			
		}
	
	}
	return changed;


}

}

I have developed an AI Bot that can assist users in Interview Preparation by using the content from tech-interview-handbook by yangshun. I'm ready to send pull request if you're interested in this idea.

Hello,

I found a broken link here.

The Facebook's Onsite Interview Guide is not working.

Suggestion to replace the link to Lago (under Interview Process -> Coding round -> Study and practise) with TheAlgorithms as it contain data structures and algorithms implemented in many more languages (Java, Javascript, Python, C, C++ etc) compared to Lago which focuses only on js.
I can go ahead with a pull request for this if thats okay.

Few days ago site worked without problem, now it's not working:

https://yangshun.github.io/tech-interview-handbook/

could you pls solve this question?

1. Found a typo in tech-interview-handbook/blob/master/preparing/README.md on line 70.
   Typo - oppurtunities.

2. Found a typo in tech-interview-handbook/blob/master/interviewers/basics.md on line 19.
   Typo - psuedocode.

Thanks for this really helpful guide! In your tree section, it says that "When you are asked to traverse a tree by level, use depth first search." In this case, should it be Breadth First Search? I remember doing a Level-Order traversal problem on LeetCode, and to solve it I used BFS with a queue. I think I may be misreading your statement too.

من میخواهم عضو تیم پشتیبانی شوم لطفا راهنمایی کنیدمن را

In the Best Practice Questions section under Week 5 – Dynamic Programming, Combination Sum linked to LeetCode Combination Sum IV. Is this intended? All other questions have the correct numbering (e.g. Word Search II).

I have created this curated list of Questions one should consider asking the interviewer and future company.
https://github.com/rohandaxini/questions-to-interviewer

@yangshun Do you think a few of these can be useful and worth adding in this section here > https://www.techinterviewhandbook.org/questions-to-ask

Add some Twitter testimonials/shoutouts like on the front page of https://turborepo.org

• https://twitter.com/umaar/status/913425809108606976
• https://twitter.com/ravinwashere/status/1328381097277681665
• https://twitter.com/rwenderlich/status/1166336060533727232
• https://twitter.com/Insharamin/status/1412978510788915205
• https://twitter.com/silvenon/status/1416842523302039552
• https://twitter.com/Justyna_Adam/status/1186166253830004736
• https://twitter.com/Vinaystwt/status/1437062973554507777
• https://twitter.com/sitepointdotcom/status/1164121717243023360
• https://twitter.com/JoeIngeno/status/1163601668384186368
• https://twitter.com/palashv2/status/1452981345899085833
• https://twitter.com/khalalw/status/1469496702365159431

file:///var/mobile/Library/SMS/Attachments/dc/12/2664D2DB-9B41-4D25-AFA2-445ECB8F22D0/takeout-20220125T041706Z-001.zip