Wildcard Matching LeetCode 44 Solution

🚀 Day 186 of #500DaysOfCode Today’s challenge was LeetCode 712 – Minimum ASCII Delete Sum for Two Strings 🧵 This problem was a great example of applying Dynamic Programming to string matching. The goal: make two strings equal with minimum deletion cost, where each deletion costs its ASCII value. 💡 Key insight: Think beyond classic LCS—here, the cost of deletion matters. A DP approach comparing characters and choosing the minimum ASCII sum at each step makes all the difference. Every problem like this sharpens intuition for string DP patterns 🔁 On to the next one! #LeetCode #DSA #DynamicProgramming #Strings #ProblemSolving #CodingJourney #Consistency

🔥 Day 8 | Round 4 — Learning Through Optimization! 🔥 Solved a LeetCode problem — Longest Arithmetic Subsequence 💡 This problem focuses on identifying the longest subsequence with a constant difference using Dynamic Programming. 🧩 Approaches Explored: Recursive DP with Memoization ➤ Worked for most cases but resulted in TLE on one test case due to high recursive overhead. Bottom-Up Tabulation using Hash Maps ➤ Efficiently stored differences and avoided repeated computations. Switching from memoization to tabulation helped optimize performance and pass all test cases 💪 A great reminder that the right approach matters as much as the logic 🚀 🔹 Concepts Used: Dynamic Programming | Hash Maps | Tabulation 🔹 Key Takeaway: When recursion hits limits, iterative DP often provides the needed performance boost 🧠 #30DaysOfCode #Round4 #Day8 #LeetCode #DynamicProgramming #Tabulation #DPOptimization #DSA #ProblemSolving #CodingChallenge #DeveloperJourney #CodeEveryday #CPlusPlus #LearnByDoing #ConsistencyIsKey 🚀

📅 Day 54 — 100 Days of Coding Challenge 🧠 Problem Solved: Permutations II (LeetCode 47) Today’s problem was about generating all unique permutations from an array that may contain duplicate elements. 🔍 Problem Highlights 1️⃣ Input array can have repeated numbers 2️⃣ Need all possible permutations 3️⃣ Duplicate permutations are not allowed ⚙️ Approach Used — Backtracking 1️⃣ Fix one position at a time 2️⃣ Use a visited map at each recursion level 3️⃣ Skip elements already used at the same level 4️⃣ Swap → recurse → backtrack This ensures only unique permutations are generated efficiently. 💡 Key Takeaways 1️⃣ Duplicate handling depends on recursion level 2️⃣ Local visited map avoids repeated states 3️⃣ Backtracking with pruning improves performance Day 54 completed — consistency over everything 🚀 #100DaysOfCode #LeetCode #Backtracking #Recursion #DSA #ProblemSolving #CodingJourney

📅 Day 50 — 100 Days of Coding Challenge 🧠 Problem Solved: Perfect Squares (LeetCode 279) Today’s problem focused on finding the minimum number of perfect square numbers whose sum equals a given number n. 🔍 Problem Summary We are given an integer n and need to: 1️⃣ Use only perfect squares (1, 4, 9, 16, …) 2️⃣ Select the minimum count of such squares 3️⃣ Return the least number of squares whose sum is n ⚙️ Approach Used (Recursive / Brute Force) 1️⃣ Try all perfect squares ≤ n 2️⃣ Subtract the chosen square from n 3️⃣ Recursively solve the remaining value 4️⃣ Take the minimum count among all possibilities 💡 Key Learnings 1️⃣ This is a classic DP optimization problem 2️⃣ Brute force recursion works but causes overlapping subproblems 3️⃣ Memoization / DP can significantly reduce time complexity Day 50 completed — halfway through the challenge 💪🔥 #100DaysOfCode #LeetCode #DP #Recursion #ProblemSolving #DeveloperJourney

Day 30/100 days of coding 🚀 Problem: Check If Two String Arrays Are Equivalent 🔍 Main Idea 💡 -Concatenate all strings from both arrays -Compare the final formed strings Approach 🛠️ -Traverse word1 and build a single string -Traverse word2 and build another string -If both strings are equal → return true ✅ -Otherwise → return false ❌ What I learned 📘 -Simple logic can solve problems efficiently -Not every problem needs heavy optimization On to Day 31 🚀🚀 #DSA #LeetCode #Strings #100DaysOfCode #Consistency

🔥 Day 17 | Round 4 — Mastering String DP! 🔥 Solved a LeetCode problem — Edit Distance 💡 This classic string-based Dynamic Programming problem focuses on converting one string into another using the minimum number of operations. 🧩 Approaches Explored: Recursive DP (Brute Force Idea) DP with Memoization Bottom-Up Tabulation Space Optimized DP (1D Arrays) By understanding insert, delete, and replace operations clearly, optimizing the solution became much more intuitive 💪 Problems like these greatly strengthen core DP concepts 🚀 🔹 Concepts Used: Dynamic Programming | String DP | Space Optimization 🔹 Key Takeaway: Clear transitions between states make even complex string problems manageable 🧠 #30DaysOfCode #Round4 #Day17 #LeetCode #DynamicProgramming #EditDistance #StringDP #DSA #ProblemSolving #CodingChallenge #DeveloperJourney #CodeEveryday #CPlusPlus #LearnByDoing #ConsistencyIsKey 🚀

🗓 Day 87 / 100 – #100DaysOfLeetCode 📌 Problem 44: Wildcard Matching Today’s problem was a classic dynamic programming challenge involving string pattern matching. The task was to determine whether a string matches a pattern containing: ? → matches any single character * → matches any sequence of characters (including empty) 🧠 My Approach: Used Dynamic Programming where: dp[i][j] represents whether the first i characters of the string match the first j characters of the pattern Handled base cases carefully: Empty string vs pattern Patterns starting with * Transition rules: If characters match or pattern has ? → inherit diagonal state If pattern has * → either: match zero characters or match one/more characters Final answer comes from dp[n][m]. This approach ensures all wildcard possibilities are handled correctly. 💡 Key Learning: This problem reinforced: ✔ thinking in terms of states and transitions ✔ handling multiple matching paths with DP ✔ importance of correct base-case initialization Wildcard matching problems are great practice for mastering string DP patterns. Day 87 done — almost at the finish line 🚀 #100DaysOfLeetCode #LeetCodeChallenge #ProblemSolving #DynamicProgramming #StringMatching #DP #Algorithms #DSA #CompetitiveProgramming #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

055 I Coding - Method .sort_values() 🟩 #Technology #DataScience #Coding Method `.sort_values()`, to sort (order) dataframe based on column values. # Syntax dataframe = dataframe.sort_values(by=“column”) # Code accidentes_viales = accidentes_viales.sort_values(by=“FECHA”)

📌 NeetCode 150 — Day 13 🔹 Problem: Valid Parentheses (Level: Easy) You are given a string s consisting of the following characters: '(', ')', '{', '}', '[' and ']'. The input string s is valid if and only if: Every open bracket is closed by the same type of close bracket. Open brackets are closed in the correct order. Every close bracket has a corresponding open bracket of the same type. Return true if s is a valid string, and false otherwise. 🔹 Key Idea The problem can be solved using a stack to track opening brackets. As we scan the string, every opening symbol is pushed onto the stack. When a closing bracket appears, we pop the most recent opening bracket and check whether it matches the current one. If it doesn’t, the string is invalid. After processing the entire string, the stack must be empty for the input to be valid—any remaining elements indicate unmatched opening brackets. 🔹 Complexity Let n be the length of the string. Time Complexity: O(n) — Each character is processed once as it is pushed to or popped from the stack. Space Complexity: O(n) — In the worst case, the stack may store up to n opening brackets. 🔹 Takeaway Stacks are perfect for problems that require tracking nested or ordered structures. If you’ve approached this problem differently, I’d love to hear your perspective. #NeetCode #DSA #SoftwareEngineering #Consistency

I thought I “knew backtracking” after solving LeetCode 46. Then LeetCode 47 humbled me. Same code. Same logic. Still wrong. Because duplicates don’t care about your confidence. Here’s the uncomfortable truth: Most of us don’t struggle with new concepts — we struggle when a problem adds one extra constraint and exposes shallow understanding. Permutations II isn’t hard. What’s hard is realizing: Copy-pasting LC 46 logic doesn’t work “Used array” alone isn’t enough If you don’t control duplicates, your recursion will happily lie to you Sorting + skipping duplicates isn’t a trick. It’s the difference between knowing a pattern and understanding it.