Valid Parentheses Problem Solution on LeetCode

💻 Revisiting LeetCode 474 – Ones and Zeroes I had solved this problem earlier using a standard DP approach, but it wasn’t memory-efficient. Revisiting it allowed me to refine the solution and optimize space usage. 🔹 Original approach: Standard DP ⏱ Time Complexity: O(m * n * len(strs)) 💾 Space Complexity: O(m * n * len(strs)) ⚡ Refined approach: Reverse DP iteration ⏱ Time Complexity: O(m * n * len(strs)) 💾 Space Complexity: O(m * n) Count 0’s and 1’s in each string Iterate backwards to avoid overwriting previous states Update DP table in-place to track the maximum subset size satisfying m 0’s and n 1’s 💡 Why I revisited: Small refinements teach how careful iteration and memory optimization can make solutions cleaner, more efficient, and production-ready. Revisiting solved problems to optimize them compounds your learning faster than brute-force problem-solving. #LeetCode #DynamicProgramming #0_1Knapsack #Optimization #CodingJourney #DSA #Refinement #Consistency

🚀 LeetCode Daily Practice – Day 36 Problem: Wildcard Matching (Dynamic Programming) Today’s problem explored pattern matching with two special characters: ? matches any single character * matches any sequence, including empty At first, the behavior feels unpredictable — but DP helps organize all possibilities into something structured and manageable. 🎯 Core Idea We use dynamic programming to determine whether a prefix of the string matches a prefix of the pattern. ? forces both sides to move forward together. * creates two choices: treat it as matching nothing, or let it absorb characters one by one. By evaluating these transitions carefully, DP ensures every valid alignment is considered without brute force backtracking. 🔍 Why This Problem Is Interesting It looks similar to regular expression matching but introduces flexible wildcard behavior. The challenge lies in handling many branching possibilities efficiently — and this is exactly where DP excels. 🧠 Key Insight * is powerful but controlled. Once we define clear transitions for it, the pattern becomes predictable and solvable in polynomial time. ⏱ Time Complexity → O(m × n) 🧠 Space Complexity → O(m × n) or O(n) with optimization 🌱 Daily Learning Takeaway When rules feel ambiguous, structure them. DP transforms even messy matching problems into systematic decision frameworks. #leetcode #dsa #dynamicprogramming #patternmatching #coding #learningeveryday #growthmindset #developer #problemsolving

Day 8: Roman to Integer (Cracking the Subtractive Rule) Consistency is key! Today, I tackled the Roman to Integer challenge on LeetCode. While it looks like a simple mapping task, the real challenge lies in handling the subtractive instances (like IV = 4, not 6). 🧠 The Logic: Look-Ahead Strategy The standard rule for Roman numerals is addition. However, when a smaller numeral precedes a larger one, you subtract it. I implemented a look-ahead check: Iterate through the string character by character. If the current value is less than the next value (e.g., 'I' before 'V'), subtract the current value from the total. Otherwise, add it to the total. ⚡ Performance Results I’m thrilled with the efficiency of this solution: Runtime: 1 ms (Beats 99.77% of C# submissions!) 🚀 Memory: 49.07 MB (Beats 93.46% of C# submissions!) Time Complexity: $O(N)$ Space Complexity: $O(1)$ Sharing these daily updates keeps me accountable and hopefully helps others on their DSA journey. If you’re also practicing for interviews, let’s connect! #DSA #LeetCode #CSharp #CodingLife #Programming #ProblemSolving #SoftwareEngineer

Leetcode POTD 1390. Four Divisors (04/01/2026) Solved today’s LeetCode Problem of the Day: 1390. Four Divisors. At first glance, the problem looks like a simple divisor counting task. But the real challenge is knowing when to stop thinking abstractly and just write correct, efficient code. The key insight is that a number has exactly four divisors only in two cases: It is a cube of a prime number, or it is a product of two distinct prime numbers. Instead of overengineering with number theory, I went with a clean sqrt-based divisor scan, counted divisor pairs, and exited early once the count crossed four. Simple logic, correct results, and efficient enough for the constraints. What I liked about this problem is that it quietly tests discipline. You can chase clever math, or you can write readable code that handles all edge cases without surprises. I chose the latter. Problems like these are a good reminder that clarity beats cleverness most of the time. If a problem feels easy, double check the assumptions. That’s usually where the trap is. Back to the grind.

🧩 LeetCode POTD: Delete Columns to Make Sorted II So, what is this problem actually asking? 🤔 We’re given a few strings, all of the same length. We’re allowed to delete columns (meaning: remove the same index from every string). After deleting, the strings as a whole should be in dictionary (lexicographic) order 📖 Our goal is to delete the minimum number of columns. 💡 Intuition When we compare two strings, we go left to right. The first character where they differ decides the order. So if at some column we find: strs[i] < strs[i+1] 👉 That pair is sorted forever ✅ No later column can change this. Because of this: We should remember which adjacent string pairs are already sorted and stop checking them again and again. ⚡ Optimization : Instead of rebuilding strings every time: Go column by column (left to right) Keep a sorted[] array sorted[i] = true → strs[i] and strs[i+1] are already in the correct order 😊 If a column breaks order for any unsorted pair......delete that column Otherwise okay, use this column to mark more pairs as sorted #leetcode #potd #problem_solving #optimization #coding

📅 Day 48 — 100 Days of Coding Challenge 🧠 Problem Solved: Wildcard Matching (LeetCode 44) Today’s problem focused on string matching with wildcards, where the pattern can contain special characters: 🔍 Problem Summary Match a string against a pattern containing: 1️⃣ ? → matches any single character 2️⃣ * → matches any sequence (including empty) The match must cover the entire string. ⚙️ Approach Used (Recursion + Backtracking) 1️⃣ Use two pointers for string and pattern 2️⃣ If characters match or pattern has ?, move both pointers 3️⃣ If pattern has *, try two choices: • Treat * as empty • Let * consume one character 4️⃣ Handle edge cases when string is exhausted 5️⃣ Return true only if both string & pattern finish together 💡 Key Learnings 1️⃣ How * drastically increases branching 2️⃣ Importance of correct base cases 3️⃣ Why this problem naturally leads to DP optimization Day 48 complete — tough problems build stronger fundamentals 🚀 #100DaysOfCode #LeetCode #Recursion #Backtracking #DP #DSA #ProblemSolving

Vibe coding is simply ascending the ladder of abstraction by one rung. Hating it is similar to hating compilers for translating source code into machine code. A developer should use all tools at their disposal. Prompting is just one of the tools that has emerged in the past few years.

🔧 Why I Still Follow the 79‑Character Rule as a Developer In a world of ultra‑wide monitors and modern IDEs, it’s easy to forget the value of small engineering disciplines. One of my favorites is the classic 79‑character line length. It’s not just a “Python thing” - it’s a mindset. It forces clarity It improves readability in terminals, diffs, and reviews It encourages smaller, more focused functions It keeps collaboration smooth across tools and teams As developers, the little habits we build shape the quality of the systems we create. Clean code isn’t about perfection - it’s about intention. If a simple constraint like 79 characters can make code easier to read, maintain, and debug, I’m all for it. Small discipline. Big impact. #CleanCode #CodeQuality #SoftwareCraftsmanship #BestPractices #CodingStandards #DeveloperLife #EngineeringMindset #ProductivityTips #TechDiscipline

Hello connections, Here is my solution to a LeetCode problem focused on dynamic programming and string manipulation. Time Complexity: O(N × M) Space Complexity: O(N × M) Learning from the problem: The key idea is to model the problem using dynamic programming, where each state represents the minimum ASCII delete cost needed to make two prefixes of the strings equal. When characters match, no deletion is required; otherwise, we choose the cheaper deletion between the two strings. This approach systematically explores all possibilities and guarantees the optimal result. This problem is a great example of how DP helps balance multiple choices while minimizing cost. #leetcode #problemsolving #cpp #dynamicprogramming #strings #datastructures #happycoding

🚀 LeetCode Daily Practice – Day 33 Problem: Distinct Subsequences (Dynamic Programming) Today’s problem focused on counting how many distinct ways we can form one string as a subsequence of another. Unlike normal subsequence problems, here we are not just checking existence — we are counting every valid possibility. 🎯 Core Idea We build a DP table where each state represents how many ways a prefix of one string can form a prefix of the target string. If the current characters match, we have two choices: use this character or skip it. If they don’t match, we can only skip from the larger string. This allows the count to accumulate naturally across all possible combinations. 🔍 Why This Problem Is Interesting It shows the power of DP in counting structured choices, not just finding optimal values. Brute force backtracking would explode in complexity, but DP captures all outcomes efficiently. 🧠 Key Insight Every matched character branches into multiple future possibilities. Dynamic programming helps ensure none of those paths are double-counted or missed. ⏱ Time Complexity → O(m × n) 🧠 Space Complexity → O(m × n) or O(n) with optimization 🌱 Daily Learning Takeaway Sometimes the challenge isn’t finding one answer — it’s accounting for every valid answer. DP gives a structured framework to explore them all. #leetcode #dsa #dynamicprogramming #strings #coding #learningeveryday #growthmindset #developer #problemsolving