"Balancing 0s and 1s with Dynamic Programming"

💻 Day 69 of #LeetCode100DaysChallenge Solved LeetCode 264: Ugly Number II a dynamic programming problem that improves sequence generation and pointer-based optimization skills. 🧩 Problem: An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5. Given an integer n, return the n-th ugly number. 💡 Approach — Dynamic Programming with Three Pointers: 1️⃣ Maintain an array dp where dp[i] stores the i-th ugly number. 2️⃣ Use three pointers p2, p3, and p5 to track multiples of 2, 3, and 5 respectively. 3️⃣ At each step, choose the smallest of dp[p2]*2, dp[p3]*3, and dp[p5]*5 as the next ugly number. 4️⃣ Increment the corresponding pointer(s) to avoid duplicates. 5️⃣ Continue until the nth ugly number is found. ⚙️ Complexity: Time: O(N) — one pass to generate all ugly numbers Space: O(N) — for storing the sequence ✨ Key Takeaways: ✅ Strengthened understanding of pointer-based DP techniques. ✅ Learned how to efficiently generate sorted multiplicative sequences. ✅ Practiced optimization over brute-force factor checking. #LeetCode #100DaysOfCode #Java #DynamicProgramming #TwoPointers #Math #DSA #ProblemSolving #CodingJourney #WomenInTech

🚀 Day 68 of #100DaysOfChallenge Today's problem: 3461. Check If Digits Are Equal in String After Operations I (LeetCode - Easy) This problem was a fun blend of pattern observation and modular arithmetic — a great reminder that even simple-looking questions can strengthen your logical flow and coding discipline on LeetCode. 🧩 Problem Overview: We’re given a string of digits, and in each step, we repeatedly calculate the sum of every pair of consecutive digits modulo 10, until only two digits remain. Finally, we check whether those two digits are equal. 💡 My Approach: Used a straightforward simulation approach — repeatedly computing new strings of digits using modular arithmetic until only two digits were left. It’s simple, direct, and performs efficiently for short strings. ⚙️ Language: Java ⚡ Runtime: 8 ms (Beats 72.03%) 💾 Memory: 44.67 MB (Beats 69.77%) ✅ Result: Accepted — 706 / 706 test cases passed Every daily problem adds another layer of precision and confidence. Consistency isn’t just about coding every day — it’s about learning something new with every attempt. 🌱 On to the next challenge 💪 #100DaysOfCode #LeetCode #ProblemSolving #Java #CodingChallenge #Programming #DeveloperJourney #LearningEveryday #TechMindset #Consistency

📌 Day 23/100 – Squares of a Sorted Array (LeetCode 977) 🔹 Problem: Given a sorted integer array (may contain negatives), return a new array of the squares of each number, sorted in non-decreasing order. 🔹 Approach (Two Pointers): Since negative values become positive when squared, the largest values will be at either end of the array. So we: Use left and right pointers Compare squares → place the larger one at the end of result array Move pointers inward and fill result from back to front This avoids sorting again and keeps the solution O(n). 🔹 Time & Space Complexity: ⏱️ Time: O(n) 💾 Space: O(n) (result array) 🔹 Key Learnings: ✅ Two-pointer technique helps avoid extra sorting ✅ Always think about value transformation (like negative → squared) ✅ Filling from the back is a smart trick when maintaining sorted order #100DaysOfCode #LeetCode #Java #DSA #ProblemSolving #CodingJourney #TwoPointers #Programming

🚀 Day-74 of #100DaysOfCodeChallenge 💡 LeetCode Problem: 3370. Smallest Number With All Set Bits (Easy) 🧠 Concepts Practiced: Bit Manipulation, Binary Representation, Logical Thinking Today’s challenge was short but conceptually sharp — finding the smallest number ≥ n whose binary representation consists only of 1’s (all set bits). This problem tested understanding of bit patterns and how to efficiently generate numbers with consecutive set bits using bitwise logic. 🔹 Key Idea: Keep generating numbers of the form (1 << k) - 1 (which gives 111...1 in binary) until we find one greater than or equal to n. It’s a neat example of how mathematical patterns meet binary logic in programming! ⚙️ ⚙️ Language: Java ⚡ Runtime: 0 ms (Beats 100.00%) 💾 Memory: 40.59 MB (Beats 87.17%) ✅ Result: 608 / 608 test cases passed — Accepted 🎯 Every problem, no matter how simple, reinforces that clarity in logic is the foundation of clean code 💪 #100DaysOfCode #LeetCode #Java #CodingChallenge #BitManipulation #BinaryLogic #ProblemSolving #Programming #DeveloperJourney #LearningEveryday #TechMindset #CleanCode

💥 Stop solving 500 random Leetcode questions! If you can master these 7 patterns, you can crack any DSA problem. Most developers don’t need more problems they need clarity on the patterns behind them. 🚀 Here’s what I wish I knew earlier: If you understand 1. Sliding Window 2. Two Pointers 3. Binary Search 4. Recursion 5. Dynamic Programming 6. Greedy 7. Backtracking ...then every new problem will start to look familiar. 💡 Save this post 🔖 and start with one pattern a week. Your consistency will matter more than your question count. 👇 Comment which pattern took you the longest to understand! #DSA #Java #BackendDevelopment #Leetcode #ProgrammersLife

✅ 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 69 of LeetCode Medium/Hard Edition Today’s challenge was “Number of Ways to Stay in the Same Place After Some Steps” — a classic Dynamic Programming problem blending recursion, state transitions, and boundary control 🧭⚙️ 📦 Problem: You start at index 0 in an array of length arrLen. In each step, you can: 1️⃣ Move right by one position 2️⃣ Move left by one position 3️⃣ Stay in the same place Your goal: Find the number of ways to still be at index 0 after exactly steps moves, without ever going out of bounds. Return the answer modulo 1e9 + 7. 🔗 Problem Link: https://lnkd.in/gvd9mFFQ ✅ My Submission: https://lnkd.in/gwREFKts 💡 Thought Process: At each move, you have three possible transitions — stay, move left, or move right. We use top-down recursion with memoization to count all valid paths that end up at index 0. Each state can be represented as (steps, index), meaning the number of ways to reach position index with steps remaining. 🎯 Recurrence Relation: dp[steps][idx] = dp[steps - 1][idx] // stay + dp[steps - 1][idx - 1] // move left + dp[steps - 1][idx + 1] // move right ⚙️ Complexity: ⏱ Time: O(steps²) — since we only need to consider indices up to steps 💾 Space: O(steps²) — due to DP memoization 💭 Takeaway: This problem beautifully demonstrates how bounded state transitions and recursive caching can tame exponential branching into efficient dynamic programming. Sometimes, staying in place is as strategic as moving ahead 🚀 #LeetCodeMediumHardEdition #100DaysChallenge #DynamicProgramming #Recursion #Memoization #Java #ProblemSolving #DSA #CodingChallenge

🚀 Day-73 of #100DaysOfCodeChallenge 💡 LeetCode Problem: 3354. Make Array Elements Equal to Zero (Easy) 🧠 Concepts Practiced: Simulation, Array Manipulation, Direction Reversal Logic Today’s problem was all about simulating a dynamic process — starting from a zero element in an array, moving in a chosen direction, and adjusting movement logic as the array updates. It’s a great exercise in understanding flow control and direction-based simulation, where small logical errors can change the entire outcome. Patience and precision made all the difference here. 🔹 Approach: Simulated each possible starting point and direction, tracking movements and reversals until all elements became zero. Focus was on correctness and clear logic rather than over-optimization. ⚙️ Language: Java ⚡ Runtime: 100 ms (Beats 23.49%) 💾 Memory: 43.44 MB (Beats 13.25%) ✅ Result: 584 / 584 test cases passed — Accepted 🎯 Each solved problem reminds me how logic, structure, and consistency build stronger foundations for solving complex challenges ahead 💪 #100DaysOfCode #LeetCode #Java #CodingChallenge #ProblemSolving #Programming #DeveloperJourney #TechMindset #LearningEveryday #Consistency #Simulation

📌 Day 18/100 - Valid Palindrome (LeetCode 125) 🔹 Problem: Determine whether a string reads the same forward and backward, ignoring case and non-alphanumeric characters. 🔹 Approach: Implemented a two-pointer technique. Skipped all non-alphanumeric characters. Compared characters from both ends in lowercase. Returned true if all matched, otherwise false. 🔹 Key Learning: Two-pointer method keeps logic clean and efficient. Character handling is key when data isn’t uniform. Time complexity: O(n), Space complexity: O(1). Sometimes, solving elegantly is better than solving fast. ✨ #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingJourney