None. Not one. Or more precisely, I wouldn’t ask him about any.

(I use the male pronouns below, because I find it awkward to be gender neutral — and besides, the actual candidate identified as male.)

When I interview someone, I want to know what he’s done, how he’s done it, how he thinks.

Me: Tell me about a project you’ve worked on.

Him: I developed a system for the control of a five stand copper rolling mill for a system integrator.

Me: What was your role in the project?

Him: I was brought onto the project after a previous developer worked on a time and material basis for many months and delivered nothing. The client and I met multiple times and hammered out a hardware design. We chose to use three Z-80 microprocessors. One controlled the first three stand, a second controlled the last two stands, and the third handled the overall command and control of the system. I chose the processor, defined the hardware interfaces, and was the sole software developer.

Me: Tell me about the software.

Him: The software was written in assembly language. I developed a real-time task scheduler — there’s a paper by Butler Lampson with the outline of a design I stole — that was installed on the three processors. The task scheduler is interrupt driven, has a real-time clock driver, serial drivers, and drivers for the display and input devices. It has sixteen priority levels.

Me: How did the scheduler decide which task to run next?

Him: There are sixteen queues, one for each priority. Each queue is organized as a linked list. There are two cases where we must decide which task to run next.

In the first case, a task needs to wait for some event and relinquishes the processor. The running task is no longer ready and is taken off the corresponding priority queue. In that case, we look at the task control block (TCB) for the currently running task to determine which priority queue it is on. Since it is always the first entry on its queue (otherwise it wouldn’t be running), that’s pretty simple. We take the next entry from that queue. (Only tasks that are ready to run are on the queue.) If the queue is empty, we advance to the next lower priority queue. There will always be at least one lower priority task to run because there is an idle task that is always ready.

In the second case, an interrupt or the currently running task causes another task to become ready. The task control block tells us the priority of of the new task. We place that entry on the queue for that priority. If the task is lower priority than the current task, nothing needs to be done. If it is higher priority, the context of the current task is saved in its TCB and the new task is started.

That’s the way I do a technical interview. I would continue to ask about the structure of TCBs, how they relate to priority queues, how the real-time clock event queue is managed, when I have to disable interrupts or use mutexes, etc. I start at the top and drill down into the details.

Notice that I don’t ask about structures and algorithms in the abstract. I ask to tell me about how something was done. If he used some specific structures or algorithms I will learn something about him. If he tells me that he used a red-black tree to maintain a priority queue where there were only sixteen priorities and a total of thirty tasks, that would tell me something.

For what it’s worth, the candidate I was interviewing was myself. The answers I gave were reasonably accurate considering that the project was done when a Z-80 was a new device.

Let me make an analogy.

Mathematics at the undergraduate level is not that hard if you have the knack for it, because it’s pure logic.

Economics can be quite complex because it combines math with subject matter. However, the math in economics is very simple. Overall, that makes the study of economics non-trivial, but not too hard either.

Physics, on the other hand, can be very hard. It combines advanced math with complex subject matter.

Algorithms in computer science are like math. Just pure logic. It’s when you apply them to real-world problems that things become difficult.

The programming equivalent of physics is something like a large distributed system that operates within a complex domain. Not only does it involve advanced algorithmic problems, but one also has to deal with how these algorithms interact with the specific quirks of the domain.

There are different kinds of difficult.

I’m going to focus on two kinds of difficult algorithm.
One is difficult to manage and sometimes even difficult to spot, though not difficult to implement.
The other is a group of algorithms that can be very varied and complex, and also overlaps with the first group.

I would first like to nominate

Computationally complex algorithms.

Starting with any intractable or NP/NP-hard/NP-complete problem.

Because there are actual physical hardware constraints that prevent them from being solved in reasonable time, and you may not always know you’re working on one.

Why? Because they’re deceptively simple brute force algorithms, easy to code, and it would seem, easy for a computer to handle, but they can quickly become unwieldy and slow down your code as the input data increases.

Even a simple O(n^2) problem where the time taken to solve is the square of the data points you’re working on, can give you problems.

Want to code a bullet hell game in C with 50,000 objects on screen? No problemo.
Now try doing collision detection between those objects, and suddenly you’re checking (50,000^2)/2 or 1.25 billion possible collisions.

So the algorithm itself isn’t hard, but you need to understand its computational complexity and find shortcuts like grid based or quad tree collision.

Large numbers of objects usually isn’t an issue for a CPU, but you start connecting those objects together and the number of connections will be an issue.

And this brings me to the second category of difficult problems I’d like to nominate:

Graph based algorithms.

(Which also overlaps with the first quite a bit, plenty of your intractable problems will be found here)

These are algorithms that work on graph structures, which can be visually and structurally complex, as well as requiring computationally complex solutions:

You’re no longer dealing with a list/array or grid of data points, but a complex structure with connections.
You have to generalise your algorithm to work for all structures, or categorise them with one algorithm (Is it a complete graph? is it planar? does it have circuits? or is it a tree?) and approach them differently.

They get very feisty very quickly. This is about 100 data points:

Because there are so many different forms they can take, there is a lot to learn, even the most basic graph theory from a mathematical point of view, gives us a lot of algorithms to study.

Sedgewick’s Algorithms parts 1–4 came in one volume:

Part 5, Graph Algorithms, was a second volume:

That I think says a lot.

—————————-

Edit - so I really appreciate the upvotes and shares.

I should probably also mention some other types of challenging algorithm that aren’t covered by computationally complex or graph algorithms. Those two alone cover a lot, but there are still a few areas that pose their own unique challenges.

1. Parallel programming, which breaks down into things like:
1. Distributed programming, for multiple machines.
2. Multithreading, for multiple CPUs and cores in one machine.
3. Parallel at the hardware level, like GPU shaders.
4. There’s also asynchronous programming, like for example the game engine Godot, that splits up functionality into different servers, or even just dealing with async operations on a webpage.

Each of the above provides challenges, and requires the use of a completely different approach due to the parallel nature of the system. Either you don’t have access to the surrounding operations, as with c) above, or you’re working with events that don’t have a specified order, as with d), and in the case of a) and b) it could be both.

Shaders are the most incredible programs and the purest expression of parallel algorithms at work, but they can be very tricky to work with. A fragment shader outputs just one pixel, and has no idea what the adjacent pixels are doing. The reason for the odd constraints is the speed.
A 4k screen at 120fps is 120x3840x2160 or 995,328,000 pixels that need to be shaded per second, so just under a billion pixels per second for a modern GPU to run a 4k screen at 120fps

..And that's the entire shader, each one could be hundreds of instructions long.

2. Then there’s Functional Programming, which in some ways is less about the algorithms and more about how they are implemented and combined, though it does have its roots in Category Theory, and while the basics are easy to grasp, at the deep end it gets very abstract.
It is all about using functions as building blocks, but also, using them as a datatype in higher order functions (see metaprogramming below) using sequences of functions and combining them to create bigger functions (currying) and then there are monads, and if I told you that: “a monad is just a monoid in the category of endofunctors”, you would be as confused as I am.

Lisp was the first well know functional language, but Haskell is more modern and I guess purer in its approach. Though you can use functional paradigms in other modern languages, Java and C++ have added functional operations now, and Javascript has kinda had it from the beginning, with it’s functions being datatypes or first class citizens.
I personally prefer a language that allows it but doesn’t force it on you.

3. Finally, there’s Metaprogramming. Programs that work on code, or create/modify their own code. Related to that is Self-Reference, Recursion, Reflection, Introspection, Quines, Higher Order Functions, Genetic Programming and Code as Data in general.
There’s a lot of jargon there for those that want to take a deeper dive.
In simple terms, algorithms that treat programs as data are a massive rabbit hole, and by their very nature can be incredibly complex and difficult, but also one of the most fascinating areas of software development.
I also think it’s an area that that has the most potential to yield new technologies and will open up more areas of research in AI when the current trends have died down.
See my answer here:

It is only beneficial if you need it.

Otherwise it would be a lot smarter to practice the skills you actually need first.

I have never been asked a single algorithm question during an interview. And I also never asked algorithm questions if I interview someone.

The reason is simple: None of the work that I do or that anyone in my team does requires algorithms.

So I ask about stuff that I know they will need when working in the company:

Multithreading, Localization, Libraries, Architecture, Network protocols, REST APIs, Framework usage, byte twiddling and math and so on.

So no, dont learn random algorithms, learn something useful.

After you have all that down, you can learn algorithms. For yourself, cause I dont care.

There are libraries out there filled with algorithms, the chance you have to write a new one is exactly 0%.

People usually say data structures and algorithms in one same breadth but the coding interview tests slightly different things. Algorithms, the proper use of data structures, some form of pattern recognition / know-how on how to deal with certain forms problems and to some extent domain knowledge.

For algorithms proper, the candidate should know:

• sorting, especially merge sort,
• binary search, tree traversal
• graph traversal - DFS, BFS
• recursion/backtracking, dynamic programming

Candidates should then know when to use / what to do with various data structures like linked lists, arrays, trees, hashes, stacks/queues/heaps and then have some sort of idea of how to use these data structures in an interview. For instance, a pattern which is often used with linked lists is the idea of a slow pointer and a fast pointer. This isn’t really part of the definition of a linked lists but so many linked list problems expect a fast pointer. Likewise, if you have an array of items, you may need to loop through them, some times you need to maintain a left and a right index, sometimes you have to manage nested loop.

Often times the coding exercise represents the world with one data structure which is not useful. The candidate may have to see that there is a much better way to organize the data. For instance, sometimes a graph is a hash table where a key corresponds to a value or another hash table. Sometimes it is an array of values and an array of links between these values. While it’s not too hard to shift from one of these representation to the other, sometimes one would make the exercise much easier.

Complex data structures and algorithms are the crux of all software solutions.

Use of a wrong data structure can bog down the performance of your application significantly.

Now, you might not really apply bubble sort or quick sort as is, but understanding these algorithms help you build your own algorithms.

Interview questions are an effort to figure out how your approach is to a given problem. You might not be able to come up with the right solution, but if the approach you adopted is proper, I believe you should be selected.

For example, if you are asked to write a program

1. Did you ask the right questions about the pre and post conditions?
2. Did you note down the corner cases?
3. Did you write pseudo code before actually writing the program?
4. Did you (if needed) draw a flowchart?

You might not write the program correctly, but the direction is right.

Talking about complex data structures, Blockchain is a complex data structure.

Experience and Intelligence. Everything really isn’t new. pretty much everything is some form of crud with some business rules and a bunch of layers between the datastore and the client. Very little is actually new. Experience before brings about a cycle of understanding what is happening. Intelligence helps because you’ve gone through and learned from other people.

Sure, there are new databases. Sure, there are new client systems. Sure, there is a lot of new stuff, but the actually work really isn’t new.

Let me provide a recent example. I do a lot of scale work, especially with databases. I had a database and a few tables in MySql where I had to query a few million records multiple times via a join. As I added each table into the join, the time to execute went by a factor of about 10–15x. At about the 10 join point, it was a couple of seconds, and the next join made the query take a couple of minutes. Given that I had to join in 36 total tables, I knew that would not work. I added two indexes, the times went down to around 200 ms and stayed there all throughout the rest of the tables. Instead of flailing for some dumb coding exercise of submitting multiple queries like a beginner would, I had the query all setup as a view, and the view returns a full set of data in that 200–250 ms timeframe. How did I know to do that? Experience and intelligence. I’m a smart guy and I’ve had the query performance problem before and knew that indexes would solve it.

In another example, I had a complex operation that knew was an O(n cubed) solution the way I was going to do. I also had enough experience to know that the amount of data was going to be small, so O(n cubed) didn’t really matter. The algo still runs in a couple of seconds vs hours to do it by hand. Experience showed me that the amount of data was not a huge deal inspite of the algo.

Incidentally, we had a Tech Fest at a college today and I was asked to conduct a Web Designing event. I had to give the undergrad students a simple web page designing problem that could be solved and evaluated in 2 hours.

I asked them to build a web page like this MyFridgeFood - Home. The site allows you to choose a few ingredients and then it tells you what preparations are possible with those.

To keep it simple, I asked the students to do everything in one page on the client side itself (using HTML & JavaScript).

The winner’s “algorithm” was very simple. There were N if statements that looked like this:

if (One.isSelected && Five.isSelected && Ten.IsSelected) echo “Sandwich”;

if (Three.isSelected && Five.isSelected && Fifteen.IsSelected) echo “Soup”;

if (Six.isSelected && Twelve.isSelected && Thirty.IsSelected) echo “Cake”;

For students who aren’t living in coding cultures, it is still reasonable given the time constraint.

However, if the same student has to be hired by a company for building a professional product, they have to think and do much better, with just a little extra time and effort.

How would you, as a professional/aspiring web developer, do it? Pause and think before you continue reading.

Here is my approach. Use one bit to represent each ingredient. I can use multiple words (32-bit or 64-bit) to encode and send the user’s complete selection to the server. So, 11000…0001 implies Apples, Avacado and Zucchini were selected (and no other ingredient was selected).

On the server, you do a bit-wise and of the user selection (words) with each recipe/preparation (which is also stored as a collection of words). If you get the recipe words back after the bit-wise and, it implies that the recipe is possible with the user selection.

Of course, you could choose to do it differently. If you don’t want to play with bits, you can pass the user selection as an array of ids (each ingredient has an id instead of a designated bit) and do the intersection on the server with each recipe/preparation array.

Now, when you were taught bit manipulations in C, you weren’t told if it could/should be used in web designing. You were just made aware of the provisions in a programming language and things were left to your imagination.

So, it is up to the developer to put data structures and algorithms to good use regardless of whether they are in to web or device driver development. The idea behind modern day coding interviews is to check this ability.

For a computer science graduate with a basic programming background, it's required to start with interview questions that assess fundamental concepts rather than diving into advanced algorithms and data structures. Here are some good interview questions suitable for such candidates:

Basic Programming Concepts:

Explain the difference between a compiler and an interpreter.

What are variables, and how do they work in programming languages?

Describe the difference between pass-by-value and pass-by-reference.

Write code to swap the values of two variables without using a temporary variable.

What is the significance of the main() function in C/C++?

Control Structures:

What are conditional statements (if-else) in programming? Provide an example.

Describe loops (for, while, do-while) and give examples of when to use each.

Data Types and Data Structures:

Differentiate between arrays and linked lists.

Explain the concept of an array index and how it relates to accessing elements.

What is a stack, and how does it work? Provide examples of its use.

Functions and Recursion:

What is a function, and why is it useful in programming?

Explain the concept of recursion with an example.

Basic Algorithms:

Write an algorithm to find the maximum value in an array.

Describe a linear search algorithm and provide its time complexity.

What is a sorting algorithm? Explain the bubble sort algorithm.

Basic Complexity Analysis:

What is Big O notation, and why is it important?

Compare the time complexity of linear search and binary search.

Memory Management:

What is dynamic memory allocation, and how is it different from static memory allocation?

Explain the concept of memory leaks and how to avoid them.

Object-Oriented Programming (OOP):

Describe the principles of OOP, including encapsulation, inheritance, and polymorphism.

Error Handling:

What is exception handling, and why is it important in programming?

Problem-Solving:

Given a simple problem statement, the candidate is asked to design an algorithm and write code to solve it. This could be something like finding the sum of all even numbers in an array or reversing a string.

You need to adapt the difficulty level of these questions based on your programming background and the specific role you're being hired for. These questions should serve as a starting point to gauge understanding of foundational concepts before delving into more complex algorithms and data structures. In order to be prepared for job interviews in tech companies you can enroll in professional online platforms that provide comprehensive Data structure and Algorithms courses along with interview preparation. Some of these platforms are Udemy, Expertifie, Coursera, Educative, etc.

One day my father bought me some lunch at a ski place. It cost $22. My dad gave a ten and a twenty to the cashier. The cashier was going to hand him $8 back, but realized they were out of ones. (They could only make a 5+1+1) .

So my dad says, “give me a ten and I’ll give you a two” 10 - 2 = 8. The cashier says “no that will not work”, the customers surrounding them agree, and the cashier proceeds to spend five minutes getting fresh one-dollar bills.

When my dad got back to the table, he said “American’s can’t do math”

Little did I know, the cashier was not doing math. No, she was using an algorithm: the cashier’s algorithm.

Take the largest bill possible, and continue until you give the amount. By using the algorithm, the cashier never had to do more than basic thinking. Need to make 22? Take a $20 bill and two $1 bills. 8 is just 5+1+1+1 (if you don’t have $2 bills :). And here’s the kicker: it is optimal.

But what about Chicken McNuggets? Chicken McNuggets come in packs of 4, 6, 9, and 20. What if I wanted to make 22? I would take 9, 9, and 4. 9+9+4 = 22. But using the cashier’s algorithm, I would take 20, then… I would be stuck. Here, the cashier’s algorithm is not optimal.

An algorithm is nothing but a procedure to produce some useful solution or solve some task. Start with algorithms that sort and search. Then maybe try some greedy algorithms, which are algorithms that choose the best answer at the moment: the cashier’s algorithm is a greedy. Then try to do dynamic programming, graph algorithms, string, and other common topics. You will be ready then.

The internet is your friend. Look at topcoder data science tutorials.

Oh, and make sure the algorithm is correct.

Cashiers at McDonalds live the hard life.

P.S The “ski place” was not McDonalds, that was another example.

Yes, but you don't learn algorithms to interview questions, you learn how to improve your coding. In your day-to-day work, you may not need to implement or do algorithm-related work, but that's at the core of programming, an algorithm is simply a sequence of steps to solve a problem. that will improve your coding. When you solve an algorithm problem, you need to clarify a problem, define the input, the input, a test case for that problem, you need to analyze the problem, break it down into a small problem. more and handle it. That will help you a lot when you try to solve the real problem. That's why the top company in the world needs you to be strong about it. being good at algorithms can show you are a good problem solver and remember, programming language or framework is just a tool, you need to be able to learn it quickly and not focus too much much on it. You need to focus on programming and problem solving.

Does web development require algorithms?

No. You don’t need an algorithm to make a website for:

• A non-profit organization
• A university department (or university)
• A small business
• A wiki website
• A the list goes on…

A lot of things in web development do require algorithms. For example, if you have an user-authentication system, you’d want to use a hashing algorithm to hash the user’s password instead of storing it as plain text (which is a cardinal sin in web development). However, you DO NOT write the hashing algorithm yourself.

In fact, you’re highly discouraged to write such algorithms yourself. You’d typically use an algorithm written by someone else, a professional who knows exactly what they’re doing. This is usually done through libraries that are widely-used, such as Werkzeug.

Edit: Don’t only think BIG when it comes to web development. There’s no job too small, especially if you’re just getting started. I’ve built websites for all the types of institutions listed above. The majority of the websites on the internet are SMALL websites. Your first website project isn’t going to be the next Quora.

The scope of algorithms asked in coding interviews is very limited. Candidates are not asked to come up with a massive breakthrough in computer science within half an hour. It’s always going to be one of the usual suspects. Without preparation, the vast majority of candidates would fail, and that’s the catch. The assumption is that with the right preparation, and that material is widely available online, the better candidates will be able to identify the problem category, apply the right algorithm/data structure, and implement a solution in a time-effective manner, while other candidates won’t be able to make these connections fast enough or will somehow mess up the implementation.

What’s interesting there is that preparation will trump credentials. Somebody who prepped correctly but who didn’t graduate from a prestigious college or who didn’t work at selective tech companies can do better than someone who has the perfect resume, but hasn’t prepped well.

Uhm… yes and no.

First of all, we have to understand what an algorithm is.

“In mathematics and computer science, an algorithm (/ˈælɡərɪðəm/ (listen)) is a finite sequence of well-defined, computer-implementable instructions, typically to solve a class of problems or to perform a computation”

Algorithm - Wikipedia

So, in this wide definition, a simple sorting operation use an algorithm.

But… when developing a web app, you’ll never write a sort algorithm, you’ll rely on your framework implementation.

More on this: when writing a web app, we are talking about the last layer of our code, which owns the presentation logic. With that in mind, you don’t need a big knownledge on algorithms to implement that.

If you are an intermediate programmer looking to learn or re-learn data structures and algorithms in order to become capable of top companies and competitive programming, the following path may be helpful:

1. Start by reviewing the basics of programming and algorithms. Ensure that you have a solid understanding of programming concepts, such as variables, control structures, loops, functions, and recursion, as well as basic algorithms, such as linear search and binary search.

2. Learn the fundamentals of data structures. Focus on basic data structures, such as arrays, linked lists, stacks, and queues, and understand their implementation and usage in various programming scenarios.

3. Master more advanced data structures. Once you have a good grasp of the basics, move on to more advanced data structures, such as trees, graphs, heaps, and hash tables, and understand how they can be used to solve complex problems.

4. Learn important algorithms. Learn and implement algorithms such as sorting, searching, dynamic programming, and graph traversal algorithms.

5. Practice, practice, practice. Practice coding problems from various sources, including coding challenges on websites like HackerRank, LeetCode, or Codeforces. Solve a wide range of problems from easy to hard.

6. Read and learn from others. Read books, watch tutorials, and learn from others' experiences. A great book for problem-solving in data structures and algorithms is "Problem Solving in Data Structures and Algorithms using Python" by Hemant Jain. This book covers a wide range of topics and provides practical examples and exercises to help you apply your knowledge.

7. Participate in programming contests. Participating in programming contests is a great way to test your skills and gain experience in solving problems under pressure.

By following these steps, you can build a strong foundation in data structures and algorithms and become capable of top companies and competitive programming. Remember to stay persistent and never give up, as mastery of these topics takes time and effort.

How do you learn when to apply which data structures and algorithms to which problems in job interviews?

When you’ve written enough code to learn when to apply which data structures and algorithms to which problems in actual code.

It isn’t like there’s thousands of data structures to learn. You got arrays, linked lists, trees, and hash tables, and that will cover 98% of real-world programming.

The *hard* part is looking at the problem and coming up with “Let’s see, if I make a hash table of wombats, hang a linked list off each entry to allow for duplicates, and then each linked list entry has a pointer to an array of trees, then we can….”

And being able to figure out whether a hash table or a tree would have been more efficient at the top,,, which will require understanding what you’re trying to do with this code.

And all those ninja sort algorithms? You’re *probably* never going to actually code one, instead you’ll just throw it at the runtime library’s default sort function - and if that doesn’t run fast enough or small enough, you’ll use the already debugged code in an additional library.

Now yes, *some* people will be interviewing for jobs where the system sort isn’t fast enough, the libraries aren’t fast enough, and you’ll be writing custom code to sort billions of data points that won’t fit into memory.

But if you’re asking how to learn when to apply which structures and algorithms, you’re probably not the person they’ll hire to write that custom code….

First of all learn HTML and CSS. HTML is the document structure, CSS styles that structure.

jQuery is a javascript library, don't see it independent to javascript. Try to learn javascript first, then you'll see why jQuery id used.

Git is just a way to keep track of what you doing, considering how easy it is (in that in most cases there are only 4 lines of code that you us - others can be easily referenced) learn it after you get your feet wet with HTML and CSS. it is like a camera in the background, it helps take snapshots of your work, so that if you ever mess up your code, you can backtrack to when the code was working.

Angularjs is a javascript framework, very powerful and a joy to work with - but you need to know how to work with javascript.

Bootstrap is just a HTML & CSS library. By using it, you get preset CSS which you can use in your project. Whilst it does save time and so forth, I would highly recommend to not use it, you would not learn anything just by using that. I would strongly recommend to study it, learn from it, wonder how and why their css works.

You did not ask about server side (I assume that's the "etc"). There are a lot of programming language, one is PHP, you can find lists easy, learn one.

If you end up liking JavaScript, you'll find that there are ways to use JavaScript as a server side language, there you get introduced to things like NodeJS.

The way to tackle the confusion is by starting with HTML and CSS. Do few projects with those two, very soon you'll end up with lots of questions: "how can I get my current project to do a, b, c". The answers to those questions will lead you to JavaScript (jQuery) or to PHP and to Databases.

When you start exploring AngularJS you'll end up reading about NodeJS, expressjs, mongoose. But you don't need to worry about all now. Learn HTML and css (with a touch of javascript) first

Note: there are a lot of libraries like bootstrap, I'd ignore them for now (only as I said, if you want to learn by reading their code)

Edited: I forgot to mention css preprocessor. They give more power to css. For example in css we don't have variables or if statements (features of programming languages - don't worry if you don't know what they are). The one I like is SASS, as far as I know is the most powerful one. But of course why would you be interested in learning something that makers something else powerful before you learn the something else in the first place! But when you hear of it, don't dismiss it.

Hope that helps

I would modify the question slightly and answer the same for problem solving. Data structures and algorithms are just different tools that help in problem solving.

Now, is problem solving knowledge necessary for a web developer? Absolutely YES! In fact, it is the most important.

For answering why, just look at any website with some level of complexity and analyse if there are some parts of it which are not that straightforward.

Let’s take a few examples from different fields out there :

1. Gaming: Let’s take a website like Chess.com. Now, before a game starts you are matched with a participant around your rating and the match starts. This matching is not an easy problem to solve considering every person can set a gap of rating with which he/she wants to play. Moreover, after the match is over, predicting how much rating should be added/subtracted also is a complex problem to solve and would require some dsa on past data. Thirdly, analysis of the game using engines would again be based off of some backtracking solution by exploring the possibilities and to be able to predict if the move was correct or not.
2. Food Apps: Finding which active delivery guys should be allocated to which order is not so easy. Even showing relevant restaurants to you when you search for “restaurants selling cakes” is not so easy. There are many parameters to take care of: Restaurant delivery radius, popularity, rating, promoted restaurants, your history of orders, etc.
3. Social Media: Designing your newsfeed itself is really complex. You need to look at so many factors: Is it a post from someone you know? Kind of posts you have interacted with? Kind of posts people like you interacted with? Some ad based on your data history? Something famous in your location? Community? Etc Etc.

So, no matter what kind of system you are creating as a web developer, you will at one point or the other, face a tough problem to solve. Then comes the use of problem solving and some common dsa like graphs, hashing, sorting, searching, recursion, backtracking etc .

Even more importantly, these form the core of the field you are working in. How can you excel in your job if you have not worked on the core skills?

Back just before the Tech Wreck in 2001 I ended up in charge of interviewing at a company of 300 sysadmins. I taught interviewing skills, interviewing legal issues, how to write up interview reports.

When we started hiring Oracle DBAs I was one of the three founding members of the DBA interviewing team. Plenty of the DBAs we hired ended up calling me months or years later to discuss their projects. When we started hiring Cisco network engineers the same thing happened.

I’m an expert UNIX sysadmin with more database proficiency than is average among sysadmins. I’ve done vacation coverage for Oracle DBAs. Oracle is not the only database technology I now. At the time the other database technology I knew was Ingres which was already obsolete.

Any DBA who wasn’t better at Oracle than I was could be easily rejected. All of the good candidates were better. The DBA though not at IT in general.

I said I was going to play the part of a client manager who used to be expert at Ingres and who know Oracle enough to get along. They were to play the part of an Oracle consultant with our company deployed to do some of their DBA work.

I started talking abut problems and various approaches to solving them. I let the discussion flow. Some DBAs ended up talking performance tuning - I eventually got credits on versions of the UNIX performance tuning section of the popular Oracle book. I don’t know SQL tuning but I know the OS end. Some DBAs ended up talking migrations - I ended up published in filesystem migrations of non-database systems so again I knew the OS end but not the DB end.

As long as you are good at what you do you’ll be able to tell who’s BSing you and who’s not. if you have related expertise, use it.

Where I write DBA, fill in whatever developer skill you are interviewing for. Where I write UNIX or OS, fill in yours.

That varies quite extremely depending upon your job.

There are jobs that simply knowing some basic simple algorithms are sufficient, such as an array (or some equivalent structure, like a C++ vector) and looping over it (or calling the relevant functions in the STL). There is a theorem that says you can write any program with just some basic operations like assignment, if statements, and while loops.

In fact, there are whole programming languages that show (Turing completeness, that is the ability to write any program) with only one weird operation. If you follow this link, you can be introduced to them. No one in their proper mind uses them to develop software for any purpose beyond showing a sick sense of humor.

However, that level of knowledge won’t get you many jobs. It certainly, won’t get you a job at a place like Google. It probably won’t even get you an internship, although there are some exceptions like the STEP program that tries to get non-traditional students along the path to becoming a software engineer (or related field).

After learning your first programming language, learning algorithms and data structures is perhaps the most important thing to do. Those are the real tools of the trade. That is about “how to think”. The only thing that competes with it (in my mind) is learning the special idioms of the language.

Some of those special idioms are learning how (and when) to:

1. write a recursive function (almost any language allows that)
2. work with immutable and mutable data (increasingly important)
3. create an object (OO programming languages)
4. deal with pointers or references (most imperative languages)
5. deal with threaded data (futures and promises in Java)
6. write regular expressions
7. use semaphores and protected regions
8. deal with exceptions and error handling
9. assertions, invariants, and induction

But, what algorithms and data structures would I learn first, i.e. along side the above:

1. hashes (how to do things without searches, O(1) versus O(n))
2. queues (how to put things in order, for doing later)
3. stacks (doing things you can walk backward and “undo”)
4. binary trees and binary search (divide and conquer, O(log n), how to balance a tree)
5. general graphs (that matches up with pointers and references)
1. especially trees (and pre-order, post-order, in-order traversals)
2. depth first and breadth first search
6. circular buffers
7. priority queues
8. finite state machines

You may not need to know all those things to get a job, but there is a pretty good chance that if you do enough programming, you will end up using almost everyone of them at one time or another. So, add those to your skill set. That is what I would consider the knowledge base of a competent software engineer. If you can do all those things in a whiteboard interview, you should be able to get (and keep) a job at a place like Google.

And the order of the list is only the order I thought of them in. I would learn dealing with errors very early if I were actually working. And assertions, invariants, and induction are in my mind the most important things to know how to do along with writing unit tests.

By the way, I suspect it takes about 4 years to learn that list. Which is the length of a typical CS bachelor’s degree, and why many employers want that before hiring a person.

I agree that you should not "memorize" a set of textbook algorithms. The goal here should be internalization, which requires more effort.

The more time one spends with algorithms, the better one will learn them and how to use them. It's like running, sports, math, or any other worthwhile discipline in this regard. Natural aptitude exists but matters little in the end compared to the amount of time invested in learning and internalizing them.

In your shoes, I probably would first learn various data structures (linked list, queue, stack, binary tree, hashmap) and their various Big-O attributes for insert, removal, traversal. Then I would move onto sorting algorithms. After that, I would branch into dynamic programming, pattern matching, pathfinding, and so forth depending on my needs.

My experience has been that no single source has helped me internalize concepts. For me, it has been a matter of settling on one concept and sticking to that concept, and googling everything about it starting with its Wikipedia entry, and also coding it in my preferred language, until I "got it." Then move onto the next concept. Go back and review as needed. Memorization is not needed nor the goal nor even always possible. The goal is to develop a big picture understanding to answer questions like "I have an array of numbers that are mostly in order, and I need to sort it. What is the best sorting algorithm to use?"

In some cases, for low-level developers are hired by small companies without attractive perks and other packages (including salary…).

As far as I know, deep understanding of Algorithm and Data structure is required at BIG TECH companies (Fb, Uber, Google, Twitter, Tencent, Taobao…) . About 6 month ago, I applied to small companies and their own interviewers just asked me about experience of using tools, libraries (Django, Python, Magento…), just a small talk via Skype (behavioral questions included), no coding on Google Doc or on whiteboard but in BIG Tech companies, the motto is “Let your code speak for you”. I was interviewed at Google, Twitter, Microsoft and Tencent and I must say ALL questions they asked me were really tough like playing “Hack and Slash” games. Though I got rejected from 3/4 companies but at least, I got a great offer with really attractive perks and salary… :)). Ok , The ability of solving algorithmic questions is required if you wanna get hired by big tech companies, otherwise, basic knowledge of programming is Ok at small companies.

P/S: a capture of email I received from Google recruiter and he recommended me to review only Algorithm and DT.

Hope this help :)

Recently I created a small game where the user has to type a word correctly within a given limit. If he succeeds, the score increases by a factor and if he fails, the game is over. I added a high score functionality where I stored the top 5 scores in the local storage of the browser. So after each game, I had to compare the current score with all the high scores and put it in the correct position (if eligible).

Now how to find the correct position. Since the high scores are sorted in decreasing order of their values, you can do the same with linear search O(n), i.e., by comparing the values of adjacent elements. In my case ’n’ was small, as I was just practising my skills by making a project. But what if it is a real time game, which may involve millions of user data? So I used binary search whose complexity is O(logn).

Hope you get the point. Algorithms help us to solve real world problems and improve the performance of our products using optimization techniques. So you must know at least the basics of time complexity, recurrence relations, searching and sorting algorithms, greedy, dynamic programming, graph algorithms, backtracking, branch and bound, etc. to be a good developer.

Best of luck! Thank You.