LeetCode Challenge: 2054 Two Non-Overlapping Events

🚀 Day 34 of #100DaysOfCode Solved LeetCode Problem #2054 – Two Best Non-Overlapping Events. This problem focused on selecting at most two non-overlapping events to maximize total value. It required combining sorting with dynamic programming + binary search–style transitions to efficiently skip overlapping events. Key Learnings: -> Sorted events by start time to enable efficient transitions -> Used DP with state (index, count) to track selections -> Learned how to compute the next non-overlapping event index -> Reinforced decision-making between include vs exclude choices Language Used: Java -> Runtime: 82 ms (Beats 16.50%) -> Memory: 206.91 MB Step by step, sharpening DP intuition and optimization skills 🚀 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode

Day 8/25 – LeetCode Challenge 🚀 🔸Problem: Find First and Last Position of Element in Sorted Array 🔸Difficulty: Medium 🔸Topic: Array, Searching 🔸Language: Java Approach 🛠️: ▫️Iterated through the array once to locate the target value. ▫️Tracked the first occurrence when the target is found initially. ▫️Continuously updated the last occurrence index for subsequent matches. ▫️Returned default values when the target does not exist in the array. ▫️This approach keeps the solution simple and easy to understand. Key Learnings 📚: 🔹Handling default values for edge cases is important 🔹Tracking first and last positions in a single pass 🔹Understanding problem constraints before optimizing 🔹Clean logic improves readability and debugging #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

Day 7/25 – LeetCode Challenge 🚀 🔸Problem: Matrix Diagonal Sum 🔸Difficulty: Easy 🔸Topic: Array, Matrix 🔸Language: Java Approach  🛠️: ▫️Iterated through the matrix once to calculate both diagonals simultaneously ▫️Added elements from the primary diagonal and secondary diagonal in a single loop ▫️Handled the overlapping middle element for odd-sized matrices by subtracting it once ▫️Used simple index-based access for clarity and efficiency Key Learnings 📚: 🔹Efficient traversal of square matrices 🔹Handling overlapping conditions in matrix problems 🔹Importance of edge cases in odd vs even dimensions 🔹Achieving optimal time complexity with a single pass #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

🚀 Day 50 of #100DaysOfCode Solved LeetCode Problem #1458 – Max Dot Product of Two Subsequences ✅ This problem focused on finding the maximum dot product between non-empty subsequences of two arrays. The tricky part was handling negative values and ensuring at least one pair is always chosen. Key Learnings: -> Used Dynamic Programming with memoization to avoid recomputation -> Carefully handled the base case using Integer.MIN_VALUE to enforce non-empty subsequences -> Explored the classic include vs exclude decision at each index -> Strengthened understanding of DP on two sequences Language Used: Java -> Runtime: 11 ms (Beats 59.26%) -> Memory: 48.77 MB Step by step, sharpening DP intuition and edge-case handling 🚀 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode

Problem 2: Convert Sorted Array to BST Level: Easy–Medium Platform: LeetCode 108 🔹 Key Idea To keep BST balanced: Pick middle element as root Left half → left subtree Right half → right subtree 🔹 Java Code class Solution { public TreeNode sortedArrayToBST(int[] nums) { return build(nums, 0, nums.length - 1); } private TreeNode build(int[] nums, int left, int right) { if (left > right) return null; int mid = left + (right - left) / 2; TreeNode root = new TreeNode(nums[mid]); root.left = build(nums, left, mid - 1); root.right = build(nums, mid + 1, right); return root; } } 🔹 Explanation Middle element becomes root → ensures minimal height Recursively divide array Base case: left > right → null Time: O(n) Space: recursion stack O(log n) (balanced) #DSA #DataStructuresAndAlgorithms #Coding #Programmer #LeetCode #CodeEveryday #JavaDSA #CodingPractice #ProblemSolving #CP #CompetitiveProgramming #DailyCoding #TechJourney #CodingCommunity #DeveloperLife #100DaysOfCode #CodeWithMe #LearnToCode #GeekForGeeks #CodingMotivation

Day 2/25 – LeetCode Challenge 🚀 🔸Problem : Merge Sorted Array 🔸Difficulty : Easy 🔸Topic : Arrays, Three Pointers 🔸Language : Java Approach 🛠️ : ▫️Used a three-pointer technique starting from the end of both arrays. ▫️Compared elements from nums1 and nums2 and placed the larger one at the correct position. ▫️By filling nums1 from the back, avoided overwriting existing values. ▫️Continued until all elements from nums2 were merged. ▫️This ensures an in-place solution with optimal time complexity. Key Learnings 📚: 🔹Efficient use of two pointers for sorted arrays 🔹Importance of reverse traversal in in-place problems 🔹How to avoid extra space while merging arrays 🔹Reinforced understanding of array manipulation #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

Day 5/25 – LeetCode Challenge 🚀 🔸Problem: Single Number 🔸Difficulty: Easy 🔸Topic: Arrays, Brute Force 🔸Language: Java Approach  🛠️: ▫️Iterate through each element in the array and count its occurrences. ▫️Use a nested loop to compare the current element with all others. ▫️Track the count and identify the number that appears only once. ▫️Handle the edge case where the array has only one element. ▫️Return the element whose frequency is exactly one. Key Learnings  📚: 🔹Reinforced understanding of nested loops and frequency counting 🔹Importance of handling edge cases explicitly 🔹Clear trade-off between simplicity and time complexity 🔹Strengthened fundamentals of array traversal #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

Day7 - LeetCode Journey Solved LeetCode 912: Sort an Array in Java ✅ This problem was a good exercise in going back to basics and understanding how sorting actually works under the hood. Instead of relying on built-in sort functions, the focus here was on writing the logic manually and thinking about time and space trade-offs. I implemented a simple comparison-based approach, paying close attention to how elements shift and settle into their correct positions. While the performance may not be the fastest possible, the process helped me strengthen my understanding of sorting fundamentals and algorithm behavior on larger inputs. Key learnings from this problem: • How element shifting impacts performance • Why algorithm choice matters for large datasets • The importance of clarity over shortcuts ✅ Accepted solution with all test cases passed ✅ Reinforced core concepts that often show up in interviews Consistent DSA practice is teaching me that improvement is not always about speed, but about understanding what’s happening at every step. Slowly building better problem-solving habits 💪 #LeetCode #DSA #Java #Algorithms #Sorting #DataStructures #ProblemSolving #CodingJourney #InterviewPreparation #Consistency

Day 6/25 – LeetCode Challenge 🚀 🔸Problem: Monotonic Array 🔸Difficulty: Easy 🔸Topic: Arrays 🔸Language: Java Approach  🛠️: ▫️Traverse the array once while tracking both increasing and decreasing trends ▫️Use two boolean flags to validate monotonic conditions ▫️Compare each element with its next neighbor ▫️Invalidate a trend when a violation is found ▫️Return true if at least one monotonic condition holds Key Learnings 📚: 🔹Efficient single-pass array traversal 🔹Handling edge cases with equal elements 🔹Using boolean flags to track multiple conditions 🔹Achieving O(n) time complexity with constant space #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency