LeetCode Challenge Day 10: Optimized DP with Prefix Sum

Day 32/50 – LeetCode Challenge 🧩 Problem #416 – Partition Equal Subset Sum Today’s problem focused on determining whether an array can be divided into two subsets with equal sum, which is a classic Dynamic Programming (Subset Sum) problem. 📌 Problem Summary: Given an array of integers, check if it can be partitioned into two subsets such that their sums are equal. 🔍 Approach Used ✔ First calculated the total sum of the array ✔ If the sum is odd → not possible to divide equally ✔ Converted the problem into: Can we find a subset with sum = total / 2 ? ✔ Used a set (DP approach) to store all possible sums ✔ Iteratively built new sums by adding each number ✔ Checked if the target sum exists ⏱ Time Complexity: O(n × target) 📦 Space Complexity: O(target) 💡 Key Learning ✔ Converting problems into Subset Sum pattern ✔ Using Dynamic Programming with sets ✔ Thinking in terms of possibility instead of brute force ✔ Recognizing important DP patterns This problem helped me understand how to simplify complex problems into familiar patterns. Consistency builds strong problem-solving intuition 🚀 🔗 Problem Link: https://lnkd.in/gCRhSyaz #50DaysOfLeetCode #LeetCode #DSA #DynamicProgramming #SubsetSum #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

Now DP is new the stage 😁 Solved the classic problem Climbing Stairs using Dynamic Programming. The problem is simple: Given n steps, you can climb either 1 or 2 steps at a time. Find the total number of distinct ways to reach the top. At first, I thought of solving it using recursion, but it leads to repeated calculations and becomes inefficient. Then I moved to memoization (top-down DP) to store already computed results and avoid recomputation. Finally, I implemented a bottom-up approach, which builds the solution iteratively. Key Idea: To reach step i: • You can come from (i-1) • Or from (i-2) So, ways[i] = ways[i-1] + ways[i-2] This makes the problem similar to the Fibonacci sequence. Time Complexity: O(N) Space Complexity: O(N) What I liked about this problem is how it clearly shows the transition from a simple recursive solution to an optimized dynamic programming approach. It’s a great example of understanding overlapping subproblems and optimizing step by step. #DSA #DynamicProgramming #Algorithms #Coding #ProblemSolving

Copy vs Move semantics in C++ — small change, big performance impact. At first glance, both can look like a simple assignment. But under the hood, they behave very differently. Copy → duplicates data → allocates new memory → keeps the source unchanged Move → transfers ownership of resources → avoids unnecessary allocations → leaves the source in a valid but unspecified state 💡 This difference becomes especially important with resource-heavy types such as std::string, std::vector, or user-defined classes managing dynamic memory. Another key point: std::move does not move anything by itself. It only casts an object to an rvalue, enabling move semantics if the type supports them. I put together this visual to make the difference easier to understand at a glance. Curious how others approach this in real code. #cpp #cplusplus #moderncpp #performance #softwareengineering #programming #coding

🔹 Part 1: C++ Concepts vs SFINAE (Practical Guide) This short video is part of my "C++ Programming Topics" series 👇 And also included in my broader C++ templates playlist. 💡 The problem: SFINAE is powerful—but it often leads to complex, hard-to-read template code. This can cause: -Cryptic compiler errors -Reduced code clarity -Higher learning curve for maintainers ❌ 📌 This is where C++20 Concepts shine: 👉 They provide a clean and expressive way to constrain templates. 💡 What you’ll learn in this video: ⚙️ Step-by-step evolution from SFINAE to Concepts: 1️⃣ Using enable_if in template parameters A cleaner alternative than putting it in the return type 2️⃣ Constraining a template class (Wrapper) Allow only integral types using SFINAE 3️⃣ Generic sum function Handle different types and control the return type 4️⃣ Concepts vs SFINAE Clear comparison in readability and maintainability 5️⃣ Writing your own concept Define a requirement for types that support add and sub 6️⃣ Combining Concepts with type_traits Reuse existing utilities for powerful constraints 🎯 Key takeaway: Concepts don’t replace SFINAE—they simplify it. Use Concepts when readability matters, and SFINAE when you need lower-level control. 🎥 Watch the video: https://lnkd.in/dpiQNQcF 📚 Full playlist: https://lnkd.in/dDNVWvVC #cpp #moderncpp #programming #softwareengineering #templates #concepts #metaprogramming #cleancode

Worked on a Dynamic Programming problem to maximize points with constraints. The task was to choose one activity each day from 3 options, with the condition that the same activity cannot be selected on consecutive days. Initially, I overcomplicated the solution by trying to track choices using additional structures. It worked, but it wasn’t clean. Then I revisited the problem and simplified the approach by focusing on the right state. Approach: • Define state as dp[i][last], where: i = current day last = activity chosen on the previous day • For each day, try all 3 activities • Skip the activity if it matches the previous one • Take the maximum among valid choices This made the solution much cleaner and efficient. Time Complexity: O(N × 3 × 3) Space Complexity: O(N × 3) What I found most valuable here was learning how important state design is in Dynamic Programming. A small change in thinking made the solution much simpler. #DSA #DynamicProgramming #Algorithms #Coding #ProblemSolving

🚀 #GeeksforGeeks 365 Day Problem Solving 🚀 Day-49 📌 Problem: Given a string s, replace all spaces ' ' with "%20" ✔ Maintain original order ✔ Only replace spaces 🧠 Example: Input: s = "i love programming" ✅ Output: "i%20love%20programming" 💡 Key Insight: ✔ Simple string transformation problem ✔ Each space expands to 3 characters → %20 👉 Just traverse and build result ⚡ Approach: ✔ Initialize empty string result ✔ Traverse each character: If ' ' → append "%20" Else → append character 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ Basic string manipulation ✔ Handling character replacement efficiently ✔ Common real-world problem (URL encoding) ✅ Day 49 Completed 🚀 Strengthening basics in String Processing 💪 #GeeksforGeeks #gfg365 #coding #learning #CodingChallenge #ProblemSolving #DSA #365DaysOfCode

🚨 C# Concept That Often Creates Confusion When learning method overloading, one question often comes up: 👉 If two methods have the same parameters but different return types, is that considered method overloading? Let's look at an example: public int Calculate(int a, int b) {   return a + b; } public string Calculate(int a, int b) {   return (a + b).ToString(); } At first glance, it may look like method overloading, because the return types are different. However, in C# this is not valid. The compiler will throw a compile-time error because both methods have the same method signature. In C#, method overloading is determined by: ✔ Method name ✔ Number of parameters ✔ Parameter types ✔ Parameter order ⚠️ Return type is NOT considered when determining method overloading. So the compiler treats both methods as the same definition. ✅ Valid example of method overloading public int Calculate(int a, int b) {   return a + b; } public int Calculate(int a, int b, int c) {   return a + b + c; } Here the parameter list is different, so the methods can coexist. 💡 Key takeaway In C#, two methods cannot be differentiated only by return type. If the method name and parameters are identical, it will result in a compile-time error. #CSharp #DotNet #SoftwareDevelopment #CodingMistakes #ProgrammingTips #CodingLife #LearnToCode #DeveloperCommunity #MethodOverloading #SoftwareEngineering #VisualStudio

The SOLID principles are five essential guidelines most powerful foundations for enhance software design. Let’s break it down 👇 🔹 S — Single Responsibility Principle (SRP) A class should have only one reason to change. Keep your code focused and modular. This principle states that "A class should have only one reason to change" which means every class should have a single responsibility and keep your code focused and modular or single purpose within the software system. 🔹 O — Open/Closed Principle (OCP) This principle states that software entities should be open for extension but closed for modification. which means you should be able to extend behavior without breaking existing code. 🔹 L — Liskov Substitution Principle (LSP) According to this principle, "derived or child classes must be able to replace their base or parent classes". This ensures that any subclass can be used in place of its parent class without 🔹 I — Interface Segregation Principle (ISP) Don’t force a class to implement interfaces it doesn’t use. Keep interfaces small and specific. 🔹 D — Dependency Inversion Principle (DIP) Depend on abstractions, Principle in object-oriented design that states that "High-level modules should not depend on low-level modules. Both should depend on abstractions". means "Big parts of your program should not directly depend on small, detailed parts. This improves flexibility and testability. #SOLIDPrinciples #CleanCode #SoftwareEngineering #Python #Django #BackendDevelopment #CodingBestPractices #SystemDesign #Developers #Programming

Ever look at a LeetCode problem and think, "Oh, this is just simple math," only to see a constraint of $10^{15}$ staring back at you? That was my experience with the "Count Good Numbers" problem today. The core logic was actually pretty straightforward: even indices get even digits (5 options), and odd indices get prime digits (4 options). But trying to calculate 5^even * 4^odd for massive numbers? Immediate Time Limit Exceeded (TLE). I had to scrap the standard approach and write a custom pow() function using Binary Exponentiation. It’s wild how applying modulo 10^9 + 7 at every single multiplication step within the recursive call is the exact difference between a failing solution and a clean O(log n) pass without integer overflow. Definitely a great reminder that knowing the brute-force math is only half the battle—optimizing it is where the real engineering happens. Back to the grind! #LeetCode #DSA #CPP #CompetitiveProgramming #SoftwareEngineering #CodingJourney

Ever merged modulo with dynamic programming and watched the problem shrink instantly? In competitive programming, the difference between a good solution and a great one is often not speed alone, but state reduction. This is learned from CodeForces itself. This problem is a clean example: instead of thinking in terms of all subset sums, we only care about the remainder after division by k. That shift matters in contests because it saves both time and mental bandwidth and some key ideas that can help you- • Read the problem as a subset-sum divisibility check, not as a full-sum enumeration problem. • Recognise that modulo preserves addition and other operations, so every number can be replaced by its remainder. • Analyse constraints early: a full combinatorial DP is too large, but a remainder-based state fits. • Select the right approach: dp[r] tells whether a remainder r is reachable. • Implement with state compression: update from dp[i][r] to dp[r] carefully. • Debug edge cases like r = 0, repeated values, and transitions that wrap around k. Try solving this problem for instance - https://lnkd.in/gJBE8Qdi What most people miss is that CP improvement is rarely passive practice. It is pattern recognition under pressure. The same mindset appears in real engineering: reduce the state, constrain the search space, and optimize what truly matters instead of brute-forcing every possibility. How often do you pause and ask whether the problem can be redefined before you try to solve it? Follow Vishu Kalier for more such insights. #CompetitiveProgramming #DynamicProgramming #ModuloDP #DSA #Algorithms #ProblemSolving #Coding #SoftwareEngineering #cfbr #Eternal #Leetcode #Codeforces