
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 60-lesson course built from freeCodeCamp.org's 12h 31m of YouTube video. 8 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by freeCodeCamp.org on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Understand the course structure, enrollment process, and how to run Jupyter notebooks on the Jovian platform using Binder.
Apply a systematic 6-step problem-solving strategy to implement and test linear search, including writing test cases and analyzing O(n) time complexity.
Implement binary search on a decreasing-order list, handle edge cases like duplicates and missing elements, and analyze O(log n) time complexity.
Create a reusable generic binary search function using closures, then adapt it to find first and last positions of a target in a sorted array with duplicates.
Complete the binary search assignment by implementing linear and binary search, handling collisions in rotated arrays, and submitting via Jovian commit.
Complete the binary search assignment by implementing linear and binary search, handling collisions in rotated arrays, and submitting via Jovian commit.
Complete the binary search assignment by implementing linear and binary search, handling collisions in rotated arrays, and submitting via Jovian commit.
Learn binary search tree properties, implement BST node class with key-value pairs, and understand balancing for O(log n) operations.
Learn binary search tree properties, implement BST node class with key-value pairs, and understand balancing for O(log n) operations.
Learn binary search tree properties, implement BST node class with key-value pairs, and understand balancing for O(log n) operations.
Learn binary search tree properties, implement BST node class with key-value pairs, and understand balancing for O(log n) operations.
Learn binary search tree properties, implement BST node class with key-value pairs, and understand balancing for O(log n) operations.
Implement insert, find, and update in a BST; analyze O(n) worst-case for unbalanced trees; introduce self-balancing AVL trees and rotations.
Implement insert, find, and update in a BST; analyze O(n) worst-case for unbalanced trees; introduce self-balancing AVL trees and rotations.
Implement insert, find, and update in a BST; analyze O(n) worst-case for unbalanced trees; introduce self-balancing AVL trees and rotations.
Implement insert, find, and update in a BST; analyze O(n) worst-case for unbalanced trees; introduce self-balancing AVL trees and rotations.
Implement insert, find, and update in a BST; analyze O(n) worst-case for unbalanced trees; introduce self-balancing AVL trees and rotations.
Build a Pythonic TreeMap class with special methods (__getitem__, __setitem__, __iter__, __len__), then begin Assignment 2 on hash tables.
Build a Pythonic TreeMap class with special methods (__getitem__, __setitem__, __iter__, __len__), then begin Assignment 2 on hash tables.
Build a Pythonic TreeMap class with special methods (__getitem__, __setitem__, __iter__, __len__), then begin Assignment 2 on hash tables.
Build a Pythonic TreeMap class with special methods (__getitem__, __setitem__, __iter__, __len__), then begin Assignment 2 on hash tables.
Build a Pythonic TreeMap class with special methods (__getitem__, __setitem__, __iter__, __len__), then begin Assignment 2 on hash tables.
Implement hash tables with linear probing for collision resolution, create get_valid_index, and build a probing hash table class.
Implement hash tables with linear probing for collision resolution, create get_valid_index, and build a probing hash table class.
Implement hash tables with linear probing for collision resolution, create get_valid_index, and build a probing hash table class.
Implement hash tables with linear probing for collision resolution, create get_valid_index, and build a probing hash table class.
Implement hash tables with linear probing for collision resolution, create get_valid_index, and build a probing hash table class.
Implement __getitem__, __setitem__, __iter__ for a dict-like interface, test with bonus questions, and submit Assignment 2 via Jovian.
Implement __getitem__, __setitem__, __iter__ for a dict-like interface, test with bonus questions, and submit Assignment 2 via Jovian.
Implement __getitem__, __setitem__, __iter__ for a dict-like interface, test with bonus questions, and submit Assignment 2 via Jovian.
Implement __getitem__, __setitem__, __iter__ for a dict-like interface, test with bonus questions, and submit Assignment 2 via Jovian.
Implement __getitem__, __setitem__, __iter__ for a dict-like interface, test with bonus questions, and submit Assignment 2 via Jovian.
Analyze bubble sort O(n²) inefficiency, implement merge sort with O(n log n) time and O(n) space, and introduce quick sort for in-place sorting.
Analyze bubble sort O(n²) inefficiency, implement merge sort with O(n log n) time and O(n) space, and introduce quick sort for in-place sorting.
Analyze bubble sort O(n²) inefficiency, implement merge sort with O(n log n) time and O(n) space, and introduce quick sort for in-place sorting.
Analyze bubble sort O(n²) inefficiency, implement merge sort with O(n log n) time and O(n) space, and introduce quick sort for in-place sorting.
Analyze bubble sort O(n²) inefficiency, implement merge sort with O(n log n) time and O(n) space, and introduce quick sort for in-place sorting.
Implement quick sort with random pivot partitioning, analyze average O(n log n) vs worst O(n²), and optimize with min-heap for O(n log n) guaranteed.
Implement quick sort with random pivot partitioning, analyze average O(n log n) vs worst O(n²), and optimize with min-heap for O(n log n) guaranteed.
Implement quick sort with random pivot partitioning, analyze average O(n log n) vs worst O(n²), and optimize with min-heap for O(n log n) guaranteed.
Implement quick sort with random pivot partitioning, analyze average O(n log n) vs worst O(n²), and optimize with min-heap for O(n log n) guaranteed.
Implement quick sort with random pivot partitioning, analyze average O(n log n) vs worst O(n²), and optimize with min-heap for O(n log n) guaranteed.
Solve Longest Common Subsequence using recursion, identify exponential complexity, apply memoization to achieve O(m*n), and convert to bottom-up DP.
Solve Longest Common Subsequence using recursion, identify exponential complexity, apply memoization to achieve O(m*n), and convert to bottom-up DP.
Solve Longest Common Subsequence using recursion, identify exponential complexity, apply memoization to achieve O(m*n), and convert to bottom-up DP.
Solve Longest Common Subsequence using recursion, identify exponential complexity, apply memoization to achieve O(m*n), and convert to bottom-up DP.
Solve Longest Common Subsequence using recursion, identify exponential complexity, apply memoization to achieve O(m*n), and convert to bottom-up DP.
Implement 0/1 knapsack recursively (O(2^n)), add memoization for O(n*capacity), and build iterative DP table for space-time tradeoffs.
Implement 0/1 knapsack recursively (O(2^n)), add memoization for O(n*capacity), and build iterative DP table for space-time tradeoffs.
Implement 0/1 knapsack recursively (O(2^n)), add memoization for O(n*capacity), and build iterative DP table for space-time tradeoffs.
Implement 0/1 knapsack recursively (O(2^n)), add memoization for O(n*capacity), and build iterative DP table for space-time tradeoffs.
Implement 0/1 knapsack recursively (O(2^n)), add memoization for O(n*capacity), and build iterative DP table for space-time tradeoffs.
Solve minimum edit distance with three recursive choices, optimize from O(3^(n+m)) to O(n*m) via memoization, and implement DP table.
Solve minimum edit distance with three recursive choices, optimize from O(3^(n+m)) to O(n*m) via memoization, and implement DP table.
Solve minimum edit distance with three recursive choices, optimize from O(3^(n+m)) to O(n*m) via memoization, and implement DP table.
Solve minimum edit distance with three recursive choices, optimize from O(3^(n+m)) to O(n*m) via memoization, and implement DP table.
Solve minimum edit distance with three recursive choices, optimize from O(3^(n+m)) to O(n*m) via memoization, and implement DP table.
Represent graphs with adjacency lists/matrices, implement BFS/DFS for traversal and cycle detection, and apply Dijkstra's algorithm for weighted shortest paths using min-heap optimization.
Represent graphs with adjacency lists/matrices, implement BFS/DFS for traversal and cycle detection, and apply Dijkstra's algorithm for weighted shortest paths using min-heap optimization.
Represent graphs with adjacency lists/matrices, implement BFS/DFS for traversal and cycle detection, and apply Dijkstra's algorithm for weighted shortest paths using min-heap optimization.