Two students get the same question in a TCS coding round: does any pair in this big array sum to a target? Both write correct code. One checks all pairs — and times out on the hidden large test. The other sorts and walks two pointers — and passes everything. Same question, same language, same day. The difference was the algorithm: the strategy chosen before the first line of code.
This is a complete, free algorithms course you can learn from without a teacher, a playlist, or prior DSA experience. And it makes one promise the usual resources don't: you will never be shown a clever solution cold. Every lesson starts from the solution YOU would naturally write, shows with real numbers why it's slow, and then walks to the fast idea one observation at a time — so every algorithm feels discovered, not memorised.
First, what is an algorithm, really?
A precise strategy for turning input into output — recipe-level precise. For any real job several strategies exist, and they differ in cost by factors of a lakh at real input sizes. Feel the entire course in one runnable taste:
import time, random
arr = sorted(random.sample(range(10_000_000), 100_000))
target = arr[99_000] + arr[99_001]
# Strategy 1: your natural first idea — check all pairs
t = time.perf_counter()
found = any(arr[i] + arr[j] == target
for i in range(len(arr))
for j in range(i + 1, len(arr)))
print("all pairs :", round(time.perf_counter() - t, 2), "s")
# Strategy 2: two pointers on the sorted array
t = time.perf_counter()
lo, hi = 0, len(arr) - 1
while lo < hi:
s = arr[lo] + arr[hi]
if s == target: break
lo, hi = (lo + 1, hi) if s < target else (lo, hi - 1)
print("two pointers:", round(time.perf_counter() - t, 4), "s")Result
all pairs : 21.4 s two pointers: 0.011 s
exact timings vary — the ratio is the point
Two thousand times faster — same data, same answer, different strategy. By lesson 3 you'll be able to invent that second strategy yourself, because you'll have seen exactly which wasted work it removes.
Why learn algorithms (seriously)
Placement season says it plainly: the coding round is an algorithms round. Service companies (TCS NQT, Infosys, Wipro, Accenture) hide one large test case that kills brute force; product companies (Google, Amazon, Microsoft, Meta, Flipkart) build entire interviews around technique choice and complexity reasoning. No subject pays more per hour of honest preparation. Pair this course with the TCS NQT, Infosys and Wipro guides once your target list firms up.
How this course teaches
Every lesson follows the same honest path: a situation you recognise → your natural first solution → why it's slow, with real numbers → the key observation → the algorithm → a dry run you can reproduce with a pen → code explained piece by piece → edge cases ("what if…?") → how to recognise the pattern in a fresh problem. Nothing arrives before the pain it cures, so nothing has to be memorised — the code rebuilds itself from the why.
Along the way: diagrams wherever a picture beats a paragraph, think-along pauses ("pause — what would you do here?"), and every lesson ends with a Practice Zone — six MCQs whose explanations teach the trap, plus hands-on coding tasks with fully traced solutions, each tagged with logos of the companies reported to ask it. Attempt first, reveal after; the wrong attempts are where the learning is.
The full roadmap
| # | Lesson | You'll be able to… |
|---|---|---|
| 1 | Sorting Algorithms | see why n² sorts die and n log n sorts don't |
| 2 | Binary Search | halve a crore to one in 24 steps — without off-by-ones |
| 3 | Two Pointers & Sliding Window | turn O(n²) pair and subarray scans into one pass |
| 4 | Recursion & Backtracking | trust the recursive leap; list ALL options safely |
| 5 | Divide & Conquer | split, solve, combine — and read off the n log n |
| 6 | Greedy Algorithms | know when grabbing the best-now is provably enough |
| 7 | Dynamic Programming | stop re-solving subproblems; write your first DP |
| 8 | DP Patterns | recognise knapsack, LCS, LIS under any costume |
| 9 | Graph Traversal: BFS & DFS | explore anything connected; win grid and island problems |
| 10 | Shortest Paths & MST | run Dijkstra by hand; pick Prim vs Kruskal with reasons |
| 11 | Bit Manipulation | use XOR, masks and shifts like a native |
| 12 | Problem Patterns & Interview Strategy | diagnose a fresh problem in a minute; perform under pressure |
Company-wise PYQ pages
After the lessons, mock-interview yourself company by company — three real-pattern questions each, attempt-first then reveal: Google, Amazon, Microsoft, Meta, Apple, Adobe, Flipkart, Salesforce, TCS and Wipro.
How to study this course
Go in order — lesson 7 leans on 4, lesson 10 leans on 9. Run every snippet yourself; typing it is half the learning. When a lesson shows a dry run, reproduce it on paper before moving on — an algorithm you can trace with a pen is an algorithm you can debug under pressure. When a lesson pauses to ask what you would do, actually stop and commit to an answer: being wrong there costs nothing and teaches the most. And don't memorise code — own the why, and the code rebuilds itself in the exam hall.
FAQ
Do I need the Data Structures course first?
Strongly recommended — algorithms act ON structures. BFS needs queues, Dijkstra needs heaps, Kruskal needs union-find, and this course uses them without re-teaching. If you haven't, start with the Data Structures course — the two cross-link at every seam.
Do I need to be good at maths?
No. The heaviest maths here is "halving 1 crore 24 times reaches 1". Everything is taught by counting real operations on small examples — no proofs, no derivations. If you can compare 10 crore with 17 lakh, you have the prerequisites.
Why Python? My interviews allow Java/C++.
Python reads closest to plain thought, so the strategy — not the syntax — stays in focus. Every idea transfers: binary search is binary search in any language, and the complexity tables are language-independent. Where Python has a sharp edge of its own, the lesson says so explicitly.
Is dynamic programming really as hard as people say?
It has a scary reputation because it's usually taught backwards — table first, reason never. Here it arrives in lesson 7 as one observation on top of recursion you already own from lesson 4: stop re-solving the same subproblem. Students who follow the order rarely find DP the hardest lesson.
Start here: Lesson 1: Sorting Algorithms →