LeetCode Daily Question: Maximum Number of Events II

🚀 Day 77 of LeetCode Challenge ✅ Problem: Add Strings 🔗 https://lnkd.in/gZatGJzA 💡 Approach: Traverse both strings from right to left Convert characters to digits and add them with a carry Append the result digit-by-digit using StringBuilder Reverse the final string to get the correct sum ⚡ Performance: ✅ All test cases passed ⏱ Runtime: 2 ms (Beats 91.47%) 💾 Memory efficient and clean implementation 📚 Key Learning: When direct numeric conversion isn’t allowed, manual digit-by-digit addition is a reliable and efficient strategy for handling large numbers stored as strings. 🔧 Language: Java 📈 Consistency over intensity—one problem at a time. #LeetCode #DSA #Java #StringManipulation #MathProblems #DailyCoding #Consistency #Day77

🚀 Day 85 of LeetCode Challenge ✅ Problem: Merge Two Sorted Lists 🔗 https://lnkd.in/g5VY8a3n 💡 Approach: Use a dummy node to simplify list construction Maintain a current pointer to build the merged list Compare nodes from both lists and attach the smaller one Move the pointer forward until one list is exhausted Attach the remaining nodes from the non-empty list ⚡ Performance: ✅ All test cases passed (208 / 208) ⏱ Runtime: 0 ms (Beats 100.00%) 💾 Memory: 44.60 MB 📚 Key Learning: Using a dummy node avoids edge-case handling and leads to cleaner, more readable linked list solutions—especially for merge operations. 🔧 Language: Java 📈 Day 85 complete — consistency is turning effort into skill. #LeetCode #DSA #Java #LinkedList #ProblemSolving #100DaysOfCode #Consistency

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 96 – LeetCode Practice 📌 Problem: First Missing Positive (LeetCode #41) 📊 Difficulty: Hard 🧠 Problem Overview: Given an unsorted integer array, the task is to find the smallest positive integer that is missing from the array. The challenge lies in solving it efficiently with strict constraints on time and space. ✅ Approach Used: Stored all values from the array for quick lookup. Iterated from the smallest possible positive integer to identify the first missing value. Returned the earliest number that was not present. 📈 Submission Results: Status: Accepted ✅ Runtime: 14 ms Memory Usage: 93.44 MB 💡 Reflection: This problem highlights the importance of understanding constraints clearly. While multiple approaches exist, optimizing time and space is the key learning takeaway from this question. #LeetCode #DSA #ProblemSolving #Arrays #Java #CodingJourney #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

Day9 - LeetCode Journey Solved LeetCode 1572: Matrix Diagonal Sum in Java ✅ This problem was a nice mix of simplicity and attention to detail. The main idea was to traverse the matrix once and add both the primary and secondary diagonal elements without double counting the middle element when the matrix size is odd. It reminded me how important small conditions are in logic-based problems. One extra check can make the difference between a correct and an incorrect solution. Clean traversal and clear understanding of matrix indexing were the key here. Key takeaways: • Understanding matrix traversal properly • Handling edge cases like overlapping diagonals • Writing efficient and readable code ✅ Accepted with 100% runtime performance ✅ Simple yet strong problem for building fundamentals Staying consistent with DSA practice and improving step by step. Every small problem adds to better clarity and confidence 💪 #LeetCode #DSA #Java #Matrices #Algorithms #ProblemSolving #LeetCode1572 #OptimalSolution #CodingPractice #InterviewPreparation #Consistency

🚀 Day 52 of #100DaysOfCode Solved LeetCode Problem #712 – Minimum ASCII Delete Sum for Two Strings. This problem focused on minimizing the total ASCII value of deleted characters to make two strings equal. A classic dynamic programming challenge that required carefully defining states and transitions for optimal substructure. Key Learnings: -> Modeled the problem using DP on string indices -> Handled base cases when one string is fully consumed -> Used memoization to avoid overlapping subproblems Strengthened understanding of string DP and cost-based optimization Language Used: Java -> Runtime: 34 ms (Beats 7.60%) -> Memory: 50.39 MB Consistent practice, deeper DP intuition, and steady progress 🚀 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode

🚀 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 46 of #100DaysOfCode Solved LeetCode Problem #1390 – Four Divisors 🔢 This problem focused on identifying numbers that have exactly four divisors and summing those divisors efficiently. The key challenge was optimizing divisor counting to avoid unnecessary computations. Key Learnings: -> Iterated divisors only up to √n for efficiency -> Carefully tracked divisor count and sum simultaneously -> Pruned early when divisor count exceeded four -> Reinforced number theory basics with practical optimization Language Used: Java -> Runtime: 9 ms (Beats 97.47%) -> Memory: 46.32 MB Small constraints, clean logic, and efficient pruning make a big difference 🚀 #LeetCode #Java #ProblemSolving #NumberTheory #100DaysOfCode #DSA