Solving Search Insert Position with Binary Search on LeetCode

🚀 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

🚀 Solved LeetCode Problem #22 – Generate Parentheses Today I worked on an interesting recursion + backtracking problem that really strengthens understanding of constraint-based generation. 🔍 Problem Insight: Given n pairs of parentheses, generate all combinations of well-formed parentheses. 💡 Key Idea: Instead of generating all combinations and filtering invalid ones, we build only valid strings by: Adding '(' only when we still have some left Adding ')' only when it won’t break validity (i.e., open > close) 🧠 This ensures we never create invalid sequences, making the solution efficient. ⚙️ Approach Used: Backtracking (DFS) with two counters: open → number of '(' used close → number of ')' used 📈 Complexity: Time complexity follows Catalan Numbers → grows approximately as O(4^n / √n) ✨ Key Learning: This problem highlights how smart constraints in recursion can avoid unnecessary computation and lead to optimal solutions. 📌 Problems like this are great for mastering: Recursion Backtracking Combinatorial generation #LeetCode #Coding #DSA #Recursion #Backtracking #Java #ProblemSolving #TechJourney

🚀 LeetCode Challenge 7/50 🔍 Problem: Valid Anagram Today’s problem was about checking whether two strings are anagrams of each other efficiently. 💡 Approach: I used the Character Frequency Count method: First checked if both strings have equal length Used an array of size 26 to track character frequencies Incremented counts for one string and decremented for the other If all values are zero, both strings are anagrams ⚡ This approach avoids sorting and ensures optimal performance. 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 📚 Key Learning: Using frequency arrays is a powerful technique for string problems. It helps achieve constant space complexity and improves efficiency compared to sorting-based approaches. Step by step, getting better at problem solving 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

🚀 Solved LeetCode Problem #47 – Permutations II Today I tackled a classic backtracking problem that adds an interesting twist—handling duplicate elements while generating permutations. 🔍 Problem Insight: Given an array that may contain duplicates, the goal is to generate all unique permutations without repetition. 💡 Approach Used: I used a Backtracking + Sorting strategy: First, sort the array to bring duplicates together Use a visited[] array to track used elements Apply a smart condition to skip duplicate choices during recursion This ensures that we only generate distinct permutations efficiently. 🧠 Key Learning: Handling duplicates in recursive problems is crucial Sorting helps simplify duplicate detection Backtracking becomes powerful when combined with pruning conditions 📈 Complexity: Time: O(n!) Space: O(n) ✨ This problem strengthened my understanding of: Backtracking techniques Recursion control and pruning Writing optimized solutions for combinatorial problems Consistency in solving such problems is helping me build stronger problem-solving skills every day! 💪 #LeetCode #DSA #Backtracking #Algorithms #Coding #ProblemSolving #Java #TechJourney

🚀 Just solved LeetCode Problem #7 – Reverse Integer At first, it looked like a simple problem: reverse the digits of a number. But while solving it, I realized it’s not about reversing… it’s about thinking deeper. Here’s what I actually learned 👇 🔹 1. Think before things break Instead of checking overflow after it happens, I learned to prevent it before it happens using conditions like: → checking limits before multiplying by 10 🔹 2. Edge cases are everything The logic was easy. Handling edge cases like: very large numbers negative values integer limits …was the real challenge. 🔹 3. Don’t trust the compiler blindly Languages like Java won’t throw an error on overflow — they silently give wrong values. That was a big realization. 🔹 4. Patterns matter The simple step: → ans = ans * 10 + digit is a powerful pattern used in many problems. 🔹 5. Clean logic > shortcuts Using long was easy, but solving it properly with constraints made me understand the problem deeply. 💡 Biggest takeaway: Writing code that works is good. Writing code that is safe and correct in all cases is what really matters. On to the next problem 💪 #LeetCode #DSA #DataStructures #Algorithms #CodingJourney #LearnToCode #Programming #Java #SoftwareEngineering #ProblemSolving #CodingPractice #TechSkills #Developers #100DaysOfCode #CodeNewbie #InterviewPrep #CodingLife #GrowthMindset

#Day92 Of Problem Solving Today’s LeetCode problem turned out to be simpler than I expected — but only after looking at it from the right angle. At first, I was thinking of solving it using loops or recursion. But then I realized there’s a much cleaner way using a small mathematical trick to check if a number is a power of three. That shift in thinking made the solution not just easier, but also more efficient. Result: Runtime: 7 ms (beats 100%) Memory: 46 MB Moments like this remind me that problem solving isn’t always about writing more code, it’s about finding better approaches.Trying to stay consistent and improve a little every day. #LeetCode #Java #DSA #ProblemSolving #CodingJourney #LinkedIn

Day 2 of my LeetCode Journey Today’s focus: Prefix Sum + HashMap - Problem Type: Counting “Good Subarrays” - Approach: Converted the problem into a prefix sum transformation Used a HashMap to track frequencies Optimized brute force (O(n²)) → O(n) Key Learning: The real trick isn’t coding — it’s recognizing how to transform the problem. Instead of checking every subarray, I tracked a derived value: prefix - (index + 1) and counted how many times it appeared before. That shift turns an impossible brute force into a clean linear solution. -Takeaway: Most DSA problems are not about new algorithms — they’re about seeing the hidden pattern faster. Building consistency, one day at a time. #LeetCode #Day2 #DSA #Java #ProblemSolving #Consistency #CodingJourney

“What I learned after solving 300+ LeetCode problems 👇” At the beginning, I made a mistake. I kept solving random problems every day thinking: “More problems = more skill” But I was wrong. I realized that solving problems randomly is mostly a waste of time if you don’t understand the pattern behind them. Everything changed when I started focusing on patterns instead of problems. Here are some important patterns I learned: • Sliding Window • Two Pointers • Prefix Sum • Binary Search • Recursion & Backtracking • Linked List Patterns • Stack & Monotonic Stack • Hashing / Frequency Count Once you understand these patterns: You don’t need to solve 1000 problems. You start recognizing solutions instantly. Now when I see a problem, I don’t panic. I ask: 👉 “Which pattern does this belong to?” That one question changed everything for me. Still learning, but now with direction 🚀 #DSA #LeetCode #Java #BackendDevelopment #CodingJourney

📅 Date: April 27, 2026 Day 6 of my LeetCode Journey 🚀 ✅ Problem Solved: 15. 3Sum 🧠 Approach & Smart Solution: This classic medium-level problem is a great test of optimizing loops! A brute-force O(n³) approach would easily hit a Time Limit Exceeded (TLE). Instead, I optimized it to O(n²) using the Sorting + Two-Pointer technique. • Pseudo-code: First, sort the given array. Iterate through the array with an index 'i'. Skip duplicate elements to avoid duplicate triplets. Set two pointers: 'j' right after 'i', and 'k' at the end of the array. While 'j' is less than 'k': Calculate the sum of elements at i, j, and k. If the sum is 0, we found a valid triplet! Add it to the result list, and smoothly skip any duplicate values for both 'j' and 'k'. If the sum is less than 0, increment 'j' to increase the sum. If the sum is greater than 0, decrement 'k' to decrease the sum. By sorting first, we can systematically eliminate duplicate triplets and efficiently navigate towards the target sum without redundant checks! ⏱️ Time Complexity: O(n²) (Sorting takes O(n log n), and the two-pointer search takes O(n²)) 📦 Space Complexity: O(1) (Auxiliary space, excluding the space required for the output list) 📊 Progress Update: • Streak: 6 Days 🔥 • Difficulty: Medium • Pattern: Two Pointers / Sorting 🔗 LeetCode Profile: https://lnkd.in/gBcDQwtb (@Hari312004) Mastering the two-pointer technique on sorted arrays is a massive level-up for optimizing complex algorithms! 💡 #LeetCode #DSA #TwoPointers #Java #CodingJourney #ProblemSolving #InterviewPrep #Consistency #BackendDevelopment

🚀 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