LeetCode 3070: Prefix Sum for Submatrix Counting

Day 77: 2D Prefix Sum Mastery 📊 Problem 3070: Count Submatrices with Top-Left Element and Sum Less Than k Today's challenge was a classic exercise in optimizing grid calculations. The goal: count how many submatrices starting from (0,0) have a total sum less than or equal to k. The Strategy: • 2D Prefix Sums: Instead of recalculating the sum for every possible submatrix, I used Dynamic Programming to build a prefix sum grid in-place. • The Formula: For any cell (i,j), the sum is the current value + the sum above + the sum to the left - the overlapping diagonal sum. • Efficient Counting: Since I only needed submatrices anchored at the top-left, a single pass through the grid was enough to compute the sums and increment the count. Using the Inclusion-Exclusion Principle turned an O(M² ⋅ N²) brute force into a crisp O(M ⋅ N) solution. One step closer to the goal. 🚀 #LeetCode #Java #Matrix #Algorithms #DataStructures #DailyCode

Day: 73/365 📌 LeetCode POTD: Minimum Absolute Difference in Sliding Submatrix Medium Key takeaways/Learnings from this problem: 1. This problem shows how sliding window ideas extend to 2D, not just arrays, but it gets trickier to manage. 2. Maintaining a sorted structure (like multiset) helps in quickly finding min absolute differences in each window. 3. Big learning: brute force over every submatrix is too slow, so optimize by reusing previous window computations. 4. Overall, it’s a solid mix of 2D traversal + smart data structures to keep things efficient. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷

Day 79: Sliding Submatrix Grinds 🔍 Problem 3567: Minimum Absolute Difference in Sliding Submatrix Today’s challenge was about finding the smallest gap between unique values within a shifting k×k window. It’s essentially a "Sliding Window" problem on a 2D scale. The Strategy: • Window Traversal: Iterated through every possible top-left coordinate where a k×k submatrix could fit. • Flatten & Sort: For each window, I gathered all elements into a list and sorted them. Sorting is the shortcut here, the minimum difference must exist between adjacent elements in a sorted list. • The "Unique" Check: Carefully calculated the absolute difference between neighboring elements, ignoring duplicates to find the true minimum gap. While the nested loops + sorting approach got the job done today, it’s a bit of a brute-force flex. It’s a solid reminder that sometimes "Make it work" is the first step before "Make it fast." 🚀 #LeetCode #Java #Algorithms #DataStructures #DailyCode

Day 29 of My DSA Journey Today I solved LeetCode 151 – Reverse Words in a String on LeetCode. 📌 Problem Given a string s, reverse the order of words. A word is defined as a sequence of non-space characters. The output string should not contain leading, trailing, or multiple spaces. Example: Input: " hello world " Output: "world hello" 🧠 Approach – String Manipulation Steps I followed: • First, remove leading and trailing spaces using trim(). • Split the string into words using split(" "). • Traverse the array from end to start. • Skip empty strings (caused by multiple spaces). • Append words into a StringBuffer with proper spacing. This approach ensures that: ✔ Words are reversed ✔ Extra spaces are removed ✔ Output is clean and formatted ⏱ Time Complexity: O(n) — Traversing the string and array 📦 Space Complexity: O(n) — Storing split words and result 💡 Key Learnings ✔ Handling string edge cases (extra spaces) ✔ Efficient use of built-in string methods ✔ Practicing string traversal and reconstruction Small problems like this help build strong fundamentals in string manipulation 🚀 Consistency continues — one day at a time 💪 #100DaysOfCode #DSA #Strings #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

The most dangerous phrase in software is: "But it works on my machine." ⚠️ I decided to eliminate that phrase entirely for my latest project. This video captures the "black box" transformation—using the Nuitka compiler to translate thousands of lines of Python into optimized C code. It’s a tense few minutes watching the machine stitch together ezdxf, win32com, and Tkinter into a single, indestructible executable. The Mystery: Why go through the trouble of a C-level compilation instead of just running a script? Because when a tool hits the production floor, it needs to be more than just "code." It needs to be a professional-grade solution for engineering efficiency. The goal was to take a complex environment and vanish it—leaving behind nothing but a high-performance, standalone tool. The Result: The "Successfully created" message at the end isn't just a build log. It’s the birth of LCPL_Grey_Scaler.exe (v1.1). No Python installation needed. No dependency errors. Just pure, compiled speed. 🚀 #Python #SoftwareEngineering #Automation #CAD #Nuitka #Innovation #CodingLife #Engineering #Deployment

🚀 Day 557 of #750DaysOfCode 🚀 🔥 Solved: XOR After Range Multiplication Queries II (Hard) Today’s problem really pushed my understanding of optimization and patterns in arrays. At first glance, it looks like a simple simulation—but with constraints up to 10⁵, a brute-force approach quickly breaks down. 💡 Key Learnings: Handling range updates efficiently is crucial Observed how step-based traversal (k jumps) affects time complexity Importance of modular arithmetic in large computations XOR properties helped in deriving the final result efficiently ⚡ Challenge: Each query updates elements at intervals, making it tricky to optimize without directly iterating every time. 🧠 Takeaway: Hard problems are less about coding and more about recognizing patterns and optimizing smartly. Consistency is the real game 💯 #LeetCode #DataStructures #Algorithms #CodingJourney #ProblemSolving #Java #100DaysOfCode #KeepGrinding

DSA series... 🚀 Chapter 3: "Sliding Window Dynamic" LeetCode #3 (Level: Medium) Longest Substring Without Repeating Characters... 🧐 At first glance, this looks like a string problem … Especially substring problem, without any doubts move to Sliding Window (Dynamic) ... 🔥 Sliding Window (Dynamic) ... ⚡ - Just move your right pointer to expand until you hit your goal, then pull your left pointer to shrink and find the optimal size. Explanation ... ✍️ 1⃣ Get the length and check the edge condition. 2⃣ Use two pointers `left` and `right`. Keep a set/map to track characters existence. 3⃣ Move `right` pointer to add characters on the string when the character is not duplicate one. 4⃣ If duplicate found, move `left pointer` to remove characters until duplicate is gone. 5⃣ Track max length during the process. --- Difference between Sliding Window Fixed vs Dynamic Programming ... 👇 ** On Fixed, we decrement 'left' pointer only once when contition met. Use if statement. ** On Dynamic Programming, we decrement 'left' pointer untill reach the condition fully met on the current window. Use while statement. Note: But sometimes it may be differ... You can see that difference from the previous chapter and the current one ... ❗ --- Easy Trigger to Remember for this pattern usage ... 😎 👉 “Longest substring without repeating characters”, 👉 “At most / no duplicate”. --- Key Insights ... 🎯 - Don’t restart the loop when duplicate appears, - Just shrink the window smartly that saves time (O(n)). Just put on your thoughts or suggestions ... 💬 Stay tuned always ... 😎 #LeetCode #SlidingWindow #DSA #CodingInterview #Java #ProblemSolving #Algorithms #TechLearning #SoftwareEngineering

Day 38 of My DSA Journey Today I solved LeetCode 152 – Maximum Product Subarray on LeetCode. 📌 Problem Given an integer array nums, find the contiguous subarray that has the largest product, and return that product. Example: Input: [2,3,-2,4] Output: 6 → subarray [2,3] 🧠 Approach – Dynamic Programming (Tracking Max & Min) This problem is tricky because of negative numbers. Key Idea: • At each index, we maintain: maxProduct → maximum product ending at current index minProduct → minimum product ending at current index 👉 Why min? Because a negative number can turn a small (negative) product into a large positive one. Steps I followed: • Initialize maxProduct, minProduct, and ans with the first element • Traverse the array from left to right • If the current number is negative → swap max and min • Update: maxProduct = max(current, current × maxProduct) minProduct = min(current, current × minProduct) • Update the final answer using maxProduct ⏱ Time Complexity: O(n) — Single pass through the array 📦 Space Complexity: O(1) — No extra space used 💡 Key Learnings ✔ Handling negative numbers in product problems ✔ Using dynamic programming with state tracking ✔ Understanding why tracking both max & min is important This is one of those problems that looks simple but tests deep understanding of edge cases 🚀 Consistency continues — leveling up every day 💪 #100DaysOfCode #DSA #DynamicProgramming #Arrays #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

🚀 Day 3 – Strings, Patterns & Optimizations! Today I dove deep into string problems and realized how much optimization matters. 💡 Highlights from Day 3: Anagram Check: Learned to map characters using frequency arrays. Why c - 'a' works now makes total sense. String Compression: Counting frequencies vs handling consecutive duplicates efficiently. Realized StringBuilder is a life-saver for performance. KMP Algorithm: Pattern searching without restarting. LPS array is the secret sauce! Learned to find patterns in O(n + m) time. 🔥 Key Lesson: It’s not just about solving a problem—it’s about solving it efficiently. Knowing the theory behind the code makes all the difference. From brute-force thinking → optimized thinking, every day I’m leveling up my coding skills. #DSA #Java #100DaysOfCode #CodingJourney #ProblemSolving #LearningDaily

📘 DSA Journey — Day 20 Today’s focus: Sliding Window with frequency constraints. Problem solved: • Maximum Number of Occurrences of a Substring (LeetCode 1297) Concepts used: • Sliding Window technique • Frequency tracking using HashMap / array • Substring counting Key takeaway: The goal is to find the maximum frequency of any substring that satisfies: • At most maxLetters distinct characters • Length between minSize and maxSize A key observation simplifies the problem: We only need to check substrings of size minSize, because larger substrings will have equal or lower frequency. Using a sliding window of fixed size minSize, we: • Track character frequencies inside the window • Ensure the number of distinct characters ≤ maxLetters • Count valid substrings using a HashMap This avoids checking all possible substring sizes and reduces complexity significantly. This problem highlights how constraints can reduce the search space, making sliding window solutions more efficient. Continuing to strengthen pattern recognition and consistency in solving DSA problems. #DSA #Java #LeetCode #CodingJourney