Placement Prep · India
Every campus and off-campus interview comes down to four rounds: the coding fundamentals, the DSA round, the system-design round, and, increasingly, an AI/ML question. This is a guided path through all four, where you learn each idea by turning a knob and watching it work, the intuition that survives interview pressure, not the definitions you forget by round two.
The DSA core & fundamentals are 100% free. Interview problems don’t care where you studied, only whether you can think.
Before DSA, you have to actually write code and query data. These two rounds sink more candidates than any tree problem, a shaky loop or a botched JOIN ends the interview early. Get fluent first.
This is the round, the one every product and service company runs. You don’t need a thousand LeetCode problems; you need the handful of ideas that generate them. Feel each one, then the patterns click.
The first thing an interviewer probes: will it scale? Watch O(n), O(log n), O(n²) diverge and never guess again.
Halve a sorted array every step, 16 elements in 4 looks. The classic, plus the two off-by-one bugs that trip up half of candidates.
Scan an array once, not k times: slide a window and keep a running sum, add what enters, subtract what leaves. The O(n·k) → O(n) pattern behind a hundred array questions.
Container with most water: two walls bound a rectangle, always move the shorter one. The greedy sweep that turns an O(n²) double loop into a single O(n) pass, and why it never misses the best.
The interview gateway to dynamic programming: fewest coins for an amount. Watch a table fill left-to-right, each cell built from earlier answers, and see why greedy overpays and naive recursion explodes.
Half of graph rounds are one question: shortest path. Watch BFS flood outward in rings and guarantee the shortest route, while DFS dives deep and settles for longer, the queue-vs-stack difference.
Are two things connected? Watch disjoint sets merge as edges stream in, and a redundant edge get caught as a cycle. Almost O(1) per op; the heart of Kruskal’s MST and cycle detection.
Course schedules, build order, dependency resolution, one problem. Watch Kahn’s algorithm peel unblocked tasks into a valid order, and catch an impossible schedule the moment a cycle appears.
“K largest”, “merge K sorted lists”, next-event simulation, all one structure. Watch push bubble a value up and pop-min sift the root down, each along a single O(log n) path. The engine behind every priority queue, Dijkstra and top-k.
“Find the k-th largest” without sorting. Partition around a pivot so it lands at its final index, then recurse into only the half that holds the answer, O(n) average, the go-to for medians, percentiles and top-k.
Sudoku, permutations, word search, all one technique. Place queens column by column, watch them get attacked and back up, and lock into a safe board. The choose / explore / un-choose skeleton behind every backtracking question.
Autocomplete, spell-check, prefix search, one structure. Store words as a tree of characters so shared prefixes are kept once; then insert, look up, and list every completion in O(L), independent of dictionary size.
Trees, backtracking, divide-and-conquer, recursion is half the question bank. Watch the call stack unwind live.
The single most-used trick in DSA rounds: turn an O(n) scan into an O(1) lookup. See collisions and load factor in action.
Insertion vs merge vs quick sort on the same array. Flip the input and the winner flips; the classic "which sort and why" question, felt.
Reverse a list in place one pointer at a time, then catch a cycle with Floyd's tortoise and hare. The two linked-list questions everyone asks.
Valid parentheses, then Next Greater Element and Daily Temperatures in one O(n) pass.
Insert, delete (incl. the successor case) and all four traversals, animated. Why in-order is sorted, and why sorted input breaks the tree.
Watch the recursion tree grow: choose, explore, un-choose. Switch on pruning and watch the work collapse.
A DP table fills itself cell by cell, then traces the answer back. Overlapping subproblems, made visible.
Take it or leave it, row by row, and see exactly where greedy-by-ratio loses.
Sort, sweep once, merge. Then the min-rooms counter that peaks at the answer.
Range sums in O(1), and the maximum subarray in one pass while brute force's counter runs away.
Paint a map, flood the islands, then race BFS vs DFS through a maze. Only BFS guarantees the shortest path.
HashMap + doubly linked list, get and put in O(1). Race it against FIFO on the same requests.
Kruskal vs Prim on the same graph: same total, different paths. And why cheapest network ≠ shortest route.
Prepping for a specific drive? Week-by-week plans mapped to these labs: TCS NQT · Infosys · Wipro / Accenture / Cognizant · Amazon SDE · DSA in Hindi · all guides →
Practising problems? 100+ classic coding interview problems, from Two Sum and Number of Islands to LRU Cache and 0/1 Knapsack, each with tested Python and a live visual →
For SDE-2 and every good product company, “how would you scale this?” decides the level and the pay. These are the exact building blocks interviewers want to hear, and the ones candidates fumble because they only ever read about them. Watch the explainer free, then build it yourself.
Sharding, caching, load balancing, the classic answer to “how do you distribute data across servers?” Add a node, watch ~1/N of keys move.
The space-saving trick that impresses in design rounds, dedup, caches, rate-limits, “have I seen this before?” in 32 bytes.
More and more JDs say “LLM”, “RAG”, or “vector search” and most candidates can only recite buzzwords. A little real depth here is a genuine differentiator in AI-adjacent and product interviews.
RAG, embeddings, semantic search, the system-design question of the AI era. Brute force vs an IVF index: 90% skipped, still accurate.
If the JD says “LLM”, this is the depth that lands the offer, precision, recall, groundedness, and why answers hallucinate.
The “do you actually understand transformers?” question, residuals, LayerNorm, and why 96-layer models train at all.
The whole DSA core and both foundation courses cost nothing. Go Pro when you’re ready for the system-design and AI rounds.
▶ Start with Big-ONo install · just your browser · learn by doing