LeetCode Daily Challenge: Rotate Matrix Solution

🚀 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

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gbtaBXYW 💡 My thought process: The algorithm first calculates a normalized shift value using k % n. Shifting a row by its total length, n, returns the original configuration. Therefore, any shift k is the same as k modulo n. Instead of rotating memory physically or creating a temporary matrix, the code uses a virtual mapping strategy. It goes through each cell (i, j) and finds the index of the element that would be in that position after the shift. For even rows (left shift), to find the original value that moves into position j after a left shift, the code looks at the index (j - shift). It manages negative results by wrapping around with an addition of n. For odd rows (right shift), it checks the index (j + shift) % n. The function has a fail-fast mechanism; it returns false right away if it finds the first difference between a cell and its shifted counterpart. 👉 My Solution: https://lnkd.in/g5myRYRj 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

💡 “Sometimes, the difference between possible and impossible comes down to just one condition.” 🚀 #geekstreak60 — Day 58 Day 58 of the streak! Today’s problem was simple in implementation but powerful in concept — a great example of how understanding properties beats brute force. 📌 Problem Statement Given a string, determine whether its characters can be rearranged to form a palindrome. 🧠 My Thought Process At first, I thought: 👉 Generate permutations and check for palindrome ❌ (too expensive) Then I asked: What actually makes a palindrome valid? 🛠️ Key Observation For any palindrome: ✔ Characters must appear in pairs ✔ Only one character (at most) can have an odd frequency That’s it. 🛠️ Approach ✅ Count frequency of each character ✅ Count how many have odd frequency ✅ If odd count ≤ 1 → possible ❌ Else → not possible ⚡ Complexity Analysis Time Complexity: O(n) Space Complexity: O(1) 💡 Key Learning Don’t solve the problem directly — understand the rule that defines it. Today strengthened my understanding of: ✅ Frequency counting patterns ✅ Mathematical properties of palindromes ✅ Avoiding brute force solutions ✅ Writing efficient logic 🔥 Big Insight of the Day “When you understand the rule, the solution becomes obvious.” 58 days strong 💪🔥 This journey keeps proving that clarity > complexity. #geekstreak60 #npci #DSA #Java #CPP #Strings #ProblemSolving #CodingJourney #Consistency #KeepLearning

🚀 LeetCode Challenge 26/50 💡 Approach: Simulation (Iterative Reduction) No complex algorithm needed here — just clean simulation! Repeatedly halve the array by applying min to even-indexed pairs and max to odd-indexed pairs, until one element survives! 🔍 Key Insight: → Even index i → newNums[i] = min(nums[2i], nums[2i+1]) → Odd index i → newNums[i] = max(nums[2i], nums[2i+1]) → Array size halves each round (n → n/2 → n/4 ... → 1) → Since n is always a power of 2, this always terminates cleanly! 📈 Complexity: ✅ Time: O(n) — total work across all rounds sums to 2n ✅ Space: O(n) — new array created each round Not every problem needs a clever trick — sometimes disciplined simulation IS the optimal solution! 🎯 #LeetCode #DSA #Simulation #Java #ADA #PBL2 #LeetCodeChallenge #Day26of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #MinMaxGame

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/giAcdv2U 💡 My thought process: This solution uses 3D dynamic programming to find the maximum coins that can be collected from the top-left to the bottom-right of a grid, allowing up to 2 neutralizations for negative cells. The state dp[i][j][k] stores the maximum coins reachable at cell (i, j) using k neutralizations. For each cell, transitions are taken from the left and top cells. If the current cell is negative, two options are considered: either neutralize it (if k > 0) and carry forward the previous value without adding the negative, or do not neutralize and add the cell value. For non-negative cells, the value is simply added to the best of the previous states. The starting cell is initialized separately based on whether it is neutralized or not. The final answer is the maximum value among dp[m-1][n-1][0], dp[m-1][n-1][1], and dp[m-1][n-1][2]. 👉 My Solution: https://lnkd.in/gZWS3Kns 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 100: Consistency, Growth, and a Milestone 💯 Problem 3740: Minimum Distance Between Three Equal Elements I Today marks 100 days of continuous problem-solving. While the number is just a marker, the real value has been the daily discipline of opening the IDE and tackling whatever challenge LeetCode throws my way. The Strategy: • Frequency Grouping: I used a HashMap to store a list of indices for every unique number in the array. This allowed me to isolate potential triplets instantly. • Sliding Window Logic: For any number appearing three or more times, I looked at a sliding window of three consecutive indices (i,i+1,i+2). • The Formula: Through testing, I identified that the minimum distance between three equal elements can be derived from the span between the first and third occurrence: (index of 3rd - index of 1st) * 2. • Optimization: By iterating through the pre-grouped index lists, I kept the solution efficient and clean. Reflecting on these 100 days, I’ve moved from basic simulations to complex optimizations like Square Root Decomposition and 3D DP. The goal isn't to stop here—it's to keep building, keep optimizing, and keep growing. 🚀 #LeetCode #Java #Algorithms #DataStructures #100DaysOfCode #Consistency #ProblemSolving #DailyCode

✅ Solved: Palindrome Number — LeetCode #9 Accepted with all 11,511 / 11,511 test cases passed! 🎯 The problem asks: Given an integer x, return true if x is a palindrome, and false otherwise. My approach: Immediately return false for negative numbers (can't be palindromes) Convert the integer to a String using String.valueOf() Reverse the string by iterating from end to start Compare original and reversed — if equal, it's a palindrome ✔️ Runtime: 16 ms | Memory: 46.48 MB A clean beginner-friendly solution. Next, I'd like to optimize it using a mathematical digit-reversal approach — no String conversion needed, better memory efficiency! 🚀 If you're grinding LeetCode, don't skip the easy problems. They build the intuition you need for the hard ones. 💪 #LeetCode #Java #DSA #DataStructures #Algorithms #CodingChallenge #Programming #SoftwareDevelopment #ProblemSolving #PalindromeNumber

🚀 Day 3 of 180 — Spiral Matrix III ✅ Yesterday I tried this problem. Today I solved it. Let's get into it. LeetCode 885 — Spiral Matrix III You start from a given cell (rStart, cStart) on a rows × cols grid and spiral outward. The goal is to collect all valid cells in the order you visit them. The catch — the spiral goes beyond the grid boundaries. You keep moving but only collect a cell if it actually exists inside the grid. My thought process: I used a direction array to handle movement cleanly: dir = 0 → East ( 0, +1) dir = 1 → South (+1, 0) dir = 2 → West ( 0, -1) dir = 3 → North (-1, 0) The most important pattern to notice in a spiral — step count increases after every 2 turns. East → 1 step South → 1 step West → 2 steps North → 2 steps East → 3 steps ... and so on So whenever direction is East or West, I increment the step count. At every cell — check if it's inside the grid. If yes, collect it. If no, just keep moving. The spiral never stops, we just skip invalid cells. Start → add (rStart, cStart) directly while(collected < rows * cols): if dir == East or West → step++ move 'step' times in current direction → inside grid? collect it turn clockwise → dir = (dir+1) % 4 One thing this problem taught me — sometimes the movement pattern is more important than the boundary logic. Once I saw the step pattern clearly, everything else followed. Day 3 done. 177 to go. 🔥 #180DaysDSA #Day3 #LeetCode #SpiralMatrix #Java #DSA #Arrays #Matrix #DSAJourney #CodingJourney #Programming #DataStructures #Algorithms #ProblemSolving #BuildInPublic #CodeNewbie #LearnToCode #100DaysOfCode #SoftwareDevelopment #Developer #StudentDeveloper #TechCommunity #LinkedInTech #CompetitiveProgramming

🚀 #GeeksforGeeks 365 Day Problem Solving 🚀 Day-51 📌 Problem: Given a string s, determine whether its characters can be rearranged to form a palindrome. Return true if possible, otherwise false. 🧠 Examples: Input: s = "baba" ✅ Output: true Explanation: Rearranged → "abba" ✔ Input: s = "geeksogeeks" ✅ Output: true Explanation: Rearranged → "geeksoskeeg" ✔ Input: s = "geeksforgeeks" ❌ Output: false 💡 Key Insight: ✔ A string can form a palindrome if: 👉 At most ONE character has odd frequency ✔ Why? Even length → all characters must appear even times Odd length → only one character can be odd (middle) ⚡ Approach: ✔ Count frequency of each character ✔ Count how many have odd frequency ✔ If odd count ≤ 1 → ✅ Possible ✔ Else → ❌ Not possible 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) (only 26 characters) 🧠 What I Learned: ✔ Frequency counting tricks 🔢 ✔ Palindrome properties 🧩 ✔ Optimization using simple logic instead of brute force ✅ Day 51 Completed 🚀 Sharpening concepts in Strings + Hashing 💪 #GeeksforGeeks #gfg365 #coding #learning #CodingChallenge #ProblemSolving #DSA #365DaysOfCode

🚀 Day 73 — Slow & Fast Pointer Pattern (Cycle Detection) After a solid sliding window revision, today I moved to a new pattern: Slow and Fast Pointers — also known as Floyd’s Cycle Detection. This single pattern can solve ~40% of linked list problems, making it a must‑know. 📌 Core Concept: - Two pointers start at the same position (usually `head`). - Slow moves 1 step at a time. - Fast moves 2 steps at a time. - If they meet → cycle exists. If fast reaches `null` → no cycle. 🧠 Key Learnings: 1️⃣ The Analogy  Two runners on a circular track — the faster one will eventually lap the slower. On a straight track, they never meet again. Perfect mental model for cycle detection. 2️⃣ Linked List Application   - `while (fast != null && fast.next != null)` → safe condition (check `fast` first to avoid null pointer). - `slow = slow.next;`    `fast = fast.next.next;` - Meeting point (`slow == fast`) confirms a cycle. 3️⃣ Beyond Linked Lists This pattern isn’t limited to linked lists. It also works for: - Arrays (finding duplicate numbers) - Mathematical sequences (recurring decimals) - String pattern matching 4️⃣ Why It Matters   Instead of memorizing 100 linked list problems, learn this reusable template. It’s the direct solution to LeetCode 141 (Linked List Cycle) and many variations. 💡 Personal Note: No guilt about the past break — every day I add a new tool to my DSA toolkit. Slow and steady wins the race (pun intended). #DSA #SlowFastPointer #FloydCycleDetection #LinkedList #CodingJourney #Revision #LeetCode #Java #ProblemSolving #Consistency #GrowthMindset #TechCommunity #LearningInPublic