Swapping nodes in pairs using Java and dummy nodes

🚀Day 93/100 #100DaysOfLeetCode 🧩Problem: Remove Duplicates from Sorted List II✅ 💻Language: Java 🧠Approach: This problem requires removing all duplicate nodes from a sorted linked list, leaving only unique elements. Steps: 1️⃣Use a dummy node to handle edge cases easily (like when the first few nodes are duplicates). 2️⃣Use two pointers — one (prev) to track the previous node and another (head) to traverse the list. 3️⃣Whenever duplicate values are found (head.val == head.next.val), move head forward until all duplicates are skipped. 4️⃣Link prev.next to the next distinct node. 5️⃣Move prev forward only when no duplicates are found. This ensures that only unique nodes remain in the resulting linked list. 🔑Key Takeaways: 🔹Handling linked list edge cases effectively using a dummy node simplifies logic. 🔹Two-pointer techniques are powerful for in-place list manipulation. 🔹Proper pointer management avoids unnecessary complexity and extra memory usage. ⚡Performance: ⏱️Runtime: 0 ms (Beats 100%) 💾Memory: 43.51 MB (Beats 24.99%) #100DaysOfLeetCode #Java #LinkedList #LeetCode #CodingJourney #DSA #CodingChallenge #ProblemSolving

#Day-68) LeetCode #3228 – Maximum Number of Operations to Move Ones to the End (Java Edition) Tackled this neat string problem using a greedy approach in Java. The challenge? Move '1's to the end of the string under specific movement rules, maximizing the number of valid operations. 🧠 Core Idea: Track how many '0's we've seen and how many '1's we've already moved. Only move a '1' if there's enough '0's to justify it and the next character is also '1'. 💻 Java Strategy: Loop through the string Use counters to manage '0's and '1's Let me know how you'd tweak this or if you see a more optimal path! #Java #LeetCode #GreedyAlgorithm #StringProblems #DSA #CodingChallenge #LinkedInTech #ProblemSolving

🚀Day 96/100 #100DaysOfLeetCode 🧩Problem: Reverse Linked List II✅ 💻Language: Java 💡 Approach: 1️⃣ First, use a dummy node to handle edge cases where reversal starts at the head. 2️⃣ Traverse to the node just before the left position — call it prev. 3️⃣ Reverse the sublist between left and right using standard pointer manipulation. 4️⃣ Reconnect the reversed portion back into the original list. 🔑Key Takeaways: 🔹Dummy nodes simplify linked list edge cases. 🔹In-place reversal reduces memory overhead. 🔹Careful pointer tracking ensures list integrity. ⚙️Performance: ⏱️Runtime: 0 ms(beats 100.00%) 💾Memory: 41.29 MB(beats 70.37%) #100DaysOfLeetCode #Java #LinkedList #CodingJourney #ProblemSolving #DSA #LeetCode #CodingChallenge

📌 Day 20/100 – Add Binary (LeetCode 67) Today’s challenge was about adding two binary strings and returning the result in binary format — just like simulating manual binary addition with carry logic. 🔹 Problem: Given two binary strings a and b, return their sum as a binary string without converting them into decimal. 🔹 Approach: Start from the end of both strings (like column-wise addition). Use a carry variable to handle overflow (0 or 1). Keep appending the result (sum % 2) to a StringBuilder. Reverse the string at the end since we append from LSB to MSB. 🔹 Key Learnings: StringBuilder is more efficient than string concatenation in Java. Handling indices carefully avoids edge-case bugs. Binary addition logic is similar to decimal addition — just base changes, logic stays. #100DaysOfCode #Day20 #LeetCode #Java #BinaryMath #DSA #ProblemSolving #CodingJourney #KeepLearning

🚀Day 95/100 #100DaysOfLeetCode 🔍Problem: Length of Last Word✅ 💻Language: Java 🧠Approach: 1️⃣ First, trim the string to remove trailing and leading spaces. 2️⃣ Initialize a counter to 0. 3️⃣ Traverse the string from the end. 4️⃣ Count characters until the first space is encountered. 5️⃣ Return the count as the length of the last word. 💡Key Takeaways: 🔹Trimming the input ensures no trailing spaces interfere. 🔹Backward traversal avoids splitting the entire string. 🔹Simple yet efficient one-pass solution. ⚡Performance: ⏱️Runtime: 0 ms (Beats 100.00%) 💾Memory: 41.58 MB (Beats 91.52%) #100DaysOfLeetCode #Java #CodingJourney #ProblemSolving #LeetCode #CodingChallenge

🚀 𝗗𝗮𝘆 𝟮𝟰𝟯 𝗼𝗳 𝟮𝟰𝟳 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 🔹 Problem: 📌 2942. Find Words Containing Character 🧩 Approach: We need to find all indices of words that contain a specific character x. Using Java’s built-in indexOf() makes this task simple — it returns -1 if the character is not found. 📘 Steps to Solve: Initialize an empty list result. Traverse through each word in the array. If indexOf(x) is not -1, add the current index to the result list. Return the final list of indices. ✅ Time Complexity: O(n * m), where n = number of words and m = average word length. ✅ Space Complexity: O(k), where k = number of words containing x. ✨ What I Learned Today: Sometimes, the simplest built-in string methods (indexOf, contains) make a problem elegant and efficient. #LeetCode #Day243 #Java #StringHandling #EasyProblem #247Challenge

Week 8 || Day 2💡 Reversing words in Java — step by step! Today I practiced reversing each word in a sentence using two different approaches: 🔹 Approach 1 — With .reverse() method: Split the sentence using split(" ") to separate words. Used StringBuffer for each word and applied .reverse() directly. Joined the reversed words back with spaces. 🔹 Approach 2 — Without using .reverse(): Again split the string into words. For each word, used a for loop running from the last character to the first. Appended each character manually into a new StringBuffer. Combined the reversed words carefully, avoiding extra spaces.⚡ #Java #StringBuffer #ProgrammingLogic #JavaFullStack

🚀Day 99/100 #100DaysOfLeetCode 🔍Problem: Sum of Two Integers✅ 💻Language: Java 💡Approach: Instead of using the ‘+’ or ‘–’ operators, this problem leverages bit manipulation to perform addition. 🔸Use XOR (^) to calculate the sum without carry. 🔸Use AND (&) followed by a left shift (<< 1) to calculate the carry. 🔸Repeat until no carry remains. 📚Key Takeaways: 🔹Reinforced understanding of bitwise operations. 🔹Learned how addition can be simulated using logical operations. 🔹Improved understanding of low-level arithmetic computation. ⚡Performance: ⏱️Runtime: 0 ms (Beats 100.00%) 💾Memory: 40.88 MB (Beats 10.05%) #100DaysOfLeetCode #Java #BitManipulation #CodingChallenge #ProblemSolving #DSA #LeetCode #CodingJourney

💻 Day 45 of #LeetCode Journey 🚀 ✅ Problem: Count and Say 📘 Language: Java 🔹 Status: Accepted (30/30 test cases passed) 🔹 Runtime: 4 ms | Beats 55.38% 🔹 Memory: 41.86 MB 🧠 Concept: This problem is about generating the n-th term in the “count and say” sequence. Each term is built by describing the previous term — count the number of digits and say them in order. 🧩 Approach: Start with "1". For each iteration, use a StringBuilder to construct the next sequence. Track consecutive digits using a counter. Append the count and digit when the sequence changes. 💡 Efficient string manipulation and iteration give optimal performance. 🔥 Every solved problem builds confidence. One step closer to mastering patterns in strings! #Day45 #LeetCode #Java #CodingChallenge #ProblemSolving #CountAndSay #50DaysOfCode