Largest Submatrix With Rearrangements: LeetCode Challenge

🚀 01/04/26 — Navigating the Cycle: Mastering Circular Array Loops Today marks the start of a new month and a massive continuation of my journey—Day 45 of my coding streak! I tackled the Circular Array Loop (LeetCode 457), a complex problem that requires tracking directions and cycle lengths within a wrapping array. 🔄 Circular Array Loop (LeetCode 457) The challenge is to find if there is a cycle in the array where the movement is either entirely forward or entirely backward, and the cycle length is greater than one. The Logic: Traversal & Validation Next Index Calculation: I implemented a helper function calNxt to handle the circular movement. For positive jumps, it uses a simple modulo. For negative jumps, it adds the array length to the modulo result to ensure the index stays within positive bounds. State Tracking: For every starting index, I use a HashSet to keep track of visited nodes in the current path. Directional Consistency: I capture the direction at the start of each path (isPos). If the movement ever switches direction (e.g., a positive jump leads to a negative value), the loop is invalidated. Cycle Length Check: A valid cycle cannot have a length of 1. I ensure this by checking curr != next before returning true. Complexity Metrics: Time: O(n^2) as we potentially start a traversal from every index. Space: O(n) to store the HashSet for visited indices. 📊 Implementation Highlights FeatureLogic AppliedCircular Jump(curr + (seq % len) + len) % lenPath TrackingHashSet<Integer> for current iterationCondition 1Must stay in original directionCondition 2Cycle length must be > 1 📈 Consistency Report Reaching a 45-day streak feels incredible! Today's problem combined the Two-Pointer-like movement of jumping through indices with the HashSet logic I mastered earlier this month. Handling the "wrapping" indices correctly was a great refresher on modulo arithmetic. Huge thanks to Anuj Kumar (a.k.a CTO Bhaiya on YouTube) for the foundational roadmap. Moving into these more advanced circular logic problems shows how much my core array skills have grown. My tested implementation for the circular loop detection is attached below! 📄👇 #DSA #Java #LeetCode #CircularArray #HashSet #CycleDetection #CodingJourney #Consistency #45DayStreak #LearningInPublic #CTOBhaiya

Solved Today’s LeetCode Daily Challenge! Problem: Check if Strings Can Be Made Equal With Operations II At first glance, it looks like a swapping problem… but the real trick is understanding the constraint You can only swap characters if the distance between indices is even. Key Insight: Characters at even indices can only swap among even positions Characters at odd indices can only swap among odd positions So instead of simulating swaps (which is messy ), I used a smarter approach: Count frequency of characters at even indices Count frequency at odd indices Compare both strings If both match → Possible Else → Not possible Time Complexity: O(n) Space Complexity: O(1) Takeaway: Sometimes problems look complex, but a small observation can simplify everything. Consistency + pattern recognition = #LeetCode #DSA #Java #Coding #ProblemSolving #TechJourney #100DaysOfCode

🚀 Today's Coding Challenge: Rotate Array Took on the Rotate Array problem and focused on getting both correctness and efficiency right. ✅ Implemented an in-place solution with O(n) time complexity and O(1) space ✅ Leveraged the array reversal technique to avoid unnecessary extra memory ✅Performance beats 42.38% of submissions This problem looks simple at first glance, but the real test is optimizing space while keeping the logic clean and bug-free. It’s a solid reminder that understanding underlying patterns always beats brute force. Consistency > intensity. Showing up daily. 💪 #DataStructures #Algorithms #CodingChallenge #Java #ProblemSolving #LeetCode

✅ Solved: Palindrome Number — LeetCode #9 Accepted with all 11,511 / 11,511 test cases passed! 🎯 The problem asks: Given an integer x, return true if x is a palindrome, and false otherwise. My approach: Immediately return false for negative numbers (can't be palindromes) Convert the integer to a String using String.valueOf() Reverse the string by iterating from end to start Compare original and reversed — if equal, it's a palindrome ✔️ Runtime: 16 ms | Memory: 46.48 MB A clean beginner-friendly solution. Next, I'd like to optimize it using a mathematical digit-reversal approach — no String conversion needed, better memory efficiency! 🚀 If you're grinding LeetCode, don't skip the easy problems. They build the intuition you need for the hard ones. 💪 #LeetCode #Java #DSA #DataStructures #Algorithms #CodingChallenge #Programming #SoftwareDevelopment #ProblemSolving #PalindromeNumber

🚀 25/03/26 — The Triple Reverse: Mastering Array Rotation Today marks a massive milestone—Day 38 of my coding journey! I tackled one of the most popular interview questions: Rotate Array (LeetCode 189). While rotating an array sounds simple, doing it in-place without extra space requires a deep understanding of index manipulation and symmetry. 🔄 Rotate Array (Reverse Method) The logic behind this approach is incredibly elegant. Instead of shifting elements one by one, we use three strategic reversals to "flip" the array into its rotated state. The Logic: Full Reverse: Reverse the entire array. This moves the last k elements to the front, but in reverse order. Part 1 Reverse: Reverse the first k elements to restore their original relative order. Part 2 Reverse: Reverse the remaining n-k elements to restore their order. The Guard Clause: I used k = k % n to handle cases where k is larger than the array length, preventing unnecessary full rotations. Complexity: Time: O(n) because each element is visited at most twice. Space: O(1), achieving perfect memory efficiency. 📊 Implementation Highlights StepOperationResult for [1,2,3,4,5], k=2InitialInput Array[1, 2, 3, 4, 5]1Reverse All[5, 4, 3, 2, 1]2Reverse first k (2)[4, 5, 3, 2, 1]3Reverse k to end[4, 5, 1, 2, 3] 📈 Consistency Report Reaching a 38-day streak feels incredible! Today's problem is a perfect example of how "Two-Pointer" logic (which I've been practicing since early March) can be combined to solve complex structural changes. Moving from simple reversals to this triple-reverse strategy shows how my problem-solving "blocks" are starting to fit together. I'm definitely excited to try the Cyclic Replacement (Juggling) Method for this problem. It's a more mathematically intensive O(n) approach that moves each element to its final position in one go! Huge thanks to Anuj Kumar (a.k.a CTO Bhaiya on YouTube) for the roadmap. The momentum is real, and the logic is getting sharper every day! My tested O(1) space implementation is attached below! 📄👇 #DSA #Java #LeetCode #ArrayRotation #TwoPointers #Consistency #38DayStreak #LearningInPublic #CTOBhaiya

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

📌 LeetCode Daily Challenge — Day 26 Problem: 3548. Equal Sum Grid Partition II Topic: Array, Matrix, Prefix Sum, HashSet, Greedy   📌 Quick Problem Sense: You're given an m × n integer grid. Make one straight cut, horizontal or vertical to split it into two non-empty parts with equal sums. The twist? You're allowed to remove at most one border element (right at the cut edge) from either side to balance the sums. Return true if such a partition is possible!   🧠 Approach (Simple Thinking): 🔹 Compute the total sum of the grid upfront 🔹 Scan row by row, maintain a running top sum, derive bottom = total - top 🔹 The imbalance is diff = top - bottom 🔹 A cut is valid if: diff == 0 → already perfectly balanced ✅ diff equals a corner cell of the top section ✅ diff equals the left-border cell of the current bottom row ✅ diff exists in a HashSet of all values seen so far ✅ 🔹 Use a HashSet to track all border values already scanned, O(1) lookup to check if removing one element fixes the imbalance 🔹 For vertical cuts → simply transpose the matrix and reuse the same horizontal cut logic! 🔹 Also try reversed row order to cover cuts scanned from the opposite direction, 4 passes total, all reusing the same function 🔄   ⏱️ Time Complexity: 4 passes through the grid (original, reversed, transposed, transposed+reversed) → O(m × n) Single scan per pass, HashSet lookups in O(1) — clean and efficient!   📦 Space Complexity: HashSet of seen values → O(m × n) worst case Transpose grid → O(m × n) Overall → O(m × n)   I wrote a full breakdown with dry run, real-life analogy, and step-by-step code walkthrough here 👇 https://lnkd.in/g2FHaT4S If you solved it by explicitly enumerating only the border cells, or used a different balance-check trick, drop it in the comments, always curious to see how others think about it 💬 See you in the next problem 👋 #LeetCode #DSA #CodingChallenge #Java #ProblemSolving #Programming

🚀 Solved Linked List Cycle Detection using Fast & Slow Pointers Used Algorithm are: - Slow pointer moves 1 step - Fast pointer moves 2 steps - If they meet → cycle exists To find cycle start: - Move slow to head - Move both one step → meeting point = cycle start ⚡ Time: O(n) | Space: O(1) #DSA #LinkedList #Java #LeetCode #Coding

🚀 Day 25 of my #100DaysOfCode Journey Today, I solved the LeetCode problem Valid Perfect Square. Problem Insight: Given a positive integer, the task is to determine whether it is a perfect square without using built-in functions like sqrt(). Approach: Used Binary Search to efficiently find whether a number has an integer square root. Initialized search range from 0 to num Calculated mid and checked mid * mid If equal → return true If square is smaller → move right (low = mid + 1) If square is larger → move left (high = mid - 1) Used long for multiplication to avoid overflow issues. Time Complexity: O(log n) — efficient binary search approach Takeaway: Binary Search is not just for arrays — it can be applied to mathematical problems to optimize performance and avoid brute force. #DSA #Java #LeetCode #CodingJourney #100DaysOfCode #BinarySearch

🚀 Day 26/100 Days of #CodeChallenge Today’s problem: Isomorphic Strings (Leetcode 205) This problem helped me understand how to map characters between two strings while maintaining consistency and order. 💡 Key Concept: Two strings are isomorphic if characters in one string can be replaced to get the other string — with: ✔️ One-to-one mapping ✔️ No two characters mapping to the same character ✔️ Order preserved 🧠 What I Learned: How to use mapping (arrays/hashmaps) efficiently Importance of bidirectional checking Handling edge cases like unequal lengths ⚡ Approach: Compare lengths first Track character mappings using arrays Ensure consistency in both directions ⏱️ Complexity Analysis: Time Complexity: O(n) → We traverse the strings once Space Complexity: O(1) → Fixed-size arrays (256 characters) ✅ Successfully solved and understood the logic! Every day is a step closer to mastering problem-solving 💪 #Day26 #100DaysOfCode #Java #DSA #LeetCode #CodingJourney #ProblemSolving #TechLearning