Dynamic Programming Simplified with Counting Bits LeetCode 338

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

Solved the classic problem House Robber using Dynamic Programming. The problem is to find the maximum amount of money that can be robbed from houses arranged in a line, with the constraint that you cannot rob two adjacent houses. At first, I approached it using recursion by exploring two choices at every house: • Rob the current house and move to i-2 • Skip the current house and move to i-1 This worked, but it involved repeated calculations. Then I optimized it using Dynamic Programming. Approach: For each index i: • choose = value at current house + dp[i-2] • notChoose = dp[i-1] So, dp[i] = max(choose, notChoose) This way, we build the solution step by step and avoid recomputation. Time Complexity: O(N) Space Complexity: O(N) What I liked about this problem is how it clearly shows the idea of making optimal decisions at each step based on previous results. It’s a great example of turning a recursive solution into an efficient DP solution. #DSA #DynamicProgramming #Algorithms #Coding #ProblemSolving

🚀 Day 212 of #300DaysOfCoding Today I solved a challenging DP problem: 👉 Minimum Distance to Type a Word Using Two Fingers This problem really tested my understanding of Dynamic Programming, state optimization, and decision making. 🧠 Key Learning At every step, we have two choices: Use finger 1 Use finger 2 The goal is to minimize total movement distance I implemented a DP solution where: State = positions of both fingers Transition = try both fingers and take minimum ⚙️ Approach Represent each character as coordinates on a grid Use Manhattan Distance for movement Apply Bottom-Up DP (27 × 27 states) Optimize transitions carefully to avoid recomputation 💡 What I Learned DP problems are not just about memorization — they are about thinking in states and transitions Small mistakes in optimization can completely break the solution 😅 Debugging teaches more than solving 🧪 Example Input: "CAKE" Output: 3 🔥 Takeaway Consistency is the real game changer. Every day, I’m getting better at problem-solving and thinking logically. #300DaysOfCoding #DataStructures #Algorithms #DynamicProgramming #CodingJourney #LeetCode #Cplusplus #ProblemSolving

Day 9 of My Dynamic Programming Journey Today I explored Longest Common Subsequence (LeetCode 1143) — my first deep dive into string-based DP. Problem Insight: Given two strings, find the length of the longest subsequence common to both. Core Idea: At every step, compare characters: If they match → include it and move diagonally If not → skip one character and take the best option DP Thinking: Defined a 2D DP table where: dp[i][j] = LCS length for first i characters of string1 and first j characters of string2 Key Realization: “DP is about exploring all possibilities efficiently — match or skip.” Optimization Learning: Reduced space from O(n×m) → O(m) using a 1D DP array and tracking diagonal values What I Learned Today: Transition from array DP → string DP Importance of 2D DP tables How to optimize space while preserving logic Next Goal: Moving to Edit Distance (LeetCode 72) to explore more advanced string transformations #DynamicProgramming #DSA #CodingJourney #ProblemSolving #LeetCode #LearningInPublic #Day9

Here’s the fix: The code used different variable names. Fixing that and keeping the print inside the loop makes it run perfectly. #DebuggingSkills #PythonForBeginners #STEMEducation #CodingChallenge #LearnCoding

Anybody else getting excited about language oriented programming in connection with coding agents? If so, I am in dire need of some sparring :). Latest experiment is creating a targeted DSL for architecture in Langium with a LSP server serving Opencode - its a way of forcing a coding agent to speak a particular language, in this case my opinionated take on the software architecture of a given software project. Anyone up for challenging this?

Day 10 of My Dynamic Programming Journey Today I solved Edit Distance (LeetCode 72) — one of the most important and practical string DP problems. Problem Insight: Convert one string into another using minimum operations: Insert Delete Replace Core Idea: At every step, I had two scenarios: If characters match → move diagonally (no cost) If not → try all 3 operations and pick the minimum DP Thinking: Defined: dp[i][j] = minimum operations to convert first i characters of string1 into first j characters of string2 Key Realization: “Every mismatch is a choice — insert, delete, or replace — DP helps choose the cheapest one.” Optimization Learning: Started with 2D DP (O(n×m)) Optimized to 1D DP (O(m)) by tracking previous (diagonal) state What I Learned Today: Strong understanding of string DP transitions Importance of base cases (empty string conversions) How to manage state transitions in space-optimized DP Next Goal: Moving to Knapsack pattern (0/1 Knapsack & Partition problems) to explore subset-based DP #DynamicProgramming #DSA #CodingJourney #ProblemSolving #LeetCode #LearningInPublic #Day10

Beyond std::thread: The C++20 Multithreading Revolution. -------------------------------------- C++20 represents a watershed moment for multithreading in the language. While C++11 gave us a solid foundation with std::thread, mutexes, and condition variables, C++20 has addressed many of the pain points that made concurrent programming error-prone and verbose. The headline feature—std::jthread—brings automatic resource management and standardized thread cancellation to the table. But the story doesn't end there: new synchronization primitives (std::latch, std::barrier, std::counting_semaphore), atomic wait/notify operations, and synchronized output streams collectively transform how we write robust, maintainable concurrent code. Read more ... https://lnkd.in/daj3hUNU

🚀 Day 7 of My LeetCode Journey Today’s problem: Reverse Integer At first glance, it looks simple — just reverse digits. But the real challenge was handling 32-bit integer overflow without using 64-bit storage. 🔍 What I learned: How to extract digits using modulo (%) Building the reversed number step by step Most importantly, checking overflow before updating the result ⚠️ Edge Case: If the reversed number goes beyond the 32-bit range [-2³¹, 2³¹ - 1], we must return 0 💡 Example: Input: 123 → Output: 321 Input: -123 → Output: -321 Input: 1534236469 → Output: 0 (Overflow case) Consistency over perfection 💪 #Day7 #LeetCode #DSA #CProgramming #CodingJourney #ProblemSolving

🚀 Understanding SOLID Principles in C++ – Liskov Substitution Principle (LSP) Today, I explored one of the most important design principles in Object-Oriented Programming – the Liskov Substitution Principle (LSP). 🔍 What is LSP? LSP states that objects of a derived class should be replaceable with objects of the base class without breaking the program. 💡 What I implemented: ✔️ Designed a clean abstraction using: DepositOnlyAccount (base interface) WithdrawableAccount (extended interface) SavingAccount (concrete implementation) ✔️ Ensured proper hierarchy where: Deposit-only accounts are not forced to implement withdrawal Withdrawal functionality is only available where it logically makes sense 🔥 Key Learning: Instead of forcing all accounts to support both deposit and withdrawal (which violates LSP), we segregate responsibilities and design flexible, scalable systems. 📌 This improves: Code maintainability Extensibility Real-world modeling accuracy 💻 Tech Stack: C++, OOP, SOLID Principles #CPlusPlus #OOP #SOLIDPrinciples #LLD #SystemDesign #Programming #SoftwareEngineering #CodingJourneyRohit Negi