Minimize Max Pair Sum in Array with Java Sorting

Day 39/100 – LeetCode Challenge ✅ Problem: #1984 Minimum Difference Between Highest and Lowest of K Scores Difficulty: Easy Language: Java Approach: Sorting + Sliding Window Time Complexity: O(n log n) Space Complexity: O(1) Key Insight: After sorting, the minimum range in k elements must come from consecutive elements in sorted order. Sliding window of size k finds the minimum difference between first and last element in window. Solution Brief: Sorted the array to bring close values together. Initialized answer with first k elements. Slided window across array, updating minimum difference. Finding minimal range in sorted array with sliding window #LeetCode #Day39 #100DaysOfCode #Sorting #SlidingWindow #Java #Algorithm #CodingChallenge #ProblemSolving #MinimumDifference #EasyProblem #Array #Optimization #DSA

Day 51: Tackling the "Hard" 🧠 Problem 761: Special Binary String After a streak of "easy"s, the difficulty spiked. This one was essentially a parentheses-balancing problem disguised as binary. The Strategy: • Identify: Tracked "Special" substrings using a balance counter. • Recurse: Processed inner strings recursively to find their best forms. • Sort: Reverse-sorted the resulting components to maximize the value. Ngl, I needed a hand with the implementation, but the logic—treating binary strings like nested structures—finally clicked. Sometimes you have to get cooked to learn. 🧗♂️ #LeetCode #Java #Recursion #Algorithms #ProblemSolving #DailyCode

Day 44: Avoiding the O(n²) Trap 🔍 Problem 3714: Longest Balanced Substring II Today’s goal: find the longest substring where all present characters appear equally. Since we only had 'a', 'b', and 'c' to deal with, I split the logic into three cases (1, 2, or 3 unique characters). Pro tip: I almost nuked my runtime by using map.clear() inside a loop. Since clear() iterates over the map to nullify entries, it’s O(n). Switching to new HashMap<>() kept the complexity at a clean O(1) reset and a total O(n) pass. Don't let built-in methods turn your linear solution into a nested nightmare. Complexity matters. 🧗♂️ #LeetCode #Java #CodingChallenge #ProblemSolving

🚀 Day 17 of #100DaysOfCode Solved 75. Sort Colors on LeetCode 🎨 🧠 Key insight: Although this problem is often solved using the Dutch National Flag algorithm, it was interesting to apply QuickSort and see how a general-purpose sorting algorithm still performs efficiently for constrained inputs. ⚙️ Approach: 🔹Applied QuickSort recursively 🔹Chose the middle element as the pivot 🔹Partitioned the array around the pivot 🔹Continued sorting left and right partitions ⏱️ Time Complexity: Average: O(n log n) 📦 Space Complexity: O(log n) (recursive stack) #100DaysOfCode #LeetCode #DSA #Sorting #QuickSort #Java #ProblemSolving #LearningInPublic #CodingJourney

Day 38/100 – LeetCode Challenge ✅ Problem: #1877 Minimize Maximum Pair Sum in Array Difficulty: Medium Language: Java Approach: Sorting + Greedy Pairing Time Complexity: O(n log n) Space Complexity: O(1) Key Insight: To minimize the maximum pair sum, pair the smallest with the largest elements. This balances the sums across all pairs, preventing any single pair from being too large. Solution Brief: Sorted the array in ascending order. Paired nums[i] with nums[n-1-i] (first with last, second with second-last, etc.). Tracked maximum pair sum during iteration. Simple yet effective greedy pairing strategy #LeetCode #Day38 #100DaysOfCode #Sorting #Greedy #Java #Algorithm #CodingChallenge #ProblemSolving #MinimizePairSum #MediumProblem #Array #Optimization #DSA

𝗗𝗮𝘆 𝟯𝟲/𝟭𝟬𝟬 | 𝗠𝗲𝗿𝗴𝗲 𝗧𝘄𝗼 𝗦𝗼𝗿𝘁𝗲𝗱 𝗟𝗶𝘀𝘁𝘀 Day 36 ✅ — Recursion over iteration. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 #𝟮𝟭: Merge Two Sorted Lists (Easy) 𝗪𝗵𝗮𝘁 𝗖𝗹𝗶𝗰𝗸𝗲𝗱: Merge two sorted linked lists. Instead of the iterative dummy node approach, I used 𝗿𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻. Compare the heads. Attach the smaller one, then recursively merge the rest. Base case: if one list is empty, return the other. Elegant. Three lines of logic. 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: 👉 Base cases: if l1 is null, return l2 (and vice versa) 👉 Compare l1.val and l2.val 👉 Attach smaller node and recurse with remaining lists Time: O(n + m), Space: O(n + m) for recursion stack 𝗠𝘆 𝗥𝗲𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Seven linked list problems, and recursion just made this one cleaner than iteration. Sometimes the simplest code is the most powerful. 𝗖𝗼𝗱𝗲:🔗 https://lnkd.in/g4f4_B69 𝗗𝗮𝘆 𝟯𝟲/𝟭𝟬𝟬 ✅ | 𝟲𝟰 𝗺𝗼𝗿𝗲 𝘁𝗼 𝗴𝗼! #100DaysOfCode #LeetCode #LinkedList #Recursion #DataStructures #CodingInterview #SoftwareEngineer #Java #Algorithms #Programming

Day 46/200 – LeetCode Challenge Multiply Strings Today’s focus was on implementing string-based multiplication without using built-in big integer libraries. The solution involved simulating manual multiplication using an integer array for positional sums. This approach ensured efficiency and accuracy even for very large inputs. Optimizing nested loops and handling digit positions carefully can significantly improve runtime in high-precision arithmetic problems. Continuing the 200-day journey with consistent progress #LeetCode #CodingChallenge #Java #ProblemSolving #200DaysOfCode #LearningEveryday

Day 58/100 – LeetCode Challenge ✅ Problem: Longest Balanced Substring II Difficulty: Medium Language: Java Approach: Multiple Pattern Detection + Prefix Difference Mapping Time Complexity: O(n) Space Complexity: O(n) Key Insight: Balanced substrings must have equal counts of characters in three possible patterns: Single character run - consecutive same characters Two characters - equal occurrences of two specific chars Three characters - all three chars appear same number of times Solution Brief: countOne(): Track longest consecutive run of same character. countTwo(): For two chars (like 'a'/'b'), use prefix sum where n1=+1, n2=-1; reset on other chars. countThree(): Track differences (a-b) and (a-c) as state; when same state repeats, balanced substring found. #LeetCode #Day58 #100DaysOfCode #String #HashMap #Java #Algorithm #CodingChallenge #ProblemSolving #LongestBalancedSubstringII #HardProblem #PrefixSum #StateTracking #DSA

🚀 Day 11/30 – Working with Numbers Without Converting to Strings Today’s problem involved checking whether a given integer is a palindrome. While one straightforward approach would be converting the number into a string and reversing it, I chose to solve it mathematically — by reversing the digits of the number itself. 💡 Approach Immediately return false for negative numbers Store the original number Reverse the digits using modulo (% 10) and division (/ 10) Compare the reversed number with the original This avoids unnecessary string conversion and keeps the logic purely numerical. 📊 Performance ✅ All test cases passed ⚡ Efficient runtime ⏱ O(log₁₀ n) time complexity 📦 O(1) space complexity 📚 Key Takeaway Sometimes the better solution isn’t the easiest one — it’s the one that respects constraints and demonstrates deeper understanding of number manipulation. Day 11 complete. Building stronger fundamentals, one problem at a time. #Day11 #30DaysOfCode #LeetCode #Java #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Consistency #TechGrowth

Day 49: Keeping the rhythm with Binary! 🎶 Problem 693: Binary Number with Alternating Bits Today was a smooth one. The challenge: check if a number's binary representation has alternating 0s and 1s with no two adjacent bits being the same. My approach: 1. Converted the integer to a binary string. 2. Ran a linear scan to compare each bit with its neighbor. 3. If any match? Immediate false. It’s a clean O(logN) solution. While there are some "galaxy brain" bitwise tricks to solve this in one line, sometimes a clear string traversal is all you need to keep the streak alive. No nested nightmares today. 🚀 #LeetCode #Java #Binary #CodingChallenge #ProblemSolving #Algorithms