Solved LeetCode 19: Remove Nth Node From End of List using two-pointer technique in C++.

🪷Day 69 LeetCode: Merge Two Sorted Lists (21) Approach: Merged two sorted linked lists by comparing nodes one by one and building a new sorted list using pointer manipulation. ✨ Learned how to handle linked list traversal and merging efficiently — a classic problem to strengthen pointer logic! 📈 Improved understanding of linked list operations, conditional traversal, and iterative merging in C++. #LeetCode #100DaysOfCode #DSA #LinkedList #Pointers #ProblemSolving #CodingJourney #CodeEveryday

🍁Day 68 LeetCode: Reverse Linked List (206) Approach: Reversed the linked list iteratively by updating pointers step-by-step while traversing through the list. ✨ Learned how pointer manipulation can transform linked list structures efficiently — a fundamental and must-know problem! 📈 Improved understanding of linked lists, pointer handling, and iterative logic in C++. #LeetCode #100DaysOfCode #DSA #LinkedList #Pointers #ProblemSolving #CodingJourney #CodeEveryday

🍂Day 61 LeetCode: Evaluate Reverse Polish Notation (150) Approach: Used a stack to evaluate postfix expressions by pushing operands and applying operators as they appear. ✨ Learned how stack-based evaluation simplifies expression parsing — a great problem to strengthen logic and operator handling! 📈 Improved understanding of stacks, expression evaluation, and efficient parsing techniques in C++. #LeetCode #100DaysOfCode #DSA #Stack #Strings #ProblemSolving #CodingJourney #CodeEveryday

💫Day 72 LeetCode: Linked List Cycle (141) Approach: Used an unordered_set to store visited nodes while traversing the list. If a node is already present in the set, a cycle exists. ✨ Learned how hashing helps in detecting cycles efficiently without modifying the linked list — a clean and intuitive solution! 📈 Improved understanding of hash-based detection, pointer traversal, and cycle identification in C++. #LeetCode #100DaysOfCode #DSA #LinkedList #Hashing #ProblemSolving #CodingJourney #CodeEveryday

✨Day 67 LeetCode: Letter Combinations of a Phone Number (17) Approach: Used backtracking to generate all possible letter combinations mapped from digits, following the classic phone keypad pattern. ✨ Learned how recursion and backtracking can explore all possible paths efficiently — a great exercise in mapping and combinatorial logic! 📈 Improved understanding of recursion, string building, and backtracking patterns in C++. #LeetCode #100DaysOfCode #DSA #Backtracking #Strings #ProblemSolving #CodingJourney #CodeEveryday

🔹 19th Problem – Remove Nth Node From End of List Difficulty: Medium 📘 Problem: Given the head of a linked list, the task is to remove the n-th node from the end of the list and return its head. Example: Input: head = [1,2,3,4,5], n = 2 Output: [1,2,3,5] 💡 Algorithm Used – Two Pointer (One-Pass) Approach: To solve this efficiently, I used the two-pointer technique. Create a dummy node before the head to handle edge cases easily. Move the first pointer n + 1 steps ahead to create a gap of n nodes. Move both pointers together until the first reaches the end. The second pointer will now be just before the node that needs to be removed. Adjust the links to remove the target node. ⏱️ Time Complexity: O(L) (We traverse the list only once.) 💾 Space Complexity: O(1) (Constant extra space used.) 🚀 Day 19 of my #120DaysLeetCodeChallenge completed! This problem helped me strengthen my understanding of linked list traversal and efficient pointer manipulation in C++. #LeetCode #DSA #CodingChallenge #TwoPointer #LinkedList #CPlusPlus #ProblemSolving #100DaysOfCode

C++ tips: user-defined structured bindings It's well known that C++17 introduced structured bindings. However, it is less known that you can use it on a user-defined type even when it's not a simple structure. To do so, you have three steps to follow: 1. Define a templated get function, which will be found either by ADL or as a member method 2. Define the tuple_size structure 3. Define the tuple_element structure You need to do it for const and non-const objects, depending on your needs. EDIT: As pointed out in comments, such a thing is primarily useful when you develop your own tuple-like objects. For classes like Person, prefer using simple getter :). Godbolt link: https://lnkd.in/eHesfzgV

C++ tips: Simplifying hashing In a previous post, we saw how to make a user-defined type hashable. We need to write much boilerplate by specializing std::hash. Since C++20, with the help of concepts, we can simplify the way we make types hashable. The core idea here is to have a compile-time interface, represented through a concept. This interface is Hashable. To implement this interface, you must provide a hash function. Then we implement std::hash for all Hashable types, and when we define our custom type, we need to provide a member function hash, and we are done :). Godbolt Link: https://lnkd.in/eaBb4VZ9

🌻Day 56 LeetCode: Number of Ways to Split Array (2270) Approach: Calculated prefix sums to efficiently determine valid split points where the left sum is greater than or equal to the right sum. ✨ Learned how prefix sums simplify cumulative comparison problems and help avoid repeated summations — boosting both logic and efficiency! 📈 Improved understanding of prefix arrays, cumulative sums, and linear-time array traversal in C++. #LeetCode #100DaysOfCode #DSA #Arrays #PrefixSum #ProblemSolving #CodingJourney #CodeEveryday

🌟Day 59 LeetCode: Subsets (78) Approach: Used backtracking to generate all possible subsets of a given array by exploring inclusion and exclusion of each element. ✨ Learned how recursion and backtracking can systematically explore all combinations — a classic and insightful problem! 📈 Improved understanding of recursion tree logic, subset generation, and backtracking techniques in C++. #LeetCode #100DaysOfCode #DSA #Backtracking #Recursion #ProblemSolving #CodingJourney #CodeEveryday