LeetCode Challenge: House Robber II with Dynamic Programming

🔥 Day 22 | LeetCode Challenge – Jump Game (Problem #55) Today’s problem tackled one of the most fundamental challenges in Dynamic Programming and Greedy Algorithms — determining whether it’s possible to reach the end of an array given that each element represents the maximum jump length from that position. 💡 Problem Overview: You start at the first index of the array. Each number indicates how far you can jump forward. The goal is to check if you can reach the last index from the starting point. 📘 Approach Used: Implemented a Dynamic Programming (DP) solution to mark reachable indices. Initialized the first position as reachable (dp[0] = true). For each reachable index, propagated possible next positions within the jump limit. The final result depends on whether the last index is marked reachable. ⚙️ Algorithm: Dynamic Programming 🧾 Language: Java ⚡ Runtime: 442 ms (Accepted ✅) 💾 Memory Usage: 48.00 MB 🧠 Key Learning: Even a simple jumping sequence can involve reachability logic, showing how dynamic programming can transform step-by-step feasibility problems into structured, deterministic solutions. #Day22 #LeetCode #JumpGame #DynamicProgramming #JavaCoding #ProblemSolving #100DaysOfCode #GreedyAlgorithm #CodingChallenge #DataStructuresAndAlgorithms #ProgrammingJourney #TechLearning

💯 Day 7/100: Dynamic Programming — LeetCode 474 Today’s challenge was a classic optimization puzzle: selecting the largest subset of binary strings under strict limits on the number of 0s and 1s. It’s essentially a two-dimensional knapsack problem, where each string consumes a portion of your limited resources. The key breakthrough was realizing that you need to traverse the DP table in reverse to preserve state dependencies. Each update reflects the best outcome when including a new string, without overwriting previous possibilities. This problem sharpened my understanding of multi-dimensional constraints and reinforced the importance of state reuse in dynamic programming. It’s a great reminder that even medium-difficulty problems can hide deep algorithmic insights. Onward to Day 8 — the grind continues. #100DaysOfCode #LeetCode #DynamicProgramming #TechJourney #ScarCodes #ProblemSolving #CodeChallenge #SoftwareEngineering

🗓️ Day 48 / 100 – House Robber (LeetCode #198) 💡 Today’s Challenge Today’s problem was House Robber, another classic Dynamic Programming problem that builds on logical decision-making. The goal: find the maximum amount of money you can rob without robbing two adjacent houses. This problem perfectly shows how DP helps in balancing choices and consequences — you decide whether to rob the current house (and skip the previous one) or skip it to include the next. 🔍 Key Learnings Dynamic Programming is about optimizing decisions step-by-step. The “non-adjacent” rule introduces real-world constraints into logic. Storing sub-results saves time and simplifies complex problems. 💭 Thought of the Day Life — like coding — is about smart choices. Sometimes, skipping an immediate gain (a nearby house 🏠) can lead to greater rewards later. Problem-solving isn’t always about doing more — it’s about doing smarter. 🔗 Problem Link:https://lnkd.in/gMCjampn #100DaysOfCode #Day48 #LeetCode #Python #DynamicProgramming #ProblemSolving #Algorithms #CodingChallenge #PythonProgramming #CodeEveryday #TechGrowth #LearningJourney #SmartDecisions #HouseRobber

🎯 LeetCode Day 46 – Unique Paths (Dynamic Programming) 🚀 Today’s challenge was about finding the number of unique paths in an m x n grid — you can only move right or down. 💡 I optimized it using a 1D Dynamic Programming approach, reducing space complexity from O(m*n) to O(n). The idea: Each cell = sum of paths from top and left. By updating rows iteratively, we achieve efficiency and elegance. ⚡ Result: ✅ All 64 test cases passed ⏱ Runtime: 0 ms (beats 100%) 💾 Memory: 40.25 MB (beats 89.65%) 📈 Learning: Sometimes, optimizing space is as impactful as optimizing time! #LeetCode #Day46 #DynamicProgramming #Java #CodingJourney #ProblemSolving #50DaysOfCode

🎯 LeetCode Day 46 – Unique Paths (Dynamic Programming) 🚀 Today’s challenge was about finding the number of unique paths in an m x n grid — you can only move right or down. 💡 I optimized it using a 1D Dynamic Programming approach, reducing space complexity from O(m*n) to O(n). The idea: Each cell = sum of paths from top and left. By updating rows iteratively, we achieve efficiency and elegance. ⚡ Result: ✅ All 64 test cases passed ⏱ Runtime: 0 ms (beats 100%) 💾 Memory: 40.25 MB (beats 89.65%) 📈 Learning: Sometimes, optimizing space is as impactful as optimizing time! #LeetCode #Day46 #DynamicProgramming #Java #CodingJourney #ProblemSolving #50DaysOfCode

📌 Day 26/100 - Maximum Subarray (LeetCode 53) 🔹 Problem: Given an integer array, find the contiguous subarray that has the largest sum and return it. 🔹 Approach: This problem is a classic example of Kadane’s Algorithm — a dynamic programming approach that efficiently finds the maximum sum subarray in linear time. Start with the first element as both current and maximum sum. Traverse through the array, at each step decide whether to add the current number to the previous sum or start fresh. Keep track of the global maximum as you go. 🔹 Complexity: ⏱ Time: O(n) 💾 Space: O(1) 🔹 Key Learning: Sometimes the optimal path starts fresh — like resetting a sum when it goes negative. Dynamic programming isn’t always about big tables — it can be as elegant as tracking a few variables. A simple algorithm can solve what appears to be a complex problem efficiently. #100DaysOfCode #LeetCode #Java #ProblemSolving #KadaneAlgorithm #DSA #CodingJourney

✅ Day 59 of LeetCode Medium/Hard Edition Today’s challenge was “Maximum Alternating Subsequence Sum” — a beautifully balanced dynamic programming problem that turns simple addition into an elegant alternation of signs ⚖️➕➖ 📦 Problem: Given an integer array nums, you need to choose a subsequence (not necessarily contiguous) that maximizes its alternating sum, defined as the sum of elements at even indices minus the sum of elements at odd indices. For example: nums = [4,2,5,3] → optimal subsequence [4,2,5,3] gives (4 + 5) - (2 + 3) = 4. 🔗 Problem Link: https://lnkd.in/g5M-iugB ✅ My Submission: https://lnkd.in/gUmnEyUU 💡 Thought Process: At each index, we have two choices — either include the current element (flipping the sign based on its position in the subsequence) or skip it. This naturally forms a two-state dynamic programming model: turn = 0 → we add the number (even position) turn = 1 → we subtract the number (odd position) The recurrence relation becomes: dp[i][turn] = max( (turn == 0 ? +nums[i] : -nums[i]) + dp[i+1][1-turn], dp[i+1][turn] ) Using memoization, we ensure that overlapping subproblems are efficiently reused. ⚙️ Complexity: ⏱ Time: O(n) 💾 Space: O(n) (can be optimized to O(1)) ✨ Key Insight: What makes this problem elegant is how a simple alternation pattern translates into a strategic inclusion/exclusion decision — showing the beauty of dynamic programming in managing state transitions efficiently. #LeetCodeMediumHardEdition #100DaysChallenge #DynamicProgramming #Recursion #ProblemSolving #Java #LeetCode #CodingChallenge

#Day_32 A Good Question to Deal With — Sliding Window + Prefix Sum Today I solved a really interesting problem — one that beautifully combines sorting, sliding window, and prefix sum concepts together. The goal: Given an array of numbers and k operations, find the maximum frequency of any number you can achieve by increasing elements (each increment costs 1 operation). At first glance, it looks like a binary search or greedy question, but the actual trick lies in realizing you can expand and shrink a sliding window to efficiently track valid ranges. Concept: Sort the array to ensure we only increase smaller numbers toward the current target. Use a sliding window to keep track of the current valid segment. Shrink the window when total operations exceed k. Takeaway: This was a great question to deal with — it really helped strengthen my understanding of how sliding windows can go beyond simple subarray problems and tackle optimization challenges too. Have you tried combining greedy + sliding window in one solution before? Would love to hear your experience #Coding #Java #SlidingWindow #LeetCode #ProblemSolving #DSA #100DaysOfCode #LearningEveryday

🎯 LeetCode 198 – House Robber | Dynamic Programming Today I revisited one of the most popular DP questions on LeetCode: House Robber. At first glance, it looks like a simple array problem — but it actually introduces one of the most important DP patterns: 👉 “Take or Skip” optimization using previous states. 🔍 Problem Insight You are given an array where each element represents the money in a house. The catch? You cannot rob two adjacent houses, or the alarm goes off. So for every house, we make a decision: ✔️ Rob this house → add its money + best answer from non-adjacent house ✔️ Skip this house → carry forward the best previous result This leads to the core DP transition: curr = max(curr, prev + nums[i]) 🧠 Why I Loved This Problem No need for a DP array Can be solved using only two variables Shows the power of optimizing space Very common interview pattern Helps understand Fibonacci-like transitions ✔️ My Java Solution (O(n) time, O(1) space) int prev = 0, curr = 0; for (int n : nums) { int temp = curr; curr = Math.max(curr, prev + n); prev = temp; } return curr; 🚀 Key Takeaways Many DP problems are just “previous state management”. Space optimization often turns complex-looking problems into simple ones. Always look for patterns like: pick / not pick take / skip include / exclude Happy to have solved and understood this one deeply — moving on to the next DP challenge! 💪🔥 #LeetCode #DynamicProgramming #JavaProgramming #CodingJourney #ProblemSolving #DSA #TechLearning #100DaysOfCode

Explore a compiler for the "Easy" language, based on the 1978 book 'Etudes for Programmers.' This project offers insights into compiler construction, converting Easy language code into C, and includes implementations of well-known programs like Brainfuck and Conway's Game of Life. Real-world use case examples include: • Compiling 'life.easy' to simulate Conway's Game of Life, demonstrating complex system behavior from simple rules. • Running 'quine', showcasing a program that outputs its own source code, highlighting self-replication in programming. Discover the compiler and contribute: github.com/begoon/easy #Compiler #ProgrammingLanguages #SoftwareDevelopment #OpenSource