Programming foundations
Solve coding interview problems
Arrays, hashing, trees, graphs, DP at the level asked in Indian product-company screens.
~60 focused hours·intermediate
Tools: Python, arrays/hashmaps, trees/graphs, dynamic programming, LeetCode/NeetCode
Market relevance — share of job ads asking for this
Prerequisite capability — not asked for directly, but needed for others.
What employers mean
You should be able to…
- Solve an array/hashmap problem in under 20 minutes with correct edge-case handling
- Traverse and modify trees and graphs (BFS/DFS, topological sort)
- Write a dynamic programming solution and explain the recurrence out loud
- Analyze time and space complexity of your own solution correctly
- Debug a failing solution against hidden test cases in a live coding round
- Explain trade-offs between two approaches (e.g. hashmap vs two-pointer) before coding
- Handle a follow-up that changes constraints (e.g. 'now the input doesn't fit in memory')
Needs first: Write production-quality Python for AI work
Learn — free, link-checked
The few resources that matter
Watch · beginner · 360 min · youtube.com
Data Structures and Algorithms in Python - Full Course for Beginners
Builds every core data structure from scratch in Python, cementing both DSA concepts and idiomatic Python at once. — freeCodeCamp.org
Read · intermediate · 30 min · techinterviewhandbook.org
Algorithms Study Cheatsheet
Pattern-based cheatsheet (sliding window, two pointers, backtracking) that turns hundreds of practice problems into a handful of recognizable techniques. — Tech Interview Handbook (Yangshun Tay)
Use · intermediate · 60 min · neetcode.io
NeetCode Roadmap
A curated, ordered problem list (arrays to graphs to DP) that mirrors what Indian product-company screens actually ask, with free video solutions per problem. — NeetCode
Practice
30-Day DSA Interview Log
Solve at least 40 problems across arrays, hashmaps, trees, graphs and DP from the NeetCode roadmap over 2-3 weeks, keeping a public log repo where each problem has your solution, a complexity note, and a short reflection on the pattern used. Redo any problem you couldn't solve in 25 minutes after a week.
Done when
- At least 40 problems solved and committed, spanning all 5 core patterns (array, hashmap, tree, graph, DP)
- Each solution file has a comment stating time/space complexity
- At least 5 problems have a documented second attempt after initially failing/timing out
- A README summarizing which patterns you're weakest on and your practice plan for them
Prove it
Evidence a recruiter can check
- Public GitHub repo of solutions with complexity notes on each
- NeetCode or LeetCode profile link showing solved-problem count and streak
- A one-page personal 'patterns cheat sheet' you wrote in your own words
Interview
Questions you'll get asked
- Given an array of transaction amounts, find two that sum to a target UPI limit.
- Detect a cycle in a directed graph of microservice dependencies.
- Find the longest increasing subsequence in a list of stock prices.
- How would you find the k most frequent search queries from a large log file?
- Reverse a linked list iteratively and then recursively.
- Given a matrix of city grid distances, find the shortest path (Dijkstra/BFS).
- What's the time complexity of your solution, and can you do better?
- How would this solution change if the input were too large to fit in memory?