Maximizing Coins in Grid with 2 Neutralizations

Day 36 of My DSA Journey Today I solved LeetCode 150 – Evaluate Reverse Polish Notation (RPN) on LeetCode. 📌 Problem Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are: +, -, *, / Each operand may be an integer. Example: Input: ["2","1","+","3","*"] Output: 9 Explanation: (2 + 1) * 3 = 9 🧠 Approach – Stack This problem is a perfect application of the Stack data structure. Steps I followed: • Traverse the tokens array. • If the element is a number → push it onto the stack. • If it is an operator: Pop the top two elements (a and b) Perform the operation (a operator b) Push the result back into the stack • At the end, the stack contains the final result. ⏱ Time Complexity: O(n) — We process each token once 📦 Space Complexity: O(n) — Stack to store operands 💡 Key Learnings ✔ Understanding Reverse Polish Notation (Postfix Expression) ✔ Applying stack for expression evaluation ✔ Handling operator precedence implicitly using stack This problem connects DSA with compiler/interpreter concepts, which makes it even more interesting 🚀 Consistency continues — improving every day 💪 #100DaysOfCode #DSA #Stack #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

🚀 Dynamic Programming — Simplifying Complex Problems Dynamic Programming (DP) helps solve problems by breaking them into overlapping subproblems and storing results to avoid recomputation. 💡 Think DP when: Repeated calculations exist Problem has optimal substructure ⚙️ Approaches: Memoization (Top-Down) Tabulation (Bottom-Up) 📌 Key idea: > Think in states + transitions, not brute force. Master DP → Master problem solving. #DynamicProgramming #DSA #Algorithms #Coding

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g9SGp2Qa 💡 My thought process: First, create a mapping from each value to a sorted list of its indices using a map<int, vector<int>>. This allows for easy lookup of all positions where a value occurs. For each query index idx, it retrieves the corresponding value num. If that value appears only once, the result is -1 because no valid pair exists. In case of multiple occurrences, we use binary search on the index list of num: * upper_bound finds the next occurrence that is strictly greater than idx. * lower_bound locates the current position and checks the previous occurrence. It calculates distances in both directions: * Forward distance: either direct (next - idx) or circular wrap (n - (idx - first)). * Backward distance: either direct (idx - prev) or circular wrap (n - (last - idx)). The minimum of these distances is stored as the answer. 👉 My Solution: https://lnkd.in/gjmKVa3y If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 Day 69 of #100DaysOfCode 🔥 Problem: Majority Element II (LeetCode 229) Today’s challenge was all about finding elements that appear more than ⌊n/3⌋ times in an array. Sounds simple, but the twist is doing it efficiently! 💡 Key Insight: Instead of counting frequencies using extra space, we can use an optimized approach based on the Boyer-Moore Voting Algorithm. ✨ Approach Highlights: • There can be at most 2 majority elements (> n/3) • Maintain 2 candidates and their counts • First pass → find potential candidates • Second pass → verify their frequency ⚡ Why this works? Because any element appearing more than n/3 times will survive the elimination process. 📈 Complexity: • Time: O(n) • Space: O(1) 🎯 Takeaway: Smart algorithms > brute force. Understanding patterns like voting algorithms can save both time and space! #DSA #LeetCode #CodingJourney #ProblemSolving #100DaysOfCode #Algorithms #Programming

Solved today’s LeetCode Daily and it made me pause 👇 “XOR After Range Multiplication Queries I” At first glance, it looks like: Segment Tree? Lazy Propagation? Some heavy optimization? 🤯 But the reality? Sometimes… brute force wins. --- Given constraints were small. And that completely changes the game. So instead of overengineering: ✔️ Just simulate each query ✔️ Jump with k steps ✔️ Apply multiplication (mod 1e9+7) ✔️ Take final XOR And that’s it. --- The interesting part 👇 As developers, we are trained to think: “Optimize first” But problems like this remind us: 👉 Understand constraints before choosing approach Because honestly, A simple O(n * q) solution can beat an overcomplicated design any day. --- What I learned today: • Not every problem needs advanced DS • Constraints are part of the problem statement for a reason • Simplicity is underrated --- Consistency check ✅ One more problem done. --- Curious 👇 Comment your approach. #LeetCode #DSA #Programming #Coding #Developers #ProblemSolving #Rust

🧠 One small mistake can break your entire logic. Today I learned this while solving a grid problem 👇 💻 LeetCode #1559 — Detect Cycles in 2D Grid At first glance, it looks like a simple DFS problem… But there’s a catch ⚠️ 🔍 Common mistake developers make: 👉 “If I visit an already visited cell → cycle exists” Sounds correct… but it’s NOT ❌ 🚀 My Approach (DFS + Parent Tracking): Traverse the grid using DFS Move in 4 directions (up, down, left, right) Only move to cells with the same character 👉 While moving, I track the parent cell 💡 Key Logic: If I reach a cell that is: Already visited AND not the parent 👉 Then a cycle exists ✅ ⚙️ Why parent check is important? Because going back to the previous cell is normal 👉 It should NOT be treated as a cycle 🧠 Takeaway: In DSA, logic rarely fails… 👉 Edge cases do 🔥 The difference between wrong and correct solution is often just one condition Have you ever fixed your solution by changing just 1 line? 😄 #LeetCode #DSA #Algorithms #Programming #Debugging #ProblemSolving #Developers #CodingJourney

Ever merged modulo with dynamic programming and watched the problem shrink instantly? In competitive programming, the difference between a good solution and a great one is often not speed alone, but state reduction. This is learned from CodeForces itself. This problem is a clean example: instead of thinking in terms of all subset sums, we only care about the remainder after division by k. That shift matters in contests because it saves both time and mental bandwidth and some key ideas that can help you- • Read the problem as a subset-sum divisibility check, not as a full-sum enumeration problem. • Recognise that modulo preserves addition and other operations, so every number can be replaced by its remainder. • Analyse constraints early: a full combinatorial DP is too large, but a remainder-based state fits. • Select the right approach: dp[r] tells whether a remainder r is reachable. • Implement with state compression: update from dp[i][r] to dp[r] carefully. • Debug edge cases like r = 0, repeated values, and transitions that wrap around k. Try solving this problem for instance - https://lnkd.in/gJBE8Qdi What most people miss is that CP improvement is rarely passive practice. It is pattern recognition under pressure. The same mindset appears in real engineering: reduce the state, constrain the search space, and optimize what truly matters instead of brute-forcing every possibility. How often do you pause and ask whether the problem can be redefined before you try to solve it? Follow Vishu Kalier for more such insights. #CompetitiveProgramming #DynamicProgramming #ModuloDP #DSA #Algorithms #ProblemSolving #Coding #SoftwareEngineering #cfbr #Eternal #Leetcode #Codeforces

Ever look at a LeetCode problem and think, "Oh, this is just simple math," only to see a constraint of $10^{15}$ staring back at you? That was my experience with the "Count Good Numbers" problem today. The core logic was actually pretty straightforward: even indices get even digits (5 options), and odd indices get prime digits (4 options). But trying to calculate 5^even * 4^odd for massive numbers? Immediate Time Limit Exceeded (TLE). I had to scrap the standard approach and write a custom pow() function using Binary Exponentiation. It’s wild how applying modulo 10^9 + 7 at every single multiplication step within the recursive call is the exact difference between a failing solution and a clean O(log n) pass without integer overflow. Definitely a great reminder that knowing the brute-force math is only half the battle—optimizing it is where the real engineering happens. Back to the grind! #LeetCode #DSA #CPP #CompetitiveProgramming #SoftwareEngineering #CodingJourney

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gxcUfyyz The first logic that came to my mind after seeing the question was — this is a cycle detection problem. Since the path isn't fixed, it's an undirected cycle detection problem. Just applied that and voila — solved! The constraints and multiple possible paths gave a clear hint towards DFS. The grid is just an undirected graph — each cell is a node, and two adjacent cells are connected only if they share the same character. So the problem reduces to: does any connected component of same-character cells contain a cycle? Run DFS from every unvisited cell, tracking the parent to avoid treating the edge we came from as a back edge. If we hit an already-visited cell that isn't our direct parent — cycle found. ⏱️ Time: O(m × n) | Space: O(m × n) 👉 My Solution: https://lnkd.in/gATmwcnU If you found this helpful, feel free to ⭐ the repo or connect! 🙂 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

Lexical Analyzer — A Deep Dive into Compiler Design Github: https://lnkd.in/gGSKZxPF 💡 A great reminder that every program we write is first understood not by humans, but by machines through structured analysis! 📄 Reads source code from files 🔎 Breaks input into meaningful tokens (Keywords, Identifiers, Constants, Operators, Special Characters) ⚙️ Performs lexical analysis using character-by-character parsing 🚫 Detects invalid or unknown tokens efficiently  What I found most fascinating about this project was how a simple piece of code is transformed into structured tokens that form the foundation of compilation.  I sincerely thank for their guidance and support throughout this project. 🎓 This project was successfully developed as part of my learning journey at Emertxe Information Technologies, where I enhanced my skills in C programming, problem-solving, and system-level thinking. #CProgramming #CompilerDesign #LexicalAnalyzer #FileHandling #EmbeddedSystems #ProjectShowcase #LearningByDoing #EngineeringJourney