Longest Consecutive Sequence LeetCode Problem Solved

🚀 Day 7 / 150 LeetCode Challenge 📌 Problem: Sort an Array Today’s problem revolved around one of the most essential building blocks in computer science—sorting. Sorting isn’t just about arranging numbers; it’s about improving efficiency across systems. Many real-world problems become significantly easier once the data is sorted. 💡 What I explored today: Difference between comparison-based sorting algorithms When to use O(n log n) algorithms like Merge Sort & Quick Sort Why built-in sorting methods are highly optimized for practical use ⚡ Key Learning: Understanding why a sorting algorithm works is more important than just implementing it. Trade-offs like time complexity, space usage, and stability matter a lot in real-world applications. 🔍 Where sorting is used: Searching (Binary Search requires sorted data) Data analysis & reporting Backend systems handling large datasets 🎯 Takeaway: Strong fundamentals in sorting directly impact your ability to solve medium & hard-level problems efficiently. Consistency + clarity = growth 📈 On to Day 8 🔥 #LeetCode #DSA #SortingAlgorithms #SoftwareEngineering #CodingJourney #Java #100DaysOfCode

🚀 Solved LeetCode 2515 – Shortest Distance to Target String in a Circular Array Today I tackled an interesting problem that highlights the importance of handling circular data structures efficiently. 🔍 Problem Insight: Given a circular array of words, a target string, and a starting index, the goal is to find the minimum number of steps required to reach the target by moving either left or right. 💡 Key Learnings: Circular arrays require thinking beyond linear traversal Always consider both directions (forward & backward) Optimizing distance using min(distance, n - distance) is the key trick Simple logic + correct observation = optimal solution ⚙️ Approach Used: Traverse the array to find all occurrences of the target Calculate distance from the starting index Take the minimum considering circular movement 📈 Complexity: Efficient O(n) solution with constant space 🔥 Takeaway: This problem reinforced how small tweaks (like circular behavior) can change the entire approach. A great example of combining logic + observation for clean and optimal solutions. #LeetCode #Algorithms #ProblemSolving #CodingJourney #Java #DataStructures #CompetitiveProgramming

🚀 LeetCode Challenge 6/50 🔍 Problem: Contains Duplicate Today’s problem focused on detecting duplicates efficiently in an array. 💡 Approach: I used a HashSet to keep track of elements while traversing the array: If an element is already present in the set → duplicate found Otherwise, keep adding elements to the set ⚡ This allows early detection without unnecessary comparisons. 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(n) 📚 Key Learning: Using the right data structure can significantly reduce time complexity. HashSet is extremely useful for lookup operations and helps avoid nested loops. Staying consistent and improving step by step 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

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 39 of My LeetCode Journey 📌 Solved: LeetCode 1848 – Minimum Distance to the Target Element Today’s problem was simple yet a great exercise in improving logical thinking and iteration skills. 🔍 Problem Insight: Given an array, a target value, and a starting index, the goal is to find the minimum distance between the start index and any index where the target exists. 💡 Approach: Traverse the array Check for elements equal to the target Compute distance using |i - start| Keep track of the minimum value ⚡ Key Learning: Sometimes, the most optimal solution is a straightforward linear scan. Don’t overcomplicate when a simple approach works efficiently! ⏱ Complexity: Time: O(n) Space: O(1) 🔥 Consistency is key! Every day, one step closer to mastering Data Structures & Algorithms. #Day39 #LeetCode #Java #DSA #CodingJourney #ProblemSolving #100DaysOfCode

🚀 LeetCode Challenge 10/50 🔍 Problem: Merge Sorted Array Today’s problem focused on efficiently merging two sorted arrays without using extra space. 💡 Approach: I used the Two Pointer technique (from the end): Started comparing elements from the back of both arrays Placed the larger element at the end of nums1 Continued this process until all elements were merged ⚡ This approach avoids unnecessary shifting and works in-place. 📊 Complexity Analysis: Time Complexity: O(m + n) Space Complexity: O(1) 📚 Key Learning: Thinking from the end can simplify problems and avoid extra operations. Two-pointer technique is extremely useful for array manipulation problems. Consistency is building confidence 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

🚀 Day 84 – DSA Journey | Maximum Depth of Binary Tree Continuing my daily DSA practice, today I focused on understanding tree depth and recursive problem solving. 📌 Problem Practiced: Maximum Depth of Binary Tree (LeetCode 104) 🔍 Problem Idea: Find the maximum depth (or height) of a binary tree — the number of nodes along the longest path from the root to a leaf node. 💡 Key Insight: The depth of a tree depends on its subtrees. At every node, we can recursively calculate the depth of left and right subtrees and take the maximum. 📌 Approach Used: • If the node is null → depth is 0 • Recursively calculate depth of left subtree • Recursively calculate depth of right subtree • Return 1 + max(left, right) 📌 Concepts Strengthened: • Binary tree traversal • Recursion • Divide and conquer approach • Tree height calculation ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Breaking problems into smaller subproblems using recursion makes complex tree problems much easier to handle. On to Day 85! 🚀 #Day84 #DSAJourney #LeetCode #BinaryTree #Recursion #Java #ProblemSolving #Coding #LearningInPublic #Consistency

Day 20 of my #30DayCodeChallenge: Efficiency through Pruning! Today's challenge was Word Search II-a complex puzzle that tests how you manage massive search spaces. The Logic: 1. Trie Integration: I stored the dictionary in a Trie to check prefixes in O(1) time. 2. DFS & Backtracking: Explored the grid cell by cell, but with a twist... 3. Intelligent Pruning: If a path doesn't match a Trie prefix, the search stops immediately. This turns an exponential problem into something much more manageable. Coding isn't just about finding the answer; it's about finding it before your timer runs out! #Java #DataStructures #Backtracking #Trie #Algorithms #CleanCode #150DaysOfCode

Day 27 – #100DaysOfLeetCode Challenge Today I solved the problem “Best Time to Buy and Sell Stock II.” Problem Summary: You are given an array prices where prices[i] is the price of a stock on day i. The goal is to maximize profit by buying and selling the stock multiple times. However, you must sell before you buy again. Approach – Greedy Strategy Instead of trying every possible transaction combination, the idea is simple: 🔹 If the next day's price is higher than today's price, we take the profit 🔹 Add all positive price differences 🔹 This captures every profitable opportunity in the price trend For example: If prices = [7,1,5,3,6,4] Profits = (5-1) + (6-3) = 7 Time Complexity: O(n) Space Complexity: O(1) Key Learning: A Greedy approach works well when we want to capture every incremental profit opportunity instead of trying complex combinations. Continuing my journey of strengthening Data Structures & Algorithms skills through the #100DaysOfLeetCode challenge. On to the next problem! #100DaysOfLeetCode #LeetCode #DSA #GreedyAlgorithm #ProblemSolving #Java #CodingJourney #LearningInPublic

🚀 Day 54 of My LeetCode Journey 🔍 Problem: Find the Index of the First Occurrence in a String Today’s problem focused on searching for a substring inside a string — a very common concept in interviews and real-world applications like text processing and search engines. 💡 Key Idea: We compare the substring (needle) with every possible starting position in the main string (haystack) until we find a match. 🧠 What I Learned: How string matching works internally Importance of boundary conditions (like empty strings) Difference between brute-force and optimized approaches Why built-in methods like indexOf() are efficient ⚡ Approaches: Using built-in method (indexOf) – simple and efficient Manual iteration (brute force) – helps understand logic deeply 📈 Time Complexity: O(n * m) for brute-force approach 🔥 Takeaway: Even simple problems can teach core fundamentals. Mastering these basics builds a strong foundation for advanced algorithms like KMP. #Day54 #LeetCode #Java #DataStructures #CodingJourney #Programming #InterviewPreparation