Today, I recognize that good software development owes nothing to data structure knowledge or obscure algorithms. This knowledge can't hurt but very few jobs or languages require you build a skip list from scratch. Instead, writing good software requires the ability to maintain a system, to debug problems, and to give constructive code review.

That's it. LnxPrgr3 on Apr 17, For functional purposes, I consider myself to know something if I could page in the details well enough to implement it in 5 minutes with Wikipedia or less. How this plays in interviews is interesting for just how inconsistent it is. Sometimes I win the algorithm lottery and have had reason to implement the obvious solution myself at least once, and the interviewer learns my memory works. Sometimes I don't know what they're going for but come up with a reasonable answer anyway and the interviewer is thrilled I managed to have an independent thought.

Sometimes I lose and the interviewer is clearly trying to guide me to the answer they want to see and I have no idea what they're getting at. Though not quite as bad as a friend failing an interview for not using a hash table, even though the answer he described was a hash table—just with the identity function as the hash. Like you can teach that language in a semester—please. There are maybe 4 proper experts on the planet.

## Nail Your Programming Interview by Focusing on These 6 Things

I think there might be a happy medium. Knowing how to implement a specific algorithm is not necessary. Knowing of algorithms and picking the right one is important. For example, a junior developer apparently forgot about hash sets. He used a list for lookup. Worked fine in his local tests. Fail miserably when we had to load millions of records. A more seasoned programmer should be able to explain why a hash would work well here.

Tade0 on Apr 17, I used to do interviews in one company I worked for and we had this online test, which consisted of four tasks very similar to those in the list. There was this one candidate who, by mistake, was given the test twice. Apparently he took offence to that. He found that his friend did the exact same tasks so he copied them. The designers of that test tout that their system is able to detect plagiarism, but that was not the case here.

Anyway eventually we hired him because even though his first attempt wasn't particularly impressive and he cheated a face-to-face interview revealed that he was a skillful programmer. One thing I learned from this experience is most of the time these test simply confirm that the candidate went to college - sometimes a particular one. I'm hoping that Disseminating these practice materials will eventually topple the whiteboard interview by exposing it's futility.

While I don't think that the current state of interviewing is perfect, this statement is pretty out there. Choosing the right data structure is critical for software that performs well or performs at all once you get to a certain scale , and demonstrating knowledge of various data structures shows at least that a candidate knows a bit about which tools they have available to them on the job. Of course not many people are implementing skip lists from scratch in their everyday job, that's why in the list of questions none of them are "Implement a skip list".

Data structure questions rarely ask you to implement some data structure from scratch, they ask you to look at a problem and figure out which data structure best lends itself to the solution. I won't argue that asking questions about obscure algorithms isn't a problem, but good interviewers aren't asking questions that need obscure algorithms, they are asking questions that need algorithms like DFS, basic variations of sorting, and basic DP problems.

You're focusing too much on a particular phrase and not enough on the overall meaning. Code review is the best time to talk about data structures and algorithms as they are a time to apply theoretical knowledge to real world problems. Good, constructive code reviews are about education and maintaining a quality code base. Interview questions about data structures and algorithms rewards memorization and classroom knowledge.

I've worked with way too many mediocre developers who are great at whiteboarding interview questions but who couldn't build a maintainable system if their lives depended on it. Consequently, I don't give a damn about a candidate's performance on these types of questions. Instead, I'd rather learn about some projects they've built, problems they've experienced and their experience with code reviews.

Yeah, the strange "data structures and algorithms are either everything or nothing" polarization in the opinions on tech interviewing is strange. Could you explain your reasoning? Someone doing really well doesn't seem like a reason to stop asking other people algorithms questions. Because he understood that this data point falsified the general theory that answering questions about algorithms and data structures implies an understanding of algorithms and data structures.

WalterBright on Apr 17, Check for understanding by not asking book questions and expecting book answers. Ask variations on book questions. For example, in junior math the prof went carefully through deriving the Fourier Transform. On the final exam, the question was to derive the Hyperbolic Transform. This was straightforward if you understood the FT, but not if all you could do was parrot it.

So that said how do you vet talent? Ask them to tell you stories about maintaining systems, debugging, etc? Personally, yes - I like asking about high-level run-downs of a project on their resume. I then choose points to stop them either randomly or if I know a lot about the subtopic and dig deeper and see where their comfort level lies.

- Graph Data Structure Interview Questions?
- A Ride In The Park.
- Perpetually Cool: The Many Lives of Anna May Wong (1905-1961) (The Scarecrow Filmmakers Series);

There are a lot of benefits to this approach: 1. Keeps the topic on something they are presumably comfortable with. Gauges their seniority level: more senior folks can talk deeply about a wider variety of topics. Tests their communication and explanation skills, again about a topic they should be comfortable with. Some potential pitfalls: 1. Makes it harder to objectively compare candidates. I think this is impossible anyway, so I don't consider it a big deal.

Some candidates, especially junior ones, simply don't have many projects on their resume to talk about. In this case I'll often ask them to explain a skill or technology they are experienced with. It's harder to conduct these interviews. Giving a problem and passively watching and helping as needed is a lot easier than keeping up an active dynamic conversation. I've seen from both sides two things that seem to work.

Firstly, write actual code to solve a simple but real, or at least realistic, problem. That could be a take-home exercise, or it could be on-site pair programming, or some other format. Memorable examples: a stock exchange submit orders, get trades ; a Tetris engine submit blocks, get rows filled ; an auction house submit bids, get winners ; an uploader for the Azure blobstore submit blocks, get files ; an online metric summarizer submit samples, get summaries.

This tests someone's ability to actually write code. Secondly, suggest an algorithm for a real, or realistic, problem that doesn't have a well-known good solution. Memorable examples: subset-sum, but on an ordered set, where the solution must be contiguous; placing primers for PCR [1]; online k-anonymisation [2]. This tests someone's ability to think on their feet, and synthesize facts they've learnt into something new.

I'm a bit dubious about the "tell me about something you worked on" question. Firstly, because it requires the candidate to have worked on something chewy, and there are lots of capable people out there who are unfortunate enough to have had crummy jobs where they don't get to do that. Secondly, because it attempts to evaluate the judgement of an individual by looking at the work of a team. Too often, as a candidate, i've had to answer "why did you do it that way? But an easy comeback from the interviewer would have been "What other ways could you have done it?

But now you're talking about ideas, rather than about experience, so you're testing something a bit different. The best way to memorise hundreds of different algorithms or anything else for that matter is to understand the few underlying principles beneath them. I would be surprised if he knew them all and couldn't come up with intelligent ways of mixing them for achieving a new task. The best way sure, not the only or even most popular way though. What do you mean by "maintain a system"?

I guess I need to elaborate, since I am getting down voted. I have only heard of maintaining systems in contexts where it means keeping a system running. Hence, my question. Bit late to the party but this is a valid question. There's a lot of focus on writing the code, but the system includes the non code components. Can the developer keep the code relevant to the organisation. Does your company have current openings? I think I can prove myself better in your metrics. We do, check out MediaMath. We will ask you design, debug and like the questions. Well also do a take hone problem.

Speak the truth. I'd hire you again, man. Yeah and you'd be the first guy I'd think of in an early stage start up. You're a gets shit done kind of guy. Thank you! The change being you have to more often create an "easy to maintain" glue layer between lots of existing code most of which your company wrote a bunch of years ago, or is external to your code in a framework or library instead of solving a problem from scratch using CS basics. Interview questions haven't shifted to "this library has such and such function calls, how would you expect it to report an error?

They're still very much in the era of OK we have two rectangles, how do we find the overlapping pixels. We don't ask about "how you handled a difficult person on your code review" or "how would you break this change in to two logical commits" or even "what's a good name for this function", all of which are more important than knowing the big-o for some obscure interval tree.

Turns out writing code that is really fast needs more than knowing the big-o. Why not just ask some fundamental graph or combinatoric counting questions? Why nothing about what is computable and what is not, or which languages are regular? What about information theory? How come no information recall or database questions?

NTDF9 on Apr 17, Here's my gripe with this interview process. It encourages engineers to spend months and years into learning and remembering optimal solutions to textbook problems. A REAL engineer would spend the same time doing something productive But then these same companies will hire some mediocre engineer who cannot think out of the box but is an expert at memorization. Said mediocre engineers then hire other mediocre engineers using the same process, because these mediocre engineers do not even have the ability to grasp what kind of engineering would lead to above points.

To top it off, these same mediocre engineers sweep this problem under the rug claiming they are trying to reduce false negatives. Sad state of the industry! JDiculous on Apr 17, Google style interviews don't screen for the best engineers, but they screen strongly for subservience.

The fact that a candidate has to go out of their way to prepare for these interviews indicates that the candidate is likely willing to jump through whatever hoops they're told to jump through. It's similar to how investment banking jobs place such a high premium on Ivy league degrees with high GPAs despite the actual job itself being so simple a high school student could do it. Someone who's willing to jump through all those hoops to get into a top school and graduate with a high GPA has a strong track record of following orders and is less likely to complain about hours workweeks.

Try saying this obvious observation to some Google engineers in real life. I've never seen such butthurt adult-kids! I mean, that's all true, but what matters is whether you have some personal goal which requires you to go through time at Google. If this materially impacts the bottom lines of companies that are practicing this approach eventually companies that are not using this process will prevail. There are other equilibria, likely because the employment market does not have the characteristics necessary for analogies of the the Efficient Market Hypothesis to apply.

It would, if companies realize that they can save millions by improving their interview processes and not have to aqui-hire so much. But this insight requires smart people who they eliminated with this interview process to be already hired in those companies. While I highly dislike this trend it's hard for me to call say Sundar Pichai not smart for example. What do you think about Marissa Mayer?

For every outlier winner person you point out, the industry is littered with losers.

### More Books by Vibrant Publishers

Perhaps stop correlating wrong things together? You realize they got hired because of their fame and expertise? They didn't have to go through intense whiteboarding. And even if they did, they would be hired even if they didn't solve a stupid N-Queens problem? I realise they have 0 problems with CS fundamentals while being at the same time top experts in respective fields. I suspect your definition of CS fundamentals is only Algos and Datastruct problems.

Said experts are very good at what they do. That does not mean they will whip out an algorithmic puzzle solution on a whiteboard under pressure. I also suspect that those experts have better things to do than get a job at Google. They'd rather not go through this process. Google wants them to be there not the other way around. There are several problems with your and the parent commenter's approach here: 1 You've not defined intelligence in an agreeable way, such that all parties are discussing the same thing you seem to have interpreted his point about Sundar Pachai as successful due to being CEO of Google, but that may not be the case.

Can we positively correlate corporate success with intellectual formidability? But you can't discriminate between the relative intelligences of members in this group, especially remotely on a forum, which makes this an issue even if 1 and 2 are solved. I know, taking dialectics this seriously on an internet messageboard is a major pain in the ass. But this brings us full circle to software engineering interviews. One person mentioned a potential proxy for intelligence they consider self-evident, someone else argued against it without full and transparent clarification, and the cycle continues.

This is how whiteboard interviews were born, this is how they became controversial, and this cycle continues even on discussions of whiteboard interviews. People who want to filter for "intelligent" in their interviewing process can't define the term. People who come up with methodologies for assessing it, or identify proxies to it, can't prove they work.

People who argue against these assessments or proxies can't prove they don't work because no one can even agree on what should be assessed. It's a Wittgensteinian clusterfuck all the way down, but the same human habits that gave rise to whiteboard interviews are perfectly manifested in the counterculture reaction to them and the resulting controversy. I propose instead that you resist the temptation to use the word "smart", even in situations you'd consider the quality self-evident.

## Top 100 Data Structure and Algorithm Interview Questions for Java Programmers

When you appease everyone's inclinations and talk about it without defining it, madness ensues. Rigorously define a problem space, correctly map a set of empirically measurable capabilities to it, and hire people who demonstrate those capabilities. But don't use descriptions like "smart" which mean everything to everyone.

My last line was, "Perhaps stop correlating wrong things together? My intention was to indicate that the person who wrote about Sundar Pichai is trying correlate something about the Google CEO to my original comment about aqui-hires. It was not an exercise to define intelligence. I simply had to point out naivety of any correlations the parent commenter was trying to make. Again, there was no exercise to define intelligence.

Same response as above. Interesting you bring this up. Let us play a thought experiment. Who would you rather work with? A person who wrote a VM for handling their cross-platform message queue but couldn't solve N-Queens problem 2. Why is data king? Have test scores ever been a representative of smartness? Is a person with 3. If your answer to above question is no.

Because, in that GPA competition, candidate 2 will win. But you didn't want to work with candidate 2 did you? BurningFrog on Apr 17, Companies that hire the best engineers already use better processes. How can we check this to be true?

## Data Structures & Algorithms Interview Questions You'll Most Likely Be Asked

You probably have to become a real good engineer, or work among them, to see it. How does this prove or disprove anything about the process they use? So what approach do you suggest for the interview process? How has it been your experience hiring under this process? Without spoilers, here's an outline of an interview problem I did last Friday: 1 Here is a very small VM fewer registers and fewer instructions than you can count on your hands.

Write an interpreter for it. Write a program analysis which will detect the property soundly and completely. Managing to finish 3 relies on knowing about certain fundamental concepts from automaton theory and program analysis. The company does actually use this knowledge regularly, so it makes sense that they'll ask. However, even parts 1 and 2 actually manage to test basic programming in a reasonable way. You were lucky! Last time i did an interview problem with a weird machine, i didn't have any registers at all!

And only three instructions, none of which were arithmetic! By the end the interviewer was telling it was all right for me to have mistakenly thought the registers were bit words, and thus concluded the machine wasn't quite Turing-complete, and he was noting that our analysis should still work for the Turing-complete version with bignum registers. What do you work on? Can I interview with you? I was the one interviewing for a job!

But, we can have even better performance. The given sum can be represented as a 1x5 matrix of ones multiplied by a 5x1 matrix of previous elements. If we use the previously mentioned optimal approach for calculating pow A, N , this solution has an O log N time complexity. We have to keep in mind that this does have a high constant bound to this complexity, since matrix multiplication takes time. But, for a large enough N, this solution is optimal. Both Red-Black Trees and B-Trees are balanced search trees that can be used on items that can have a comparison operator defined on them. They allow operations like minimum, maximum, predecessor, successor, insert, and delete, in O log N time with N being the number of elements.

Thus, they can be used for implementing a map, priority queue, or index of a database, to name a few examples. Binary Search Trees use binary trees to perform the named operations, but the depth of the tree is not controlled - so operations can end up taking a lot more time than expected.

Red-Black Trees solve this issue by marking all nodes in the tree as red or black, and setting rules of how certain positions between nodes should be processed. This is the ideal structure for implementing ordered maps and priority queues. B-Trees branch into K-2K branches for a given number K rather than into 2, as is typical for binary trees. Other than that, they behave pretty similarly to a binary search tree. This has the advantage of reducing access operations, which is particularly useful when data is stored on secondary storage or in a remote location.

This way, we can request data in larger chunks, and by the time we finish processing a previous request, our new request is ready to be handled. This structure is often used in implementing databases, since they have a lot of secondary storage access. What are the Dijkstra and Prim algorithms, and how are they implemented? How does the Fibonacci heap relate to them? Dijkstra is an algorithm for finding single source shortest paths.

Prim is an algorithm for finding minimum spanning trees. Both algorithms have a similar implementation. Both algorithms form a tree by taking branches with the smallest price from the MinHeap. In Dijkstra, the point closest to the starting point has the smallest price, while in Prim the point closest to their parent has the smallest price. Thus, the heap can have as many item additions as there are edges in the graph.

The bottleneck is the fact that, in the worst case, we will add all edges to the heap at some point. Multiple edges can point to one vertex, so all but one edge pointing to that vertex will be thrown away in the visited check. This operation has the complexity of O log V.

In a Fibonacci Heap this operation has an O 1 complexity. What is the Bellman-Ford algorithm for finding single source shortest paths? What are its main advantages over Dijkstra? The Bellman-Ford algorithm finds single source shortest paths by repeatedly relaxing distances until there are no more distances to relax. Relaxing distances is done by checking if an intermediate point provides a better path than the currently chosen path.

After a number of iterations that is slightly less than the node count, we can check if the solution is optimal. If not, there is a cycle of negative edges that will provide better paths infinitely long. This algorithm has the advantage over Dijkstra because it can handle graphs with negative edges, while Dijkstra is limited to non-negative ones. The only limitation it has are graphs with cycles that have an overall negative path, but this would just mean that there is no finite solution.

So this algorithm should be used only when we expect negative edges to exist. It does this by employing a heuristic that approximates the distance of a node from the goal node. This is most trivially explained on a graph that represents a path mesh in space. If our goal is to find a path from point A to point B, we could set the heuristic to be the Euclidean distance from the queried point to point B, scaled by a chosen factor. This heuristic is employed by adding it to our distance from the start point.

Beyond that, the rest of the implementation is identical to Dijkstra.

### Bestselling Series

We are given an array of numbers. How would we find the sum of a certain subarray? How could we query an arbitrary number of times for the sum of any subarray? If we wanted to be able to update the array in between sum queries, what would be the optimal solution then? The first problem consists of calculating the sum of the array. There is no preprocessing involved and we do one summing operation of O N complexity. The second problem needs to calculates sums multiple times.

Thus, it would be wise to perform preprocessing to reduce the complexity of each query. Now each element k stores the sum of a[0:k]. The hardest problem is responding to an arbitrary number of data updates and queries. First, let us look at the previous solutions. The first solution has O 1 insertion complexity, but O N query complexity. The second solution has the opposite, O N insertion and O 1 queries. Neither of these approaches is ideal for the general case. Ideally, we want to achieve a low complexity for both operations.

A Fenwick tree or binary indexed tree is ideal for this problem. Now we can easily calculate the sum by following M until we reach 0. Updates are done in the opposite direction. You need to design a scheduler that to schedule a set of tasks. A number of the tasks need to wait for some other tasks to complete prior to running themselves. What algorithm could we use to design the schedule and how would we implement it? What we need to do is a topological sort. We connect a graph of all the task dependencies. We then mark the number of dependencies for each node and add nodes with zero dependencies to a queue.

As we take nodes from that queue, we remove a dependency from all of its children. As nodes reach zero dependencies, we add them to the queue. Otherwise, we have a solution:. You are given a matrix of MxN boolean values representing a board of free True or occupied False fields. Find the size of the largest square of free fields.

A field with a True value represents a 1x1 square on its own. If those three fields are all bottom-right corners of a 5x5 square, then their overlap, plus the queried field being free, form a 6x6 square. We can use this logic to solve this problem. Now, size[x, y] represents the largest square for which the field is the bottom-right corner.

Tracking the maximum number achieved will give us the answer to our problem. You are given the task of choosing the optimal route to connect a master server to a network of N routers. The routers are connected with the minimum required N-1 wires into a tree structure, and for each router we know the data rate at which devices that are not routers that are connected to it will require information. That information requirement represents the load on each router if that router is not chosen to host the master. Determine which router we need to connect the master to in order to minimize congestion along individual lines.

First we form an array of connections for each router connections variable. In the tree of routers, these are the leaf nodes. We start from each leaf node and prune the tree along the way, ignoring pruned nodes. Overall load minus outbound data is the data the router will receive from the leftover branch if it hosts the master server. We can then use a for loop to find the leftover branch, add the outbound data to its influx, prune the branch, and check if the other router becomes a leaf node if it is added to the queue.

At the end, we retrieve the node with minimum congestion. Throughout the whole algorithm, the congestion variable held an array, whereby each element represents the load on the most loaded branch if that router holds the server. The algorithm runs at O N time complexity, which is as efficient as we can get. Pseudocode for the solution is as follows:. A significantly large static set of string keys has been given, together with data for each of those keys.

We need to create a data structure that allows us to update and access that data quickly, with constant time even in worst cases. How can we solve this problem? The problem presented is a problem of perfect hashing. We do a similar approach as a normal HashTable, but instead of storing collisions in a list, we store them in a secondary HashTable.

We choose primary hashing functions until all buckets have a relatively small number of elements in them. Even though this seems to result in high memory complexity, expected memory complexity is O N. This makes it easy to choose hashing functions that will not result in collisions. You have a set of date intervals represented by StartDate and EndDate.

How would you efficiently calculate the longest timespan covered by them? Take first interval as actual range. Loop over intervals and if the current StartDate is within the actual range, extend EndDate of the actual range if needed and extend maximal timespan achieved so far if needed.

Otherwise, use current interval as new actual range. Time complexity is O N. How do Insertion sort, Heapsort, Quicksort, and Merge sort work? Let us first design an approach with optimal worst case time.

An example of what we want to achieve: Array: -7 4 -3 2 2 -8 -2 3 3 7 -2 3 -2 Sorted: -2 -2 -2 2 2 -3 3 3 4 -7 7 -8 We see that after our special sorting method, we have [-2, 2], [-3, 3] and [-7, 7] combinations happening consecutively exactly once. What is the best use case for each of them? For the sake of notation, let us represent the length of the array as N. Determine if two rectangles intersect. Give an algorithm to solve this problem when rectangles are defined by their width, height, and x, y coordinates of their top-left corners.

Give another algorithm where rectangles are defined by their width, height, and x, y coordinates of their centers.