Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Let's Learn Algorithms

Let's Learn Algorithms is an interactive blog/screencast series I am experimenting with to help new developers not only learn algorithms, but to also learn how they are implemented, and how to go from a and how to approach problem solving in general. I decided to go ahead with it after receiving positive feedback on reddit here - https://www.reddit.com/r/learnprogramming/comments/56aboa/i_can_understand_the_basic_algorithms_and_how/.

Lessons will likely be done weekly, but that could vary depending on my own schedule. Each lesson will focus on a single algorithm or topic, with the exception being when two algorithms are heavily related and there is a benefit in pairing the two together.

Each lesson will consist of the following pieces:

1. Introduction to the new algorithm

I start each lesson by explaining what the algorithm is, how it works, what it is useful for, and any other important details about the algorithm.

I am aiming to do this in both screencast and written blog format, but that may change over time. If you have a preference please reach out and let me know - jon@calhoun.io.

2. A walk-through showing how to implement the algorithm

I won't use any hand-waving or pseudo-code. I will actually write a working implementation of the algorithm so that you can see exactly how it could be implemented in your own code.

I strongly encourage that you code along (even if in another language) and then try to write the algorithm yourself a few days later without referencing my implementation. This will help make everything stick a little better.

3. Practice problems

On top of an implementation, I will also try to provide 2-3 practice problems that can be solved using the algorithm. I won't exactly say how, and many of these problems could be solved by other means, but I encourage you to try to use the algorithm you just learned to solve the problem.

And don't just solve it conceptually. Actually sit down and code a solution and verify that it works. I may not have a comprehensive test suite for each problem, but I will try to provide you with a few use cases that will help find bugs in your code.

That said, DO NOT rely on the test cases to ensure your code is correct. I suggest that you don't even look at which particular use case your code fails, and instead step back and think "What about my algorithm is fundamentally flawed?" or "What about my implementation differs from the algorithm I had envisioned?"

4. Review of practice problems

I will also post (possibly a week or two later) a follow-up video/article that covers how to solve every practice problem with real code so that you can reference it to verify your solutions, or to help you understand the solutions to problems you couldn't solve.

Name		Name	Last commit message	Last commit date
001_bubble_sort		001_bubble_sort
002_binary_search		002_binary_search
.gitignore		.gitignore
README.md		README.md

Name		Name	Last commit message	Last commit date
001_bubble_sort		001_bubble_sort
002_binary_search		002_binary_search
.gitignore		.gitignore
README.md		README.md

Name		Name	Last commit message	Last commit date
001_bubble_sort		001_bubble_sort
002_binary_search		002_binary_search
.gitignore		.gitignore
README.md		README.md

Name		Name	Last commit message	Last commit date
001_bubble_sort		001_bubble_sort
002_binary_search		002_binary_search
.gitignore		.gitignore
README.md		README.md

Name		Name	Last commit message	Last commit date
001_bubble_sort		001_bubble_sort
002_binary_search		002_binary_search
.gitignore		.gitignore
README.md		README.md

Latest commit

History

Folders and files

Repository files navigation

Let's Learn Algorithms

1. Introduction to the new algorithm

2. A walk-through showing how to implement the algorithm

3. Practice problems

4. Review of practice problems

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Let's Learn Algorithms

1. Introduction to the new algorithm

2. A walk-through showing how to implement the algorithm

3. Practice problems

4. Review of practice problems

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Let's Learn Algorithms

1. Introduction to the new algorithm

2. A walk-through showing how to implement the algorithm

3. Practice problems

4. Review of practice problems

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Let's Learn Algorithms

1. Introduction to the new algorithm

2. A walk-through showing how to implement the algorithm

3. Practice problems

4. Review of practice problems

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Let's Learn Algorithms

1. Introduction to the new algorithm

2. A walk-through showing how to implement the algorithm

3. Practice problems