Solved Linked List Cycle with Floyd's Algorithm in Java

🚀 Day 43 of #100DaysOfLeetCode Today's problem: LeetCode #160 – Intersection of Two Linked Lists 💡 Concept: Find the node where two singly linked lists intersect. Used the Two Pointer Approach — a smart and efficient way to solve this without using extra memory. 🧠 Logic: Move both pointers through the lists. When one pointer reaches the end, switch it to the other list’s head. They’ll either meet at the intersection node or end up as null together. ✅ Complexity: Time – O(n + m) Space – O(1) 💬 Takeaway: Sometimes, the best solutions come from balancing the path — literally! Understanding how pointers sync up teaches a lot about memory references and linked list behavior. #LeetCode #CodingChallenge #Java #DataStructures #TwoPointerTechnique #ProblemSolving #LinkedLists

🚀 Day 43 of #100DaysOfLeetCode Today's problem: LeetCode #160 – Intersection of Two Linked Lists 💡 Concept:  Find the node where two singly linked lists intersect.  Used the Two Pointer Approach — a smart and efficient way to solve this without using extra memory. 🧠 Logic:  Move both pointers through the lists.  When one pointer reaches the end, switch it to the other list’s head.  They’ll either meet at the intersection node or end up as null together. ✅ Complexity:  Time – O(n + m)  Space – O(1) 💬 Takeaway:  Sometimes, the best solutions come from balancing the path — literally!  Understanding how pointers sync up teaches a lot about memory references and linked list behavior. #LeetCode #CodingChallenge #Java #DataStructures #TwoPointerTechnique #ProblemSolving #LinkedLists

🚀 Day 43 of #100DaysOfLeetCode Today's problem: LeetCode #160 – Intersection of Two Linked Lists 💡 Concept:  Find the node where two singly linked lists intersect.  Used the Two Pointer Approach — a smart and efficient way to solve this without using extra memory. 🧠 Logic:  Move both pointers through the lists.  When one pointer reaches the end, switch it to the other list’s head.  They’ll either meet at the intersection node or end up as null together. ✅ Complexity:  Time – O(n + m)  Space – O(1) 💬 Takeaway:  Sometimes, the best solutions come from balancing the path — literally!  Understanding how pointers sync up teaches a lot about memory references and linked list behavior. #LeetCode #CodingChallenge #Java #DataStructures #TwoPointerTechnique #ProblemSolving #LinkedLists

🚀 115 days of #200DaysOfCode Problem: 24. Swap Nodes in Pairs Problem Statement: Given the head of a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes, only nodes themselves may be changed. Approach: Used a dummy node and iteratively swapped each adjacent node pair via pointer manipulation, which enabled in-place node swaps without extra space. Logic: Leveraged pointer rewiring to achieve the swaps efficiently with O(1) extra space and O(n) time complexity, cleanly iterating through the list to handle both even and odd-length cases. 👉 Question link 🔗: https://lnkd.in/g6cwvMgz #LeetCode #Java #LinkedList #Pointers #DSA #Coding #Algorithms #InterviewPrep #200DaysOfCode

#Day_33 Today’s challenge was an interesting one — "Find the Duplicate Number" Given an array of integers where each number is between 1 and n, with one number repeating — the goal is to identify that duplicate efficiently. Approach: Create a boolean array seen[] to track which numbers have appeared. As we iterate through the array, if we encounter a number already marked as true, that’s our duplicate! Complexity: Time: O(n) Space: O(n) (due to the boolean array) Though this works efficiently, I also explored the Floyd’s Tortoise and Hare approach for a space-optimized version — a fascinating concept using cycle detection Sometimes the simplest approach is the clearest — but exploring alternatives is what sharpens your problem-solving mindset. #LeetCode #CodingChallenge #Java #ProblemSolving #100DaysOfCode #MudassirCodes

#100DaysOfCode – Day 74 Count and Say Problem: Given an integer n, return the n-th term of the “Count and Say” sequence a fascinating pattern where each term describes the previous one. Example: Input: n = 4 Output: "1211" My Approach: Used recursion to generate the previous term. Applied run-length encoding logic counted consecutive digits and built the next term using a StringBuilder. Optimized for clean, readable iteration with O(N²) complexity (due to string building). Understanding recursive string construction deepens how we visualize “generation-based” sequences it’s not just about coding, it’s about seeing patterns grow. #100DaysOfCode #Java #LeetCode #ProblemSolving #Recursion #StringManipulation #CodingJourney #TechWithPurpose #takeUforward

✅Day 41 : Leetcode 153 - Find Minimum in Rotated Sorted Array #60DayOfLeetcodeChallenge 🧩 Problem Statement Given a sorted array that has been rotated at an unknown pivot, find the minimum element in the array. The array contains unique elements, and the solution must run in O(log n) time. 💡 My Approach I used a binary search technique to efficiently find the minimum element. I maintained two pointers, low and high. At each step, I calculated the mid-point. If the left part (nums[low] to nums[mid]) was sorted, I updated my answer with the smaller of nums[low] and current ans, and moved low to mid + 1. Otherwise, I updated my answer with nums[mid] and moved high to mid - 1. This approach ensures we keep narrowing the search space toward the minimum element. ⏱️ Time Complexity O(log n) — Because the search space is halved in each iteration. #BinarySearch #LeetCode #RotatedSortedArray #DSA #CodingPractice #Java #ProblemSolving

Today’s problem: Merge Two Sorted Lists 🔗 Problem: Given two sorted linked lists, merge them into one sorted list and return it. Example: Input: list1 = [1,2,4], list2 = [1,3,4] Output: [1,1,2,3,4,4] Approach I used: ✅ Create a dummy node to simplify pointer operations. ✅ Use a pointer (tail) to build the merged list by comparing the heads of both lists. ✅ Append the smaller node each time and move forward. ✅ When one list ends, attach the remaining nodes of the other. A clean iterative solution that keeps the space usage minimal (O(1) extra space). ⚡

🔥 Day 31/100 of #100DaysOfCode - Linked List Cleanup! Today's Problem: Remove Duplicates from Sorted List Task: Delete all duplicates from a sorted linked list so each element appears only once. Solution: Used a straightforward iterative approach with a single pointer! Traversed the list and whenever the current node's value matched the next node's value, I "skipped" the duplicate by pointing current.next to current.next.next. Key Insights: Since the list is pre-sorted, duplicates are guaranteed to be adjacent Only need one pointer to traverse and remove duplicates in place O(n) time complexity with O(1) space - very efficient! Edge Cases Handled: Empty list (head == null) Single node lists Multiple consecutive duplicates Simple but elegant linked list manipulation! Each problem builds better intuition for pointer operations. 🎯 #100DaysOfCode #LeetCode #Java #DataStructures #LinkedList #Algorithm #CodingJourney

🚀 Day 77/100 of #100DaysOfLeetCode Today I solved Binary Search (LeetCode Problem 704), a classic algorithmic challenge and an important concept for efficient searching. The task was to determine the index of a target value in a sorted array using an algorithm with O(log n) time complexity. If the target exists, return its index; otherwise return -1. 💡 Key Takeaway: Binary search is a fundamental algorithm that helps build strong problem-solving intuition and improves understanding of time complexity. #100DaysOfCode #LeetCode #CodingJourney #Java #DSA #BinarySearch #KeepLearning #ProblemSolving