Minimum Swaps to Arrange Binary Grid on LeetCode

🚀 Day 54 of #100DaysOfCode 🌱 Topic: Stack / Two Pointers ✅ Problem Solved: LeetCode 42 – Trapping Rain Water 🛠 Approach: Used a Monotonic Stack to calculate trapped water. Traversed the array and maintained a stack of indices. When current height is greater than stack top: Popped the top → this forms a “valley”. If stack becomes empty → break (no left boundary). Calculated: Height = min(left boundary, right boundary) − current height Width = distance between boundaries Added height × width to total water. Pushed current index into stack. This effectively finds water trapped between bars. #100DaysOfCode #Day54 #DSA #Stack #TwoPointers #LeetCode #HardProblems #Java #ProblemSolving #CodingJourney #Consistency

Day 16/30 – LeetCode streak Today’s problem: Minimum Swaps to Arrange a Binary Grid. Goal: using only adjacent row swaps, make the grid such that all cells above the main diagonal are 0. Key observation: - For row 'i' (0-indexed), everything to the right of column 'i' must be 0. - That means row 'i' must have at least 'n - 1 - i' trailing zeros in its binary row.  - Row 0 needs 'n - 1' trailing zeros, row 1 needs 'n - 2', … last row needs '0'. Greedy approach: - First, for each row, precompute how many trailing zeros it has. - Then, for each target position 'i' from top to bottom:  - Compute 'need = n - 1 - i'.  - Scan rows 'i..n-1' to find the first row whose 'trailing[j] >= need'.  - If none exists → impossible → return '-1'.  - Otherwise, “bubble” that row up to 'i' by swapping it with rows above it one by one, counting each swap. Day 16 takeaway: Once you rephrase the condition as “row i needs at least 'n-1-i' trailing zeros” and only track those counts, the problem turns into a simple greedy row-bubbling simulation instead of a scary matrix puzzle. #leetcode #dsa #java #greedy #consistency

📌 LeetCode Daily Challenge — Day 2 Problem: 1536. Minimum Swaps to Arrange a Binary Grid Topic: Greedy, Array, Matrix 🔑 The Core Insight: For a grid to be valid, row i must have at least n-1-i trailing zeros. That single observation turns a complex matrix problem into a straightforward Greedy scan! 🛠️ The Approach: ✅ Count trailing zeros for each row ✅ Greedily find the closest row that satisfies each position ✅ Bubble it up using adjacent swaps ✅ If no valid row exists → return -1 ⚡ Complexity: → Time: O(n²) | Space: O(n) → One pass greedy. Clean. Efficient. No drama. 💡 Biggest Takeaway: The hardest part wasn't the code it is seeing the pattern. Once you realize each row has a trailing zero requirement, everything else falls into place naturally. 📖 Want the full breakdown with dry runs, code walkthrough, and complexity analysis? I've documented everything in detail my medium page, check it out here: 👉 https://lnkd.in/gK_9_D47 If you solved it using different approach, I’d love to hear it. Drop your thoughts in comments. See you in the next problem👋 #LeetCode #DSA #Greedy #Java #ProblemSolving #SoftwareEngineering #CodingInterview #Tech #Engineering

Day 82 - LeetCode Journey 🚀 Solved LeetCode 92: Reverse Linked List II (Medium) — a powerful problem that takes basic reversal to the next level. We already know how to reverse an entire linked list. But here, the challenge is to reverse only a specific portion — between positions left and right — while keeping the rest intact. 💡 Core Idea (Partial Reversal + Pointer Rewiring): Use a dummy node to simplify edge cases Move a pointer (prev) to the node just before position left Start reversing nodes one by one within the given range Reconnect the reversed sublist back to the original list This is done using in-place pointer manipulation. 🤯 Why it works? Because instead of reversing the entire list, we carefully rewire only the required segment, preserving connections before and after the range. ⚡ Key Learning Points: • Partial reversal of linked list • Advanced pointer manipulation • Importance of dummy node in edge cases • In-place modification without extra space • Maintaining O(n) time and O(1) space This problem is a big step up from basic linked list reversal. Also, this pattern connects with: Reverse Linked List (full reversal) Reverse Nodes in k-Group Reorder List Palindrome Linked List ✅ Better control over pointer operations ✅ Strong understanding of in-place transformations ✅ Confidence with medium-level linked list problems From full reversal to selective reversal — this is real progress 🚀 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

🚀 Day 37 — LeetCode Practice 🚀 Today’s focus was on strengthening linked list fundamentals and mastering pointer manipulation. ✅ Problem solved today: 🔹 Merge Two Sorted Lists 💡 Key learnings from today: • Strengthened understanding of the two-pointer technique in linked lists • Learned how using a dummy node simplifies head handling • Practiced merging nodes without creating a new list • Improved clarity on pointer movement and reference updates • Handled edge cases like one list being null Initially, I was carefully thinking about how to manage the head of the merged list. Then I realized that using a dummy node removes unnecessary conditional checks and makes the logic much cleaner. That small structural decision made the implementation simpler and more readable — achieving O(n + m) time complexity with O(1) extra space. This problem reminded me: Sometimes clean structure matters more than complex logic. Better pointer control. Cleaner implementation. Stronger linked list foundation. 💪 On to Day 38 🚀 #Day37 #DSA #LeetCode #ProblemSolving #Java #LinkedList #CodingJourney #Consistency #FutureEngineer

Day 76/365 – Wiggle Subsequence Today’s problem was all about identifying patterns in sequences and optimizing with a greedy approach. 🔍 **Problem** Find the length of the longest subsequence where differences between consecutive numbers strictly alternate (up-down-up... or down-up-down...). 💡 **Key Insight** We don’t need to build the subsequence — just track the pattern! Maintain two variables: • `up` → last difference was positive • `down` → last difference was negative Update them as you iterate through the array. 🧠 **Approach (Greedy)** * If current > previous → update `up = down + 1` * If current < previous → update `down = up + 1` * Ignore equal elements ⚡ **Why it works?** We only care about direction changes, not exact values. This keeps the solution efficient. ⏱ **Complexity** Time: O(n) Space: O(1) ✨ **Key Learning** Sometimes the optimal solution isn’t about building the answer — it’s about tracking the right states efficiently. Consistency > complexity. #Day76 #365DaysOfCode #LeetCode #Greedy #Algorithms #DSA #CodingJourney #Java #ProblemSolving #TechGrowth

🚀 Day 53 of #100DaysOfCode Solved 3100. Water Bottles II on LeetCode 🔗 🧠 Key Insight: This problem is a twist on the classic water bottle exchange. Unlike the original, the exchange rate increases after each trade, making it slightly more tricky. ⚙️ Approach: 1️⃣ Start with numBottles → initial full bottles 2️⃣ While we can exchange: 🔹Spend numExchange empty bottles 🔹Gain 1 full bottle 🔹Increment numExchange (cost increases each time) 3️⃣ Keep tracking total bottles drunk 🔁 This is essentially a simulation problem with a dynamic condition. ⏱️ Time Complexity: O(k) (number of exchanges) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #Greedy #Simulation #Java #CodingJourney

🚀 Day 81 / 100 – LeetCode Daily Challenge 📌 Problem: Minimum Partitions to Decompose a Number (1689) 🧠 Concept: Greedy | String Manipulation Today’s problem was deceptively simple but conceptually rich — finding the minimum number of deci-binary numbers needed to sum up to a given string n. The key insight? 🔍 The answer is simply the maximum digit in the string! Why? Because in any addition of deci-binary numbers (each made of only 0s and 1s), the largest digit in the target number dictates how many numbers are needed in the worst-case scenario. So if the number is "82734", we need at least 8 numbers (one for each unit at the position of '8'). ✅ One pass. One max check. Clean and greedy. 📊 Runtime: 6 ms | Beats 75.56% 💾 Memory: 47.43 MB ✨ Key takeaway: Sometimes the most efficient solution is hiding in plain sight — just read the problem carefully and think about the underlying constraints. #LeetCode #CodingJourney #100DaysOfCode #Day81 #GreedyAlgorithm #Java #ProblemSolving #TechCommunity #DevLife #CodeNewbie

LeetCode Problem || Minimum Swaps to Arrange a Binary Grid(1536)🚀 Today I solved an interesting greedy problem from LeetCode. 💡 Key Idea: Count trailing zeros in each row. For row i, ensure it has at least n-1-i trailing zeros. If not, find a valid row below and bring it up using adjacent swaps. If no such row exists → return -1. Concept Used: Greedy Strategy Bubble swap logic Matrix row manipulation ⏱ Time Complexity: O(n²) 📦 Space Complexity: O(n) This problem strengthened my understanding of: ✔ Greedy decision making ✔ How local swaps can build global structure #DSA #Java #Greedy #LeetCode #CodingJourney #ProblemSolving

Day 15 of my #30DayCodeChallenge: Swapping Nodes in Pairs! The Problem: Swap Nodes in Pairs. Given a linked list, the goal is to swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (only nodes themselves may be changed). The Logic: This problem is a classic exercise in Pointer Manipulation and maintaining structural integrity in a Linked List: 1. Dummy Node Strategy: I initialized a dummy node pointing to the head. This acts as a fixed anchor, ensuring I can easily return the new head of the list even after the original head has been swapped. 2. The Three-Pointer Dance: To swap two nodes (cur and t), I need ✓ nage three specific connections for every pair: **-Point the previous node (pre) to the second node of the pair (t). **- Point the first node (cur) to the node following the pair (t. next). **- Point the second node (t) back to the first node (cur). 3. Iterative Traversal: The loop continues as long as there is a full pair remaining (cur ! = nul1 && cur.next ! = null). After each swap, the pre and cur pointers shift forward to prepare for the next pair. Another step closer to mastery. Onward to Day 16! #Java #Algorithms #DataStructures #LinkedList #ProblemSolving #150DaysOfCode #SoftwareEngineering