Solved LeetCode 61 – Rotate List with Efficient Pointer Handling

🚀 Day 76 of #100DaysOfCode Today, I solved LeetCode 18 – 4Sum, a classic problem that extends the two-pointer technique to higher complexity. 💡 Problem Overview: Given an array, the task is to find all unique quadruplets that sum up to a target value. 🧠 Approach: ✔️ Sorted the array to simplify processing ✔️ Fixed two elements using nested loops ✔️ Applied the two-pointer technique for the remaining two elements ✔️ Carefully handled duplicates to ensure unique quadruplets This approach efficiently reduces unnecessary computations compared to brute force. ⚡ Key Takeaways: Sorting + Two Pointers is a powerful combination Avoiding duplicates is crucial in combination problems Breaking a complex problem into smaller parts simplifies logic 📊 Complexity Analysis: Time Complexity: O(n³) Space Complexity: O(1) (excluding output) Consistently pushing boundaries and solving more complex problems 🚀 #LeetCode #100DaysOfCode #DSA #TwoPointers #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep

🚀 Day 79 of #100DaysOfCode Today, I solved LeetCode 32 – Longest Valid Parentheses, a challenging problem that focuses on stack-based logic and string processing. 💡 Problem Overview: Given a string containing only '(' and ')', the goal is to find the length of the longest valid (well-formed) parentheses substring. 🧠 Approach: ✔️ Used a stack-based approach to track indices ✔️ Initialized stack with -1 to handle edge cases ✔️ For every closing bracket, popped from stack ✔️ Calculated valid substring length using current index and stack top This approach efficiently tracks valid sequences and avoids reprocessing. ⚡ Key Takeaways: Stack is powerful for handling matching problems Index-based tracking simplifies substring calculations Handling edge cases (like invalid starting brackets) is crucial 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(n) Solving hard problems step by step and improving every day 🚀 #LeetCode #100DaysOfCode #DSA #Stack #Strings #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep #HardProblems

🚀 Day 45/100 – LeetCode Challenge 🔗 Problem: Linked List Components (LeetCode 817) 💡 Difficulty: Medium Today’s problem was all about understanding connected components in a linked list using a smart approach. 🧠 Key Insight: Instead of checking every possible combination, I used a HashSet for quick lookups. A component is counted only when a sequence ends, i.e., when the current node is in nums but the next node is not. ⚡ Approach: Convert nums into a set for O(1) lookup Traverse the linked list Count only when a component ends 📈 Time Complexity: O(n) 📦 Space Complexity: O(n) ✨ What I learned: Sometimes, solving problems efficiently is about identifying where something ends rather than where it starts. Consistency is key 🔥 Halfway through the journey — staying committed! #Day45 #100DaysOfCode #LeetCode #DataStructures #LinkedList #CodingJourney #ProblemSolving #SoftwareEngineering

🚀 Day 78 of #100DaysOfCode Today, I solved LeetCode 154 – Find Minimum in Rotated Sorted Array II, a problem that focuses on binary search and handling edge cases with duplicates. 💡 Problem Overview: Given a rotated sorted array that may contain duplicates, the goal is to find the minimum element efficiently. 🧠 Approach: ✔️ Applied modified binary search ✔️ Compared mid element with the right boundary ✔️ Carefully handled duplicate values to avoid incorrect elimination of search space This approach ensures correctness even when duplicates are present. ⚡ Key Takeaways: Binary search can be adapted for complex scenarios Duplicates introduce edge cases that must be handled carefully Choosing the correct condition is key to narrowing the search space 📊 Complexity Analysis: Time Complexity: O(log n) (average), O(n) (worst case due to duplicates) Space Complexity: O(1) Strengthening problem-solving with optimized approaches 🚀 #LeetCode #100DaysOfCode #DSA #BinarySearch #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep

LeetCode Progress 37/50 — Remove Duplicates from Sorted List Today I worked on a problem focused on linked list traversal and in-place modifications 🧩 💡 The challenge was to remove duplicate nodes from a sorted linked list while preserving only one occurrence of each value. 🧠 Approach: Used pointer-based traversal to compare adjacent nodes and remove duplicates by updating links in-place whenever repeated values were found. ⏱ Time Complexity: O(n) 💡 What I learned: This problem reinforced how efficient pointer manipulation can simplify linked list operations without requiring extra space. 📈 Strengthening understanding of linked list fundamentals and improving confidence in pointer-based problem-solving. #LeetCode #DSA #LinkedList #ProblemSolving #Cpp #CodingJourney #Consistency 🚀

Day 40 Today I solved: Find N Unique Integers Sum up to Zero (LeetCode 1304) 💡 Problem: Given an integer n, return any array of n unique integers such that their sum equals 0. 💡 My Approach: I used a simple construction-based approach: 1️⃣ Add numbers from 1 to n-1 into the array 2️⃣ Keep track of their sum 3️⃣ Add the last element as -sum to balance everything to zero If sum of first n-1 elements is S, 👉 last element = -S ensures total sum = 0 ⚡ Complexity: Time: O(n) Space: O(n) 🔥 Alternative Idea: Use pairs like (x, -x) and include 0 if n is odd. #LeetCode #DSA #ProblemSolving #CodingJourney #LearnInPublic

🔥 Day 178 of My LeetCode Journey Problem 143: Reorder List 💡 Problem Insight: Today’s problem was about rearranging a linked list in a specific pattern: 👉 L0 → Ln → L1 → Ln-1 → L2 → Ln-2 ... It’s not just traversal — it’s about restructuring the list in-place. Each step is simple individually, but combining them correctly is the real challenge. 💪 Key Takeaway: Many linked list problems are just compositions of smaller patterns. Master the basics (reverse, find middle, merge), and complex problems become manageable. ✨ Daily Reflection: This problem reinforced structured thinking — breaking a problem into steps is more effective than trying to solve everything at once. #Day178 #LeetCode #LinkedList #ReorderList #TwoPointer #ProblemSolving #DSA #CodingJourney #Consistency

LeetCode Progress 35/50 — Remove Duplicates from Sorted List II Today I worked on a problem focused on linked list manipulation and careful edge case handling 🧩 💡 The challenge was to remove all nodes that have duplicate values, leaving only distinct numbers from the sorted linked list. 🧠 Approach: Used pointer-based traversal with a dummy node to handle edge cases effectively. Identified duplicate sequences and skipped them while preserving only unique nodes in the final list. ⏱ Time Complexity: O(n) 💡 What I learned: This problem highlighted how using dummy nodes and careful pointer handling can simplify linked list problems involving deletions and edge cases. 📈 Strengthening understanding of linked list operations and improving confidence in solving pointer-based problems. #LeetCode #DSA #LinkedList #ProblemSolving #Cpp #CodingJourney #Consistency 🚀

🚀 Day 29/50 – LeetCode Challenge 🧩 Problem: Swap Nodes in Pairs Today’s problem focused on swapping nodes of a linked list in pairs, which helped strengthen concepts of pointer manipulation and linked list traversal. 📌 Problem Summary: Given a linked list, swap every two adjacent nodes and return the modified list. You must not modify node values, only change the links. 🔍 Approach Used (My Implementation) ✔ Used a dummy node to handle edge cases easily ✔ Maintained two pointers: prev → points to node before the pair cur → points to the first node of the pair ✔ For each pair: Stored next pair using npn = cur.next.next Identified second node → second = cur.next ✔ Swapped nodes by updating pointers: second.next = cur cur.next = npn prev.next = second ✔ Moved pointers forward: prev = cur cur = npn ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 💡 Key Learning ✔ Importance of dummy node in linked list problems ✔ Mastering pointer manipulation ✔ Handling edge cases in linked lists ✔ Writing clean and efficient in-place solutions This problem really improved my confidence in working with linked list pointer operations. Consistency builds strong fundamentals 🚀 🔗 Problem Link: https://lnkd.in/gDjVrGur #50DaysOfLeetCode #LeetCode #DSA #LinkedList #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

Day 50 of my #50DaysOfCode challenge is done ✅🎉 📌 Problem Solved Reorder Linked List We were given a linked list. Task was to reorder it like: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 … Not just reverse. Rearrange in a specific pattern. 💻 Approach 🔹️Find the middle of the linked list. 🔹️Reverse the second half. 🔹️Merge both halves alternately. Step by step: 🔹️Use slow and fast pointers to find middle 🔹️Reverse second half of list 🔹️Merge nodes one by one Careful pointer handling needed. 📊 Complexity Analysis Time Complexity: O(n) Space Complexity: O(1) 📚 What I learned today: ▫️Linked list problems often combine multiple steps. ▫️Finding middle + reversing + merging is a common pattern. ▫️Pointer manipulation needs careful attention. ▫️Breaking problem into parts makes it manageable. 🎯 50 Days Completed Started with basic patterns. Reached linked lists, stacks, recursion, sliding window. Some days were easy. Some were confusing. But I showed up every day. That’s the biggest win. This challenge was not just about coding. It was about consistency and discipline. #50DaysOfCode #CodingChallenge #Consistency #LearningInPublic