Max Dot Product of Two Subsequences LeetCode Challenge

🚀 LeetCode Daily Challenge – Day 10 Problem #712: Minimum ASCII Delete Sum for Two Strings (Medium) This was a really interesting Dynamic Programming + Strings problem that made me think beyond the usual edit-distance pattern. 🧭 How I Approached the Question: Instead of directly minimizing the delete cost, I flipped the perspective. 👉 If I can maximize the ASCII sum of the common subsequence between the two strings, then: The characters not in this subsequence are the ones that must be deleted The minimum delete cost = (total ASCII of s1 + total ASCII of s2) − 2 × (ASCII sum of common subsequence) So the problem becomes: ➡️ Find the maximum ASCII sum common subsequence (a weighted LCS). 🧠 Core Insight: I used a 2D DP table where: dp[i][j] represents the maximum ASCII sum of a common subsequence between s1[:i] and s2[:j] Transition: If characters match → add their ASCII value Else → carry forward the best result by skipping one character 🛠️ Why This Works: By maximizing what we keep, we automatically minimize what we delete. This reframing made the solution much cleaner and intuitive. ⏱ Time Complexity: O(n × m) 📦 Space Complexity: O(n × m) #LeetCode #DailyCoding #DynamicProgramming #Strings #ProblemSolving #DSA #Python #CodingJourney

🚀 LeetCode 904 – Fruit Into Baskets | Sliding Window Mastery 🍎 Today’s problem looked simple at first… but it’s a perfect test of thinking in windows, not loops. 🧠 The Challenge You’re walking through an orchard, picking fruits 🍓🍎 You can carry only 2 types of fruits, but you want to collect as many as possible in a row. Sounds easy? The trick is knowing when to expand and when to shrink your window. ✨ Key Insight (Aha Moment!) Instead of restarting every time the rule breaks: 👉 Maintain a sliding window that always contains at most 2 fruit types When a 3rd type appears: 🔹 Shrink the window from the left 🔹 Remove fruits until only 2 types remain 🔹 Keep tracking the maximum window size This converts a brute-force problem into an O(n) optimal solution ⚡ 📌 What this problem really teaches 🔹 How to manage frequency with a hashmap 🔹 When and why to shrink a window 🔹 How “at most K distinct elements” problems work 🔹 Real-world thinking applied to DSA 💡 Pattern Recognition Tip If you see: ➡️ Longest subarray ➡️ At most 2 / K distinct elements 🎯 Think Sliding Window + Frequency Map 🔥 Problems like this build intuition, not just code. Each sliding window problem makes the next one feel easier. #LeetCode #DSA #SlidingWindow #ProblemSolving #CodingJourney #Java #Python #TechLearning

𝑴𝒚 𝒊𝒏𝒔𝒊𝒈𝒉𝒕𝒔 𝒘𝒉𝒊𝒍𝒆 𝒄𝒐𝒎𝒑𝒂𝒓𝒊𝒏𝒈 '𝑴𝒚 𝒄𝒐𝒅𝒆' 𝒕𝒐 𝒕𝒉𝒆 '𝑺𝒐𝒍𝒖𝒕𝒊𝒐𝒏 𝑪𝒐𝒅𝒆' 🙄 To be honest, I've only recently started using functions and using comments in my code... since I didn't know that they were so handy 😅 But when I look at the solution, it feels like: "Wow! You just have to look once to get what's happening in there 😮" And hence, I started using 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬 and 𝐂𝐨𝐦𝐦𝐞𝐧𝐭𝐬 in my code which made it look less messy and more understandable 😁 I guess, just 'making the code work and give the desired solution' is not the only step, but making it more READABLE and UNDERSTANDABLE is what makes the code more awesome 😆 (It helps to solve bugs easily too 👍) Suggestions and Insights are appreciated 🙌✨ #Python #Programming #CSE #StudentDeveloper #LearningWhileCoding

Today’s focus was a LeetCode Easy problem that tests real logical discipline, not tricks. 🔹 LeetCode #9 – Palindrome Number At first glance, this looks trivial. It isn’t. The task is simple: Check whether a number reads the same forward and backward. What actually matters while solving it: Negative numbers must be rejected immediately The original value must be preserved before mutation Digits must be extracted and rebuilt correctly Loop termination has to be precise The approach I used: Reverse the number digit by digit using modulo and integer division Compare the reversed value with the original number The logic is straightforward, but any missed condition silently breaks the solution. Key takeaway: Easy problems don’t fail because of complexity. They fail because of careless edge-case handling. Alongside this, I’m also solving smaller logic-building problems focused on: Conditional branching Boundary validation Correct ordering of conditions These reinforce the same thinking from a different angle. 🔗 GitHub Repository (all solutions): 👉https://lnkd.in/d5J4MA8q #LeetCode #Python #ProblemSolving #LogicBuilding #BackendDevelopment #LearningInPublic

Day 12/30: Building a Functional Utility Library in Python 🛠️📏 For Day 12 of my #30DaysOfPython challenge, I built a Modular Unit Converter. This project was about moving beyond simple scripts and embracing Functional Programming. Instead of writing "spaghetti code," I created a library of reusable conversion tools. Why this is a step up: ✅ Functional Logic (def): Learning to wrap mathematical formulas into reusable functions for cleaner code. ✅ Modular Design: Building a menu-driven interface that can easily scale (I can add 100 more conversions without breaking the app!). ✅ Data Precision: Using f-string formatting to ensure engineering outputs are rounded to the correct decimal place. ✅ Input Flexibility: Handling user inputs and converting them to float to ensure the math handles decimals correctly. Whether it’s converting Celsius to Fahrenheit or Kilometers to Miles, building your own "tools of the trade" is how you master the logic behind the software! Check out the "Unit Converter Code" below! 👇 #Python #Engineering #DataScience #CodingChallenge #Day12 #ModularProgramming #UtilityTools

🏎️ Day 12 of The Product-Engineer-Max Challenge After mastering the Bun runtime, I’ve now shifted gears into Python, alongside Rus, focusing on fundamentals, clarity, and how languages actually teach you to think. This phase is less about frameworks and more about first principles: how code runs, how bugs happen, and how developers debug in the real world. Repo: https://lnkd.in/eiUTGx8V Reflections & Learnings: - Started Python from absolute scratch, assuming zero prior knowledge - Revisited Hello World as a runtime + tooling check, not just a ritual - Learned how Python executes via the terminal and why print() is your window into execution - Understood what a bug really is: code that runs but behaves incorrectly - Practiced debugging by reading output before touching code - Differentiated logic bugs vs syntax errors - Learned how Python reports syntax errors clearly and why that matters - Understood what the console/terminal actually is: a text-only conversation with the machine - Clarified backend vs frontend thinking early - Revisited source code vs machine code fundamentals - Reinforced that code executes top-to-bottom, instruction by instruction - Compared syntax across languages (Python vs Go vs Fortran) - Realized Python isn’t just easy — it’s deliberately readable and expressive Overall takeaway: After systems-level tooling with Bun, Python feels like learning to explain ideas clearly to a computer. Pairing it with Rust keeps me grounded between simplicity and correctness. One tool teaches speed. Another teaches discipline. Together, they teach engineering. Coding_is_meditation #ProductEngineer #Python #Rust #BackendEngineering #ComputerScience #LearnBuildShip #SoftwareEngineering #ProgrammingFundamentals

🚀 Turbocharge your RAG pipelines with SymRank.   If you are building RAG systems, you know that every millisecond counts during the retrieval step. We've just upgraded SymRank to v0.2.0, and the performance gains are substantial.   SymRank is a high-performance cosine similarity ranking library that replaces standard NumPy/scikit-learn calls with a blazing-fast Rust backend.   What’s new in v0.2.0? • Matrix API: A new optimized path for 2D NumPy arrays that delivers up to 5x faster re-ranking compared to standard Python baselines. •  Python 3.14 Ready: Fully tested and compatible with the latest Python release. • Smart Dispatch: Automatically selects serial or parallel execution based on your workload. • Memory Efficient: Native batching support to keep your footprint low.   SymRank is designed to be a drop-in upgrade for your vector search and ranking workflows.   Benchmarks (10k vectors): ⏱️ SymRank: ~1.8ms   Check it out on GitHub (link in first comment) and let us know what you think! 👇 #RAG #VectorSearch #Python #Rust #MachineLearning #LLM #ReRanking

🚀 Deep Dive into Dynamic Programming — Max Dot Product of Two Subsequences Today I worked on solving LeetCode 1458: Max Dot Product of Two Subsequences, and it turned out to be a great exercise in DP mindset + edge-case handling. What made this problem interesting wasn’t just writing the code — it was understanding why certain choices matter . Key learnings: - Dynamic Programming isn’t about memorizing formulas — it’s about defining the right state - When negatives are involved, returning 0 can be wrong — sometimes a large negative sentinel is necessary - At every step, think in terms of choices: . take both elements . skip from either array . or start fresh with the current pair - Memoization drastically reduces repeated work and improves performance 📌 The final solution uses Top-Down DP with recursion + memoization, handling all edge cases correctly and running in O(m × n) time. More than getting an accepted solution, this problem strengthened my understanding of: ✅ DP transitions ✅ Handling negative values safely ✅ Translating logic cleanly into Python Step by step, problem by problem — getting better at thinking, not just coding 💪 #DynamicProgramming #LeetCode #Python #DSA #ProblemSolving #SoftwareEngineering #LearningJourney

⚡ Tackling if-else statements be like… We’ve all been there: one more condition, then another, and just one more edge case. Before you know it, your code works… but nobody wants to touch it. 😅 The problem isn’t that nested conditionals work. The problem is what happens six months later when you need to change them. Here are some alternatives I reach for: → Early returns instead of deep nesting → Guard clauses to fail fast → Lookup tables instead of long if-else chains → Strategy pattern for complex logic → Well-named functions for clarity The best refactoring moment? When you catch yourself adding the third level of nesting. 🚨 What’s your rule of thumb for refactoring nested conditionals? #SoftwareEngineering #Programming #CleanCode #DevLife #Python #Java #LinkedIn

LeetCode Progress Update Recently crossed 254 problems solved with consistent daily practice and a strong focus on improving problem-solving depth. Difficulty breakdown: 🔹 39 Hard 🔹 140 Medium 🔹 75 Easy Current focus areas include Dynamic Programming, Backtracking, and pattern-based DSA problems where identifying states, transitions, and constraints matters more than just coding the solution. Regular practice is helping me strengthen: • Structured thinking • Optimization techniques • Handling edge cases effectively Always working on writing better, more efficient solutions. #LeetCode #DSA #ProblemSolving #DynamicProgramming #Backtracking #Python #SoftwareEngineering #Consistency #ContinuousLearning