Solved LeetCode problem 19: Remove Nth Node From End of List in Java

Day 91 of #100DaysOfCode Solved Base 7 in Java 🔢 Approach The challenge was to convert a given integer (num) to its base 7 string representation. Conversion Method The core of the solution lies in the standard algorithm for base conversion: repeated division and remainder collection. Handle Zero and Negatives: If the input num is 0, the result is immediately "0". I determined if the number is negative and stored this in a boolean flag, then proceeded with the absolute value of the number (num = Math.abs(num)) for the conversion logic. Conversion Loop: I used a while loop that continues as long as num > 0. In each iteration: The remainder when num is divided by 7 (num % 7) gives the next digit in base 7. This digit is appended to a StringBuilder. num is then updated by integer division by 7 (num /= 7). Final Result: Since the remainders are collected in reverse order, I called sb.reverse(). If the original number was negative, I prepended a hyphen (-) to the reversed string. Finally, I returned the result as a string. This simple and efficient implementation had a very fast runtime, beating 77.39% of submissions. #Java #100DaysOfCode #LeetCode #CodingChallenge #Algorithms #BaseConversion #ProblemSolving

🚀Day 92/100 #100DaysOfLeetCode 🧩Problem: Swap Nodes in Pairs✅ 💻Language: Java 🔍Approach: 🔹To swap every two adjacent nodes in a linked list, I used a dummy node to simplify pointer handling. 🔹The dummy node helps manage edge cases (like swapping the first pair). 🔹I iteratively swapped pairs by adjusting the next pointers of each node. 🔹Finally, I returned dummy.next as the new head of the list. 🧠Key Takeaways: 🔹Dummy nodes are powerful tools for simplifying linked list manipulations. 🔹Careful pointer tracking ensures no data loss during swaps. 🔹Iterative solutions can be more memory-efficient than recursion in linked lists. ⚙️Performance: ⏱️Runtime: 0 ms (Beats 100.00%) 💾Memory: 41.76 MB (Beats 11.86%) #100DaysOfLeetCode #Java #LinkedList #CodingJourney #ProblemSolving #LeetCode #CodingChallenge

🧠 Day 71 of #100DaysOfLeetCode 🔸 Problem: 1752. Check if Array Is Sorted and Rotated 🔸 Difficulty: Easy 🔸 Language: Java ☕ 📌 Problem Summary: Given an array, we need to determine whether it was originally sorted in non-decreasing order and then rotated some number of times (including zero). There may be duplicate elements as well. For example: [3,4,5,1,2] → ✅ True (original [1,2,3,4,5] rotated by 2) [2,1,3,4] → ❌ False 💡 Key Insight: 👉 In a sorted and rotated array, there can be at most one point where the array decreases (nums[i] > nums[i+1]). 👉 If we find more than one such “drop,” the array is not sorted and rotated. ✨ Takeaway: This problem reinforces the power of simple observations over brute force. Sometimes, counting a single pattern is enough to solve the entire question efficiently. #LeetCode #Day71 #JavaProgramming #100DaysOfCode #CodingChallenge #ProblemSolving #DSA #PlacementPreparation #SowmiyaCodes

💻 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

🚀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

🚀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

(Largest Perimeter Triangle — Java 🔺) Hey everyone 👋 Today I explored how to find the largest perimeter triangle from a given array of side lengths using Java. While solving this, I understood how a simple mathematical condition can help in optimizing the entire logic 🔥 Here’s the breakdown 👇 🧠 Concept: To form a valid triangle from 3 sides, the sum of any two sides must be greater than the third one. → a + b > c → a + c > b → b + c > a 💡 Approach 1: Sort the array in descending order and check triplets from the start. If any 3 consecutive sides satisfy the triangle condition, their sum gives the largest perimeter. ⚡ Approach 2 (Optimized): Instead of reversing the array, just sort it in ascending order and iterate from the end — gives the same result but with cleaner logic and less work. 🧩 Time Complexity: O(N log N) 💾 Space Complexity: O(1) This problem helped me understand how sorting order and traversal direction can make an algorithm more elegant and efficient 🚀 📁 Code is available on my GitHub repo: https://lnkd.in/ekjD9s22 #Java #DSA #ProblemSolving #Arrays #CodingJourney #Developers #LearningByDoing #FullStackDeveloper #MCA #GitHub

🧠 Daily LeetCode Grind — Java Edition Today’s challenge: ✅ Container With Most Water (#11 - Medium) 📌 Goal: Given an integer array height[], find two lines that, together with the x-axis, form a container that holds the most water. 📌 Approach: 🔹 Use the Two-Pointer Technique to optimize the search for the maximum area. 🔹 Start with two pointers at both ends of the array and calculate the area at each step. 🔹 Move the pointer pointing to the smaller height inward to maximize potential area. 🔹 Continue until both pointers meet. 🧩 Test Case: Input: height = [1,8,6,2,5,4,8,3,7] Output: 49 💡 Key Takeaways: 🔹 Learned to balance area optimization using width × height. 🔹 Reinforced the power of the two-pointer approach for reducing time complexity. 🔹 Strengthened problem-solving speed through mathematical reasoning. 💻 Language: Java 🧠 Complexity: O(n) — single pass using two pointers. #LeetCode #Java #CodingPractice #ProblemSolving #TwoPointer #Algorithm #DeveloperLife #CybernautEdTech #AcceptedSolution

Day 90 of #100DaysOfCode Solved Squares of a Sorted Array in Java 🔠 Approach The task was to take an array of integers sorted in non-decreasing order, square each number, and then return the result array also sorted in non-decreasing order. Brute-Force Method The solution implemented here is a straightforward two-step brute-force approach: Squaring: I iterated through the input array nums and replaced each element with its square (i.e., nums[i] * nums[i]). This handles both positive and negative numbers correctly. Sorting: After squaring all elements, I used Java's built-in Arrays.sort(nums) method to sort the entire array. While correct, this approach has a time complexity dominated by the sorting step, which is O(NlogN), where N is the number of elements. The runtime of 10 ms shows that a more efficient, two-pointer approach (which can solve this in O(N) time) is generally preferred for optimal performance. #Java #100DaysOfCode #LeetCode #CodingChallenge #Algorithms #Array #Sorting #ProblemSolving