✨ Level | 🕗 Duration | 💻 Practice |
Intermediate | 4-8 months | 400+ coding exercises |
Welcome to a comprehensive course on Algorithms and Data Structures. By the end of the course, you’ll have enough knowledge to massively optimize programs, develop an intuition of how efficient each program is, and ace interviews at top tech companies like Google, Meta, Amazon, etc. The course starts from the basics of algorithms and data structures and dives deep into the most popular topics in the field.
Large tech companies like Google, Meta, Netflix, and Amazon conduct their interviews checking for deep knowledge of data structures and algorithms. Completing this course will make sure you are prepared for those interviews.
📚 Prerequisites
This course is designed for people who already have some background in a general-purpose programming language (like Python, C++, Java, or C#), and would like to dive deep into the world of algorithms and data structures. Before starting this course, you should feel confident with working with loops, creating functions, and using the built-in data structures (like lists, sets, or maps).
🤩 Outcomes
By the end of this course, you’ll know how to use various popular data structures to write efficient algorithms that would perform an order of magnitude faster than naive solutions. We will cover best practices for writing code for algorithms and how to prepare for algorithmic interviews.
This course focuses on the mastery of each concept. So, you will work with different algorithms and will implement their variations to solve many problems to fully master each of those.
💻 Learn By Doing
The goal of learning algorithms isn’t just learning the theory.
The goal is to develop problem-solving skills.
In this course, you learn by doing! Each concept has several interactive challenges that you will solve to pass on to the next one. In fact, there are more than 400 practical coding problems in this course. We believe that hands-on learning is the best way to get in-depth knowledge. Here you will have many challenging and at the same time interesting exercises to practice each and every concept that is covered.
⚡ Study At Your Own Pace
You can go hard and complete several levels in one week, or take it slow and focus on each concept for longer. You get to decide the pace that works for you. The only requirement to successfully finish the course is consistency. Practicing 1 or 2 hours every day has tremendously higher returns than practicing once a week for several hours.
To make sure you don’t get stuck, there is a forum to ask questions. You can ask questions or help others by answering theirs under each challenge.
🎓 Curriculum
This course focuses on the core concepts of Data Structures and Algorithms and introduces each of them in an intuitive manner. To make the process more fun and engaging, the concepts are organized into levels, and passing each level means you’ve mastered a new concept. These are the main things we will be covering here:
Implementation problems
- The algorithm is stated right in the problem
- Work with basic data structures like arrays, dictionaries, sets, etc.
Bitwise operations
- The binary representation of numbers (int → bin, bin → int conversions)
- Negative numbers in binary
- Bitwise operations OR, AND, XOR
- base-k representation (base-10 → base-k, base-k → base-10)
Prefix sums
- 1D Prefix sum
- 2D Prefix sum
Sliding window / Two pointers
- Sliding window to find the sum
- Sliding window to find unique values
Number theory
- Primality check - ,
- Sieve of Eratosthenes
- Prime factorization
- Greatest Common divisor (GCD) and Least common multiple (LCM)
- Modular arithmetic
Binary Search
- Linear Search VS Binary Search
- Finding a value in a sorted array with a binary search
- Finding a floating-point number with precision
- Including the left endpoint VS including the right endpoint in the answer
- Binary search the answer
Sorting
- Bogosort
- Selection sort
- Insertion sort
- Bubble sort
Greedy Algorithms
- Follow a greedy strategy
- Greedy heuristics
Dynamic Programming
- 1D Dynamic programming (Fibonacci, etc)
- Coin change (min coins)
- Coin change (number of ways)
Recursion
- Branching factors
- Gray code
- Towers of Hanoi
- Recursive division of a problem into subproblems
Divide & Conquer & Advanced Sorting
- Merge sort
- Quick sort
- In-place sorting
- The complexity of a comparison-based sorting is always ≥
Linked List
- Nodes and links
- Traversal and search
- Delete and insert operations
Queue & Stack
- Insertion and pop order
- Optimizing search with a stack
Binary Tree & Binary Search Tree (BST)
- Construction of a binary tree
- Searching in a binary tree
- Update and delete elements from a tree
Heap
- Heapify
- Heap sort
Hashing
- Hashing functions
- Collisions
Advanced Dynamic Programming
- Edit Distance
- Knapsack problem
- Longest Increasing Subsequence
- Efficient multiplication of
nmatrices
Graph Representations
- Adjacency matrix
- Adjacency list
- Edge list
- Degrees of vertices
Breadth-First Search (BFS)
- BFS on graphs
- Finding the shortest path
- BFS on a grid
- BFS on other structures
Depth-First Search (DFS)
- Connectedness
- Cycles
- Topological sort
- Bipartidness
Trie
- String searching
Dijkstra
- Finding the shortest path in a weighted graph
- Tricks to use in different problems to simplify and improve the running time of a program
Backtracking
- N Queens
- Graph coloring
- Filling out grids with values
Segment Tree
- Basic segment tree - construct, get, update
- Range queries and value updates
- Binary search on a prefix
- Store multiple values in a node
- Preprocess the input and then use a segment tree
Algorithm Complexity
- Big notation formalized
- P vs NP
🚀 Welcome
Learning is 80% individual work. Completing this course will be your accomplishment and we’re here to support that journey!