Solving Palindrome Number on LeetCode with Java

🚀 Day 6/30 — LeetCode Challenge Solved "Divide Two Integers" on LeetCode using Java. This problem restricts the use of division, multiplication, and modulus — forcing an alternative approach using "bit manipulation and subtraction logic". Handled tricky edge cases like overflow (Integer.MIN_VALUE / -1) to ensure correctness. ✅ Key takeaway: Constraints push you to think beyond standard solutions and understand how operations work at a deeper level. #LeetCode #Java #Algorithms #ProblemSolving #Consistency

🚀 Day 7/30 — LeetCode Challenge Solved "Roman to Integer" on LeetCode using Java. The key challenge was handling "subtractive notation"— cases like IV (4) and IX (9), where a smaller value appears before a larger one. Used a HashMap for value mapping and adjusted the result based on the relationship between adjacent characters. ✅ Key takeaway: Understanding patterns in rules is more important than just implementing logic. #LeetCode #Java #Algorithms #ProblemSolving #Consistency

🚀 Day 2/30 — LeetCode Challenge Solved the Reverse Integer problem on using Java. At first glance, reversing digits looks straightforward. But the real challenge is handling integer overflow within 32-bit limits — that’s where most implementations fail. ✅ Key takeaway: Correctness isn’t just about logic — it’s about respecting constraints and edge cases. Continuing to focus on writing solutions that are not just working, but reliable. #LeetCode #Java #ProblemSolving #DataStructures #Algorithms #Consistency

🚀 Day 8/30 — LeetCode Challenge Solved "Swap Nodes in Pairs" on LeetCode using Java. This problem focuses on "rearranging node connections", not just swapping values — making pointer handling critical. Used a dummy node approach to simplify edge cases and ensure smooth pair-wise swapping. ✅ Key takeaway: Linked list problems are less about logic and more about **precise pointer management** — one wrong link can break the entire structure. #LeetCode #Java #LinkedList #DataStructures #ProblemSolving #Consistency

Day 22 of #50DaysLeetCode Challenge 🚀 Today I solved the “Remove Element” problem using Java. 🔹 Problem: Given an array and a value, remove all occurrences of that value in-place and return the number of remaining elements. 🔹 Approach: Used the two-pointer technique. One pointer iterates through the array, while the other keeps track of where to place elements that are not equal to the given value. 🔹 Key Learning: In-place array problems often rely on pointer manipulation instead of extra space. 🔹 Time Complexity: O(n) 🔹 Example: Input: nums = [3,2,2,3], val = 3 Output: 2 (array becomes [2,2,...]) Simple problem, but important for mastering array manipulation techniques. #Day22 #LeetCode #Java #DSA #Arrays #TwoPointers #CodingJourney #ProblemSolving

Day 98 - LeetCode Journey Solved LeetCode 20: Valid Parentheses in Java ✅ A classic stack problem that looks simple but tests your attention to detail. The idea is straightforward: Push opening brackets into stack and match them correctly when a closing bracket appears. If anything mismatches → invalid. Clean logic, zero confusion 💡 Key takeaways: • Stack fundamentals • Matching pairs efficiently • Handling edge cases (empty stack, wrong order) • Writing clean conditional logic ✅ All test cases passed ⚡ O(n) time and O(n) space Sometimes basics like this are the real building blocks of strong DSA 🔥 #LeetCode #DSA #Java #Stack #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode

Day 92 - LeetCode Journey Solved LeetCode 143: Reorder List in Java ✅ This problem looks tricky at first, but once you break it into steps, it becomes clean and elegant. The idea is simple: 1️⃣ Find the middle of the list (slow-fast pointers) 2️⃣ Reverse the second half 3️⃣ Merge both halves alternately That’s it. Three steps, one solid solution. Key takeaways: • Mastering slow & fast pointer technique • In-place reversal of linked list • Merging two lists efficiently • Breaking complex problems into smaller parts ✅ All test cases passed ⚡ O(n) time and O(1) space Problems like this build real confidence in linked lists 💯 #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode

Debugged & Optimized: Beats 100% on LeetCode! 🚀 By switching to a Two-Pass O(n) logic in Java, I was able to find all valid elements while beating 100% of submissions in speed. Key Takeaway: Debugging is just as important as coding. Sticking with the problem until the logic is optimal is where the real learning happens. Onwards to more complex challenges! #Java #DSA #LeetCode #ProblemSolving #Engineering

Day 35/100 – Exploring ListIterator in Java 🔁 Today I explored the use of ListIterator in Java while working with ArrayList. Unlike a normal iterator, ListIterator allows traversal in both directions, making it more flexible when working with lists. Key learnings: • Traverse elements using next() • Move backward using previous() • Check elements using hasNext() and hasPrevious() • Useful for bidirectional iteration and modifications Understanding different ways to iterate through data structures helps in writing more efficient and flexible code. Learning something new every day, one step at a time. 🚀 #100DaysOfCode #Java #ArrayList #DataStructures #CodingJourney #LearningInPublic

#Day72 Of Problem Solving Solved today’s LeetCode Daily Challenge ✅. Problem: Check if Binary String Has at Most One Segment of Ones Sometimes, the simplest logic gives the best results. Instead of overthinking, I went with a clean approach—just checking if "01" exists in the string. If it does, that means more than one segment of 1’s… and that’s it! ✔️ All test cases passed ⚡ Runtime: 0 ms 📊 Beat 100% in performance This problem was a good reminder that not every solution needs complexity—clarity matters more. Consistency > Complexity 🚀 On to the next challenge! #LeetCode #DailyChallenge #Java #ProblemSolving #CodingJourney #100DaysOfCode #LinkedIn