Rotating a Matrix by 90° in Java with Auxiliary Matrix

🚀 Day 14/60 - DSA Challenge Problem: Convert a 1D Array Into a 2D Array. In this problem, the task was to reshape a 1D array into a 2D matrix with given rows (m) and columns (n) — or return an empty array if the transformation isn’t possible. The key idea lies in index mapping: 👉 The element at index i in the 1D array maps to position [i / n][i % n] in the 2D array. #Day14 #Java #DSA #CodingChallenge #ProblemSolving #LeetCode #CodeInJava #Programming #60DaysDSAChallenge

🚀 Day 414 of #500DaysOfCode 🔢 LeetCode 2536: Increment Submatrices by One (Medium) Today I worked on an interesting matrix manipulation problem that teaches an important optimization idea — 2D Difference Arrays. 🧠 Problem Summary We are given an n x n matrix initialized with zeros and a list of queries. Each query represents a submatrix, and we need to increment every element inside that submatrix by 1. A brute-force solution would update each cell for every query, which becomes inefficient when the matrix and number of queries grow. ⚡ Key Insight Instead of updating all cells directly, we use a 2D prefix / difference matrix technique: Update only the corners of each submatrix Convert the difference matrix into the final matrix using prefix sums Achieve O(n² + q) performance instead of O(q · n²) A neat trick that’s extremely useful for range update problems! ✅ Takeaways Difference arrays are not just for 1D — they scale beautifully to 2D Matrix prefix sums simplify many complex update operations Thinking in terms of range operations often leads to faster algorithms 💻 Tech Used Java 2D prefix sum optimization Matrix manipulation Another day, another concept mastered. On to the next challenge! 💪🔥 #coding #leetcode #java #programming #dsa #matrix #problemsolving #500DaysOfCode #Day414

🚀 Day 111 of #gfg160 – 160 Days of Coding Challenges ✅ Problem Solved: Longest String Chain 🟡 Difficulty: Medium 🧠 Approach: Used Dynamic Programming + Sorting to efficiently find the Longest Possible Word Chain. 🔹 Step 1: Sort all words by their length — shorter words come first. 🔹 Step 2: For each word, generate all possible predecessors by removing one character at a time. 🔹 Step 3: Use a HashMap dp where dp[word] represents the longest chain ending at that word. 🔹 Step 4: If a predecessor exists in the map → dp[word] = max(dp[word], dp[predecessor] + 1) Else → Start a new chain with length 1. 🔹 Step 5: Keep track of the global maximum chain length throughout the iteration. ✅ This approach efficiently checks possible chains by reusing previous computations instead of recomputing subsequences. ⚡ Complexity: 🕒 Time Complexity: O(N * L²) → For each word (N), we generate and check up to L possible predecessors. 💾 Space Complexity: O(N) → For the DP map storing longest chain lengths. 📊 Result: ✔️ 1114 / 1114 test cases passed 📈 Accuracy: 100% Dynamic Programming beautifully captures the “build-up” of word sequences — turning small steps into long, powerful chains! 💪 #Day111 #gfg160 #GeeksforGeeks #Java #DynamicProgramming #HashMap #Strings #ProblemSolving #DSA #CodingChallenge #LearnByDoing #160DaysOfCode #DailyDSA #SoftwareEngineering #CodingJourney #Consistency #StJosephsInstituteOfTechnology

📌 Day 158 of Coding - Number of Laser Beams in a Bank (LeetCode - Medium) 🎯 Goal: Given a binary matrix representing a bank’s security system, where '1' indicates a security device, find the total number of laser beams between rows. Two rows form beams only if both have at least one device, and there are no devices in between. 💡Approach & Debugging: Traversed each row, counted the number of devices ('1's). If the current row had devices, multiplied its device count with the previous row’s count to get the number of beams. Updated prev for the next valid row. ✔️ Time Complexity: O(M*N) - M rows, N columns ✔️ Space Complexity: O(1) - constant extra space #Day158 #LeetCode #Arrays #Matrix #Java #ProblemSolving #DSA #CodingChallenge #100DaysOfCode #Algorithms #InterviewPrep #SoftwareEngineering #DataStructures #CodeNewbie #ProgrammersLife

🌟 Day 144 of 150 – LeetCode Challenge 📌 Problem #63: Unique Paths II 🔗 Category: Dynamic Programming 🧩 Problem Brief: ✔ Given an $m \times n$ grid with obstacles (marked as 1) and empty spaces (marked as 0), find the number of unique paths from the top-left to the bottom-right corner. The robot can only move down or right. 🧠 Approach Summary: ➤ This is an extension of the classic Unique Paths problem, solved efficiently using Dynamic Programming with Space Optimization. ➤ A 1D DP array, $\text{dp}$, is used to store the number of unique paths to reach the cells in the current row. The size of $\text{dp}$ is $n$ (the number of columns). ➤ Initialization: * $\text{dp}[0]$ is set to 1, representing one path to the first column's first cell (if it's not an obstacle). ➤ DP Transition: The grid is iterated row by row. For each cell $(i, j)$: * If the cell contains an obstacle ($\text{obstacleGrid}[i][j] == 1$), $\text{dp}[j]$ is set to 0, as no path can go through it. * If the cell is not an obstacle and $j > 0$, the number of paths to reach it is the sum of paths from the cell above it ($\text{dp}[j]$ from the previous row) and the cell to its left ($\text{dp}[j-1]$ from the current row). * If the cell is the first column ($j=0$) and not an obstacle, its path count only depends on the cell above it (which is already stored in $\text{dp}[0]$ before the update). ➤ The final answer is the value at the last column of the DP array, $\text{dp}[n-1]$. ⚡ Result: ✔ Runtime: 0 ms (Beats 100.00%) ✔ Memory: 41.76 MB (Beats 66.83%) #LeetCode #150DaysOfCode #CodingChallenge #Java #DSA #DynamicProgramming #ProblemSolving #CodeEveryday

💡 Day 56 of #100DaysOfCode 💡 Today, I tackled LeetCode Problem #2220 – Minimum Bit Flips to Convert Number ⚙️ A bit flip means toggling a binary bit from 0 → 1 or 1 → 0. The goal: find the minimum number of flips needed to convert one integer into another using their binary forms. 💻 Language: Java ⚡ Runtime: 0 ms — Beats 💯% 🚀 📉 Memory: 40.31 MB — Beats 90.20% 🧠 Key Learnings: Refreshed bitwise manipulation concepts. Learned efficient use of XOR (^) to find differing bits. Strengthened understanding of binary representation and counting set bits. 🧩 Approach: 1️⃣ Use XOR (start ^ goal) to identify bits that differ. 2️⃣ Count the number of set bits (1s) — each represents one flip needed. 3️⃣ Return the total count as the minimum flips. ✅ Complexity: Time: O(1) — 32-bit integer fixed loop Space: O(1) ✨ Takeaway: Bitwise problems help sharpen low-level thinking — a must for optimizing performance in system-level or embedded applications. #100DaysOfCode #LeetCode #Java #BitManipulation #CodingChallenge #ProblemSolving #CleanCode #Programming #SoftwareEngineering #TechLearning #Algorithms

#Day13 2 – Add Two Numbers Solved this classic linked list problem by implementing an efficient algorithm to add two numbers represented as reverse-digit linked lists. 💡 Approach: Used a dummy node to simplify list construction, iterated through both lists while handling different lengths, and maintained a carry value for proper digit summation. The solution elegantly handles cases where lists have different sizes and final carry propagation. #LeetCode #Java #LinkedList #DataStructures #Algorithms #ProblemSolving #Coding #Tech #SoftwareEngineering #DailyCoding #Programming

🚀 Day 103 of #gfg160 – 160 Days of Coding Challenges ✅ Problem Solved: Histogram Maximum Rectangular Area 🔴 Difficulty: Hard 🧠 Approach: Solved the Largest Rectangle in Histogram problem — a classic and challenging Stack-based question in DSA. Here’s the breakdown of the logic: 1️⃣ For each bar in the histogram, determine the largest rectangle that can be formed with that bar as the smallest height. 2️⃣ Used a stack to store indices of bars in increasing height order. 3️⃣ When a bar smaller than the stack’s top is found: Pop the stack and calculate the area with the popped bar as the smallest height. The width is determined by the difference between the current index and the new stack top (or total bars if empty). 4️⃣ Repeated the process for all remaining bars in the stack after iteration. This ensures we efficiently find the maximum possible rectangular area. ⚡ Complexity: 🕒 Time Complexity: O(N) → Each element is pushed and popped at most once. 💾 Space Complexity: O(N) → Stack to store indices. 📊 Result: ✔️ 1121 / 1121 test cases passed 📈 Accuracy: 100% An excellent problem that tests the power of stacks in optimizing space and time for real-world computation patterns like histograms and skyline problems! 💪 #Day103 #gfg160 #GeeksforGeeks #Java #Stack #HistogramProblem #LargestRectangle #ProblemSolving #DSA #CodingChallenge #LearnByDoing #160DaysOfCode #DailyDSA #SoftwareEngineering #CodingJourney #TechJourney #Consistency #StJosephsInstituteOfTechnology

✅Day 77 of #100DaysOfLeetCode 📌Problem: 2169. Count Operations to Obtain Zero 🟢 Difficulty: Easy 📍Topic: Simulation 🎯 Goal: Given two non-negative integers num1 and num2, return the number of operations required to make either num1 or num2 equal to 0. In each operation, subtract the smaller number from the larger one. 🧠Key idea: Approach 1: Use a simple loop to repeatedly subtract the smaller number from the larger until one becomes zero. Initialize a counter to track the number of operations. If num1 > num2, subtract num2 from num1; otherwise, subtract num1 from num2. Increment the counter after each subtraction. Stop the loop when either number reaches zero and return the count. #LeetCode #DailyChallenge #Programming #Java #CodingChallenge #Algorithms #CodeNewbie #100DaysChallenge #LearnToCode #ProblemSolving #DataStructures #TechCareers #WomenWhoCode #DevCommunity #LeetCodeJourney