Maximize Square Hole Area in Grid with LeetCode Solution

Day 24 / #100DaysOfCode LeetCode 1877 — Minimize Maximum Pair Sum in Array (Medium) Problem (short): Given an array of even length, pair up all elements such that the maximum pair sum is minimized. Each element must be used exactly once. Key Insight: - To minimize the maximum pair sum, we must balance extremes. - Pairing large numbers together increases the maximum. - Pairing small numbers together wastes the chance to offset large values. So the optimal strategy is: - Sort the array - Pair the smallest with the largest, second smallest with second largest, and so on - Track the maximum among these pair sums This greedy pairing ensures no pair becomes unnecessarily large. Approach: 1. Sort the array 2. Use two pointers from both ends 3. For each pair, compute sum and update the maximum - Time Complexity: O(n log n) - Space Complexity: O(1) (ignoring sort space) #Leetcode #DSA #Java

Hello Everyone, Day 16 / #100DaysOfCode LeetCode 2975 — Maximum Square Area by Removing Fences From a Field (Medium) Problem: You’re given a large rectangular field divided by horizontal and vertical fences. Some fences can be removed (boundary fences cannot). The goal is to form the largest possible square area by removing fences and return its area modulo 10^9 + 7. Key Insight: A square is possible only if the horizontal gap equals the vertical gap. So the problem reduces to: 1. Find all possible distances between pairs of horizontal fences. 2. Find all possible distances between pairs of vertical fences. 3. The largest common distance between the two determines the side of the square. Approach: - Add boundary fences (1 and m / n). - Sort fence positions. - Compute all possible differences between fence pairs. - Store horizontal differences in a set. - Iterate vertical differences and pick the maximum one that also exists in the horizontal set. - Square the side length and apply modulo. Why this works: Removing fences merges segments. Any square formed must span the same distance horizontally and vertically, so intersecting the two distance sets guarantees validity. Complexity: - Time: O(n^2+m^2) - Space: O(n^2) #Leetcode #DSA #Java

Solved LeetCode 26: Remove Duplicates from Sorted Array This problem focuses on modifying a sorted array in-place without using extra memory. I used the two-pointer approach, where one pointer tracks unique elements and the other scans the array. Whenever a new value is found, it is placed at the next valid position. This ensures that only unique elements remain in the first part of the array. The solution works in O(n) time complexity and O(1) space complexity, making it optimal. #DSA #Java

Finished the code-based part of the Loops module by comparing different loop structures. The logic stayed the same, but the control flow changed. // for loop for (int i = 1; i <= 5; i++) {   System.out.print(i + " "); } // while loop int i = 1; while (i <= 5) {   System.out.print(i + " ");   i++; } // do-while loop int j = 1; do {   System.out.print(j + " ");   j++; } while (j <= 5); What this comparison made clear: - for is best when the number of iterations is known - while fits when the loop depends on a condition - do-while guarantees at least one execution - choosing the right loop improves readability, not just correctness This felt like a good way to close the practical part of loops. #Java #Loops #LearningInPublic #Beginner #DSA

📘 LeetCode Daily — Balanced Binary Tree Checked tree balance by recursively comparing left and right subtree heights at every node. The solution worked, but it clearly showed how repeated height calculations increase time complexity—an important reminder that correct logic isn’t always optimal logic. Solid recursion practice and a good lead-in to optimization. #LeetCode #BinaryTree #Recursion #DSA #Java

📘 LeetCode Daily — Balance a Binary Search Tree Solved this by first using inorder traversal to convert the BST into a sorted list, then reconstructing the tree from the middle element to ensure balance. This approach clearly showed how traversal order captures structure and how choosing the midpoint at each step naturally leads to a height-balanced tree. A neat example of combining traversal + divide-and-conquer. #LeetCode #BinarySearchTree #InorderTraversal #DivideAndConquer #DSA #Java

📝 Day 11/30 – LeetCode #26 (Remove Duplicates from Sorted Array) | Java A brute-force approach using extra space would work, but the constraint here is to modify the array in-place. Since the array is already sorted, duplicates always appear next to each other. Using a two-pointer approach, one pointer tracks the position of the last unique element while the other scans through the array. Whenever a new value is found, it is placed at the next valid position. This results in an O(n) solution with O(1) extra space. This problem reinforced how understanding input constraints can significantly simplify the solution. #LeetCode #Java #DSA #TwoPointers #Arrays #ProblemSolving #Consistency #LearningInPublic

📝 Day 17/30 – LeetCode #238 (Product of Array Except Self) | Java The straightforward solution using division fails due to edge cases involving zeros and is explicitly disallowed. A brute-force approach would also be inefficient with O(n²) time complexity. By computing prefix products and suffix products, I was able to calculate the result for each index without using division. Each element in the output array represents the product of all numbers before and after it, resulting in an O(n) time solution with constant extra space. This problem highlighted how breaking a problem into directional passes can simplify complex constraints. #LeetCode #Java #DSA #Arrays #PrefixSum #ProblemSolving #Consistency #LearningInPublic

Hello Everyone, Day 26 / #100DaysOfCode LeetCode 1200 — Minimum Absolute Difference (Easy) Problem (short): Given an array of distinct integers, find all pairs [a, b] such that |a - b| is minimum among all possible pairs. Key Insight: After sorting, the minimum absolute difference can only occur between adjacent elements. Why? - Any non-adjacent pair will have a larger gap due to sorting. - So instead of checking all O(n²) pairs, we only scan once. Approach: 1. Sort the array 2. Traverse from left to right 3. Track the smallest difference between arr[i] and arr[i-1] 4. Reset the result list when a smaller diff is found 5. Append pairs when the diff matches the current minimum Complexity: - Time: O(n log n) (sorting) - Space: O(1) extra (excluding output) #Leetcode #DSA #Java

𝗗𝗮𝘆 𝟵/𝟮𝟬 — 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 Solve Merge Sorted Array using the Two Pointer (from end) technique. ➤  Approach (O(m + n), O(1) space): Set three pointers: —> i = m - 1 (end of nums1 valid elements) —> j = n - 1 (end of nums2) —> k = m + n - 1 (end of nums1 total capacity) Compare elements from the back and place the larger one at index k Move pointers accordingly until one array is exhausted ➤ Key Insight: Merging from the front would overwrite values. Merging from the back avoids extra space and keeps everything in-place. #LeetCode #Java #DSA #TwoPointers #ArrayProblems #ProblemSolving #20DaysChallenge #Consistency