Amit Kumar’s Post

😱 Most beginners solve this problem in O(N²) or O(N³) But experienced programmers solve it in O(N). The trick? Sliding Window Technique. Let’s understand it with a simple example. Array : 1 2 3 4 5 Window size = 3 Instead of recalculating every subarray like this: [1 2 3] [2 3 4] [3 4 5] We simply slide the window. Old window : [1 2 3] Slide → [2 3 4] Instead of recomputing everything we just : • Remove 1 • Add 4 That’s it. Time Complexity improves from O(N²) → O(N). Key Idea New Window = Previous Window - element leaving + element entering I wrote a detailed explanation with code and visuals here : https://lnkd.in/gKRuKHy8 If you're learning DSA or Competitive Programming, this technique is extremely useful. Follow me for more simple explanations of algorithms  #DSA #CompetitiveProgramming #Algorithms #CodingInterview #SlidingWindow #LeetCode #Programming

𝐃𝐚𝐲 𝟒 𝐨𝐟 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦 𝐃𝐞𝐬𝐢𝐠𝐧 𝐚𝐧𝐝 𝐑𝐨𝐛𝐮𝐬𝐭 𝐂𝐨𝐝𝐞 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 : 𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠: 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬 𝐚𝐧𝐝 𝐈𝐧𝐭𝐫𝐨𝐝𝐮𝐜𝐭𝐨𝐫𝐲 𝐏𝐫𝐨𝐛𝐥𝐞𝐦𝐬 (𝐞.𝐠., 𝐅𝐢𝐛𝐨𝐧𝐚𝐜𝐜𝐢, 𝐂𝐨𝐢𝐧 𝐂𝐡𝐚𝐧𝐠𝐞) Dynamic Programming (DP) can feel intimidating, but it's essentially about breaking down problems into overlapping subproblems and storing their solutions to avoid redundant calculations. Think divide and conquer, but with memory! The Fibonacci sequence and Coin Change problem are classic introductory examples. They beautifully illustrate the core concepts of memoization (top-down) and tabulation (bottom-up). Interestingly, many real-world optimization problems, from route planning to resource allocation, can be modeled and solved effectively using DP techniques. It's not just theoretical! What's a DP problem you initially struggled with, but now feel confident solving? I'm curious to hear your experiences! #DynamicProgramming #Algorithms #Coding #SoftwareEngineering #ComputerScience #ProblemSolving

🚀 DSA Roadmap – Topics I’m Covering (In Order) This is not random. This is structured learning. 🔹 Arrays 🔹 Linked Lists 🔹 Recursion 🔹 Sorting 🔹 Binary Search 🔹 Trees 🔹 Backtracking 🔹 Heap / Priority Queue 🔹 Hashing 🔹 Graphs 🔹 Dynamic Programming 🔹 Bit Manipulation Building foundations first. Then logic. Then optimization. No shortcuts. Just consistency. 💻🔥 If you're serious about mastering DSA, let’s connect. 👇 #DSA #Coding #CPP #BuildInPublic #LeetCode #100DaysOfCode

🛑 Can you spot the memory bug? Most of us think we understood object layout, but this snippet hides a "silent killer." 💣 class Test { public:    int a; int b;    virtual void fun() {} // The "Hidden" Player    Test(int t1, int t2) : a(t1), b(t2) {} }; int main() {    Test obj(5, 10);    int* pInt = (int*)&obj;   *(pInt + 0) = 100; // Guess what happens here?    *(pInt + 1) = 200;  cout << obj.a;  } 🧠 The Reality Check We might expect obj.a to print 100. But it won’t, because of this virtual function, compiler inserts a vPtr at the very start of the object. 💡 The Lesson Virtual keyword doesn't just enable polymorphism, it physically reshapes data in memory. Manual pointer arithmetic on classes is a one-way ticket to undefined behaviour. Have you ever been faced such hidden compiler-injected members? Let’s talk in the comments! 👇 #Cpp #Programming #Coding #SoftwareEngineering

𝐃𝐚𝐲 𝟏𝟑 𝐨𝐟 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐢𝐧𝐠 𝐚𝐧𝐝 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦𝐢𝐜 𝐓𝐡𝐢𝐧𝐤𝐢𝐧𝐠 𝐔𝐬𝐢𝐧𝐠 𝐂𝐨𝐝𝐞 : 𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠: 𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠 𝐭𝐡𝐞 𝐂𝐨𝐧𝐜𝐞𝐩𝐭 𝐚𝐧𝐝 𝐒𝐢𝐦𝐩𝐥𝐞 𝐄𝐱𝐚𝐦𝐩𝐥𝐞𝐬 Dynamic Programming (DP) can seem intimidating, but at its core, it's about solving problems by breaking them down into smaller, overlapping subproblems. We store the solutions to these subproblems to avoid redundant calculations. Think of it like building with LEGOs. You solve a small piece once, then reuse that solution wherever it fits, building towards the final structure. A common example is calculating Fibonacci numbers. A naive recursive approach recalculates the same values repeatedly. DP optimizes this by storing previously computed Fibonacci numbers in a table. Here's a lesser-known fact: DP can be approached in two main ways: top-down (memoization) and bottom-up (tabulation). While both achieve the same result, memoization can sometimes be more intuitive for problems with complex recursion structures. What's a DP problem you initially struggled with, but now find straightforward? Share your moment! #DynamicProgramming #Algorithms #Coding #ProblemSolving #ComputerScience #DataStructures

🚀 DSA Deep Dive – Day 32 Solved Longest Common Subsequence today. And I realized… Dynamic Programming is not about matching characters. It’s about managing choices between two paths. 🤯 The problem looks simple: Given two strings, find the length of their longest common subsequence. Not substring. Subsequence. That means you can skip characters — but order must remain the same. 👀 Here’s what I learned 👇 • Define dp[i][j] = LCS length till text1[0..i-1] and text2[0..j-1] • If characters match → extend previous answer • If they don’t match → take max of two possibilities • Either skip from first string • Or skip from second string This is pure decision-based DP. At every cell, you decide: 👉 If text1[i-1] == text2[j-1] → 1 + dp[i-1][j-1] 👉 Else → max(dp[i-1][j], dp[i][j-1]) Every state depends on smaller prefixes. Brute force recursion: Exponential 💀 Optimized DP: O(n × m) time ⚡ Space optimized possible 🚀 The powerful shift? Instead of asking “What is the longest common sequence overall?” Ask “What is the answer for these two prefixes?” Small answers build the big one. That’s dynamic programming. Lesson: When two strings are involved, DP is usually hiding behind prefixes. Define the right state. Trust the transitions. Build step by step. 2-D DP getting stronger 💪 Consistency continues. Follow for more DSA breakdowns 🚀 #LeetCode #DSA #DynamicProgramming #InterviewPrep #CodingJourney #ProblemSolving #100DaysOfCode #SoftwareEngineering #TechGrowth

🚀 Day 8/50 of DSA Practice – Reverse Words in a String 📝 Problem Statement Given a string s, reverse the order of words. Remove extra spaces Return words separated by a single space 🔎 Example Input: s = " the sky is blue " Output: "blue is sky the" 🐢 Brute Force Approach Traverse string and extract each word manually. Store words in a vector. Reverse the vector. Join words with single space. ⏱ Time Complexity: O(n) 💾 Space Complexity: O(n) (extra space for storing words) ⚡ Optimal Approach Reverse entire string. Traverse and reverse each individual word. Handle spaces properly. ⏱ Time Complexity: O(n) 💾 Space Complexity: O(1) (if done in-place) #DSA #LeetCode #Cplusplus #Coding #ProblemSolving #logicBuilding #TechSkill.

🚀 DSA Deep Dive – Day 26 Solved Decode Ways today. And I realized… Dynamic Programming is not about memorizing formulas. It’s about understanding decisions at every index. 🤯 The problem looks simple: "A" → "1" "B" → "2" ... "Z" → "26" Given a digit string, count how many ways it can be decoded. Sounds easy… until you see zeros. 👀 Here’s what I learned 👇 • If a digit is not ‘0’, it can stand alone • If two digits form a valid number (10–26), they can pair • ‘0’ cannot stand alone ❌ • Every index depends on previous states This is classic DP thinking: At every position, you decide: 👉 Take one digit 👉 Or take two digits If valid → add ways from previous states. Brute force recursion: Exponential 💀 Optimized DP: O(n) time, O(1) space ⚡ The powerful shift? Instead of asking “How many total combinations?” Ask “How many ways can I reach THIS index?” That’s dynamic programming. Lesson: DP is not about arrays. It’s about building answers step by step from smaller subproblems. 1-D DP getting stronger 💪 Consistency continues. Follow for more DSA breakdowns 🚀 #LeetCode #DSA #DynamicProgramming #InterviewPrep #CodingJourney #ProblemSolving #100DaysOfCode #SoftwareEngineering #TechGrowth

🚀 Day 5/60 — LeetCode Discipline Problem Solved: Range Sum Query – Immutable (Revision) Difficulty: Easy Today’s practice was centered around strengthening prefix sum intuition for efficient range queries. Instead of recalculating sums repeatedly, the focus was on preprocessing the array to enable constant-time query responses. 💡 Focus Areas: • Reinforced prefix sum technique • Practiced preprocessing for query optimization • Improved time–space trade-off understanding • Focused on writing clean and efficient logic ⚡ Performance Highlight: Achieved ~99% runtime efficiency on submission. Quiet, consistent refinement of core patterns continues. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #PrefixSum #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

🚀 Exploring Array Problem-Solving Patterns After revisiting the basic operations of arrays, today I focused on understanding important problem-solving patterns used in array-based coding challenges. Instead of memorizing solutions, learning these patterns helps in recognizing the right approach for many interview problems. 📌 #Today’sFocus: Array Patterns 🔹 Two Pointer Technique This technique uses two pointers that move through the array in different directions or at different speeds to solve problems efficiently. It is commonly used in problems involving: ✔ Pair comparisons ✔ Removing duplicates ✔ Sorted arrays 🔹 Sliding Window Technique The sliding window pattern is used when dealing with subarrays or contiguous segments of data. Instead of recalculating values repeatedly, the window moves across the array while maintaining the required condition. It is widely used in problems involving: ✔ Maximum or minimum subarray sums ✔ Substrings or subarrays ✔ Continuous range calculations Looking forward to practicing these patterns through more array problems and coding challenges. #DataStructures #Algorithms #DSA #Arrays #ProblemSolving  #LeetCode #Programming #Coding #TechLearning #TechnicalTraining