LeetCode Challenge: Get Biggest Three Rhombus Sums in a Grid

🚀 Day 18 of 100 Days LeetCode Challenge Problem: Count Submatrices with Top-Left Element and Sum ≤ k Today’s problem is a clean application of 2D Prefix Sum (Cumulative Sum) 🔥 💡 Key Insight: All valid submatrices must: Start from the top-left corner (0,0) Extend to any cell (i, j) 👉 So instead of checking all submatrices, we just: Compute sum from (0,0) to (i,j) Check if it’s ≤ k 🔍 Core Approach: 1️⃣ Build Prefix Sum Matrix prefix[i][j] = sum of all elements from (0,0) to (i,j) 2️⃣ Iterate Through Grid For every (i, j): If prefix[i][j] ≤ k → count it ✅ 👉 That’s it! No need for complex nested submatrix checks 🚀 🔥 What I Learned Today: Constraints simplify problems → use them wisely 2D prefix sum reduces O(n⁴) → O(n²) Always check if the problem has a fixed starting point 📈 Challenge Progress: Day 18/100 ✅ Almost 20 days consistency! LeetCode, Prefix Sum, Matrix, 2D Arrays, Optimization, Algorithms, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #PrefixSum #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 17 of 100 Days LeetCode Challenge Problem: Largest Submatrix With Rearrangements Today’s problem is a powerful mix of matrix + greedy + sorting optimization 🔥 💡 Key Insight: We are allowed to rearrange columns, which changes everything! 👉 Instead of fixed positions: Focus on heights of consecutive 1’s in each column 🔍 Core Approach: 1️⃣ Build Heights Matrix For each cell: If 1 → increase height from previous row If 0 → reset to 0 👉 This converts the problem into a histogram per row 2️⃣ Sort Each Row (Greedy Move) Sort heights in descending order Why? → To maximize width for larger heights 3️⃣ Calculate Max Area For each position j: Area = height[j] × (j + 1) Track maximum across all rows 🔥 What I Learned Today: Rearrangement problems → think flexibility optimization Converting matrix → histogram simplifies logic Sorting can unlock hidden maximums 📈 Challenge Progress: Day 17/100 ✅ Strong consistency streak! LeetCode, Matrix, Greedy Algorithm, Sorting, Histogram, Optimization, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #GreedyAlgorithm #Sorting #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 21 of 100 Days LeetCode Challenge Problem: Flip Square Submatrix Vertically Day 21 brings a clean matrix manipulation problem—simple logic, but important for fundamentals 🔥 💡 Key Insight: We are given: Top-left corner (x, y) Size k 👉 We need to flip the k x k submatrix vertically → Meaning: reverse the order of rows inside that square 🔍 Core Approach: 1️⃣ Identify Submatrix Boundaries Rows: x → x + k - 1 Columns: y → y + k - 1 2️⃣ Swap Rows Vertically Swap: Row x ↔ Row x + k - 1 Row x + 1 ↔ Row x + k - 2 Continue until middle 👉 Only swap elements within column range [y, y + k - 1] 💡 Visualization: Top row ⬇️ becomes bottom Bottom row ⬆️ becomes top 🔥 What I Learned Today: Matrix problems often come down to index manipulation Clear boundary definition avoids mistakes Simple operations can still test precision 📈 Challenge Progress: Day 21/100 ✅ 3 Weeks Consistency Strong! 💪 LeetCode, Matrix Manipulation, Arrays, Simulation, Indexing, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #Arrays #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 6 — Remove Duplicates from Sorted Array Continuing my journey of improving problem-solving skills with consistency and discipline — one problem every day. Today’s problem focused on optimizing space and modifying arrays efficiently in-place. 🧩 Problem Solved: • Remove Duplicates from Sorted Array (LeetCode #26) 📚 Topic: Two Pointers + Array Manipulation 💡 Key Insight: Since the array is already sorted, duplicates are adjacent — making it possible to remove them using a two-pointer approach without extra space. ⚡ Approach: • Initialize a pointer i to track unique elements • Traverse array using another pointer j • Compare nums[j] with nums[i] • If different → move i forward and update value • Return i + 1 as the count of unique elements 🎯 Takeaway: Understanding problem constraints (like sorted input) can lead to more efficient and elegant solutions. ⏱ Complexity: • Time → O(n) • Space → O(1) 💻 Example: Input → [1, 1, 2] Output → 2 (Array becomes [1, 2, _]) Input → [0,0,1,1,1,2,2,3,3,4] Output → 5 (Array becomes [0,1,2,3,4,_,_,_,_,_]) Efficiency isn’t always about doing more — sometimes it’s about doing less, smarter 🚀 #ProblemSolving #LeetCode #TwoPointers #CodingJourney #100DaysOfCode #Consistency #LearningInPublic

Recently, I solved LeetCode 84 – Largest Rectangle in Histogram  At first glance, it looks like a simple array problem—but finding the maximum area efficiently requires a clever use of stacks. Problem We are given an array representing heights of histogram bars. 👉 Each bar has width = 1 👉 We need to find the largest rectangular area 🎯 Goal: Return the maximum possible rectangle area Naive Approach → Try all possible rectangles For every bar: 1. Expand left 2. Expand right ❌ Time Complexity → O(n²) ❌ Not efficient for large inputs Optimized Approach (Monotonic Stack) Instead of checking every possibility: 👉 Use a stack to maintain increasing heights 👉 Calculate area only when needed Next Smaller Element (NSE) → right boundary Previous Smaller Element (PSE) → left boundary Then: Width = NSE - PSE - 1 Area = height × width Code Flow 1️⃣ Traverse the array We go from 0 → n, and even one step beyond (important 👇) for (int i = 0; i <= n; i++) {   int curr = (i == n) ? 0 : arr[i]; 👉 At i == n, we force stack cleanup using 0 2️⃣ Maintain increasing stack while (!st.isEmpty() && arr[st.peek()] > curr) 👉 When current height is smaller → we found NSE 3️⃣ Calculate area int ele = st.pop(); int nse = i; int pse = st.isEmpty() ? -1 : st.peek(); maxi = Math.max(maxi, arr[ele] * (nse - pse - 1)); 4️⃣ Push index st.push(i); Complexity Time Complexity: O(n)  Space Complexity: O(n) (stack)  💡 Learning Some problems are not about brute force… 👉 They are about finding boundaries efficiently 👉 And using a monotonic stack to avoid repeated work ✨ This problem teaches: How to convert a 2D area problem into 1D boundary problem The power of Next Smaller + Previous Smaller logic Let’s keep learning and improving every day #LeetCode #Stack #MonotonicStack #DSA #ProblemSolving #CodingJourney #InterviewPreparation

🚀 #LeetCode Day Problem Solving 🚀 Day-39 📌 Problem: You are given points on the boundary of a square 🟥 and an integer k. 🎯 Select k points such that the minimum Manhattan distance between any pair is maximized. 🧠 Example: Input: side = 2 points = [[0,2],[2,0],[2,2],[0,0]] k = 4 ✅ Output: 2 📖 Explanation: Selecting all 4 corners → minimum distance = 2 💡 Key Insight: ✔ This is a maximize minimum distance problem 👉 Classic pattern: Binary Search on Answer 🔥 ⚡ Approach: 1️⃣ Convert each point to a 1D perimeter distance 👉 Treat square boundary as a circular line 2️⃣ Sort the positions 3️⃣ Apply Binary Search on answer d ✔ Check if we can pick k points such that minimum pairwise distance ≥ d 4️⃣ Use greedy selection to validate 🔁 Why this works? ✔ Boundary → circular structure ✔ Greedy ensures maximum spacing ✔ Binary search finds optimal minimum distance 📊 Complexity Analysis: ⏱ Time Complexity: O(n log n + n log side) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ Binary Search on answer technique 🔍 ✔ Converting 2D geometry → 1D circular problem ✔ Greedy + sorting for feasibility check ✅ Day 39 Completed 🚀 Mastering Binary Search + Geometry + Greedy 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

⚡Subarray Problems Are Not Always About Sum I solved LeetCode 713. 🔍 Problem Count subarrays where product is less than k. 🧠 Initial thought Check every subarray and calculate product. Works, but becomes O(n²). 🚀 The shift Use sliding window. Expand right, multiply product. If product ≥ k, shrink from left. 🧩 Mental model Not all subarrays need exact match. Sometimes it’s about maintaining a valid range. 🎯 Interview takeaway If problem says: subarray + condition (not exact) Think: sliding window instead of prefix sum. 💡 Practical insight For every valid window, you don’t get 1 subarray. You get: window size worth of subarrays. That’s the real trick. #DSA #LeetCode #Algorithms #SlidingWindow #CodingInterview #ProblemSolving #Learning

🚀 Keeping it Simple: Solving the "Mirror Distance" Problem! 🧩 I recently tackled an interesting problem on LeetCode: Mirror Distance of an Integer. 🔍 The Challenge: Find the "Mirror Distance," which is the absolute difference between an integer n and its reverse. 🧪 Example: Input: n = 25 Reverse: 52 Calculation: |25 - 52| = 27 ⚙️ My Approach: 1️⃣ Reverse the digits: Used a simple while loop to extract digits and rebuild the number in reverse. 2️⃣ Handle Constraints: Used long long to prevent potential overflow since n can go up to 10⁹. 3️⃣ Absolute Difference: Calculated the final result using the abs() logic. 💡 Insight: Sometimes, the most satisfying part of coding is finding a clean and efficient solution to a straightforward problem. 💻 Keep coding! 🚀 #LeetCode #CodingChallenge #DataStructures #Algorithms #ProblemSolving #Cpp #SoftwareEngineering #DailyCoding

I just put together a complete analysis on the classic "n-th Ugly Number" problem (LeetCode 264).I was curious to know exactly what happens at a large enough n, so decided to dive deep into it! The analysis breaks down: 🔹 O(n^2) Linked Lists vs. Optimal O(n) 3-Pointer Dynamic Programming (DP is currently beyond my scope, so I have skipped the code and logic and focusing solely on the standard time and space complexity results) 🔹 Combinatorics and the limits of the "Stars and Bars" method 🔹 Deriving a continuous approximation using 3-D Geometry and Tetrahedron volumes 🔹 Using Gauss’s Principle then refining the error bound using Ehrhart Polynomials. If you love the intersection of algorithmic complexity and number theory, check out the rigorous derivations in the PDF below! 📄👇 Sir Srinivasa Raghava K ,I would be grateful if u could give some insight on this analysis . #Algorithms #Mathematics #LeetCode #ComputerScience #NumberTheory

Flexibility in a problem isn’t confusion. It’s a pattern. Day 48 — Daily Engineering Practice Solved: LeetCode 2833 — Furthest Distance from Origin Problem: Given a string of moves containing L, R, and _, find the maximum distance from the origin. _ can be replaced with either L or R. --- Approach: • Count L, R, and _ • Treat _ as flexible moves • Assign all _ in one direction to maximize distance Distance = |L - R| + _ --- Pattern: When choices are flexible, push all of them in the direction that maximizes the outcome. --- Day 48. Applying patterns to simplify decisions. Let’s stay consistent. 🤝 #DSA #LeetCode #Algorithms #ProblemSolving #LearningInPublic