Rotated Array Search Challenge: Binary Search Optimization

🚀 LeetCode Problem Solved: Peak Index in a Mountain Array (#852) Today I solved the Peak Index in a Mountain Array problem using an optimized Binary Search approach. 💡 Approach: Instead of using a brute-force linear scan, I applied Binary Search to reduce the search space: Compare the middle element with its neighbors. If it's greater than both → it's the peak. If the sequence is increasing → move right. If decreasing → move left. ⚡ Time Complexity: O(log n) ⚡ Space Complexity: O(1) 📈 Performance: ✅ Runtime: 0 ms (Beats 100%) ✅ Efficient and scalable solution Consistency in problem-solving is the real game changer 💪 #LeetCode #DataStructures #Algorithms #BinarySearch #CodingJourney #Java #ProblemSolving

🚀 Just solved the Contains Duplicate problem with a fresh perspective! Instead of going with the traditional sorting + two pointer approach, I used the property of Set (uniqueness) to achieve an O(n) time complexity solution. 💡 Approach: - Traverse the array once - Use a HashSet to track elements - If an element already exists → duplicate found ⚡ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔁 On the other hand, the sorting + two pointer approach gives: - Time: O(n log n) - Space: O(1) 👉 So it’s a classic trade-off: - Optimize time → use Set - Optimize space → use Sorting+two pointer Really enjoyed breaking down this problem and comparing approaches — small problems like this build strong intuition for bigger ones 💪 #DataStructures #Algorithms #LeetCode #Java #CodingJourney #ProblemSolving #100DaysOfCode

🚀 #Day54 of #100DaysDSAChallenge Solved #LeetCode160: Intersection of Two Linked Lists The problem asks us to find the node where two singly linked lists intersect. 🔹 Approach: 🔸 Brute Force Store nodes of one list in a hashmap/set and check while traversing the second list. ⏱️ Time: O(n + m) | 📦 Space: O(n) 🔸 Better Find lengths of both lists, move the longer list ahead by the difference, then traverse together to find intersection. ⏱️ Time: O(n + m) | 📦 Space: O(1) 🔸 Optimal Use two pointers and switch heads when reaching null so both traverse equal distance and meet at intersection. ⏱️ Time: O(n + m) | 📦 Space: O(1) 💡 Great example of improving from extra space → alignment → elegant pointer trick. 🔗 Github repo: https://lnkd.in/g_rSFCh8 #100DaysOfDSA #DSA #LeetCode #Java #Algorithms #DataStructures #KunalKushwaha #Striver #GeeksForGeeks #ProblemSolving #CodingJourney #LearningInPublic #InterviewPrep #PlacementPreparation 🚀

Day 105: Circular Arrays & Shortest Paths 🔄 Problem 2515: Shortest Distance to Target String in a Circular Array Today’s challenge involved finding the minimum steps to reach a target string in a circular array, allowing movement in both directions. The Strategy: • Bidirectional Search: Since the array is circular, the distance can be calculated in two ways: moving forward or moving backward. • Modular Arithmetic: I used (dist + n) % n to handle the wrap-around logic seamlessly, ensuring the index stays within bounds regardless of the direction. • Optimization: By iterating once through the array and comparing the distances for every occurrence of the target, I maintained an O(N) time complexity. Sometimes the most elegant way to handle a "circular" problem is simply embracing the symmetry of the path. 🚀 #LeetCode #Java #Algorithms #ProblemSolving #DailyCode

Worked on a challenging problem: “Subarrays with K Different Integers” Key takeaway: Instead of directly solving for exactly K distinct elements, I learned a smarter approach: 👉 count(at most K) − count(at most K−1) 🔹 Concepts I practiced: Sliding Window technique HashMap for frequency tracking Two-pointer approach 🔹 What stood out: The idea of counting all valid subarrays ending at each index using (r - l + 1) was really powerful. It completely changed how I think about subarray problems. Always learning, one problem at a time. #DataStructures #Algorithms #Java #LeetCode #SlidingWindow #LearningJourney #ProblemSolving

Day 09 of #50DaysOfLeetCode Challenge Just tackled the "Combination Sum" problem! This was a fantastic exercise in backtracking. The challenge is to find all unique combinations of numbers that sum up to a specific target, with the twist that you can use the same number multiple times. Key Insights: Backtracking Power: It’s all about exploring every possible path and "backtracking" as soon as the sum exceeds the target. State Space Tree: Visualizing how the recursion branches out helped me understand how to avoid duplicate combinations while allowing multiple uses of the same element. Decision Making: Learning when to include an element and when to move to the next index is crucial for optimizing the search. Each day, the logic gets sharper and the problems get more interesting! #DataStructures #Algorithms #CodingJourney #Java #Backtracking #LeetCode #ProblemSolving #SoftwareEngineering

🚀 Day 565 of #750DaysOfCode 🚀 🔍 Problem Solved: Minimum Absolute Distance Between Mirror Pairs Today’s problem was all about identifying mirror pairs in an array — where reversing one number equals another — and finding the minimum index distance between such pairs. 💡 Key Insight: Instead of brute force (O(n²)), we can optimize using a HashMap to track previously seen reversed values. 🧠 Approach: Traverse the array once For each number: Check if it already exists in the map → update minimum distance Compute its reverse Store the reversed number with its index Return the minimum distance, or -1 if no pair exists 📊 Complexity: Time: O(n × d) → d = number of digits Space: O(n) 🔥 Takeaway: Using a reverse transformation + hashmap lookup converts a nested loop problem into a linear scan — a classic optimization pattern! #Day565 #750DaysOfCode #LeetCode #Java #DataStructures #Algorithms #CodingJourney #HashMap #ProblemSolving

🚀 Day 74/100 – LeetCode Challenge 🔍 Problem Solved: Find the Duplicate Number (287) Today’s problem was a great reminder that sometimes the best solutions come from thinking differently 💡 Instead of using extra space or modifying the array, I used Floyd’s Cycle Detection Algorithm (Tortoise & Hare) — treating the array like a linked list to detect a cycle. 👉 Key Learnings: • Arrays can sometimes be visualized as linked structures • Cycle detection is not just for linked lists! • Optimizing for O(1) space is a common interview expectation ⚡ Approach: Use two pointers (slow & fast) First, find intersection point Then, find the cycle start → duplicate number ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) ✅ Successfully passed all test cases! Consistency > Perfection. Let’s keep going 💪 #Day74 #LeetCode #100DaysOfCode #Java #CodingInterview #ProblemSolving #DataStructures #Algorithms

Today’s problem: Bitonic Point (Peak Element in Array) In a world where data rises and falls, finding the turning point is everything — just like in business and life. 💡 Learned how to efficiently identify the peak using Binary Search instead of brute force. ⚡ Optimized thinking > Hard work alone Every day, one problem. Every problem, one step closer to mastery. Consistency is the real algorithm. 🔁 #DataStructures #Algorithms #Java #CodingJourney #ProblemSolving #BinarySearch #TechGrowth #DeveloperLife #Consistency #LearningInPublic #CarpenterBullet #FutureEngineer

🚀 Day 81 – DSA Journey | Binary Tree Inorder Traversal Continuing my daily DSA practice, today I explored tree traversal and how stacks can simulate recursion. 📌 Problem Practiced: Binary Tree Inorder Traversal (LeetCode 94) 🔍 Problem Idea: Traverse a binary tree in inorder sequence — Left → Root → Right — and return the values of nodes. 💡 Key Insight: Instead of recursion, we can use a stack to iteratively traverse the tree by going as left as possible, then processing nodes and moving right. 📌 Approach Used: • Use a stack to simulate recursion • Start from root and go to the leftmost node • Push nodes while moving left • Pop from stack, process the node • Move to the right subtree and repeat 📌 Concepts Strengthened: • Tree traversal (Inorder) • Stack usage in trees • Iterative vs recursive approaches • Understanding tree structure ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔥 Today’s takeaway: Recursion can always be converted into iteration using stacks — understanding this gives more control over traversal logic. On to Day 82! 🚀 #Day81 #DSAJourney #LeetCode #BinaryTree #Stack #Java #ProblemSolving #Coding #LearningInPublic #Consistency