Solved 2257. Count Unguarded Cells in the Grid on LeetCode

🚀 LeetCode POTD — 2536. Increment Submatrices by One 🎯 Difficulty: Medium | Topics: 2D Difference Array, Prefix Sums, Matrix Manipulation 🔗 Solution Link: https://lnkd.in/gpjg6t5w Today’s #LeetCode Problem of the Day was a classic 2D difference array question — simple once you recognize the pattern, but extremely efficient compared to brute-force updates. We’re given an n × n zero matrix and multiple queries, where each query asks us to increment every element in a submatrix by 1. Updating each cell one-by-one would be too slow, so difference-array logic makes the solution clean and optimal. 🧠 My Approach: For each query [x, y, a, b], instead of updating the entire submatrix, update only the start and end boundaries using difference marks: matrix[i][y] += 1; if (b + 1 < n) matrix[i][b + 1] -= 1; Loop from row x to a and apply these boundary updates. After processing all queries, run a prefix sum row-wise to build the final matrix. This reduces the complexity drastically and leverages the power of prefix operations. 📈 Complexity: Time: O(n² + q × submatrix_height) Space: O(n²) 💡 Takeaway: Difference arrays (1D or 2D) are among the most elegant techniques to convert repeated updates into boundary operations — a pattern that appears often in competitive programming and system-level problems. #LeetCode #ProblemOfTheDay #DSA #Matrix #PrefixSum #DifferenceArray #CodingChallenge #Programming #SoftwareEngineering #CodingJourney #100DaysOfCode #TechCommunity

🧩 Day 64 of #100DaysOfCode 🧩 🔹 Problem: Remove All Adjacent Duplicates in String – LeetCode ✨ Approach: Used a stack-based approach to efficiently remove adjacent duplicates. For each character, if it matches the stack’s top element, pop it — otherwise, push it. A simple yet powerful way to process strings in O(n) time while maintaining clean logic. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — each character is processed once Space Complexity: O(n) — for the stack and output string ✅ Runtime: 23 ms (Beats 54.52%) ✅ Memory: 45.26 MB (Beats 85.43%) 🔑 Key Insight: Sometimes, solving problems isn’t about brute force — it’s about using the right data structure to make every step count. 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Stack #StringManipulation #CleanCode #CodingChallenge #AlgorithmDesign #LogicBuilding #CodeJourney #Programming

🌟 Day 71 of #100DaysOfCode 🌟 💡 Problem: Matrix Diagonal Sum – LeetCode ✨ Approach: Traversed both primary and secondary diagonals in a single loop — adding elements smartly while avoiding double-counting the center in odd-sized matrices. Simple logic, elegant optimization! ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal through the matrix rows Space Complexity: O(1) — constant auxiliary space ✅ Runtime: 0 ms (Beats 100%🔥) ✅ Memory: 46.26 MB 🔑 Key Insight: In coding, clarity wins. The shortest paths often come from the clearest logic. 🎯 #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #ProgrammingChallenge #CodeJourney #LogicBuilding #Efficiency #DeveloperGrowth #CodingDaily

🚀 Day 18 of my 120 Days of LeetCode Challenge 📘 Problem 18: 4Sum Difficulty: Medium 🧩 Problem Statement: Given an integer array nums of length n, return all unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that: 0 <= a, b, c, d < n a, b, c, and d are distinct nums[a] + nums[b] + nums[c] + nums[d] == target You may return the answer in any order. Example: Input: nums = [1, 0, -1, 0, -2, 2], target = 0 Output: [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]] 💡 Approach Used: To solve this problem efficiently, I used a combination of sorting and the two-pointer technique (an optimized version of the 3Sum approach): Sort the array to handle duplicates and simplify traversal. Fix two numbers using two nested loops. For the remaining two numbers, apply the two-pointer approach (left and right) to find pairs that make up the target sum. Skip duplicates for all four numbers to ensure only unique quadruplets are added to the result. Use long long to avoid integer overflow when numbers are large. This structured and optimized method ensures that all valid quadruplets are found without redundancy. ⏱️ Time Complexity: O(n³) → Sorting takes O(n log n), and the nested loops with two-pointers make it cubic overall. 💾 Space Complexity: O(1) (excluding the result storage) since only pointers and a few variables are used. ✨ Key Takeaway: This problem builds upon the logic of 3Sum and extends it to a higher combination level, helping improve understanding of multi-pointer techniques and nested search optimizations. #LeetCode #Day18 #4Sum #C++ #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #TwoPointer #Sorting #Programming

💡 (7th Nov 2025) Today I Learned: Patterns — Advanced (Part 1) After mastering basic star and shape patterns, today I moved into advanced pattern problems — where logic meets precision. Here’s what I learned and practiced 👇 1️⃣ Hollow Rectangle Pattern — Learning how to print borders while leaving the center blank using nested loops. 2️⃣ Dry Run: Hollow Rectangle Pattern — Understanding each iteration of i and j to visualize how the pattern is formed. 3️⃣ Inverted & Rotated Half Pyramid — Controlling spaces and stars to achieve mirrored symmetry. 4️⃣ Inverted Half Pyramid with Numbers — Introducing numerical logic within pattern loops. 5️⃣ Floyd’s Triangle Pattern — A beautiful number pattern that fills a triangle incrementally. 💬 Key Takeaway: Pattern problems aren’t just about visuals — they sharpen loop control, logic sequencing, and dry-run analysis. Every pattern teaches precision, patience, and problem-solving — three key skills for any developer. #CodingJourney #Patterns #Java #dsa #Programming #DeveloperGrowth #ApnaCollege #LearningInPublic #LogicBuilding

🚀 Day 63 of #100DaysOfCode — LeetCode 1799: Maximize Score After N Operations (Hard) My Submission:https://lnkd.in/gDTGaHA5 Today’s problem focused on applying bitmask dynamic programming to optimize pair selection in a sequence of operations. The challenge was to maximize the total score obtained from pairing numbers, where each operation contributes a score of i × gcd(x, y). Since elements are removed after pairing, an efficient way to explore valid combinations was key. 💡 Approach: I implemented a recursive + memoized DP solution using bitmasking: Each bit in the mask represents whether an element has been used. For each operation, I iterated over all possible pairs of unused elements (i, j) and computed the score as (operation_index + 1) * gcd(nums[i], nums[j]). The recursive function explores all valid pairings, while memoization (dp[mask][index]) ensures overlapping subproblems are computed once. This approach efficiently handles up to 14 elements (since n ≤ 7) while ensuring the optimal global result. ⏱️ Time Complexity: O((2n)² × 2^(2n)) 💾 Space Complexity: O(2^(2n) × n) A great exercise in bitmask optimization and recursive state management — one of those problems that really sharpen implementation clarity. #LeetCode #DynamicProgramming #Bitmasking #ProblemSolving #Cplusplus #100DaysOfCode #LearningEveryday #AlgorithmDesign

🚀 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 56 of #100DaysOfCode 🎯 Problem: Rotate Image ✨ Approach: Rotating a matrix by 90° clockwise involves transposing and then reversing, but here I implemented it using an auxiliary matrix for clarity and precision. Each element’s new position is determined by transforming its coordinates — a great test of matrix manipulation logic! 🧩 ⚙️ Complexity Analysis: Time Complexity: O(n²) — every element is visited once Space Complexity: O(n²) — used an additional matrix for transformation 📊 Result: ✅ Runtime: 0 ms (Beats 💯%) ✅ Memory: 41.8 MB (Beats 99.32%) 💡 Key Insight: Matrix rotation is more than a pattern — it’s spatial reasoning in action! Perfect for mastering 2D array manipulation and index mapping 🔄 #100DaysOfCode #LeetCode #Java #MatrixRotation #ProblemSolving #CodingChallenge #DSA #Programming #LogicBuilding #CleanCode #DeveloperJourney #CodeEveryday

🔥 Day 21 | LeetCode Challenge – Unique Paths (Problem #62) Today’s challenge focused on finding the number of unique ways a robot can move from the top-left corner to the bottom-right corner of an m x n grid — with the restriction that it can only move right or down at any step. 💡 Concept Overview: The task is a classic Dynamic Programming problem that leverages the principle of counting paths using cumulative sub-solutions. Each cell’s path count is derived from the sum of paths from the top and left cells — as those are the only directions available to reach it. 📘 Approach Used: Used a 1D DP array to optimize space. Initialized the first row with one path since there’s only one way to move horizontally. Iteratively updated the DP array to accumulate paths from top and left cells. The final value in the array represents all unique paths to the target. ⚙️ Algorithm Used: Dynamic Programming (Space Optimized) 🧾 Language: Java ⚡ Runtime: 0 ms (Beats 100%) 💾 Memory: 41.86 MB 🧠 Key Insight: Efficient path-counting problems often reveal that simple cumulative logic and state reuse can drastically minimize memory usage while maintaining optimal performance. #Day21 #LeetCode #UniquePaths #DynamicProgramming #JavaCoding #ProblemSolving #100DaysOfCode #DataStructuresAndAlgorithms #CodingChallenge #TechLearning #ProgrammingJourney #CodeOptimization

🚀 DSA Progress – Day 99 ✅ Problem #190: Reverse Bits 🧠 Difficulty: Easy | Topics: Bit Manipulation, Binary Representation, Bitwise Operations 🔍 Approach: Implemented a bitwise manipulation method to reverse all 32 bits of an unsigned integer. This problem helps build a strong understanding of how bits can be extracted, shifted, and reassembled — a key concept in low-level programming and embedded systems. Step 1 (Initialization): Start with rev = 0 to store the reversed bits. Step 2 (Extract + Reverse): For each bit position i from 0 to 31: Extract the ith bit using (n >> i) & 1. Move that bit to its reversed position (31 - i) using (bit << (31 - i)). Combine it into rev using bitwise OR (|=). Step 3 (Return Result): After processing all bits, return the reversed number as the final result. 🕒 Time Complexity: O(32) → effectively O(1) (constant time) 💾 Space Complexity: O(1) → no extra data structures used 📁 File: https://lnkd.in/gKeNZQf9 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem deepened my understanding of bit-level operations like shifting (<<, >>) and masking (&, |). It showed how reversing bits is similar to flipping binary mirrors — a useful concept in embedded systems, graphics, and cryptographic algorithms. The challenge reinforced that mastering bitwise logic is essential for writing efficient, low-level optimized code. ✅ Day 99 complete — flipped every bit, reversed the logic, and came out enlightened! ⚡💡💻 #LeetCode #DSA #Python #BitManipulation #Binary #CodingChallenge #InterviewPrep #100DaysOfCode #DailyCoding #GitHubJourney