Minimize Max Pair Sum in Array with Optimal Pairing Strategy

day 6: LeetCode 283. Move Zeroes make new array approach -> make a new array , store non zero element at starting positions rest remaining positions will have default value zero already or you can fill it your self. totally in-place arrray -> store every non zero element set it to starting positions of original array using a pointer , reamining position after external pointer will always be zero so set it to zero by running a loop from ptr -> nums.length, reduced space complexity to O(1) as previous solution had space complexity of O(n). #day6of150daysofcode #150daysofcode #Java #leetcode #dailycode

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

🚀 Day 16 of #100DaysOfCode Solved Remove Nth Node from End of List on LeetCode 🔗✂️ 🧠 Key insight: To remove the Nth node from the end, we need to carefully handle edge cases—especially when the node to remove is the head or when n equals the list length. ⚙️ Approach: 🔹First determine the length of the linked list 🔹Calculate the position from the start 🔹Traverse to the node just before the target 🔹Adjust pointers to remove the node safely ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

🚀 Day 22 – LeetCode 3 Longest Substring Without Repeating Characters Solved using Sliding Window + HashMap. Instead of checking all substrings (O(n²) ❌), I maintained a window of unique characters and jumped the left pointer whenever a duplicate appeared. Time Complexity: O(n) Space Complexity: O(1) Key takeaway: Most substring problems are solved using sliding window patterns, not brute force. Day 22/90 consistency streak continues 🔥 #leetcode #dsa #slidingwindow #java #softwareengineering

Day 109 🚀 | Restore String (LeetCode) Rebuild the string using index mapping 🔁 👉 Place each character at its correct position ⏱ O(n) | 📦 O(n) Consistency > everything 💪 #Day109 #LeetCode #DSA #Java #GeekStreak #CodingJourney

🚀 Day 14 of #100DaysOfCode Solved Merge Two Sorted Lists on LeetCode 🔗🔀 🧠 Key insight: Using a dummy (sentinel) node simplifies pointer handling and avoids edge cases when building the merged list. ⚙️ Approach: 🔹Initialize a dummy node to act as the start of the merged list 🔹Compare nodes from both lists one by one 🔹Attach the smaller node and move the pointer forward 🔹Append remaining nodes once one list is exhausted ⏱️ Time Complexity: O(n + m) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

🚀 Day 15 of #100DaysOfCode Solved Reverse Linked List on LeetCode 🔄🔗 🧠 Key insight: Reversing a linked list is all about careful pointer manipulation. By tracking prev, current, and next, we can reverse links in-place without extra memory. ⚙️ Approach: 🔹Initialize prev = null, current = head 🔹Store next node before breaking the link 🔹Reverse current.next to point to prev 🔹Move pointers forward until the list ends ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

📝 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

Day 5/30 – LeetCode streak  Today’s problem: Count Binary Substrings   Goal: count substrings where 0s and 1s are grouped and appear the same number of times. Brute‑forcing all substrings would be O(n^2), so I went with the "group lengths" trick: - Scan the string once, tracking only two numbers:'prev' group length and 'curr' group length.   - If the current char matches the previous, increase 'curr'.   - If it changes, add 'min(prev, curr)' to the answer, then slide prev = curr, reset curr = 1.   - At the end, add 'min(prev, curr)' one more time to account for the last pair. Day 5 takeaway:   Instead of thinking in terms of individual substrings, thinking in terms of runs of characters makes the problem linear and much cleaner. #leetcode #dsa #java #strings #consistency

day 10: LeetCode 189. Rotate Array Approach Use an extra result array. Copy the last k elements first (they wrap to the front), then copy the remaining elements after them. Why k = k % n? 7 rotations on size-7 array → same array 14 rotations → same array 22 rotations → 21 cancel out, only 1 real rotation So any multiple of n rotations = no change, only the remainder matters. Code Walkthrough Loop 1 — copy last k elements to front of res i starts at n-k, goes to n Loop 2 — copy remaining elements right after, ptr continues where loop 1 left off i starts at 0, goes to n-k Loop 3 — copy res back into nums (since rotate is void) Key Trick ptr++ inside the assignment — assigns first, then increments. Keeps both loops flowing into res seamlessly without overlap or gap. #day10of150daysofcode #150daysofcode #Java #leetcode #dailycode