Java String Theory and Practice Day 6

Day 27 of #100DaysOfLeetCode 💻✅ Solved #83. Remove Duplicates from Sorted List on LeetCode using Java. Approach: • Utilized the fact that the linked list is already sorted • Traversed the list using a single pointer • Compared current node value with next node value • If duplicate found, skipped the next node by updating links • Continued traversal until reaching the end of the list Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 45.30 MB (Beats 85.70% submissions) Key Learning: ✓ Understood how sorting simplifies duplicate removal logic ✓ Strengthened pointer manipulation skills in linked lists ✓ Learned efficient in-place modification without extra space Learning one problem every single day 🚀 #Java #LeetCode #DSA #LinkedList #ProblemSolving #CodingJourney #100DaysOfCode

Day 23 of #100DaysOfLeetCode 💻✅ Solved #19. Remove Nth Node From End of List on LeetCode using Java. Approach: • Used a dummy node to handle edge cases (like removing the head) • Initialized two pointers: fast and slow • Moved fast pointer n+1 steps ahead to maintain a gap • Traversed both pointers together until fast reached null • Slow pointer stopped just before the node to delete • Updated links to remove the target node in one pass Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 43.77 MB Key Learning: ✓ Mastered two-pointer (fast & slow) technique ✓ Understood importance of dummy node for edge cases ✓ Solved the problem in a single traversal (O(n) time, O(1) space) Consistency is building confidence 🚀 #Java #LeetCode #DSA #LinkedList #TwoPointers #ProblemSolving #100DaysOfCode

Day 68 of #100DaysOfCode 🚀 Today I implemented Pascal’s Triangle using Java. At first glance, it looks like just a pattern problem. But internally, it teaches something powerful — building current state from previous state. 🔹 The first and last elements of every row are always 1 🔹 Every middle element = sum of two elements from the previous row 🔹 This is a classic example of bottom-up thinking Instead of hardcoding values, we dynamically generate each row based on the previous one. This problem strengthened: Nested loop understanding 2D List handling in Java Pattern recognition Thinking in terms of recurrence Small problems. Strong foundations. Consistent progress. On to the next one 💪 #100DaysOfCode #Java #DSA #ProblemSolving #LearningInPublic #dsawithkunal

🚀 Day 8 of My 90 Days Java Full Stack Challenge Today, I practiced two interesting String problems that helped me strengthen my understanding of string manipulation and logical thinking in Java. 🧩 1️⃣ Reverse Words in a Sentence Input: "Java is fun" Output: "fun is Java" 🔎 Approach: Traverse from the end Extract words Rebuild the sentence in reverse order Handle edge cases like multiple spaces 💡 Learned how to manage string traversal without relying completely on inbuilt methods. 🧩 2️⃣ Check Rotation of String Example: "abcd" & "cdab" 🔎 Key Insight: If s2 is a rotation of s1, then s2 must be a substring of (s1 + s1). ✔ Length check first ✔ Then verify using substring logic This problem improved my understanding of pattern recognition in strings. 🧠 Key Takeaways: Two-pointer & traversal techniques Importance of handling edge cases Writing optimized logic instead of brute force Understanding how string concatenation helps solve rotation problems 📅 Next step: Continue exploring more intermediate-level string problems. Consistency > Motivation 💪 #90DaysJavaFullStack #Java #StringManipulation #ProblemSolving #LearningInPublic #DeveloperJourney

Day 26 of #100DaysOfLeetCode 💻✅ Solved #203. Remove Linked List Elements on LeetCode using Java. Approach: • Handled edge cases by removing matching nodes from the beginning of the list • Traversed the linked list using a pointer • Checked the next node’s value instead of the current node • If value matched, updated links to skip the node • Maintained in-place modification without using extra data structures Performance: ✓ Runtime: 1 ms (Beats 95.94% submissions) ✓ Memory: 47.62 MB Key Learning: ✓ Improved understanding of linked list pointer manipulation ✓ Learned how to handle head node edge cases carefully ✓ Strengthened in-place deletion logic in singly linked lists Learning one problem every single day 🚀 #Java #LeetCode #DSA #LinkedList #ProblemSolving #CodingJourney #100DaysOfCode

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

Day 21 of #100DaysOfLeetCode 💻✅ Solved #27. Remove Element problem on LeetCode in Java. Approach: • Used a two-pointer technique to modify the array in-place • Maintained a pointer k to place elements not equal to val • Iterated through the array and skipped elements equal to val • Placed non-val elements at the k-th position and incremented k • Returned k as the number of remaining elements Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 44 MB (Beats ~75% submissions) Key Learning: ✓ Strengthened understanding of in-place array manipulation ✓ Learned how to skip unwanted elements efficiently ✓ Improved confidence in two-pointer techniques for array problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #ProblemSolving #CodingJourney #100DaysOfCode

Day 36 of #100DaysOfLeetCode 💻✅ Solved #111. Minimum Depth of Binary Tree on LeetCode using Java. Approach: • Used recursive approach to calculate minimum depth • Returned 0 when root is null (base case) • If one subtree is null, avoided taking minimum of 0 (handled edge case carefully) • Returned 1 + minimum depth of valid subtree • Ensured correct handling of skewed trees Performance: ✓ Runtime: 6 ms ✓ Memory: 82.20 MB Key Learning: ✓ Understood difference between minimum depth and maximum depth logic ✓ Learned importance of handling null subtree cases correctly ✓ Improved confidence in solving binary tree recursion problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeProblems #ProblemSolving #CodingJourney #100DaysOfCode

🚀 DSA Day 5 / 100 Solved the Two Sum problem on LeetCode using Java. Logic : • Go through the array one number at a time • For each number, check what value is needed to reach the target • Store each number with its index in a HashMap • If the needed value is already stored, we’ve found the answer #DSA #100DaysOfCode #Java #LeetCode #BeginnerDSA #LearningStepByStep #Consistency

🚀 #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