Merging Two Sorted Linked Lists in C++ with LeetCode

🍁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 71 LeetCode: Remove Nth Node From End of List (19) Approach: Used the two-pointer technique — moved one pointer n steps ahead, then traversed both to locate and remove the target node efficiently. ✨ Learned how the two-pointer approach simplifies linked list problems and improves traversal logic! 📈 Improved understanding of pointer manipulation, edge case handling, and linked list traversal in C++. #LeetCode #100DaysOfCode #DSA #LinkedList #TwoPointers #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

🌟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

🍂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

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

🔹 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: 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

3461. Check If Digits Are Equal in String After Operations I 🧩 LeetCode Problem of the Day — Solved! 🔗 Solution Link: https://lnkd.in/gRdq2P9M Today’s Problem of the Day was quite easy — just needed to carefully follow the steps described in the question. The task was to repeatedly combine consecutive digits by summing them modulo 10 until only two digits remained, and then check if they’re equal. 🧠 Key Idea: Iterate over the string and compute new digits as (s[i] + s[i+1]) % 10. Continue until only two digits are left. Return true if both digits are equal, else false. 🕒 Complexity: Time: O(n²) (due to repeated reductions) Space: O(1) 💡 Takeaway: Sometimes the simplest problems remind us that precise implementation and attention to detail matter as much as complex logic. #LeetCode #ProblemOfTheDay #DSA #CodingJourney #Consistency #EasyProblem #Implementation