Tips for Mastering Algorithms

In the last 15 years, I have interviewed 800+ Software Engineers across Google, Paytm, Amazon & various startups. Here are the most actionable tips I can give you on how to approach  solving coding problems in Interviews  (My DMs are always flooded with this particular question) 1. Use a Heap for K Elements      - When finding the top K largest or smallest elements, heaps are your best tool.      - They efficiently handle priority-based problems with O(log K) operations.      - Example: Find the 3 largest numbers in an array.   2. Binary Search or Two Pointers for Sorted Inputs      - Sorted arrays often point to Binary Search or Two Pointer techniques.      - These methods drastically reduce time complexity to O(log n) or O(n).      - Example: Find two numbers in a sorted array that add up to a target.   3. Backtracking    - Use Backtracking to explore all combinations or permutations.      - They’re great for generating subsets or solving puzzles.      - Example: Generate all possible subsets of a given set.   4. BFS or DFS for Trees and Graphs      - Trees and graphs are often solved using BFS for shortest paths or DFS for traversals.      - BFS is best for level-order traversal, while DFS is useful for exploring paths.      - Example: Find the shortest path in a graph.   5. Convert Recursion to Iteration with a Stack      - Recursive algorithms can be converted to iterative ones using a stack.      - This approach provides more control over memory and avoids stack overflow.      - Example: Iterative in-order traversal of a binary tree.   6. Optimize Arrays with HashMaps or Sorting      - Replace nested loops with HashMaps for O(n) solutions or sorting for O(n log n).      - HashMaps are perfect for lookups, while sorting simplifies comparisons.      - Example: Find duplicates in an array.   7. Use Dynamic Programming for Optimization Problems      - DP breaks problems into smaller overlapping sub-problems for optimization.      - It's often used for maximization, minimization, or counting paths.      - Example: Solve the 0/1 knapsack problem.   8. HashMap or Trie for Common Substrings      - Use HashMaps or Tries for substring searches and prefix matching.      - They efficiently handle string patterns and reduce redundant checks.      - Example: Find the longest common prefix among multiple strings.   9. Trie for String Search and Manipulation      - Tries store strings in a tree-like structure, enabling fast lookups.      - They’re ideal for autocomplete or spell-check features.      - Example: Implement an autocomplete system.   10. Fast and Slow Pointers for Linked Lists      - Use two pointers moving at different speeds to detect cycles or find midpoints.      - This approach avoids extra memory usage and works in O(n) time.      - Example: Detect if a linked list has a loop.   💡 Save this for your next interview prep!

I spent 2+ years grinding Leetcode and learning DSA & problem-solving as a CSE student at BITS Pilani. If I had to start again from 0, this is exactly how I’d do it to get hired as a Software Engineer in 2025:  1️⃣ 𝗺𝗮𝘀𝘁𝗲𝗿 𝗰𝗼𝗿𝗲 𝗮𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 𝗯𝗲𝗳𝗼𝗿𝗲 𝗮𝗻𝘆𝘁𝗵𝗶𝗻𝗴 𝗲𝗹𝘀𝗲 ○ Before touching random Leetcode problems, I’d master core algorithms like: Binary Search, DFS, BFS, Sliding Window, Two Pointers, Recursion, Backtracking, and Dynamic Programming. ○ The goal isn’t just to “understand” these but to be able to implement them from scratch without hesitation. ○ I’d write each algorithm at least 5-10 times from memory until it becomes second nature.  2️⃣ 𝗳𝗼𝗰𝘂𝘀 𝗼𝗻 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝘀𝗼𝗹𝘃𝗶𝗻𝗴 𝗽𝗿𝗼𝗯𝗹𝗲𝗺𝘀 ○The biggest mistake people make is solving hundreds of random problems without recognizing patterns. ○ 90% of interview problems fall into ~20 coding patterns. ○ Instead of solving 1000+ questions, I’d focus on understanding:    ►How problems within a pattern are similar.    ►What small variations make them different.    ►Which techniques help optimize them.  3️⃣ 𝗿𝗲𝗽𝗲𝗮𝘁 𝗽𝗿𝗼𝗯𝗹𝗲𝗺𝘀 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝗷𝘂𝘀𝘁 𝗺𝗼𝘃𝗶𝗻𝗴 𝗼𝗻 ○ Just because I solved a problem once doesn’t mean I’ll remember it. ○ I’d follow this reinforcement schedule for problems I struggled with: Solve it today, solve it again in 1 week and finally solve it again in 1 month. ○This is how I’d make sure I actually retain what I learn.  4️⃣ 𝘀𝘁𝘂𝗱𝘆 𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻𝘀 𝘁𝗵𝗲 𝗿𝗶𝗴𝗵𝘁 𝘄𝗮𝘆 ○ When I can’t solve a problem, I’d first struggle with it for at least 30 minutes before looking at the solution. ○ Then, I’d:   ► Write out the solution from memory after understanding. ► Explain why it works in simple words ► (if I can’t explain it, I don’t truly understand it).   ► Look at alternative solutions to compare trade-offs.  5️⃣ 𝗯𝘂𝗶𝗹𝗱 𝗮 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝘀𝘁 (𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗿𝗮𝗻𝗱𝗼𝗺 𝗴𝗿𝗶𝗻𝗱𝗶𝗻𝗴) ○ Instead of jumping between random problems, I’d follow a structured roadmap like:  ► First 50-60 easy problems → Get comfortable with implementation.   ► Next 80-100 medium problems → Focus on pattern recognition & optimization.   ► Last 30-40 hard problems → Only after mastering the fundamentals.  ○ 150-200 well-selected problems are enough to crack most interviews.  6️⃣ 𝘀𝘁𝗮𝗿𝘁 𝗺𝗼𝗰𝗸 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄𝘀 𝗲𝗮𝗿𝗹𝘆 (𝗲𝘃𝗲𝗻 𝘄𝗵𝗲𝗻 𝗜 𝗳𝗲𝗹𝘁 𝘂𝗻𝗽𝗿𝗲𝗽𝗮𝗿𝗲𝗱)   ○ Simulating real interviews early helps with time pressure & communication skills.  ○ I’d start setting strict 30-45 min timers on problems to simulate interview conditions.  ○ I’d practice explaining my thought process out loud, since half of the interview is about communication.  (Bonus tip in the comments) ↓

I'm often asked what to do if one can't solve a coding problem after pondering it for 15-20 minutes. People often hit a wall while preparing for coding interviews. I did too. Here are my suggestions: 👉𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐞 𝐀𝐜𝐭𝐢𝐯𝐞𝐥𝐲: Instead of passively reading the explanation after 15-20 minutes, try to struggle with the problem a bit longer. This is where the learning really happens. If you can't solve it, try to identify which part of the problem you find challenging. Is it the initial approach? Is it a tricky corner case? Once you've identified your weak point, you can then focus on solutions to that specific issue. 👉𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝 𝐭𝐡𝐞 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬, 𝐍𝐨𝐭 𝐉𝐮𝐬𝐭 𝐭𝐡𝐞 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧𝐬: While it's tempting to memorize solutions, the interviewers are more interested in how you think and approach a problem. So, focus on the underlying techniques, patterns, and algorithms. Once you deeply understand a concept, you'll be able to apply it to a variety of questions. 👉𝐒𝐩𝐚𝐜𝐞𝐝 𝐑𝐞𝐩𝐞𝐭𝐢𝐭𝐢𝐨𝐧: Instead of reviewing all questions every day, use the spaced repetition technique. For example: 1. Review a question you've solved today. 2. Review it again in two days. 3. If you solve it successfully, review it again in a week. 4. If you still solve it successfully, review it again in two weeks. This technique will help you remember the approach over the long term. 👉𝐃𝐢𝐬𝐜𝐮𝐬𝐬 𝐰𝐢𝐭𝐡 𝐏𝐞𝐞𝐫𝐬: Talking through your solution, or even your confusion, with someone else can be very beneficial. This could be in online forums, study groups, or with friends preparing for similar interviews. Explaining your thought process to someone else can help solidify your understanding. 👉𝐂𝐚𝐭𝐞𝐠𝐨𝐫𝐢𝐳𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦𝐬: Many problems can be grouped together into certain categories like sliding window. Once you've solved a few problems in a category, try to summarize the general approach that apply to that category. This way, when faced with a new problem, you can try to fit it into a known category and apply the corresponding techniques. 👉𝐌𝐨𝐜𝐤 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰𝐬: Consider mock interviews with friends or using platforms that offer this service (check https://lnkd.in/gwrarnyD). This not only helps with problem-solving but also gets you comfortable with explaining your thought process. 👉𝐕𝐚𝐫𝐢𝐚𝐭𝐢𝐨𝐧 𝐢𝐬 𝐊𝐞𝐲: Instead of solving similar problems repeatedly in a short span, try a mix. For instance, after two-pointer problems, move on to recursion, then sliding window, and then come back to two-pointers. This cyclic variation helps cement your learning better. 👉𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝 𝐌𝐢𝐬𝐭𝐚𝐤𝐞𝐬: Whenever you can't solve a problem, instead of just reading the solution, ask yourself why you couldn't solve it. Is there a pattern or concept you're consistently missing? By recognizing your weak spots, you can focus on improving in those areas. #codinginterview #datastructures

At one point I had over 1000 tech books on my shelf (photo attached). And roughly 70 of the top 100 algorithm books. Being self-taught, algorithms was the hardest challenge for me and it took many many many years before it clicked. There are good books and ones to hold of on until later. If I had to do it over again, I’d follow this sequence: Step 1–5 (gentle but solid intro) 1️⃣ Invitation to Computer Science (5th ed — cheaper than the 6th) 2️⃣ Discovering Computer Science (1st) — not just coding, but why computing matters 3️⃣ Data Structures Using C (Thareja) — extremely clear teaching style 4️⃣ Algorithms (4th ed, Sedgewick & Wayne) — practical, applied 5️⃣ The Algorithm Design Manual (Skiena) — a true gem once you’re ready Good supplements 🔥 Data Structures Using C (Tenenbaum) — older, deep insights 🔥 Data Structures Made Easy — interview-prep style, very visual 🔥 Data Structures & Algorithms in C++ (4th) Programming Challenges 🔥 Thinking Recursively in Java — recursion only, but transformative When you’re ready for more 🔥 Algorithms and Data Structures: The Basic Toolbox — my current favorite 🔥 Advanced Data Structures — for strengthening graph practice 🔥 Foundations of Algorithms (5th) 🔥 Algorithms (Dasgupta, Papadimitriou, Vazirani) — I liked it despite mixed reviews 🔥 Handbook of Data Structures and Applications — esp. the chapter on Amortized Analysis (better than CLRS in my opinion) Bridging into theory 🔥 How to Prove It (2nd) — gentle intro to proofs & logic 🔥 How to Think About Algorithms — trains your problem-solving mindset 🔥 Analysis of Algorithms: An Active Learning Approach (2nd) — applied but approachable Math foundations 🔥 Mathematical Reasoning (2nd) 🔥 Art of Problem Solving books + solution manuals 🔥 Discrete Mathematics with Applications (4th, Susanna Epp) — don’t start here unless you already have strong math or you’ve done AoPS + How to Prove It That would be my suggestion for self-learners and in that rough progression. I left TAoCP and Intro to Algorithms off the list because I don't recommed them to beginners and honestly, I like the above ones better. If you’re self-learning: · Start with 1 – 5. · Add supplements to reinforce. · Then branch into advanced material when you’re ready. The more theoretical books and math foundations will deepen your understanding — but don’t rush into them. Build confidence first. I originally wrote this on quora 7 years ago, can view it here with links to each book on Amazon: https://lnkd.in/g6ax8uhR

Most people don’t fail in DSA because it’s hard. They fail because they try to learn everything instead of learning the right patterns. If you’re a fresher preparing for coding interviews, stop collecting questions. Start mastering patterns. Here’s the exact roadmap I recommend 👇 1️⃣ Arrays Core patterns you must know: • Two Pointers • Sliding Window (fixed and variable) • Prefix Sum • Kadane’s Algorithm • Hashing / Frequency Map • Sorting + Greedy • Cyclic Sort • Binary Search 2️⃣ Linked Lists Core patterns: • Fast & Slow Pointer • Dummy Node • Reversal (entire list / k-group) • Merge Lists • Pointer Rewiring 3️⃣ Stack & Queue Core patterns: • Monotonic Stack • Monotonic Queue • Stack for Previous / Next Greater • Sliding Window + Deque 4️⃣ Trees & Graphs Core patterns: • DFS (pre / in / post order) • BFS (level order) • Recursion • Backtracking on Trees • Dijkstra • Topological Sort • Union Find 5️⃣ Advanced Patterns • Binary Search on Answer • Greedy • Dynamic Programming ◦ 0/1 Knapsack ◦ Unbounded Knapsack ◦ DP on Strings • Heap (Top K, Merge K) • Bit Manipulation You don’t need 1000 problems. You need clarity on these patterns. Once you understand the pattern, 10 different questions start looking the same. That’s when preparation becomes smart. If you’re preparing for placements or switching jobs, save this post and follow for more such content ❤️

I grinded Leetcode, CodeChef & Codeforces for 3+ years before I finally got my first internship during placements. Back then, there were about 2000 total problems on Leetcode, today they’re over 3500+ (It's really too much) Yet 90% of MAANG+ companies are still asking Leetcode-style questions, and the most common questions college students ask me about Leetcode: – How do I even start? – How many questions are enough? – How to select which questions to solve? Well, this post is the answer to everything. How to Start (Step-by-Step):  1. Learn the Basics Before Jumping In  - Stick to one language you’re comfortable with (Python, Java, or C++).       ◘ Python is beginner-friendly and has helpful libraries.       ◘ Focus on basics: loops, conditions, arrays, strings, functions, and classes.  - Data Structures and Algorithms:    ◘ Start with arrays, strings, linked lists, stacks, queues, hash tables, and binary trees.    ◘ Learn sorting, binary search, and recursion. These are crucial for many problems.  2. Choose the Right Problems    ◘ Start Small: Solve easy problems first to build confidence.    ◘ Use curated lists on Leetcode, you can find them easily  ◘ Focus on common patterns like sliding window, two pointers, backtracking, and dynamic programming.  3. How Many Problems Are Enough?    ◘ 300 high-quality problems is the sweet spot. This ensures you cover all key topics and patterns.    ◘For each topic, solve 4–5 easy problems, then move to mediums. Skip hard problems until you’re confident.  4. Practical Tips While Solving Problems    ◘Spend 30–60 minutes per problem.    ◘ If stuck, check solutions, but rewrite and re-solve them yourself.    ◘ Focus on why the solution works and the key insight that simplifies the problem.  5. Consistency is Everything    ◘ Solve 1–2 problems every day. Don’t rush to finish. Quality matters more than quantity.      - Revisit tough problems after a few weeks to strengthen your understanding.  6. Simulate Interviews:  ◘ Practice in timed conditions:        - Easy: 15 minutes        - Medium: 30 minutes        - Hard: 1 hour    ◘ Use mock interviews or contests to get used to pressure.  LeetCode can feel overwhelming, but it’s about consistency and working smarter. Focus on patterns, solve the right problems, and revisit tough ones. Stick to the process, you’ve got this. P.S: If you’re currently preparing for DSA, HLD, and LLD. Check out my one-stop resource guide on Topmate: https://lnkd.in/e-detVTg (280+ students are already using it) This guide will help you with: - DSA, HLD, and LLD for interviews - good resources that I used included to save you time - lots of problems and case studies for DSA and system design

“I Kept Facing Rejections Until I Learned These 10 DSA Tips” Rejections can be tough, especially when they happen repeatedly. Early in my career, I faced several setbacks during technical interviews. Each rejection taught me something new, and I eventually realized that a strong grasp of Data Structures and Algorithms (DSA) was essential to success. Here are the 10 tips that changed everything for me: 1. Master the Basics: Understand fundamental data structures like arrays, linked lists, stacks, queues, and trees. 2. Grasp Complexity: Learn how to calculate time and space complexity to write optimized code. 3. Practice Recursion: Many problems rely on recursion, so make it your strength. 4. Sort and Search: Know algorithms like quicksort, mergesort, and binary search inside out. 5. Dynamic Programming: Learn to break problems into smaller subproblems—it’s a game-changer. 6. Graphs and Trees: Understand traversals, shortest paths, and spanning trees. 7. Focus on Patterns: Recognize problem patterns to apply the right solutions quickly. 8. Debugging Skills: Develop a habit of tracing your code for errors before running it. 9. Consistency is Key: Daily practice matters more than sporadic efforts. 10. Mock Interviews: Simulate real interviews to handle pressure and improve problem-solving speed. These tips not only improved my DSA skills but also gave me the confidence to crack challenging interviews. If you’re currently facing rejections, don’t give up—use them as opportunities to grow and improve. What’s one tip that has helped you succeed in technical interviews? Let’s share and grow together! #DSA #CodingInterviews #CareerGrowth #NeverGiveUp #SoftwareEngineering #JobSearch

Reality Check for Aspiring Software Engineers: If you're not proficient in Data Structures and Algorithms (DSA), you're missing out on numerous opportunities with top tech companies. Mastering DSA is not just about cracking interviews; it's about building a solid foundation for problem-solving and efficient coding. Here's a structured path to guide you through mastering DSA: 1. Array & Hashing: → These basics will form the building blocks for more complex topics. → Recommended Problems: Frequency count, Anagram checks, Subarray sums. 2. Two Pointer & Stack: → Perfect for problems involving sequences and order management. → Recommended Problems: Pair sums, Valid parentheses, Largest rectangle in histogram. 3. Two Pointer ->Binary Search, LinkedList, Sliding Window: → Dive deeper into efficient searching with Binary Search, manage data dynamically with Linked Lists, and tackle contiguous data problems with Sliding Windows. → Recommended Problems: Search in a rotated array, Detect cycle in linked list, Longest substring without repeating characters. 4. Trees: → Understand hierarchical data structures with Trees, manage parent-child relationships efficiently. → Recommended Problems: Binary tree traversal, Lowest common ancestor. 5. Tries, Heap, Backtracking: → Level up with Tries for prefix-based searches, → Heaps for priority management, and Backtracking for exploring possibilities. → Recommended Problems: Word search, Priority queues, Sudoku solver. 6. Backtracking ->Graph, 1D & 2D DP: → Graphs are used for networked data, and Dynamic Programming (DP) → Recommended Problems: Shortest path, Knapsack problem, Unique paths in a grid. 7. Bit Manipulation: → Solve problems with efficient, low-level operations. → Recommended Problems: Single number, Subset generation using bits. 8. Intervals, Greedy, Advanced Graph: → Tackle interval problems for range-based data, use Greedy algorithms for locally optimal solutions, and explore advanced graph topics for complex networks. → Recommended Problems: Meeting rooms, Minimum number of platforms, Maximum flow. ▶️ Resources: → Online coding platforms (LeetCode, HackerRank) → Comprehensive courses (Coursera, Udemy) → Books (Cracking the Coding Interview, Introduction to Algorithms) Pro Tip: Consistent practice and understanding the underlying principles are key. Solve diverse problems and learn from each one. Stay determined, keep learning, and soon you'll be acing those coding interviews! Follow me for insights on Leadership, System Design, and Career Growth!

🌻As you progress in your coding journey, the complexity of challenges grows, requiring a deeper understanding of algorithms and data structures. Here's a roadmap of challenges to tackle at different stages: ✨Beginner-Level Challenges 🌻Start here if you’re looking to solidify your foundation: -Implement a Queue using Arrays/Linked Lists -Reverse a Linked List -Implement a Stack with Arrays/Linked Lists -Check for Palindromes in Strings -Calculate Factorial Using Recursion -Implement Binary Search -Find the Largest/Smallest Element in an Array -Implement Merge Sort -Implement Quick Sort -Find the Middle Node in a Linked List -Intermediate-Level Challenges 🌻Dive into these problems: -Perform Depth-First Search (DFS) on a Graph -Perform Breadth-First Search (BFS) on a Graph -Detect Cycles in a Linked List -Find the Intersection of Two Linked Lists -Validate a Binary Search Tree (BST) -Find the Height of a Binary Tree -Reverse a Binary Tree -Print All Leaf Nodes of a Binary Tree -Identify the Next Greater Element in an Array -Check Graph Connectivity ✨Advanced-Level Challenges 🌻For those aiming to master complex algorithms and data structures: -Implement Dijkstra’s Algorithm for Shortest Path -Implement Kruskal’s Algorithm for Minimum -Spanning Tree -Implement Prim’s Algorithm for Minimum -Spanning Tree -Implement a Trie Data Structure -Solve the Longest Common Subsequence Problem -Implement the KMP Algorithm for String Matching -Implement the Rabin-Karp Algorithm for String Matching -Count Inversions in an Array -Find the Median of Two Sorted Arrays -Implement a Priority Queue 🌻✨Bonus Challenges 🌻Tackle these bonus problems to truly set yourself apart: -Design and Implement an LRU Cache -Solve the Longest Palindromic Substring Problem -Check if a Graph is Bipartite -Find the Kth Smallest/Largest Element in an Array -Solve the Josephus Problem -Generate All Subsets of a Set -Implement Consistent Hashing -Find the Shortest Path in a Maze -Design a File System with a Trie -Implement Static and Dynamic Hashmaps 🌻💡 Reminder: A deep understanding of Big-O analysis and efficient problem-solving techniques is essential for excelling in algorithm design. Keep practicing, stay curious, and never stop learning! #CodingJourney #ProblemSolving #AlgorithmDesign #DataStructures #TechGrowth #SoftwareEngineering #LearningNeverStops