Two Sum II Java Solution with Two Pointers

🚀 #100DaysOfCode | Day 35 📌 LeetCode : Minimum Depth of Binary Tree Today I solved the Minimum Depth of Binary Tree problem using Java. The goal was to find the shortest path from the root node to the nearest leaf node. I applied a recursive approach while carefully handling edge cases where one subtree is null. Instead of directly taking the minimum of both sides, I ensured the solution correctly skips null paths to avoid incorrect depth calculations. 📌 Key takeaways: 🔹 Understood the difference between minimum and maximum depth logic 🔹 Learned the importance of handling null child nodes 🔹 Strengthened recursion and tree traversal concepts 🔹 Improved problem-solving accuracy in edge cases This problem helped me think more clearly about tree structures and reinforced the importance of precise base conditions in recursion. #Java #LeetCode #DSA #ProblemSolving #CodingJourney #100DaysOfCode

DSA journey 🚀 📌 LeetCode #977 – Squares of a Sorted Array 💻 Language: Java 🔹 Approach (Two Pointer Technique): Initialize two pointers at the start and end of the array Compare squares of both ends Place the larger square at the end of the result array Move pointers inward accordingly Continue until all elements are processed This works because the array is already sorted, but negative numbers can produce larger squares 💡 ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(n) Efficient and elegant ✨ Consistency over perfection 💯 #DSA #Java #LeetCode #ProblemSolving #LearningInPublic

Day 24 of #100DaysOfLeetCode 💻✅ Solved #35. Search Insert Position on LeetCode using Java. Approach: • Applied Binary Search to achieve O(log n) time complexity • Initialized two pointers: left and right • Calculated mid using left + (right - left) / 2 to avoid overflow • Compared mid element with target to adjust search space • If target not found, returned left as the correct insert position Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 43.2 MB Key Learning: ✓ Strengthened understanding of Binary Search pattern ✓ Learned how to determine insert position when element is absent ✓ Improved confidence in handling sorted array problems efficiently Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinarySearch #ProblemSolving #CodingJourney #100DaysOfCode

Day25 - LeetCode Journey Solved LeetCode 344: Reverse String in Java ✅ This was a simple problem on the surface, but it perfectly highlights how powerful clean logic can be. The goal was to reverse a string in-place using O(1) extra space, which means no extra arrays and no shortcuts. Just pure two-pointer logic. Using the left and right pointers and swapping characters step by step felt very satisfying. It’s one of those patterns that looks small but appears everywhere in interviews and real-world problems. Mastering this makes many string and array problems much easier later on. What I liked about this problem is how it teaches efficiency. Instead of creating new memory, we directly modify the existing array. That mindset of optimizing space is extremely important in DSA. Key takeaways: • Strong practice of the two-pointer technique • In-place operations with constant extra space • Clean and readable swapping logic • Reinforced fundamentals of string manipulation ✅ Accepted successfully ✅ 0 ms runtime with optimal performance Sometimes the simplest problems build the strongest foundations. Consistency with basics is what makes complex problems feel easier later 💪 #LeetCode #DSA #Java #Strings #ProblemSolving #Algorithms #CodingJourney #InterviewPreparation #TwoPointers #Consistency #DailyPractice

📝 Day 19/30 – LeetCode #33 (Search in Rotated Sorted Array) | Java This problem combines binary search with array rotation, making it more about logic than syntax. The main challenge was identifying which half of the array is sorted at every step and deciding whether the target lies within that range. By comparing boundary values and narrowing the search space accordingly, the problem can be solved efficiently in O(log n) time. This reinforced how adaptable binary search becomes when combined with careful condition checks. Another reminder that mastering patterns is far more important than memorizing solutions. #LeetCode #Java #DSA #BinarySearch #Arrays #ProblemSolving #LearningInPublic

DSA journey 🚀 📌 LeetCode #1464 – Maximum Product of Two Elements in an Array 💻 Language: Java 🔹 Approach: Traverse the array once to find the largest and second largest elements Update both values in a single loop Apply the formula: (max − 1) × (secondMax − 1) ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(1) Small optimizations, big wins 💡 Consistency over perfection 💯 #DSA #Java #LeetCode #ProblemSolving #LearningInPublic #DSAWithedSlash 🚀

LeetCode Daily — Problem #3794: Reverse String Prefix Today’s challenge was a fun string manipulation task: Problem: Given a string s and an integer k, reverse the first k characters and return the resulting string. Example: Input: s = "abcd", k = 2 Output: "bacd" Approach: I converted the string to a character array, reversed the first k characters using a loop, and then appended the rest. Here's the Java solution:✅ Result: Accepted with 0 ms runtime! Takeaway: This problem reinforced how simple logic and clean iteration can solve string-based challenges efficiently. It’s a great reminder that even “Easy” problems can sharpen your fundamentals. #LeetCode #Java #StringManipulation #CodingChallenge #100DaysOfCode #ProblemSolving #LinkedInLearning

Day 46: Binary Addition from scratch! 🔢 Problem 67: Add Binary Java's BigInteger is a thing, but manual bit manipulation is just more satisfying. My approach: 1. Padded both strings to the same length using character arrays. 2. Simulated schoolbook addition from right to left. 3. Used % 2 for the result bit and / 2 for the carry. It’s a clean O(N) solution that avoids overflow and keeps the logic transparent. No shortcuts, just pure logic. 🚀 #LeetCode #Java #Binary #Algorithms #CodingChallenge #ProblemSolving

Day41 - LeetCode Journey Solved LeetCode 821: Shortest Distance to a Character in Java ✅ Today’s problem was a great reminder that even simple-looking string questions can test how clearly you think. The goal was to find the shortest distance from every character in a string to a given target character. Sounds straightforward, but doing it efficiently is the real challenge. Instead of checking every position again and again, I used a smart two-pass approach. First pass from left to right to track the last seen occurrence. Second pass from right to left to ensure we capture the closest distance from both directions. Taking the minimum from both sides gave a clean and optimal solution. What I liked about this problem is how it trains you to think beyond brute force and focus on pattern recognition. Key takeaways: • Importance of multi-pass traversal in strings • Precomputing values to avoid unnecessary comparisons • Writing clean and readable logic • Thinking in terms of distance and optimization ✅ All test cases passed ✅ Improved confidence in string traversal patterns Small optimizations like these make a big difference in interviews. Staying consistent and sharpening fundamentals every day 💪 #LeetCode #DSA #Java #Strings #Algorithms #ProblemSolving #CodingJourney #InterviewPreparation #Consistency

Day 44 - LeetCode Journey Solved LeetCode 917: Reverse Only Letters in Java ✅ A clean two-pointer problem that really tests your understanding of string manipulation. The goal was simple: reverse only the letters while keeping all non-letter characters in their original positions. Instead of creating extra data structures, I used two pointers from both ends. If a character is not a letter, we skip it. When both pointers land on letters, we swap them. This continues until the pointers meet. What I liked about this problem is how it teaches you to control movement smartly rather than brute forcing the solution. Key takeaways: • Two-pointer technique for efficient traversal • Handling edge cases (symbols, numbers) • Writing in-place logic without extra space • Clean and readable code ✅ All test cases passed ✅ 100% runtime performance Problems like this improve your thinking for real interview scenarios where optimization matters. #LeetCode #DSA #Java #Strings #TwoPointers #Algorithms #ProblemSolving #CodingJourney #InterviewPrep #Consistency