Dynamic Programming Concepts and Introductory Problems

Day 51 on LeetCode — Permutation in String 🔤✅ Today’s problem was a strong application of the Sliding Window + Frequency Count technique. 🔹 Approach Used in My Solution The goal was to check if any permutation of s1 exists as a substring in s2. Key idea in the solution: • Use two frequency arrays (size 26) to track character counts • Initialize frequencies for s1 and the first window of s2 • Compare both frequency arrays — if equal, permutation exists • Slide the window across s2:   – Add incoming character   – Remove outgoing character • Check for a match at each step This ensures we efficiently check all substrings of size k without recomputing frequencies. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered sliding window with fixed-size frequency arrays • Learned how to efficiently detect anagram/permutation patterns • Reinforced optimizing from brute force to linear-time solutions #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Strings #Hashing #FrequencyArray #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

I just put together a complete analysis on the classic "n-th Ugly Number" problem (LeetCode 264).I was curious to know exactly what happens at a large enough n, so decided to dive deep into it! The analysis breaks down: 🔹 O(n^2) Linked Lists vs. Optimal O(n) 3-Pointer Dynamic Programming (DP is currently beyond my scope, so I have skipped the code and logic and focusing solely on the standard time and space complexity results) 🔹 Combinatorics and the limits of the "Stars and Bars" method 🔹 Deriving a continuous approximation using 3-D Geometry and Tetrahedron volumes 🔹 Using Gauss’s Principle then refining the error bound using Ehrhart Polynomials. If you love the intersection of algorithmic complexity and number theory, check out the rigorous derivations in the PDF below! 📄👇 Sir Srinivasa Raghava K ,I would be grateful if u could give some insight on this analysis . #Algorithms #Mathematics #LeetCode #ComputerScience #NumberTheory

Day 42 on LeetCode — Merge Sorted Array (Two Pointer Approach) ✅ Today’s problem focused on efficient in-place array manipulation using the two-pointer technique. 🔹 Approach Used in My Solution The key insight was to compare elements from the back of both arrays instead of the front. Since nums1 already has extra space at the end to accommodate elements from nums2, we can fill the array from the last index backwards. Key points in the logic: • Initialize pointers at the end of the valid elements of nums1 and nums2 • Compare the elements and place the larger one at the back of nums1 • Move the pointers accordingly until all elements are merged • This allows the final sorted array to be stored directly in nums1 This strategy avoids unnecessary shifting of elements and keeps the solution efficient. ⚡ Complexity: • Time Complexity: O(m + n) • Space Complexity: O(1) (in-place merge) 💡 Key Takeaways: • Learned how working from the back can simplify in-place merges • Strengthened understanding of the two-pointer technique • Practiced optimizing array operations without using extra space #LeetCode #DSA #Algorithms #DataStructures #TwoPointers #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Day 40 on LeetCode — Longest Consecutive Sequence ✅ Today’s challenge was about finding the longest sequence of consecutive numbers in an unsorted array. 🔹 Approach Used in My Solution In my implementation, I first sorted the array, which makes consecutive numbers appear next to each other. After sorting, I traversed the array once to track the current streak of consecutive numbers. Key points in the logic: • Skip duplicates to avoid breaking the sequence • Increase the counter when the current number is exactly previous + 1 • Reset the counter when the sequence breaks and update the longest streak This approach keeps the implementation simple, readable, and effective. ⚡ Complexity: • Time Complexity: O(n log n) due to sorting • Space Complexity: O(1) (excluding sorting space) 💡 Key Takeaways: • Sorting can simplify many sequence detection problems • Careful handling of duplicates is important in consecutive sequence problems • Reinforces writing clean traversal logic after preprocessing #LeetCode #DSA #Algorithms #DataStructures #Arrays #Sorting #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Heap Sort is a comparison-based sorting algorithm based on the Binary Heap data structure. It is an optimized version of selection sort. The algorithm repeatedly finds the maximum (or minimum) element and swaps it with the last (or first) element. Using a binary heap allows efficient access to the max (or min) element in O(log n) time instead of O(n). The process is repeated for the remaining elements until the array is sorted. Overall, Heap Sort achieves a time complexity of O(n log n). #softwareengineer #datastructures #coding #algorithms #programming

🔍 Concept Practiced: Abundant Number Explored the concept of “Abundant Numbers”, which are numbers where the sum of proper divisors exceeds the number itself. 📌 Key Insight: Efficient divisor calculation using √n optimization significantly reduces time complexity. 🧠 Why this matters: Strengthens understanding of number theory Improves optimization thinking Builds foundation for advanced math-based problems 📈 Even though this is not a direct LeetCode problem, it is a common concept used in coding interviews and competitive programming. #Algorithms #DataStructures #ProblemSolving #Coding #Math #InterviewPreparation #SoftwareEngineering #SavecodeS

🛑 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

When I’m solving problems on LeetCode, I usually hit a wall—not because I don't understand the logic, but because I struggle to recall the exact template or pattern for specific categories. While Binary Search is straightforward, I found myself constantly falling short on Graphs, Backtracking, and Dynamic Programming. It gets even trickier when a problem requires layering multiple patterns to get that optimized solution. To help myself, I started documenting at-a-glance patterns and templates. I realized this could help others who are stuck in the same "grind" as me, so I put everything together into a central hub called AlgoSheet. Check it out here: https://lnkd.in/gCNPzDwj It’s currently a GitHub page where I’ve compiled the most frequent patterns. It's built by a dev, for devs. If you find it useful, feel free to use it for your interview prep. I’m also totally open to suggestions or PRs if you want to help expand the pattern library! #LeetCode #CodingInterview #SoftwareEngineering #DSA #AlgoSheet

 Day 12 of #30DaysOfLeetCode Solved #26 – Remove Duplicates from Sorted Array using C. Problem: Given a sorted array, remove duplicates in-place and return the number of unique elements while keeping the order unchanged. Approach: • Used the two-pointer technique • One pointer scans the array • Another pointer stores only unique elements • Since the array is already sorted, duplicates appear next to each other – which makes the solution efficient Performance: • Runtime: 0 ms (Beats 100% ) • Memory: 12.98 MB What I learned today: • How powerful the two-pointer technique is • Writing clean in-place algorithms without extra memory • Better understanding of array manipulation • Small problems help build strong fundamentals #LeetCode #DSA #Algorithms #TwoPointers #CProgramming #ProblemSolving

Day 9 of my 30-Day Hard DSA Challenge Today I solved “273. Integer to English Words”, a problem that focuses on number decomposition and structured string construction. Problem overview: Convert a non-negative integer into its English words representation. Approach: • Broke the number into groups of three digits (thousands, millions, billions) • Processed each segment independently • Used predefined mappings for numbers below twenty and multiples of ten • Combined segments with scale words like Thousand, Million, and Billion • Built the final result through structured recursion/string composition Key takeaway: Large conversion problems often become manageable by decomposing the input into smaller repeating units and handling each segment systematically. Full implementation:https://lnkd.in/gDZ5C6Bf #DSA #Algorithms #CodingChallenge #ProblemSolving #Programming