Rotating Matrices in Place with Transpose and Reverse

Day 51/100 | #100DaysOfDSA 🚀⚡ Today’s problem: Product of Array Except Self Given an array, return a new array where each element is the product of all elements except itself — without using division. Brute force? Too slow. Division? Not allowed. Optimized Approach: • Build prefix product array (left to right) • Then multiply with suffix product (right to left) • No extra space needed (excluding output) Time Complexity: O(n) Space Complexity: O(1) Big takeaway: Breaking a problem into prefix + suffix patterns can unlock optimal solutions. Clean logic. Efficient approach. 💯 Day 51 done. 🔥 #100DaysOfCode #LeetCode #DSA #Algorithms #Arrays #PrefixSum #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

Day 89: Lane-Based Swapping 🏎️ Problem 2840: Check if Strings Can be Made Equal With Operations II Yesterday’s problem was a fixed-length vibe check; today, the constraints opened up. The mission: can we sync two strings of any length by swapping characters at any even-to-even or odd-to-odd indices? The Logic: • Two Separate Lanes: Characters at even indices can never move to odd positions. They live in two parallel universes. • Frequency over Simulation: Instead of actually swapping, I just checked if the "pool" of characters in each lane matched between both strings. • The Check: If the count of 'a'-'z' at all even positions in s1 matches s2, and the same holds for odd positions, any arrangement is reachable. It’s a classic case of seeing past the "swapping" distraction and realizing it’s just a frequency distribution problem. One more day down, logic still sharp. 🚀 #LeetCode #Java #Algorithms #DataStructures #DailyCode

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝: 𝐃𝐞𝐭𝐞𝐫𝐦𝐢𝐧𝐞 𝐖𝐡𝐞𝐭𝐡𝐞𝐫 𝐌𝐚𝐭𝐫𝐢𝐱 𝐂𝐚𝐧 𝐁𝐞 𝐎𝐛𝐭𝐚𝐢𝐧𝐞𝐝 𝐁𝐲 𝐑𝐨𝐭𝐚𝐭𝐢𝐨𝐧 (𝟏𝟖𝟖𝟔) Today I solved an interesting matrix problem that involves matrix rotation and comparison. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: Given two n × n binary matrices mat and target, determine whether mat can become target by rotating it in 90° increments (0°, 90°, 180°, 270°). 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Check if the current matrix equals the target. If not, rotate the matrix 90° clockwise. Repeat the process up to 4 rotations. If any rotation matches the target → return true. 𝐇𝐨𝐰 𝐫𝐨𝐭𝐚𝐭𝐢𝐨𝐧 𝐰𝐨𝐫𝐤𝐬: Step 1: Transpose the matrix (swap mat[i][j] with mat[j][i]) Step 2: Reverse every row This efficiently performs a 90° clockwise rotation in-place. Time Complexity: O(4 × n²) → effectively O(n²) Space Complexity: O(1) (in-place rotation) 𝐊𝐞𝐲 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Matrix rotation problems can often be solved efficiently using the transpose + reverse technique, which is a powerful pattern for many 2D array problems. #LeetCode #DataStructures #Algorithms #Java #CodingPractice #ProblemSolving #SoftwareEngineering

Day 16/100 – LeetCode Challenge Problem Solved: Binary Tree Level Order Traversal Today’s problem focused on traversing a binary tree level by level. Instead of visiting nodes in depth-first order, the goal is to group nodes according to their depth in the tree. The idea behind the solution is to track the level of each node while traversing the tree. Starting from the root at level 0, each recursive call increases the level for its child nodes. When visiting a node, we check whether a list for that level already exists. If not, we create one; otherwise, we append the node value to the existing level list. By doing this, the traversal naturally organizes nodes into separate lists representing each level of the tree. Time Complexity: O(n) Space Complexity: O(n) Key takeaway: Tree problems often become easier when you track additional context during traversal. In this case, maintaining the current level allows the recursion to build a structured level-by-level result. Day 16 completed. Continuing the consistency streak and strengthening tree traversal concepts. #100DaysOfLeetCode #Java #BinaryTree #TreeTraversal #Algorithms #ProblemSolving

Day 18/100 – LeetCode Challenge Problem Solved: Reverse Linked List Today’s problem focused on reversing a singly linked list. While it looks simple, it’s a fundamental concept that tests pointer manipulation and understanding of linked structures. The idea is to iterate through the list and reverse the direction of each node’s pointer. At every step, we keep track of three things: the current node, the previous node, and the next node. We reverse the link by pointing the current node to the previous one, then move all pointers one step forward. By the end of the traversal, the previous pointer will be pointing to the new head of the reversed list. Time Complexity: O(n) Space Complexity: O(1) Performance: Runtime 0 ms Key takeaway: Linked list problems are all about pointer control. Mastering how pointers move and change direction is essential for solving more complex problems efficiently. Day 18 completed. Staying consistent and reinforcing core data structure fundamentals. #100DaysOfLeetCode #Java #LinkedList #Algorithms #ProblemSolving #Consistency

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

🚀 Day 44 of #100DaysOfCode Solved 1011. Capacity To Ship Packages Within D Days on LeetCode 📦 🧠 Key Insight: We need to find the minimum ship capacity such that all packages can be shipped within D days. This is a classic case of Binary Search on Answer. ⚙️ Approach: 1️⃣ The minimum capacity = max(weight) (since one package must fit) 2️⃣ The maximum capacity = sum of all weights 3️⃣ Apply Binary Search between these bounds 4️⃣ For each capacity mid, simulate shipping: 🔹Keep adding weights until capacity exceeds 🔹Move to the next day when exceeded 5️⃣ If we can ship within D days → try smaller capacity 6️⃣ Else → increase capacity This helps us find the minimum valid capacity efficiently. ⏱️ Time Complexity: O(n log(sum)) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #BinarySearch #Algorithms #Java #InterviewPrep #CodingJourney

🚀 Day 37 of my #100DaysOfCode Journey Today, I solved the LeetCode problem: Transpose Matrix Problem Insight: Given a matrix, the task is to convert its rows into columns. If no transformation is possible in-place (for non-square matrices), we create a new matrix. Approach: • Identify number of rows and columns • Create a new matrix with reversed dimensions (col × row) • Traverse each element of the original matrix • Place elements by swapping indices → (i, j) becomes (j, i) Time Complexity: • O(m × n) — visiting each element once Space Complexity: • O(m × n) — due to new matrix creation Key Learnings: • Transpose = swapping row and column indices • Dimension handling is crucial to avoid errors • In-place transpose is only possible for square matrices Takeaway: A small change in indexing can completely transform how we view and solve a problem. #DSA #Java #LeetCode #100DaysOfCode #CodingJourney #ProblemSolving #Matrix

Day 17/100 – LeetCode Challenge Problem Solved: Spiral Matrix Today’s problem required traversing a matrix in spiral order, starting from the top-left corner and moving right, down, left, and up repeatedly until all elements are visited. The key idea is to maintain four boundaries that represent the current layer of the matrix being processed: top, bottom, left, and right. We move in four directions step by step: ->Traverse from left to right across the top row. ->Traverse from top to bottom along the right column. ->Traverse from right to left across the bottom row. ->Traverse from bottom to top along the left column. After completing each direction, the corresponding boundary is adjusted inward so the traversal continues with the inner layer of the matrix. This process continues until the boundaries cross, ensuring every element is visited exactly once. Time Complexity: O(m × n) Space Complexity: O(1) (excluding the result list) Performance: Runtime 0 ms Key takeaway: Many matrix traversal problems become manageable when you define clear boundaries and shrink them step by step. Day 17 completed. Continuing the journey of strengthening algorithmic thinking through consistent practice. #100DaysOfLeetCode #Java #Algorithms #MatrixTraversal #ProblemSolving #Consistency

Day 24 of my #30DayCodeChallenge: The Art of In-Place Transformation! The Problem: Rotate Image (90 Degrees Clockwise) How do you rotate an n × n matrix without using extra space? The challenge isn't just the rotation- it's doing it in-place, maintaining O(1) extra space complexity. The Logic: Instead of trying to move every element to its final destination in one leap, this problem is best solved by breaking it down into two simple geometric transformations: 1. The Transpose: First, I flipped the matrix over its main diagonal. This turns all rows into columns (and vice versa). Mathematically, we swap matrix [i][j] with matrix [j][i]. 2. The Reflection: Once transposed, the image "sideways." To fix the orientation for a clockwise rotation, I ersed each row. This horizontal flip move columns into their correct 90-dearee positions. One step closer to mastery. Onward to Day 25! #Java #Algorithms #DataStructures #Matrix #ProblemSolving #150DaysOfCode #SoftwareEngineering #LeetCode